1 /* 2 * parser.c : an XML 1.0 parser, namespaces and validity support are mostly 3 * implemented on top of the SAX interfaces 4 * 5 * References: 6 * The XML specification: 7 * http://www.w3.org/TR/REC-xml 8 * Original 1.0 version: 9 * http://www.w3.org/TR/1998/REC-xml-19980210 10 * XML second edition working draft 11 * http://www.w3.org/TR/2000/WD-xml-2e-20000814 12 * 13 * Okay this is a big file, the parser core is around 7000 lines, then it 14 * is followed by the progressive parser top routines, then the various 15 * high level APIs to call the parser and a few miscellaneous functions. 16 * A number of helper functions and deprecated ones have been moved to 17 * parserInternals.c to reduce this file size. 18 * As much as possible the functions are associated with their relative 19 * production in the XML specification. A few productions defining the 20 * different ranges of character are actually implanted either in 21 * parserInternals.h or parserInternals.c 22 * The DOM tree build is realized from the default SAX callbacks in 23 * the module SAX.c. 24 * The routines doing the validation checks are in valid.c and called either 25 * from the SAX callbacks or as standalone functions using a preparsed 26 * document. 27 * 28 * See Copyright for the status of this software. 29 * 30 * daniel (at) veillard.com 31 */ 32 33 #define IN_LIBXML 34 #include "libxml.h" 35 36 #if defined(WIN32) && !defined (__CYGWIN__) 37 #define XML_DIR_SEP '\\' 38 #else 39 #define XML_DIR_SEP '/' 40 #endif 41 42 #include <stdlib.h> 43 #include <limits.h> 44 #include <string.h> 45 #include <stdarg.h> 46 #include <libxml/xmlmemory.h> 47 #include <libxml/threads.h> 48 #include <libxml/globals.h> 49 #include <libxml/tree.h> 50 #include <libxml/parser.h> 51 #include <libxml/parserInternals.h> 52 #include <libxml/valid.h> 53 #include <libxml/entities.h> 54 #include <libxml/xmlerror.h> 55 #include <libxml/encoding.h> 56 #include <libxml/xmlIO.h> 57 #include <libxml/uri.h> 58 #ifdef LIBXML_CATALOG_ENABLED 59 #include <libxml/catalog.h> 60 #endif 61 #ifdef LIBXML_SCHEMAS_ENABLED 62 #include <libxml/xmlschemastypes.h> 63 #include <libxml/relaxng.h> 64 #endif 65 #ifdef HAVE_CTYPE_H 66 #include <ctype.h> 67 #endif 68 #ifdef HAVE_STDLIB_H 69 #include <stdlib.h> 70 #endif 71 #ifdef HAVE_SYS_STAT_H 72 #include <sys/stat.h> 73 #endif 74 #ifdef HAVE_FCNTL_H 75 #include <fcntl.h> 76 #endif 77 #ifdef HAVE_UNISTD_H 78 #include <unistd.h> 79 #endif 80 #ifdef HAVE_ZLIB_H 81 #include <zlib.h> 82 #endif 83 #ifdef HAVE_LZMA_H 84 #include <lzma.h> 85 #endif 86 87 #include "buf.h" 88 #include "enc.h" 89 90 static void 91 xmlFatalErr(xmlParserCtxtPtr ctxt, xmlParserErrors error, const char *info); 92 93 static xmlParserCtxtPtr 94 xmlCreateEntityParserCtxtInternal(const xmlChar *URL, const xmlChar *ID, 95 const xmlChar *base, xmlParserCtxtPtr pctx); 96 97 /************************************************************************ 98 * * 99 * Arbitrary limits set in the parser. See XML_PARSE_HUGE * 100 * * 101 ************************************************************************/ 102 103 #define XML_PARSER_BIG_ENTITY 1000 104 #define XML_PARSER_LOT_ENTITY 5000 105 106 /* 107 * XML_PARSER_NON_LINEAR is the threshold where the ratio of parsed entity 108 * replacement over the size in byte of the input indicates that you have 109 * and eponential behaviour. A value of 10 correspond to at least 3 entity 110 * replacement per byte of input. 111 */ 112 #define XML_PARSER_NON_LINEAR 10 113 114 /* 115 * xmlParserEntityCheck 116 * 117 * Function to check non-linear entity expansion behaviour 118 * This is here to detect and stop exponential linear entity expansion 119 * This is not a limitation of the parser but a safety 120 * boundary feature. It can be disabled with the XML_PARSE_HUGE 121 * parser option. 122 */ 123 static int 124 xmlParserEntityCheck(xmlParserCtxtPtr ctxt, size_t size, 125 xmlEntityPtr ent, size_t replacement) 126 { 127 size_t consumed = 0; 128 129 if ((ctxt == NULL) || (ctxt->options & XML_PARSE_HUGE)) 130 return (0); 131 if (ctxt->lastError.code == XML_ERR_ENTITY_LOOP) 132 return (1); 133 if (replacement != 0) { 134 if (replacement < XML_MAX_TEXT_LENGTH) 135 return(0); 136 137 /* 138 * If the volume of entity copy reaches 10 times the 139 * amount of parsed data and over the large text threshold 140 * then that's very likely to be an abuse. 141 */ 142 if (ctxt->input != NULL) { 143 consumed = ctxt->input->consumed + 144 (ctxt->input->cur - ctxt->input->base); 145 } 146 consumed += ctxt->sizeentities; 147 148 if (replacement < XML_PARSER_NON_LINEAR * consumed) 149 return(0); 150 } else if (size != 0) { 151 /* 152 * Do the check based on the replacement size of the entity 153 */ 154 if (size < XML_PARSER_BIG_ENTITY) 155 return(0); 156 157 /* 158 * A limit on the amount of text data reasonably used 159 */ 160 if (ctxt->input != NULL) { 161 consumed = ctxt->input->consumed + 162 (ctxt->input->cur - ctxt->input->base); 163 } 164 consumed += ctxt->sizeentities; 165 166 if ((size < XML_PARSER_NON_LINEAR * consumed) && 167 (ctxt->nbentities * 3 < XML_PARSER_NON_LINEAR * consumed)) 168 return (0); 169 } else if (ent != NULL) { 170 /* 171 * use the number of parsed entities in the replacement 172 */ 173 size = ent->checked / 2; 174 175 /* 176 * The amount of data parsed counting entities size only once 177 */ 178 if (ctxt->input != NULL) { 179 consumed = ctxt->input->consumed + 180 (ctxt->input->cur - ctxt->input->base); 181 } 182 consumed += ctxt->sizeentities; 183 184 /* 185 * Check the density of entities for the amount of data 186 * knowing an entity reference will take at least 3 bytes 187 */ 188 if (size * 3 < consumed * XML_PARSER_NON_LINEAR) 189 return (0); 190 } else { 191 /* 192 * strange we got no data for checking just return 193 */ 194 return (0); 195 } 196 xmlFatalErr(ctxt, XML_ERR_ENTITY_LOOP, NULL); 197 return (1); 198 } 199 200 /** 201 * xmlParserMaxDepth: 202 * 203 * arbitrary depth limit for the XML documents that we allow to 204 * process. This is not a limitation of the parser but a safety 205 * boundary feature. It can be disabled with the XML_PARSE_HUGE 206 * parser option. 207 */ 208 unsigned int xmlParserMaxDepth = 256; 209 210 211 212 #define SAX2 1 213 #define XML_PARSER_BIG_BUFFER_SIZE 300 214 #define XML_PARSER_BUFFER_SIZE 100 215 #define SAX_COMPAT_MODE BAD_CAST "SAX compatibility mode document" 216 217 /** 218 * XML_PARSER_CHUNK_SIZE 219 * 220 * When calling GROW that's the minimal amount of data 221 * the parser expected to have received. It is not a hard 222 * limit but an optimization when reading strings like Names 223 * It is not strictly needed as long as inputs available characters 224 * are followed by 0, which should be provided by the I/O level 225 */ 226 #define XML_PARSER_CHUNK_SIZE 100 227 228 /* 229 * List of XML prefixed PI allowed by W3C specs 230 */ 231 232 static const char *xmlW3CPIs[] = { 233 "xml-stylesheet", 234 "xml-model", 235 NULL 236 }; 237 238 239 /* DEPR void xmlParserHandleReference(xmlParserCtxtPtr ctxt); */ 240 static xmlEntityPtr xmlParseStringPEReference(xmlParserCtxtPtr ctxt, 241 const xmlChar **str); 242 243 static xmlParserErrors 244 xmlParseExternalEntityPrivate(xmlDocPtr doc, xmlParserCtxtPtr oldctxt, 245 xmlSAXHandlerPtr sax, 246 void *user_data, int depth, const xmlChar *URL, 247 const xmlChar *ID, xmlNodePtr *list); 248 249 static int 250 xmlCtxtUseOptionsInternal(xmlParserCtxtPtr ctxt, int options, 251 const char *encoding); 252 #ifdef LIBXML_LEGACY_ENABLED 253 static void 254 xmlAddEntityReference(xmlEntityPtr ent, xmlNodePtr firstNode, 255 xmlNodePtr lastNode); 256 #endif /* LIBXML_LEGACY_ENABLED */ 257 258 static xmlParserErrors 259 xmlParseBalancedChunkMemoryInternal(xmlParserCtxtPtr oldctxt, 260 const xmlChar *string, void *user_data, xmlNodePtr *lst); 261 262 static int 263 xmlLoadEntityContent(xmlParserCtxtPtr ctxt, xmlEntityPtr entity); 264 265 /************************************************************************ 266 * * 267 * Some factorized error routines * 268 * * 269 ************************************************************************/ 270 271 /** 272 * xmlErrAttributeDup: 273 * @ctxt: an XML parser context 274 * @prefix: the attribute prefix 275 * @localname: the attribute localname 276 * 277 * Handle a redefinition of attribute error 278 */ 279 static void 280 xmlErrAttributeDup(xmlParserCtxtPtr ctxt, const xmlChar * prefix, 281 const xmlChar * localname) 282 { 283 if ((ctxt != NULL) && (ctxt->disableSAX != 0) && 284 (ctxt->instate == XML_PARSER_EOF)) 285 return; 286 if (ctxt != NULL) 287 ctxt->errNo = XML_ERR_ATTRIBUTE_REDEFINED; 288 289 if (prefix == NULL) 290 __xmlRaiseError(NULL, NULL, NULL, ctxt, NULL, XML_FROM_PARSER, 291 XML_ERR_ATTRIBUTE_REDEFINED, XML_ERR_FATAL, NULL, 0, 292 (const char *) localname, NULL, NULL, 0, 0, 293 "Attribute %s redefined\n", localname); 294 else 295 __xmlRaiseError(NULL, NULL, NULL, ctxt, NULL, XML_FROM_PARSER, 296 XML_ERR_ATTRIBUTE_REDEFINED, XML_ERR_FATAL, NULL, 0, 297 (const char *) prefix, (const char *) localname, 298 NULL, 0, 0, "Attribute %s:%s redefined\n", prefix, 299 localname); 300 if (ctxt != NULL) { 301 ctxt->wellFormed = 0; 302 if (ctxt->recovery == 0) 303 ctxt->disableSAX = 1; 304 } 305 } 306 307 /** 308 * xmlFatalErr: 309 * @ctxt: an XML parser context 310 * @error: the error number 311 * @extra: extra information string 312 * 313 * Handle a fatal parser error, i.e. violating Well-Formedness constraints 314 */ 315 static void 316 xmlFatalErr(xmlParserCtxtPtr ctxt, xmlParserErrors error, const char *info) 317 { 318 const char *errmsg; 319 char errstr[129] = ""; 320 321 if ((ctxt != NULL) && (ctxt->disableSAX != 0) && 322 (ctxt->instate == XML_PARSER_EOF)) 323 return; 324 switch (error) { 325 case XML_ERR_INVALID_HEX_CHARREF: 326 errmsg = "CharRef: invalid hexadecimal value"; 327 break; 328 case XML_ERR_INVALID_DEC_CHARREF: 329 errmsg = "CharRef: invalid decimal value"; 330 break; 331 case XML_ERR_INVALID_CHARREF: 332 errmsg = "CharRef: invalid value"; 333 break; 334 case XML_ERR_INTERNAL_ERROR: 335 errmsg = "internal error"; 336 break; 337 case XML_ERR_PEREF_AT_EOF: 338 errmsg = "PEReference at end of document"; 339 break; 340 case XML_ERR_PEREF_IN_PROLOG: 341 errmsg = "PEReference in prolog"; 342 break; 343 case XML_ERR_PEREF_IN_EPILOG: 344 errmsg = "PEReference in epilog"; 345 break; 346 case XML_ERR_PEREF_NO_NAME: 347 errmsg = "PEReference: no name"; 348 break; 349 case XML_ERR_PEREF_SEMICOL_MISSING: 350 errmsg = "PEReference: expecting ';'"; 351 break; 352 case XML_ERR_ENTITY_LOOP: 353 errmsg = "Detected an entity reference loop"; 354 break; 355 case XML_ERR_ENTITY_NOT_STARTED: 356 errmsg = "EntityValue: \" or ' expected"; 357 break; 358 case XML_ERR_ENTITY_PE_INTERNAL: 359 errmsg = "PEReferences forbidden in internal subset"; 360 break; 361 case XML_ERR_ENTITY_NOT_FINISHED: 362 errmsg = "EntityValue: \" or ' expected"; 363 break; 364 case XML_ERR_ATTRIBUTE_NOT_STARTED: 365 errmsg = "AttValue: \" or ' expected"; 366 break; 367 case XML_ERR_LT_IN_ATTRIBUTE: 368 errmsg = "Unescaped '<' not allowed in attributes values"; 369 break; 370 case XML_ERR_LITERAL_NOT_STARTED: 371 errmsg = "SystemLiteral \" or ' expected"; 372 break; 373 case XML_ERR_LITERAL_NOT_FINISHED: 374 errmsg = "Unfinished System or Public ID \" or ' expected"; 375 break; 376 case XML_ERR_MISPLACED_CDATA_END: 377 errmsg = "Sequence ']]>' not allowed in content"; 378 break; 379 case XML_ERR_URI_REQUIRED: 380 errmsg = "SYSTEM or PUBLIC, the URI is missing"; 381 break; 382 case XML_ERR_PUBID_REQUIRED: 383 errmsg = "PUBLIC, the Public Identifier is missing"; 384 break; 385 case XML_ERR_HYPHEN_IN_COMMENT: 386 errmsg = "Comment must not contain '--' (double-hyphen)"; 387 break; 388 case XML_ERR_PI_NOT_STARTED: 389 errmsg = "xmlParsePI : no target name"; 390 break; 391 case XML_ERR_RESERVED_XML_NAME: 392 errmsg = "Invalid PI name"; 393 break; 394 case XML_ERR_NOTATION_NOT_STARTED: 395 errmsg = "NOTATION: Name expected here"; 396 break; 397 case XML_ERR_NOTATION_NOT_FINISHED: 398 errmsg = "'>' required to close NOTATION declaration"; 399 break; 400 case XML_ERR_VALUE_REQUIRED: 401 errmsg = "Entity value required"; 402 break; 403 case XML_ERR_URI_FRAGMENT: 404 errmsg = "Fragment not allowed"; 405 break; 406 case XML_ERR_ATTLIST_NOT_STARTED: 407 errmsg = "'(' required to start ATTLIST enumeration"; 408 break; 409 case XML_ERR_NMTOKEN_REQUIRED: 410 errmsg = "NmToken expected in ATTLIST enumeration"; 411 break; 412 case XML_ERR_ATTLIST_NOT_FINISHED: 413 errmsg = "')' required to finish ATTLIST enumeration"; 414 break; 415 case XML_ERR_MIXED_NOT_STARTED: 416 errmsg = "MixedContentDecl : '|' or ')*' expected"; 417 break; 418 case XML_ERR_PCDATA_REQUIRED: 419 errmsg = "MixedContentDecl : '#PCDATA' expected"; 420 break; 421 case XML_ERR_ELEMCONTENT_NOT_STARTED: 422 errmsg = "ContentDecl : Name or '(' expected"; 423 break; 424 case XML_ERR_ELEMCONTENT_NOT_FINISHED: 425 errmsg = "ContentDecl : ',' '|' or ')' expected"; 426 break; 427 case XML_ERR_PEREF_IN_INT_SUBSET: 428 errmsg = 429 "PEReference: forbidden within markup decl in internal subset"; 430 break; 431 case XML_ERR_GT_REQUIRED: 432 errmsg = "expected '>'"; 433 break; 434 case XML_ERR_CONDSEC_INVALID: 435 errmsg = "XML conditional section '[' expected"; 436 break; 437 case XML_ERR_EXT_SUBSET_NOT_FINISHED: 438 errmsg = "Content error in the external subset"; 439 break; 440 case XML_ERR_CONDSEC_INVALID_KEYWORD: 441 errmsg = 442 "conditional section INCLUDE or IGNORE keyword expected"; 443 break; 444 case XML_ERR_CONDSEC_NOT_FINISHED: 445 errmsg = "XML conditional section not closed"; 446 break; 447 case XML_ERR_XMLDECL_NOT_STARTED: 448 errmsg = "Text declaration '<?xml' required"; 449 break; 450 case XML_ERR_XMLDECL_NOT_FINISHED: 451 errmsg = "parsing XML declaration: '?>' expected"; 452 break; 453 case XML_ERR_EXT_ENTITY_STANDALONE: 454 errmsg = "external parsed entities cannot be standalone"; 455 break; 456 case XML_ERR_ENTITYREF_SEMICOL_MISSING: 457 errmsg = "EntityRef: expecting ';'"; 458 break; 459 case XML_ERR_DOCTYPE_NOT_FINISHED: 460 errmsg = "DOCTYPE improperly terminated"; 461 break; 462 case XML_ERR_LTSLASH_REQUIRED: 463 errmsg = "EndTag: '</' not found"; 464 break; 465 case XML_ERR_EQUAL_REQUIRED: 466 errmsg = "expected '='"; 467 break; 468 case XML_ERR_STRING_NOT_CLOSED: 469 errmsg = "String not closed expecting \" or '"; 470 break; 471 case XML_ERR_STRING_NOT_STARTED: 472 errmsg = "String not started expecting ' or \""; 473 break; 474 case XML_ERR_ENCODING_NAME: 475 errmsg = "Invalid XML encoding name"; 476 break; 477 case XML_ERR_STANDALONE_VALUE: 478 errmsg = "standalone accepts only 'yes' or 'no'"; 479 break; 480 case XML_ERR_DOCUMENT_EMPTY: 481 errmsg = "Document is empty"; 482 break; 483 case XML_ERR_DOCUMENT_END: 484 errmsg = "Extra content at the end of the document"; 485 break; 486 case XML_ERR_NOT_WELL_BALANCED: 487 errmsg = "chunk is not well balanced"; 488 break; 489 case XML_ERR_EXTRA_CONTENT: 490 errmsg = "extra content at the end of well balanced chunk"; 491 break; 492 case XML_ERR_VERSION_MISSING: 493 errmsg = "Malformed declaration expecting version"; 494 break; 495 case XML_ERR_NAME_TOO_LONG: 496 errmsg = "Name too long use XML_PARSE_HUGE option"; 497 break; 498 #if 0 499 case: 500 errmsg = ""; 501 break; 502 #endif 503 default: 504 errmsg = "Unregistered error message"; 505 } 506 if (info == NULL) 507 snprintf(errstr, 128, "%s\n", errmsg); 508 else 509 snprintf(errstr, 128, "%s: %%s\n", errmsg); 510 if (ctxt != NULL) 511 ctxt->errNo = error; 512 __xmlRaiseError(NULL, NULL, NULL, ctxt, NULL, XML_FROM_PARSER, error, 513 XML_ERR_FATAL, NULL, 0, info, NULL, NULL, 0, 0, &errstr[0], 514 info); 515 if (ctxt != NULL) { 516 ctxt->wellFormed = 0; 517 if (ctxt->recovery == 0) 518 ctxt->disableSAX = 1; 519 } 520 } 521 522 /** 523 * xmlFatalErrMsg: 524 * @ctxt: an XML parser context 525 * @error: the error number 526 * @msg: the error message 527 * 528 * Handle a fatal parser error, i.e. violating Well-Formedness constraints 529 */ 530 static void 531 xmlFatalErrMsg(xmlParserCtxtPtr ctxt, xmlParserErrors error, 532 const char *msg) 533 { 534 if ((ctxt != NULL) && (ctxt->disableSAX != 0) && 535 (ctxt->instate == XML_PARSER_EOF)) 536 return; 537 if (ctxt != NULL) 538 ctxt->errNo = error; 539 __xmlRaiseError(NULL, NULL, NULL, ctxt, NULL, XML_FROM_PARSER, error, 540 XML_ERR_FATAL, NULL, 0, NULL, NULL, NULL, 0, 0, "%s", msg); 541 if (ctxt != NULL) { 542 ctxt->wellFormed = 0; 543 if (ctxt->recovery == 0) 544 ctxt->disableSAX = 1; 545 } 546 } 547 548 /** 549 * xmlWarningMsg: 550 * @ctxt: an XML parser context 551 * @error: the error number 552 * @msg: the error message 553 * @str1: extra data 554 * @str2: extra data 555 * 556 * Handle a warning. 557 */ 558 static void 559 xmlWarningMsg(xmlParserCtxtPtr ctxt, xmlParserErrors error, 560 const char *msg, const xmlChar *str1, const xmlChar *str2) 561 { 562 xmlStructuredErrorFunc schannel = NULL; 563 564 if ((ctxt != NULL) && (ctxt->disableSAX != 0) && 565 (ctxt->instate == XML_PARSER_EOF)) 566 return; 567 if ((ctxt != NULL) && (ctxt->sax != NULL) && 568 (ctxt->sax->initialized == XML_SAX2_MAGIC)) 569 schannel = ctxt->sax->serror; 570 if (ctxt != NULL) { 571 __xmlRaiseError(schannel, 572 (ctxt->sax) ? ctxt->sax->warning : NULL, 573 ctxt->userData, 574 ctxt, NULL, XML_FROM_PARSER, error, 575 XML_ERR_WARNING, NULL, 0, 576 (const char *) str1, (const char *) str2, NULL, 0, 0, 577 msg, (const char *) str1, (const char *) str2); 578 } else { 579 __xmlRaiseError(schannel, NULL, NULL, 580 ctxt, NULL, XML_FROM_PARSER, error, 581 XML_ERR_WARNING, NULL, 0, 582 (const char *) str1, (const char *) str2, NULL, 0, 0, 583 msg, (const char *) str1, (const char *) str2); 584 } 585 } 586 587 /** 588 * xmlValidityError: 589 * @ctxt: an XML parser context 590 * @error: the error number 591 * @msg: the error message 592 * @str1: extra data 593 * 594 * Handle a validity error. 595 */ 596 static void 597 xmlValidityError(xmlParserCtxtPtr ctxt, xmlParserErrors error, 598 const char *msg, const xmlChar *str1, const xmlChar *str2) 599 { 600 xmlStructuredErrorFunc schannel = NULL; 601 602 if ((ctxt != NULL) && (ctxt->disableSAX != 0) && 603 (ctxt->instate == XML_PARSER_EOF)) 604 return; 605 if (ctxt != NULL) { 606 ctxt->errNo = error; 607 if ((ctxt->sax != NULL) && (ctxt->sax->initialized == XML_SAX2_MAGIC)) 608 schannel = ctxt->sax->serror; 609 } 610 if (ctxt != NULL) { 611 __xmlRaiseError(schannel, 612 ctxt->vctxt.error, ctxt->vctxt.userData, 613 ctxt, NULL, XML_FROM_DTD, error, 614 XML_ERR_ERROR, NULL, 0, (const char *) str1, 615 (const char *) str2, NULL, 0, 0, 616 msg, (const char *) str1, (const char *) str2); 617 ctxt->valid = 0; 618 } else { 619 __xmlRaiseError(schannel, NULL, NULL, 620 ctxt, NULL, XML_FROM_DTD, error, 621 XML_ERR_ERROR, NULL, 0, (const char *) str1, 622 (const char *) str2, NULL, 0, 0, 623 msg, (const char *) str1, (const char *) str2); 624 } 625 } 626 627 /** 628 * xmlFatalErrMsgInt: 629 * @ctxt: an XML parser context 630 * @error: the error number 631 * @msg: the error message 632 * @val: an integer value 633 * 634 * Handle a fatal parser error, i.e. violating Well-Formedness constraints 635 */ 636 static void 637 xmlFatalErrMsgInt(xmlParserCtxtPtr ctxt, xmlParserErrors error, 638 const char *msg, int val) 639 { 640 if ((ctxt != NULL) && (ctxt->disableSAX != 0) && 641 (ctxt->instate == XML_PARSER_EOF)) 642 return; 643 if (ctxt != NULL) 644 ctxt->errNo = error; 645 __xmlRaiseError(NULL, NULL, NULL, 646 ctxt, NULL, XML_FROM_PARSER, error, XML_ERR_FATAL, 647 NULL, 0, NULL, NULL, NULL, val, 0, msg, val); 648 if (ctxt != NULL) { 649 ctxt->wellFormed = 0; 650 if (ctxt->recovery == 0) 651 ctxt->disableSAX = 1; 652 } 653 } 654 655 /** 656 * xmlFatalErrMsgStrIntStr: 657 * @ctxt: an XML parser context 658 * @error: the error number 659 * @msg: the error message 660 * @str1: an string info 661 * @val: an integer value 662 * @str2: an string info 663 * 664 * Handle a fatal parser error, i.e. violating Well-Formedness constraints 665 */ 666 static void 667 xmlFatalErrMsgStrIntStr(xmlParserCtxtPtr ctxt, xmlParserErrors error, 668 const char *msg, const xmlChar *str1, int val, 669 const xmlChar *str2) 670 { 671 if ((ctxt != NULL) && (ctxt->disableSAX != 0) && 672 (ctxt->instate == XML_PARSER_EOF)) 673 return; 674 if (ctxt != NULL) 675 ctxt->errNo = error; 676 __xmlRaiseError(NULL, NULL, NULL, 677 ctxt, NULL, XML_FROM_PARSER, error, XML_ERR_FATAL, 678 NULL, 0, (const char *) str1, (const char *) str2, 679 NULL, val, 0, msg, str1, val, str2); 680 if (ctxt != NULL) { 681 ctxt->wellFormed = 0; 682 if (ctxt->recovery == 0) 683 ctxt->disableSAX = 1; 684 } 685 } 686 687 /** 688 * xmlFatalErrMsgStr: 689 * @ctxt: an XML parser context 690 * @error: the error number 691 * @msg: the error message 692 * @val: a string value 693 * 694 * Handle a fatal parser error, i.e. violating Well-Formedness constraints 695 */ 696 static void 697 xmlFatalErrMsgStr(xmlParserCtxtPtr ctxt, xmlParserErrors error, 698 const char *msg, const xmlChar * val) 699 { 700 if ((ctxt != NULL) && (ctxt->disableSAX != 0) && 701 (ctxt->instate == XML_PARSER_EOF)) 702 return; 703 if (ctxt != NULL) 704 ctxt->errNo = error; 705 __xmlRaiseError(NULL, NULL, NULL, ctxt, NULL, 706 XML_FROM_PARSER, error, XML_ERR_FATAL, 707 NULL, 0, (const char *) val, NULL, NULL, 0, 0, msg, 708 val); 709 if (ctxt != NULL) { 710 ctxt->wellFormed = 0; 711 if (ctxt->recovery == 0) 712 ctxt->disableSAX = 1; 713 } 714 } 715 716 /** 717 * xmlErrMsgStr: 718 * @ctxt: an XML parser context 719 * @error: the error number 720 * @msg: the error message 721 * @val: a string value 722 * 723 * Handle a non fatal parser error 724 */ 725 static void 726 xmlErrMsgStr(xmlParserCtxtPtr ctxt, xmlParserErrors error, 727 const char *msg, const xmlChar * val) 728 { 729 if ((ctxt != NULL) && (ctxt->disableSAX != 0) && 730 (ctxt->instate == XML_PARSER_EOF)) 731 return; 732 if (ctxt != NULL) 733 ctxt->errNo = error; 734 __xmlRaiseError(NULL, NULL, NULL, ctxt, NULL, 735 XML_FROM_PARSER, error, XML_ERR_ERROR, 736 NULL, 0, (const char *) val, NULL, NULL, 0, 0, msg, 737 val); 738 } 739 740 /** 741 * xmlNsErr: 742 * @ctxt: an XML parser context 743 * @error: the error number 744 * @msg: the message 745 * @info1: extra information string 746 * @info2: extra information string 747 * 748 * Handle a fatal parser error, i.e. violating Well-Formedness constraints 749 */ 750 static void 751 xmlNsErr(xmlParserCtxtPtr ctxt, xmlParserErrors error, 752 const char *msg, 753 const xmlChar * info1, const xmlChar * info2, 754 const xmlChar * info3) 755 { 756 if ((ctxt != NULL) && (ctxt->disableSAX != 0) && 757 (ctxt->instate == XML_PARSER_EOF)) 758 return; 759 if (ctxt != NULL) 760 ctxt->errNo = error; 761 __xmlRaiseError(NULL, NULL, NULL, ctxt, NULL, XML_FROM_NAMESPACE, error, 762 XML_ERR_ERROR, NULL, 0, (const char *) info1, 763 (const char *) info2, (const char *) info3, 0, 0, msg, 764 info1, info2, info3); 765 if (ctxt != NULL) 766 ctxt->nsWellFormed = 0; 767 } 768 769 /** 770 * xmlNsWarn 771 * @ctxt: an XML parser context 772 * @error: the error number 773 * @msg: the message 774 * @info1: extra information string 775 * @info2: extra information string 776 * 777 * Handle a namespace warning error 778 */ 779 static void 780 xmlNsWarn(xmlParserCtxtPtr ctxt, xmlParserErrors error, 781 const char *msg, 782 const xmlChar * info1, const xmlChar * info2, 783 const xmlChar * info3) 784 { 785 if ((ctxt != NULL) && (ctxt->disableSAX != 0) && 786 (ctxt->instate == XML_PARSER_EOF)) 787 return; 788 __xmlRaiseError(NULL, NULL, NULL, ctxt, NULL, XML_FROM_NAMESPACE, error, 789 XML_ERR_WARNING, NULL, 0, (const char *) info1, 790 (const char *) info2, (const char *) info3, 0, 0, msg, 791 info1, info2, info3); 792 } 793 794 /************************************************************************ 795 * * 796 * Library wide options * 797 * * 798 ************************************************************************/ 799 800 /** 801 * xmlHasFeature: 802 * @feature: the feature to be examined 803 * 804 * Examines if the library has been compiled with a given feature. 805 * 806 * Returns a non-zero value if the feature exist, otherwise zero. 807 * Returns zero (0) if the feature does not exist or an unknown 808 * unknown feature is requested, non-zero otherwise. 809 */ 810 int 811 xmlHasFeature(xmlFeature feature) 812 { 813 switch (feature) { 814 case XML_WITH_THREAD: 815 #ifdef LIBXML_THREAD_ENABLED 816 return(1); 817 #else 818 return(0); 819 #endif 820 case XML_WITH_TREE: 821 #ifdef LIBXML_TREE_ENABLED 822 return(1); 823 #else 824 return(0); 825 #endif 826 case XML_WITH_OUTPUT: 827 #ifdef LIBXML_OUTPUT_ENABLED 828 return(1); 829 #else 830 return(0); 831 #endif 832 case XML_WITH_PUSH: 833 #ifdef LIBXML_PUSH_ENABLED 834 return(1); 835 #else 836 return(0); 837 #endif 838 case XML_WITH_READER: 839 #ifdef LIBXML_READER_ENABLED 840 return(1); 841 #else 842 return(0); 843 #endif 844 case XML_WITH_PATTERN: 845 #ifdef LIBXML_PATTERN_ENABLED 846 return(1); 847 #else 848 return(0); 849 #endif 850 case XML_WITH_WRITER: 851 #ifdef LIBXML_WRITER_ENABLED 852 return(1); 853 #else 854 return(0); 855 #endif 856 case XML_WITH_SAX1: 857 #ifdef LIBXML_SAX1_ENABLED 858 return(1); 859 #else 860 return(0); 861 #endif 862 case XML_WITH_FTP: 863 #ifdef LIBXML_FTP_ENABLED 864 return(1); 865 #else 866 return(0); 867 #endif 868 case XML_WITH_HTTP: 869 #ifdef LIBXML_HTTP_ENABLED 870 return(1); 871 #else 872 return(0); 873 #endif 874 case XML_WITH_VALID: 875 #ifdef LIBXML_VALID_ENABLED 876 return(1); 877 #else 878 return(0); 879 #endif 880 case XML_WITH_HTML: 881 #ifdef LIBXML_HTML_ENABLED 882 return(1); 883 #else 884 return(0); 885 #endif 886 case XML_WITH_LEGACY: 887 #ifdef LIBXML_LEGACY_ENABLED 888 return(1); 889 #else 890 return(0); 891 #endif 892 case XML_WITH_C14N: 893 #ifdef LIBXML_C14N_ENABLED 894 return(1); 895 #else 896 return(0); 897 #endif 898 case XML_WITH_CATALOG: 899 #ifdef LIBXML_CATALOG_ENABLED 900 return(1); 901 #else 902 return(0); 903 #endif 904 case XML_WITH_XPATH: 905 #ifdef LIBXML_XPATH_ENABLED 906 return(1); 907 #else 908 return(0); 909 #endif 910 case XML_WITH_XPTR: 911 #ifdef LIBXML_XPTR_ENABLED 912 return(1); 913 #else 914 return(0); 915 #endif 916 case XML_WITH_XINCLUDE: 917 #ifdef LIBXML_XINCLUDE_ENABLED 918 return(1); 919 #else 920 return(0); 921 #endif 922 case XML_WITH_ICONV: 923 #ifdef LIBXML_ICONV_ENABLED 924 return(1); 925 #else 926 return(0); 927 #endif 928 case XML_WITH_ISO8859X: 929 #ifdef LIBXML_ISO8859X_ENABLED 930 return(1); 931 #else 932 return(0); 933 #endif 934 case XML_WITH_UNICODE: 935 #ifdef LIBXML_UNICODE_ENABLED 936 return(1); 937 #else 938 return(0); 939 #endif 940 case XML_WITH_REGEXP: 941 #ifdef LIBXML_REGEXP_ENABLED 942 return(1); 943 #else 944 return(0); 945 #endif 946 case XML_WITH_AUTOMATA: 947 #ifdef LIBXML_AUTOMATA_ENABLED 948 return(1); 949 #else 950 return(0); 951 #endif 952 case XML_WITH_EXPR: 953 #ifdef LIBXML_EXPR_ENABLED 954 return(1); 955 #else 956 return(0); 957 #endif 958 case XML_WITH_SCHEMAS: 959 #ifdef LIBXML_SCHEMAS_ENABLED 960 return(1); 961 #else 962 return(0); 963 #endif 964 case XML_WITH_SCHEMATRON: 965 #ifdef LIBXML_SCHEMATRON_ENABLED 966 return(1); 967 #else 968 return(0); 969 #endif 970 case XML_WITH_MODULES: 971 #ifdef LIBXML_MODULES_ENABLED 972 return(1); 973 #else 974 return(0); 975 #endif 976 case XML_WITH_DEBUG: 977 #ifdef LIBXML_DEBUG_ENABLED 978 return(1); 979 #else 980 return(0); 981 #endif 982 case XML_WITH_DEBUG_MEM: 983 #ifdef DEBUG_MEMORY_LOCATION 984 return(1); 985 #else 986 return(0); 987 #endif 988 case XML_WITH_DEBUG_RUN: 989 #ifdef LIBXML_DEBUG_RUNTIME 990 return(1); 991 #else 992 return(0); 993 #endif 994 case XML_WITH_ZLIB: 995 #ifdef LIBXML_ZLIB_ENABLED 996 return(1); 997 #else 998 return(0); 999 #endif 1000 case XML_WITH_LZMA: 1001 #ifdef LIBXML_LZMA_ENABLED 1002 return(1); 1003 #else 1004 return(0); 1005 #endif 1006 case XML_WITH_ICU: 1007 #ifdef LIBXML_ICU_ENABLED 1008 return(1); 1009 #else 1010 return(0); 1011 #endif 1012 default: 1013 break; 1014 } 1015 return(0); 1016 } 1017 1018 /************************************************************************ 1019 * * 1020 * SAX2 defaulted attributes handling * 1021 * * 1022 ************************************************************************/ 1023 1024 /** 1025 * xmlDetectSAX2: 1026 * @ctxt: an XML parser context 1027 * 1028 * Do the SAX2 detection and specific intialization 1029 */ 1030 static void 1031 xmlDetectSAX2(xmlParserCtxtPtr ctxt) { 1032 if (ctxt == NULL) return; 1033 #ifdef LIBXML_SAX1_ENABLED 1034 if ((ctxt->sax) && (ctxt->sax->initialized == XML_SAX2_MAGIC) && 1035 ((ctxt->sax->startElementNs != NULL) || 1036 (ctxt->sax->endElementNs != NULL))) ctxt->sax2 = 1; 1037 #else 1038 ctxt->sax2 = 1; 1039 #endif /* LIBXML_SAX1_ENABLED */ 1040 1041 ctxt->str_xml = xmlDictLookup(ctxt->dict, BAD_CAST "xml", 3); 1042 ctxt->str_xmlns = xmlDictLookup(ctxt->dict, BAD_CAST "xmlns", 5); 1043 ctxt->str_xml_ns = xmlDictLookup(ctxt->dict, XML_XML_NAMESPACE, 36); 1044 if ((ctxt->str_xml==NULL) || (ctxt->str_xmlns==NULL) || 1045 (ctxt->str_xml_ns == NULL)) { 1046 xmlErrMemory(ctxt, NULL); 1047 } 1048 } 1049 1050 typedef struct _xmlDefAttrs xmlDefAttrs; 1051 typedef xmlDefAttrs *xmlDefAttrsPtr; 1052 struct _xmlDefAttrs { 1053 int nbAttrs; /* number of defaulted attributes on that element */ 1054 int maxAttrs; /* the size of the array */ 1055 const xmlChar *values[5]; /* array of localname/prefix/values/external */ 1056 }; 1057 1058 /** 1059 * xmlAttrNormalizeSpace: 1060 * @src: the source string 1061 * @dst: the target string 1062 * 1063 * Normalize the space in non CDATA attribute values: 1064 * If the attribute type is not CDATA, then the XML processor MUST further 1065 * process the normalized attribute value by discarding any leading and 1066 * trailing space (#x20) characters, and by replacing sequences of space 1067 * (#x20) characters by a single space (#x20) character. 1068 * Note that the size of dst need to be at least src, and if one doesn't need 1069 * to preserve dst (and it doesn't come from a dictionary or read-only) then 1070 * passing src as dst is just fine. 1071 * 1072 * Returns a pointer to the normalized value (dst) or NULL if no conversion 1073 * is needed. 1074 */ 1075 static xmlChar * 1076 xmlAttrNormalizeSpace(const xmlChar *src, xmlChar *dst) 1077 { 1078 if ((src == NULL) || (dst == NULL)) 1079 return(NULL); 1080 1081 while (*src == 0x20) src++; 1082 while (*src != 0) { 1083 if (*src == 0x20) { 1084 while (*src == 0x20) src++; 1085 if (*src != 0) 1086 *dst++ = 0x20; 1087 } else { 1088 *dst++ = *src++; 1089 } 1090 } 1091 *dst = 0; 1092 if (dst == src) 1093 return(NULL); 1094 return(dst); 1095 } 1096 1097 /** 1098 * xmlAttrNormalizeSpace2: 1099 * @src: the source string 1100 * 1101 * Normalize the space in non CDATA attribute values, a slightly more complex 1102 * front end to avoid allocation problems when running on attribute values 1103 * coming from the input. 1104 * 1105 * Returns a pointer to the normalized value (dst) or NULL if no conversion 1106 * is needed. 1107 */ 1108 static const xmlChar * 1109 xmlAttrNormalizeSpace2(xmlParserCtxtPtr ctxt, xmlChar *src, int *len) 1110 { 1111 int i; 1112 int remove_head = 0; 1113 int need_realloc = 0; 1114 const xmlChar *cur; 1115 1116 if ((ctxt == NULL) || (src == NULL) || (len == NULL)) 1117 return(NULL); 1118 i = *len; 1119 if (i <= 0) 1120 return(NULL); 1121 1122 cur = src; 1123 while (*cur == 0x20) { 1124 cur++; 1125 remove_head++; 1126 } 1127 while (*cur != 0) { 1128 if (*cur == 0x20) { 1129 cur++; 1130 if ((*cur == 0x20) || (*cur == 0)) { 1131 need_realloc = 1; 1132 break; 1133 } 1134 } else 1135 cur++; 1136 } 1137 if (need_realloc) { 1138 xmlChar *ret; 1139 1140 ret = xmlStrndup(src + remove_head, i - remove_head + 1); 1141 if (ret == NULL) { 1142 xmlErrMemory(ctxt, NULL); 1143 return(NULL); 1144 } 1145 xmlAttrNormalizeSpace(ret, ret); 1146 *len = (int) strlen((const char *)ret); 1147 return(ret); 1148 } else if (remove_head) { 1149 *len -= remove_head; 1150 memmove(src, src + remove_head, 1 + *len); 1151 return(src); 1152 } 1153 return(NULL); 1154 } 1155 1156 /** 1157 * xmlAddDefAttrs: 1158 * @ctxt: an XML parser context 1159 * @fullname: the element fullname 1160 * @fullattr: the attribute fullname 1161 * @value: the attribute value 1162 * 1163 * Add a defaulted attribute for an element 1164 */ 1165 static void 1166 xmlAddDefAttrs(xmlParserCtxtPtr ctxt, 1167 const xmlChar *fullname, 1168 const xmlChar *fullattr, 1169 const xmlChar *value) { 1170 xmlDefAttrsPtr defaults; 1171 int len; 1172 const xmlChar *name; 1173 const xmlChar *prefix; 1174 1175 /* 1176 * Allows to detect attribute redefinitions 1177 */ 1178 if (ctxt->attsSpecial != NULL) { 1179 if (xmlHashLookup2(ctxt->attsSpecial, fullname, fullattr) != NULL) 1180 return; 1181 } 1182 1183 if (ctxt->attsDefault == NULL) { 1184 ctxt->attsDefault = xmlHashCreateDict(10, ctxt->dict); 1185 if (ctxt->attsDefault == NULL) 1186 goto mem_error; 1187 } 1188 1189 /* 1190 * split the element name into prefix:localname , the string found 1191 * are within the DTD and then not associated to namespace names. 1192 */ 1193 name = xmlSplitQName3(fullname, &len); 1194 if (name == NULL) { 1195 name = xmlDictLookup(ctxt->dict, fullname, -1); 1196 prefix = NULL; 1197 } else { 1198 name = xmlDictLookup(ctxt->dict, name, -1); 1199 prefix = xmlDictLookup(ctxt->dict, fullname, len); 1200 } 1201 1202 /* 1203 * make sure there is some storage 1204 */ 1205 defaults = xmlHashLookup2(ctxt->attsDefault, name, prefix); 1206 if (defaults == NULL) { 1207 defaults = (xmlDefAttrsPtr) xmlMalloc(sizeof(xmlDefAttrs) + 1208 (4 * 5) * sizeof(const xmlChar *)); 1209 if (defaults == NULL) 1210 goto mem_error; 1211 defaults->nbAttrs = 0; 1212 defaults->maxAttrs = 4; 1213 if (xmlHashUpdateEntry2(ctxt->attsDefault, name, prefix, 1214 defaults, NULL) < 0) { 1215 xmlFree(defaults); 1216 goto mem_error; 1217 } 1218 } else if (defaults->nbAttrs >= defaults->maxAttrs) { 1219 xmlDefAttrsPtr temp; 1220 1221 temp = (xmlDefAttrsPtr) xmlRealloc(defaults, sizeof(xmlDefAttrs) + 1222 (2 * defaults->maxAttrs * 5) * sizeof(const xmlChar *)); 1223 if (temp == NULL) 1224 goto mem_error; 1225 defaults = temp; 1226 defaults->maxAttrs *= 2; 1227 if (xmlHashUpdateEntry2(ctxt->attsDefault, name, prefix, 1228 defaults, NULL) < 0) { 1229 xmlFree(defaults); 1230 goto mem_error; 1231 } 1232 } 1233 1234 /* 1235 * Split the element name into prefix:localname , the string found 1236 * are within the DTD and hen not associated to namespace names. 1237 */ 1238 name = xmlSplitQName3(fullattr, &len); 1239 if (name == NULL) { 1240 name = xmlDictLookup(ctxt->dict, fullattr, -1); 1241 prefix = NULL; 1242 } else { 1243 name = xmlDictLookup(ctxt->dict, name, -1); 1244 prefix = xmlDictLookup(ctxt->dict, fullattr, len); 1245 } 1246 1247 defaults->values[5 * defaults->nbAttrs] = name; 1248 defaults->values[5 * defaults->nbAttrs + 1] = prefix; 1249 /* intern the string and precompute the end */ 1250 len = xmlStrlen(value); 1251 value = xmlDictLookup(ctxt->dict, value, len); 1252 defaults->values[5 * defaults->nbAttrs + 2] = value; 1253 defaults->values[5 * defaults->nbAttrs + 3] = value + len; 1254 if (ctxt->external) 1255 defaults->values[5 * defaults->nbAttrs + 4] = BAD_CAST "external"; 1256 else 1257 defaults->values[5 * defaults->nbAttrs + 4] = NULL; 1258 defaults->nbAttrs++; 1259 1260 return; 1261 1262 mem_error: 1263 xmlErrMemory(ctxt, NULL); 1264 return; 1265 } 1266 1267 /** 1268 * xmlAddSpecialAttr: 1269 * @ctxt: an XML parser context 1270 * @fullname: the element fullname 1271 * @fullattr: the attribute fullname 1272 * @type: the attribute type 1273 * 1274 * Register this attribute type 1275 */ 1276 static void 1277 xmlAddSpecialAttr(xmlParserCtxtPtr ctxt, 1278 const xmlChar *fullname, 1279 const xmlChar *fullattr, 1280 int type) 1281 { 1282 if (ctxt->attsSpecial == NULL) { 1283 ctxt->attsSpecial = xmlHashCreateDict(10, ctxt->dict); 1284 if (ctxt->attsSpecial == NULL) 1285 goto mem_error; 1286 } 1287 1288 if (xmlHashLookup2(ctxt->attsSpecial, fullname, fullattr) != NULL) 1289 return; 1290 1291 xmlHashAddEntry2(ctxt->attsSpecial, fullname, fullattr, 1292 (void *) (long) type); 1293 return; 1294 1295 mem_error: 1296 xmlErrMemory(ctxt, NULL); 1297 return; 1298 } 1299 1300 /** 1301 * xmlCleanSpecialAttrCallback: 1302 * 1303 * Removes CDATA attributes from the special attribute table 1304 */ 1305 static void 1306 xmlCleanSpecialAttrCallback(void *payload, void *data, 1307 const xmlChar *fullname, const xmlChar *fullattr, 1308 const xmlChar *unused ATTRIBUTE_UNUSED) { 1309 xmlParserCtxtPtr ctxt = (xmlParserCtxtPtr) data; 1310 1311 if (((long) payload) == XML_ATTRIBUTE_CDATA) { 1312 xmlHashRemoveEntry2(ctxt->attsSpecial, fullname, fullattr, NULL); 1313 } 1314 } 1315 1316 /** 1317 * xmlCleanSpecialAttr: 1318 * @ctxt: an XML parser context 1319 * 1320 * Trim the list of attributes defined to remove all those of type 1321 * CDATA as they are not special. This call should be done when finishing 1322 * to parse the DTD and before starting to parse the document root. 1323 */ 1324 static void 1325 xmlCleanSpecialAttr(xmlParserCtxtPtr ctxt) 1326 { 1327 if (ctxt->attsSpecial == NULL) 1328 return; 1329 1330 xmlHashScanFull(ctxt->attsSpecial, xmlCleanSpecialAttrCallback, ctxt); 1331 1332 if (xmlHashSize(ctxt->attsSpecial) == 0) { 1333 xmlHashFree(ctxt->attsSpecial, NULL); 1334 ctxt->attsSpecial = NULL; 1335 } 1336 return; 1337 } 1338 1339 /** 1340 * xmlCheckLanguageID: 1341 * @lang: pointer to the string value 1342 * 1343 * Checks that the value conforms to the LanguageID production: 1344 * 1345 * NOTE: this is somewhat deprecated, those productions were removed from 1346 * the XML Second edition. 1347 * 1348 * [33] LanguageID ::= Langcode ('-' Subcode)* 1349 * [34] Langcode ::= ISO639Code | IanaCode | UserCode 1350 * [35] ISO639Code ::= ([a-z] | [A-Z]) ([a-z] | [A-Z]) 1351 * [36] IanaCode ::= ('i' | 'I') '-' ([a-z] | [A-Z])+ 1352 * [37] UserCode ::= ('x' | 'X') '-' ([a-z] | [A-Z])+ 1353 * [38] Subcode ::= ([a-z] | [A-Z])+ 1354 * 1355 * The current REC reference the sucessors of RFC 1766, currently 5646 1356 * 1357 * http://www.rfc-editor.org/rfc/rfc5646.txt 1358 * langtag = language 1359 * ["-" script] 1360 * ["-" region] 1361 * *("-" variant) 1362 * *("-" extension) 1363 * ["-" privateuse] 1364 * language = 2*3ALPHA ; shortest ISO 639 code 1365 * ["-" extlang] ; sometimes followed by 1366 * ; extended language subtags 1367 * / 4ALPHA ; or reserved for future use 1368 * / 5*8ALPHA ; or registered language subtag 1369 * 1370 * extlang = 3ALPHA ; selected ISO 639 codes 1371 * *2("-" 3ALPHA) ; permanently reserved 1372 * 1373 * script = 4ALPHA ; ISO 15924 code 1374 * 1375 * region = 2ALPHA ; ISO 3166-1 code 1376 * / 3DIGIT ; UN M.49 code 1377 * 1378 * variant = 5*8alphanum ; registered variants 1379 * / (DIGIT 3alphanum) 1380 * 1381 * extension = singleton 1*("-" (2*8alphanum)) 1382 * 1383 * ; Single alphanumerics 1384 * ; "x" reserved for private use 1385 * singleton = DIGIT ; 0 - 9 1386 * / %x41-57 ; A - W 1387 * / %x59-5A ; Y - Z 1388 * / %x61-77 ; a - w 1389 * / %x79-7A ; y - z 1390 * 1391 * it sounds right to still allow Irregular i-xxx IANA and user codes too 1392 * The parser below doesn't try to cope with extension or privateuse 1393 * that could be added but that's not interoperable anyway 1394 * 1395 * Returns 1 if correct 0 otherwise 1396 **/ 1397 int 1398 xmlCheckLanguageID(const xmlChar * lang) 1399 { 1400 const xmlChar *cur = lang, *nxt; 1401 1402 if (cur == NULL) 1403 return (0); 1404 if (((cur[0] == 'i') && (cur[1] == '-')) || 1405 ((cur[0] == 'I') && (cur[1] == '-')) || 1406 ((cur[0] == 'x') && (cur[1] == '-')) || 1407 ((cur[0] == 'X') && (cur[1] == '-'))) { 1408 /* 1409 * Still allow IANA code and user code which were coming 1410 * from the previous version of the XML-1.0 specification 1411 * it's deprecated but we should not fail 1412 */ 1413 cur += 2; 1414 while (((cur[0] >= 'A') && (cur[0] <= 'Z')) || 1415 ((cur[0] >= 'a') && (cur[0] <= 'z'))) 1416 cur++; 1417 return(cur[0] == 0); 1418 } 1419 nxt = cur; 1420 while (((nxt[0] >= 'A') && (nxt[0] <= 'Z')) || 1421 ((nxt[0] >= 'a') && (nxt[0] <= 'z'))) 1422 nxt++; 1423 if (nxt - cur >= 4) { 1424 /* 1425 * Reserved 1426 */ 1427 if ((nxt - cur > 8) || (nxt[0] != 0)) 1428 return(0); 1429 return(1); 1430 } 1431 if (nxt - cur < 2) 1432 return(0); 1433 /* we got an ISO 639 code */ 1434 if (nxt[0] == 0) 1435 return(1); 1436 if (nxt[0] != '-') 1437 return(0); 1438 1439 nxt++; 1440 cur = nxt; 1441 /* now we can have extlang or script or region or variant */ 1442 if ((nxt[0] >= '0') && (nxt[0] <= '9')) 1443 goto region_m49; 1444 1445 while (((nxt[0] >= 'A') && (nxt[0] <= 'Z')) || 1446 ((nxt[0] >= 'a') && (nxt[0] <= 'z'))) 1447 nxt++; 1448 if (nxt - cur == 4) 1449 goto script; 1450 if (nxt - cur == 2) 1451 goto region; 1452 if ((nxt - cur >= 5) && (nxt - cur <= 8)) 1453 goto variant; 1454 if (nxt - cur != 3) 1455 return(0); 1456 /* we parsed an extlang */ 1457 if (nxt[0] == 0) 1458 return(1); 1459 if (nxt[0] != '-') 1460 return(0); 1461 1462 nxt++; 1463 cur = nxt; 1464 /* now we can have script or region or variant */ 1465 if ((nxt[0] >= '0') && (nxt[0] <= '9')) 1466 goto region_m49; 1467 1468 while (((nxt[0] >= 'A') && (nxt[0] <= 'Z')) || 1469 ((nxt[0] >= 'a') && (nxt[0] <= 'z'))) 1470 nxt++; 1471 if (nxt - cur == 2) 1472 goto region; 1473 if ((nxt - cur >= 5) && (nxt - cur <= 8)) 1474 goto variant; 1475 if (nxt - cur != 4) 1476 return(0); 1477 /* we parsed a script */ 1478 script: 1479 if (nxt[0] == 0) 1480 return(1); 1481 if (nxt[0] != '-') 1482 return(0); 1483 1484 nxt++; 1485 cur = nxt; 1486 /* now we can have region or variant */ 1487 if ((nxt[0] >= '0') && (nxt[0] <= '9')) 1488 goto region_m49; 1489 1490 while (((nxt[0] >= 'A') && (nxt[0] <= 'Z')) || 1491 ((nxt[0] >= 'a') && (nxt[0] <= 'z'))) 1492 nxt++; 1493 1494 if ((nxt - cur >= 5) && (nxt - cur <= 8)) 1495 goto variant; 1496 if (nxt - cur != 2) 1497 return(0); 1498 /* we parsed a region */ 1499 region: 1500 if (nxt[0] == 0) 1501 return(1); 1502 if (nxt[0] != '-') 1503 return(0); 1504 1505 nxt++; 1506 cur = nxt; 1507 /* now we can just have a variant */ 1508 while (((nxt[0] >= 'A') && (nxt[0] <= 'Z')) || 1509 ((nxt[0] >= 'a') && (nxt[0] <= 'z'))) 1510 nxt++; 1511 1512 if ((nxt - cur < 5) || (nxt - cur > 8)) 1513 return(0); 1514 1515 /* we parsed a variant */ 1516 variant: 1517 if (nxt[0] == 0) 1518 return(1); 1519 if (nxt[0] != '-') 1520 return(0); 1521 /* extensions and private use subtags not checked */ 1522 return (1); 1523 1524 region_m49: 1525 if (((nxt[1] >= '0') && (nxt[1] <= '9')) && 1526 ((nxt[2] >= '0') && (nxt[2] <= '9'))) { 1527 nxt += 3; 1528 goto region; 1529 } 1530 return(0); 1531 } 1532 1533 /************************************************************************ 1534 * * 1535 * Parser stacks related functions and macros * 1536 * * 1537 ************************************************************************/ 1538 1539 static xmlEntityPtr xmlParseStringEntityRef(xmlParserCtxtPtr ctxt, 1540 const xmlChar ** str); 1541 1542 #ifdef SAX2 1543 /** 1544 * nsPush: 1545 * @ctxt: an XML parser context 1546 * @prefix: the namespace prefix or NULL 1547 * @URL: the namespace name 1548 * 1549 * Pushes a new parser namespace on top of the ns stack 1550 * 1551 * Returns -1 in case of error, -2 if the namespace should be discarded 1552 * and the index in the stack otherwise. 1553 */ 1554 static int 1555 nsPush(xmlParserCtxtPtr ctxt, const xmlChar *prefix, const xmlChar *URL) 1556 { 1557 if (ctxt->options & XML_PARSE_NSCLEAN) { 1558 int i; 1559 for (i = ctxt->nsNr - 2;i >= 0;i -= 2) { 1560 if (ctxt->nsTab[i] == prefix) { 1561 /* in scope */ 1562 if (ctxt->nsTab[i + 1] == URL) 1563 return(-2); 1564 /* out of scope keep it */ 1565 break; 1566 } 1567 } 1568 } 1569 if ((ctxt->nsMax == 0) || (ctxt->nsTab == NULL)) { 1570 ctxt->nsMax = 10; 1571 ctxt->nsNr = 0; 1572 ctxt->nsTab = (const xmlChar **) 1573 xmlMalloc(ctxt->nsMax * sizeof(xmlChar *)); 1574 if (ctxt->nsTab == NULL) { 1575 xmlErrMemory(ctxt, NULL); 1576 ctxt->nsMax = 0; 1577 return (-1); 1578 } 1579 } else if (ctxt->nsNr >= ctxt->nsMax) { 1580 const xmlChar ** tmp; 1581 ctxt->nsMax *= 2; 1582 tmp = (const xmlChar **) xmlRealloc((char *) ctxt->nsTab, 1583 ctxt->nsMax * sizeof(ctxt->nsTab[0])); 1584 if (tmp == NULL) { 1585 xmlErrMemory(ctxt, NULL); 1586 ctxt->nsMax /= 2; 1587 return (-1); 1588 } 1589 ctxt->nsTab = tmp; 1590 } 1591 ctxt->nsTab[ctxt->nsNr++] = prefix; 1592 ctxt->nsTab[ctxt->nsNr++] = URL; 1593 return (ctxt->nsNr); 1594 } 1595 /** 1596 * nsPop: 1597 * @ctxt: an XML parser context 1598 * @nr: the number to pop 1599 * 1600 * Pops the top @nr parser prefix/namespace from the ns stack 1601 * 1602 * Returns the number of namespaces removed 1603 */ 1604 static int 1605 nsPop(xmlParserCtxtPtr ctxt, int nr) 1606 { 1607 int i; 1608 1609 if (ctxt->nsTab == NULL) return(0); 1610 if (ctxt->nsNr < nr) { 1611 xmlGenericError(xmlGenericErrorContext, "Pbm popping %d NS\n", nr); 1612 nr = ctxt->nsNr; 1613 } 1614 if (ctxt->nsNr <= 0) 1615 return (0); 1616 1617 for (i = 0;i < nr;i++) { 1618 ctxt->nsNr--; 1619 ctxt->nsTab[ctxt->nsNr] = NULL; 1620 } 1621 return(nr); 1622 } 1623 #endif 1624 1625 static int 1626 xmlCtxtGrowAttrs(xmlParserCtxtPtr ctxt, int nr) { 1627 const xmlChar **atts; 1628 int *attallocs; 1629 int maxatts; 1630 1631 if (ctxt->atts == NULL) { 1632 maxatts = 55; /* allow for 10 attrs by default */ 1633 atts = (const xmlChar **) 1634 xmlMalloc(maxatts * sizeof(xmlChar *)); 1635 if (atts == NULL) goto mem_error; 1636 ctxt->atts = atts; 1637 attallocs = (int *) xmlMalloc((maxatts / 5) * sizeof(int)); 1638 if (attallocs == NULL) goto mem_error; 1639 ctxt->attallocs = attallocs; 1640 ctxt->maxatts = maxatts; 1641 } else if (nr + 5 > ctxt->maxatts) { 1642 maxatts = (nr + 5) * 2; 1643 atts = (const xmlChar **) xmlRealloc((void *) ctxt->atts, 1644 maxatts * sizeof(const xmlChar *)); 1645 if (atts == NULL) goto mem_error; 1646 ctxt->atts = atts; 1647 attallocs = (int *) xmlRealloc((void *) ctxt->attallocs, 1648 (maxatts / 5) * sizeof(int)); 1649 if (attallocs == NULL) goto mem_error; 1650 ctxt->attallocs = attallocs; 1651 ctxt->maxatts = maxatts; 1652 } 1653 return(ctxt->maxatts); 1654 mem_error: 1655 xmlErrMemory(ctxt, NULL); 1656 return(-1); 1657 } 1658 1659 /** 1660 * inputPush: 1661 * @ctxt: an XML parser context 1662 * @value: the parser input 1663 * 1664 * Pushes a new parser input on top of the input stack 1665 * 1666 * Returns -1 in case of error, the index in the stack otherwise 1667 */ 1668 int 1669 inputPush(xmlParserCtxtPtr ctxt, xmlParserInputPtr value) 1670 { 1671 if ((ctxt == NULL) || (value == NULL)) 1672 return(-1); 1673 if (ctxt->inputNr >= ctxt->inputMax) { 1674 ctxt->inputMax *= 2; 1675 ctxt->inputTab = 1676 (xmlParserInputPtr *) xmlRealloc(ctxt->inputTab, 1677 ctxt->inputMax * 1678 sizeof(ctxt->inputTab[0])); 1679 if (ctxt->inputTab == NULL) { 1680 xmlErrMemory(ctxt, NULL); 1681 xmlFreeInputStream(value); 1682 ctxt->inputMax /= 2; 1683 value = NULL; 1684 return (-1); 1685 } 1686 } 1687 ctxt->inputTab[ctxt->inputNr] = value; 1688 ctxt->input = value; 1689 return (ctxt->inputNr++); 1690 } 1691 /** 1692 * inputPop: 1693 * @ctxt: an XML parser context 1694 * 1695 * Pops the top parser input from the input stack 1696 * 1697 * Returns the input just removed 1698 */ 1699 xmlParserInputPtr 1700 inputPop(xmlParserCtxtPtr ctxt) 1701 { 1702 xmlParserInputPtr ret; 1703 1704 if (ctxt == NULL) 1705 return(NULL); 1706 if (ctxt->inputNr <= 0) 1707 return (NULL); 1708 ctxt->inputNr--; 1709 if (ctxt->inputNr > 0) 1710 ctxt->input = ctxt->inputTab[ctxt->inputNr - 1]; 1711 else 1712 ctxt->input = NULL; 1713 ret = ctxt->inputTab[ctxt->inputNr]; 1714 ctxt->inputTab[ctxt->inputNr] = NULL; 1715 return (ret); 1716 } 1717 /** 1718 * nodePush: 1719 * @ctxt: an XML parser context 1720 * @value: the element node 1721 * 1722 * Pushes a new element node on top of the node stack 1723 * 1724 * Returns -1 in case of error, the index in the stack otherwise 1725 */ 1726 int 1727 nodePush(xmlParserCtxtPtr ctxt, xmlNodePtr value) 1728 { 1729 if (ctxt == NULL) return(0); 1730 if (ctxt->nodeNr >= ctxt->nodeMax) { 1731 xmlNodePtr *tmp; 1732 1733 tmp = (xmlNodePtr *) xmlRealloc(ctxt->nodeTab, 1734 ctxt->nodeMax * 2 * 1735 sizeof(ctxt->nodeTab[0])); 1736 if (tmp == NULL) { 1737 xmlErrMemory(ctxt, NULL); 1738 return (-1); 1739 } 1740 ctxt->nodeTab = tmp; 1741 ctxt->nodeMax *= 2; 1742 } 1743 if ((((unsigned int) ctxt->nodeNr) > xmlParserMaxDepth) && 1744 ((ctxt->options & XML_PARSE_HUGE) == 0)) { 1745 xmlFatalErrMsgInt(ctxt, XML_ERR_INTERNAL_ERROR, 1746 "Excessive depth in document: %d use XML_PARSE_HUGE option\n", 1747 xmlParserMaxDepth); 1748 ctxt->instate = XML_PARSER_EOF; 1749 return(-1); 1750 } 1751 ctxt->nodeTab[ctxt->nodeNr] = value; 1752 ctxt->node = value; 1753 return (ctxt->nodeNr++); 1754 } 1755 1756 /** 1757 * nodePop: 1758 * @ctxt: an XML parser context 1759 * 1760 * Pops the top element node from the node stack 1761 * 1762 * Returns the node just removed 1763 */ 1764 xmlNodePtr 1765 nodePop(xmlParserCtxtPtr ctxt) 1766 { 1767 xmlNodePtr ret; 1768 1769 if (ctxt == NULL) return(NULL); 1770 if (ctxt->nodeNr <= 0) 1771 return (NULL); 1772 ctxt->nodeNr--; 1773 if (ctxt->nodeNr > 0) 1774 ctxt->node = ctxt->nodeTab[ctxt->nodeNr - 1]; 1775 else 1776 ctxt->node = NULL; 1777 ret = ctxt->nodeTab[ctxt->nodeNr]; 1778 ctxt->nodeTab[ctxt->nodeNr] = NULL; 1779 return (ret); 1780 } 1781 1782 #ifdef LIBXML_PUSH_ENABLED 1783 /** 1784 * nameNsPush: 1785 * @ctxt: an XML parser context 1786 * @value: the element name 1787 * @prefix: the element prefix 1788 * @URI: the element namespace name 1789 * 1790 * Pushes a new element name/prefix/URL on top of the name stack 1791 * 1792 * Returns -1 in case of error, the index in the stack otherwise 1793 */ 1794 static int 1795 nameNsPush(xmlParserCtxtPtr ctxt, const xmlChar * value, 1796 const xmlChar *prefix, const xmlChar *URI, int nsNr) 1797 { 1798 if (ctxt->nameNr >= ctxt->nameMax) { 1799 const xmlChar * *tmp; 1800 void **tmp2; 1801 ctxt->nameMax *= 2; 1802 tmp = (const xmlChar * *) xmlRealloc((xmlChar * *)ctxt->nameTab, 1803 ctxt->nameMax * 1804 sizeof(ctxt->nameTab[0])); 1805 if (tmp == NULL) { 1806 ctxt->nameMax /= 2; 1807 goto mem_error; 1808 } 1809 ctxt->nameTab = tmp; 1810 tmp2 = (void **) xmlRealloc((void * *)ctxt->pushTab, 1811 ctxt->nameMax * 3 * 1812 sizeof(ctxt->pushTab[0])); 1813 if (tmp2 == NULL) { 1814 ctxt->nameMax /= 2; 1815 goto mem_error; 1816 } 1817 ctxt->pushTab = tmp2; 1818 } 1819 ctxt->nameTab[ctxt->nameNr] = value; 1820 ctxt->name = value; 1821 ctxt->pushTab[ctxt->nameNr * 3] = (void *) prefix; 1822 ctxt->pushTab[ctxt->nameNr * 3 + 1] = (void *) URI; 1823 ctxt->pushTab[ctxt->nameNr * 3 + 2] = (void *) (long) nsNr; 1824 return (ctxt->nameNr++); 1825 mem_error: 1826 xmlErrMemory(ctxt, NULL); 1827 return (-1); 1828 } 1829 /** 1830 * nameNsPop: 1831 * @ctxt: an XML parser context 1832 * 1833 * Pops the top element/prefix/URI name from the name stack 1834 * 1835 * Returns the name just removed 1836 */ 1837 static const xmlChar * 1838 nameNsPop(xmlParserCtxtPtr ctxt) 1839 { 1840 const xmlChar *ret; 1841 1842 if (ctxt->nameNr <= 0) 1843 return (NULL); 1844 ctxt->nameNr--; 1845 if (ctxt->nameNr > 0) 1846 ctxt->name = ctxt->nameTab[ctxt->nameNr - 1]; 1847 else 1848 ctxt->name = NULL; 1849 ret = ctxt->nameTab[ctxt->nameNr]; 1850 ctxt->nameTab[ctxt->nameNr] = NULL; 1851 return (ret); 1852 } 1853 #endif /* LIBXML_PUSH_ENABLED */ 1854 1855 /** 1856 * namePush: 1857 * @ctxt: an XML parser context 1858 * @value: the element name 1859 * 1860 * Pushes a new element name on top of the name stack 1861 * 1862 * Returns -1 in case of error, the index in the stack otherwise 1863 */ 1864 int 1865 namePush(xmlParserCtxtPtr ctxt, const xmlChar * value) 1866 { 1867 if (ctxt == NULL) return (-1); 1868 1869 if (ctxt->nameNr >= ctxt->nameMax) { 1870 const xmlChar * *tmp; 1871 tmp = (const xmlChar * *) xmlRealloc((xmlChar * *)ctxt->nameTab, 1872 ctxt->nameMax * 2 * 1873 sizeof(ctxt->nameTab[0])); 1874 if (tmp == NULL) { 1875 goto mem_error; 1876 } 1877 ctxt->nameTab = tmp; 1878 ctxt->nameMax *= 2; 1879 } 1880 ctxt->nameTab[ctxt->nameNr] = value; 1881 ctxt->name = value; 1882 return (ctxt->nameNr++); 1883 mem_error: 1884 xmlErrMemory(ctxt, NULL); 1885 return (-1); 1886 } 1887 /** 1888 * namePop: 1889 * @ctxt: an XML parser context 1890 * 1891 * Pops the top element name from the name stack 1892 * 1893 * Returns the name just removed 1894 */ 1895 const xmlChar * 1896 namePop(xmlParserCtxtPtr ctxt) 1897 { 1898 const xmlChar *ret; 1899 1900 if ((ctxt == NULL) || (ctxt->nameNr <= 0)) 1901 return (NULL); 1902 ctxt->nameNr--; 1903 if (ctxt->nameNr > 0) 1904 ctxt->name = ctxt->nameTab[ctxt->nameNr - 1]; 1905 else 1906 ctxt->name = NULL; 1907 ret = ctxt->nameTab[ctxt->nameNr]; 1908 ctxt->nameTab[ctxt->nameNr] = NULL; 1909 return (ret); 1910 } 1911 1912 static int spacePush(xmlParserCtxtPtr ctxt, int val) { 1913 if (ctxt->spaceNr >= ctxt->spaceMax) { 1914 int *tmp; 1915 1916 ctxt->spaceMax *= 2; 1917 tmp = (int *) xmlRealloc(ctxt->spaceTab, 1918 ctxt->spaceMax * sizeof(ctxt->spaceTab[0])); 1919 if (tmp == NULL) { 1920 xmlErrMemory(ctxt, NULL); 1921 ctxt->spaceMax /=2; 1922 return(-1); 1923 } 1924 ctxt->spaceTab = tmp; 1925 } 1926 ctxt->spaceTab[ctxt->spaceNr] = val; 1927 ctxt->space = &ctxt->spaceTab[ctxt->spaceNr]; 1928 return(ctxt->spaceNr++); 1929 } 1930 1931 static int spacePop(xmlParserCtxtPtr ctxt) { 1932 int ret; 1933 if (ctxt->spaceNr <= 0) return(0); 1934 ctxt->spaceNr--; 1935 if (ctxt->spaceNr > 0) 1936 ctxt->space = &ctxt->spaceTab[ctxt->spaceNr - 1]; 1937 else 1938 ctxt->space = &ctxt->spaceTab[0]; 1939 ret = ctxt->spaceTab[ctxt->spaceNr]; 1940 ctxt->spaceTab[ctxt->spaceNr] = -1; 1941 return(ret); 1942 } 1943 1944 /* 1945 * Macros for accessing the content. Those should be used only by the parser, 1946 * and not exported. 1947 * 1948 * Dirty macros, i.e. one often need to make assumption on the context to 1949 * use them 1950 * 1951 * CUR_PTR return the current pointer to the xmlChar to be parsed. 1952 * To be used with extreme caution since operations consuming 1953 * characters may move the input buffer to a different location ! 1954 * CUR returns the current xmlChar value, i.e. a 8 bit value if compiled 1955 * This should be used internally by the parser 1956 * only to compare to ASCII values otherwise it would break when 1957 * running with UTF-8 encoding. 1958 * RAW same as CUR but in the input buffer, bypass any token 1959 * extraction that may have been done 1960 * NXT(n) returns the n'th next xmlChar. Same as CUR is should be used only 1961 * to compare on ASCII based substring. 1962 * SKIP(n) Skip n xmlChar, and must also be used only to skip ASCII defined 1963 * strings without newlines within the parser. 1964 * NEXT1(l) Skip 1 xmlChar, and must also be used only to skip 1 non-newline ASCII 1965 * defined char within the parser. 1966 * Clean macros, not dependent of an ASCII context, expect UTF-8 encoding 1967 * 1968 * NEXT Skip to the next character, this does the proper decoding 1969 * in UTF-8 mode. It also pop-up unfinished entities on the fly. 1970 * NEXTL(l) Skip the current unicode character of l xmlChars long. 1971 * CUR_CHAR(l) returns the current unicode character (int), set l 1972 * to the number of xmlChars used for the encoding [0-5]. 1973 * CUR_SCHAR same but operate on a string instead of the context 1974 * COPY_BUF copy the current unicode char to the target buffer, increment 1975 * the index 1976 * GROW, SHRINK handling of input buffers 1977 */ 1978 1979 #define RAW (*ctxt->input->cur) 1980 #define CUR (*ctxt->input->cur) 1981 #define NXT(val) ctxt->input->cur[(val)] 1982 #define CUR_PTR ctxt->input->cur 1983 1984 #define CMP4( s, c1, c2, c3, c4 ) \ 1985 ( ((unsigned char *) s)[ 0 ] == c1 && ((unsigned char *) s)[ 1 ] == c2 && \ 1986 ((unsigned char *) s)[ 2 ] == c3 && ((unsigned char *) s)[ 3 ] == c4 ) 1987 #define CMP5( s, c1, c2, c3, c4, c5 ) \ 1988 ( CMP4( s, c1, c2, c3, c4 ) && ((unsigned char *) s)[ 4 ] == c5 ) 1989 #define CMP6( s, c1, c2, c3, c4, c5, c6 ) \ 1990 ( CMP5( s, c1, c2, c3, c4, c5 ) && ((unsigned char *) s)[ 5 ] == c6 ) 1991 #define CMP7( s, c1, c2, c3, c4, c5, c6, c7 ) \ 1992 ( CMP6( s, c1, c2, c3, c4, c5, c6 ) && ((unsigned char *) s)[ 6 ] == c7 ) 1993 #define CMP8( s, c1, c2, c3, c4, c5, c6, c7, c8 ) \ 1994 ( CMP7( s, c1, c2, c3, c4, c5, c6, c7 ) && ((unsigned char *) s)[ 7 ] == c8 ) 1995 #define CMP9( s, c1, c2, c3, c4, c5, c6, c7, c8, c9 ) \ 1996 ( CMP8( s, c1, c2, c3, c4, c5, c6, c7, c8 ) && \ 1997 ((unsigned char *) s)[ 8 ] == c9 ) 1998 #define CMP10( s, c1, c2, c3, c4, c5, c6, c7, c8, c9, c10 ) \ 1999 ( CMP9( s, c1, c2, c3, c4, c5, c6, c7, c8, c9 ) && \ 2000 ((unsigned char *) s)[ 9 ] == c10 ) 2001 2002 #define SKIP(val) do { \ 2003 ctxt->nbChars += (val),ctxt->input->cur += (val),ctxt->input->col+=(val); \ 2004 if (*ctxt->input->cur == '%') xmlParserHandlePEReference(ctxt); \ 2005 if ((*ctxt->input->cur == 0) && \ 2006 (xmlParserInputGrow(ctxt->input, INPUT_CHUNK) <= 0)) \ 2007 xmlPopInput(ctxt); \ 2008 } while (0) 2009 2010 #define SKIPL(val) do { \ 2011 int skipl; \ 2012 for(skipl=0; skipl<val; skipl++) { \ 2013 if (*(ctxt->input->cur) == '\n') { \ 2014 ctxt->input->line++; ctxt->input->col = 1; \ 2015 } else ctxt->input->col++; \ 2016 ctxt->nbChars++; \ 2017 ctxt->input->cur++; \ 2018 } \ 2019 if (*ctxt->input->cur == '%') xmlParserHandlePEReference(ctxt); \ 2020 if ((*ctxt->input->cur == 0) && \ 2021 (xmlParserInputGrow(ctxt->input, INPUT_CHUNK) <= 0)) \ 2022 xmlPopInput(ctxt); \ 2023 } while (0) 2024 2025 #define SHRINK if ((ctxt->progressive == 0) && \ 2026 (ctxt->input->cur - ctxt->input->base > 2 * INPUT_CHUNK) && \ 2027 (ctxt->input->end - ctxt->input->cur < 2 * INPUT_CHUNK)) \ 2028 xmlSHRINK (ctxt); 2029 2030 static void xmlSHRINK (xmlParserCtxtPtr ctxt) { 2031 xmlParserInputShrink(ctxt->input); 2032 if ((*ctxt->input->cur == 0) && 2033 (xmlParserInputGrow(ctxt->input, INPUT_CHUNK) <= 0)) 2034 xmlPopInput(ctxt); 2035 } 2036 2037 #define GROW if ((ctxt->progressive == 0) && \ 2038 (ctxt->input->end - ctxt->input->cur < INPUT_CHUNK)) \ 2039 xmlGROW (ctxt); 2040 2041 static void xmlGROW (xmlParserCtxtPtr ctxt) { 2042 if ((((ctxt->input->end - ctxt->input->cur) > XML_MAX_LOOKUP_LIMIT) || 2043 ((ctxt->input->cur - ctxt->input->base) > XML_MAX_LOOKUP_LIMIT)) && 2044 ((ctxt->input->buf) && (ctxt->input->buf->readcallback != (xmlInputReadCallback) xmlNop)) && 2045 ((ctxt->options & XML_PARSE_HUGE) == 0)) { 2046 xmlFatalErr(ctxt, XML_ERR_INTERNAL_ERROR, "Huge input lookup"); 2047 ctxt->instate = XML_PARSER_EOF; 2048 } 2049 xmlParserInputGrow(ctxt->input, INPUT_CHUNK); 2050 if ((ctxt->input->cur != NULL) && (*ctxt->input->cur == 0) && 2051 (xmlParserInputGrow(ctxt->input, INPUT_CHUNK) <= 0)) 2052 xmlPopInput(ctxt); 2053 } 2054 2055 #define SKIP_BLANKS xmlSkipBlankChars(ctxt) 2056 2057 #define NEXT xmlNextChar(ctxt) 2058 2059 #define NEXT1 { \ 2060 ctxt->input->col++; \ 2061 ctxt->input->cur++; \ 2062 ctxt->nbChars++; \ 2063 if (*ctxt->input->cur == 0) \ 2064 xmlParserInputGrow(ctxt->input, INPUT_CHUNK); \ 2065 } 2066 2067 #define NEXTL(l) do { \ 2068 if (*(ctxt->input->cur) == '\n') { \ 2069 ctxt->input->line++; ctxt->input->col = 1; \ 2070 } else ctxt->input->col++; \ 2071 ctxt->input->cur += l; \ 2072 if (*ctxt->input->cur == '%') xmlParserHandlePEReference(ctxt); \ 2073 } while (0) 2074 2075 #define CUR_CHAR(l) xmlCurrentChar(ctxt, &l) 2076 #define CUR_SCHAR(s, l) xmlStringCurrentChar(ctxt, s, &l) 2077 2078 #define COPY_BUF(l,b,i,v) \ 2079 if (l == 1) b[i++] = (xmlChar) v; \ 2080 else i += xmlCopyCharMultiByte(&b[i],v) 2081 2082 /** 2083 * xmlSkipBlankChars: 2084 * @ctxt: the XML parser context 2085 * 2086 * skip all blanks character found at that point in the input streams. 2087 * It pops up finished entities in the process if allowable at that point. 2088 * 2089 * Returns the number of space chars skipped 2090 */ 2091 2092 int 2093 xmlSkipBlankChars(xmlParserCtxtPtr ctxt) { 2094 int res = 0; 2095 2096 /* 2097 * It's Okay to use CUR/NEXT here since all the blanks are on 2098 * the ASCII range. 2099 */ 2100 if ((ctxt->inputNr == 1) && (ctxt->instate != XML_PARSER_DTD)) { 2101 const xmlChar *cur; 2102 /* 2103 * if we are in the document content, go really fast 2104 */ 2105 cur = ctxt->input->cur; 2106 while (IS_BLANK_CH(*cur)) { 2107 if (*cur == '\n') { 2108 ctxt->input->line++; ctxt->input->col = 1; 2109 } 2110 cur++; 2111 res++; 2112 if (*cur == 0) { 2113 ctxt->input->cur = cur; 2114 xmlParserInputGrow(ctxt->input, INPUT_CHUNK); 2115 cur = ctxt->input->cur; 2116 } 2117 } 2118 ctxt->input->cur = cur; 2119 } else { 2120 int cur; 2121 do { 2122 cur = CUR; 2123 while (IS_BLANK_CH(cur)) { /* CHECKED tstblanks.xml */ 2124 NEXT; 2125 cur = CUR; 2126 res++; 2127 } 2128 while ((cur == 0) && (ctxt->inputNr > 1) && 2129 (ctxt->instate != XML_PARSER_COMMENT)) { 2130 xmlPopInput(ctxt); 2131 cur = CUR; 2132 } 2133 /* 2134 * Need to handle support of entities branching here 2135 */ 2136 if (*ctxt->input->cur == '%') xmlParserHandlePEReference(ctxt); 2137 } while (IS_BLANK(cur)); /* CHECKED tstblanks.xml */ 2138 } 2139 return(res); 2140 } 2141 2142 /************************************************************************ 2143 * * 2144 * Commodity functions to handle entities * 2145 * * 2146 ************************************************************************/ 2147 2148 /** 2149 * xmlPopInput: 2150 * @ctxt: an XML parser context 2151 * 2152 * xmlPopInput: the current input pointed by ctxt->input came to an end 2153 * pop it and return the next char. 2154 * 2155 * Returns the current xmlChar in the parser context 2156 */ 2157 xmlChar 2158 xmlPopInput(xmlParserCtxtPtr ctxt) { 2159 if ((ctxt == NULL) || (ctxt->inputNr <= 1)) return(0); 2160 if (xmlParserDebugEntities) 2161 xmlGenericError(xmlGenericErrorContext, 2162 "Popping input %d\n", ctxt->inputNr); 2163 xmlFreeInputStream(inputPop(ctxt)); 2164 if ((*ctxt->input->cur == 0) && 2165 (xmlParserInputGrow(ctxt->input, INPUT_CHUNK) <= 0)) 2166 return(xmlPopInput(ctxt)); 2167 return(CUR); 2168 } 2169 2170 /** 2171 * xmlPushInput: 2172 * @ctxt: an XML parser context 2173 * @input: an XML parser input fragment (entity, XML fragment ...). 2174 * 2175 * xmlPushInput: switch to a new input stream which is stacked on top 2176 * of the previous one(s). 2177 * Returns -1 in case of error or the index in the input stack 2178 */ 2179 int 2180 xmlPushInput(xmlParserCtxtPtr ctxt, xmlParserInputPtr input) { 2181 int ret; 2182 if (input == NULL) return(-1); 2183 2184 if (xmlParserDebugEntities) { 2185 if ((ctxt->input != NULL) && (ctxt->input->filename)) 2186 xmlGenericError(xmlGenericErrorContext, 2187 "%s(%d): ", ctxt->input->filename, 2188 ctxt->input->line); 2189 xmlGenericError(xmlGenericErrorContext, 2190 "Pushing input %d : %.30s\n", ctxt->inputNr+1, input->cur); 2191 } 2192 ret = inputPush(ctxt, input); 2193 if (ctxt->instate == XML_PARSER_EOF) 2194 return(-1); 2195 GROW; 2196 return(ret); 2197 } 2198 2199 /** 2200 * xmlParseCharRef: 2201 * @ctxt: an XML parser context 2202 * 2203 * parse Reference declarations 2204 * 2205 * [66] CharRef ::= '&#' [0-9]+ ';' | 2206 * '&#x' [0-9a-fA-F]+ ';' 2207 * 2208 * [ WFC: Legal Character ] 2209 * Characters referred to using character references must match the 2210 * production for Char. 2211 * 2212 * Returns the value parsed (as an int), 0 in case of error 2213 */ 2214 int 2215 xmlParseCharRef(xmlParserCtxtPtr ctxt) { 2216 unsigned int val = 0; 2217 int count = 0; 2218 unsigned int outofrange = 0; 2219 2220 /* 2221 * Using RAW/CUR/NEXT is okay since we are working on ASCII range here 2222 */ 2223 if ((RAW == '&') && (NXT(1) == '#') && 2224 (NXT(2) == 'x')) { 2225 SKIP(3); 2226 GROW; 2227 while (RAW != ';') { /* loop blocked by count */ 2228 if (count++ > 20) { 2229 count = 0; 2230 GROW; 2231 if (ctxt->instate == XML_PARSER_EOF) 2232 return(0); 2233 } 2234 if ((RAW >= '0') && (RAW <= '9')) 2235 val = val * 16 + (CUR - '0'); 2236 else if ((RAW >= 'a') && (RAW <= 'f') && (count < 20)) 2237 val = val * 16 + (CUR - 'a') + 10; 2238 else if ((RAW >= 'A') && (RAW <= 'F') && (count < 20)) 2239 val = val * 16 + (CUR - 'A') + 10; 2240 else { 2241 xmlFatalErr(ctxt, XML_ERR_INVALID_HEX_CHARREF, NULL); 2242 val = 0; 2243 break; 2244 } 2245 if (val > 0x10FFFF) 2246 outofrange = val; 2247 2248 NEXT; 2249 count++; 2250 } 2251 if (RAW == ';') { 2252 /* on purpose to avoid reentrancy problems with NEXT and SKIP */ 2253 ctxt->input->col++; 2254 ctxt->nbChars ++; 2255 ctxt->input->cur++; 2256 } 2257 } else if ((RAW == '&') && (NXT(1) == '#')) { 2258 SKIP(2); 2259 GROW; 2260 while (RAW != ';') { /* loop blocked by count */ 2261 if (count++ > 20) { 2262 count = 0; 2263 GROW; 2264 if (ctxt->instate == XML_PARSER_EOF) 2265 return(0); 2266 } 2267 if ((RAW >= '0') && (RAW <= '9')) 2268 val = val * 10 + (CUR - '0'); 2269 else { 2270 xmlFatalErr(ctxt, XML_ERR_INVALID_DEC_CHARREF, NULL); 2271 val = 0; 2272 break; 2273 } 2274 if (val > 0x10FFFF) 2275 outofrange = val; 2276 2277 NEXT; 2278 count++; 2279 } 2280 if (RAW == ';') { 2281 /* on purpose to avoid reentrancy problems with NEXT and SKIP */ 2282 ctxt->input->col++; 2283 ctxt->nbChars ++; 2284 ctxt->input->cur++; 2285 } 2286 } else { 2287 xmlFatalErr(ctxt, XML_ERR_INVALID_CHARREF, NULL); 2288 } 2289 2290 /* 2291 * [ WFC: Legal Character ] 2292 * Characters referred to using character references must match the 2293 * production for Char. 2294 */ 2295 if ((IS_CHAR(val) && (outofrange == 0))) { 2296 return(val); 2297 } else { 2298 xmlFatalErrMsgInt(ctxt, XML_ERR_INVALID_CHAR, 2299 "xmlParseCharRef: invalid xmlChar value %d\n", 2300 val); 2301 } 2302 return(0); 2303 } 2304 2305 /** 2306 * xmlParseStringCharRef: 2307 * @ctxt: an XML parser context 2308 * @str: a pointer to an index in the string 2309 * 2310 * parse Reference declarations, variant parsing from a string rather 2311 * than an an input flow. 2312 * 2313 * [66] CharRef ::= '&#' [0-9]+ ';' | 2314 * '&#x' [0-9a-fA-F]+ ';' 2315 * 2316 * [ WFC: Legal Character ] 2317 * Characters referred to using character references must match the 2318 * production for Char. 2319 * 2320 * Returns the value parsed (as an int), 0 in case of error, str will be 2321 * updated to the current value of the index 2322 */ 2323 static int 2324 xmlParseStringCharRef(xmlParserCtxtPtr ctxt, const xmlChar **str) { 2325 const xmlChar *ptr; 2326 xmlChar cur; 2327 unsigned int val = 0; 2328 unsigned int outofrange = 0; 2329 2330 if ((str == NULL) || (*str == NULL)) return(0); 2331 ptr = *str; 2332 cur = *ptr; 2333 if ((cur == '&') && (ptr[1] == '#') && (ptr[2] == 'x')) { 2334 ptr += 3; 2335 cur = *ptr; 2336 while (cur != ';') { /* Non input consuming loop */ 2337 if ((cur >= '0') && (cur <= '9')) 2338 val = val * 16 + (cur - '0'); 2339 else if ((cur >= 'a') && (cur <= 'f')) 2340 val = val * 16 + (cur - 'a') + 10; 2341 else if ((cur >= 'A') && (cur <= 'F')) 2342 val = val * 16 + (cur - 'A') + 10; 2343 else { 2344 xmlFatalErr(ctxt, XML_ERR_INVALID_HEX_CHARREF, NULL); 2345 val = 0; 2346 break; 2347 } 2348 if (val > 0x10FFFF) 2349 outofrange = val; 2350 2351 ptr++; 2352 cur = *ptr; 2353 } 2354 if (cur == ';') 2355 ptr++; 2356 } else if ((cur == '&') && (ptr[1] == '#')){ 2357 ptr += 2; 2358 cur = *ptr; 2359 while (cur != ';') { /* Non input consuming loops */ 2360 if ((cur >= '0') && (cur <= '9')) 2361 val = val * 10 + (cur - '0'); 2362 else { 2363 xmlFatalErr(ctxt, XML_ERR_INVALID_DEC_CHARREF, NULL); 2364 val = 0; 2365 break; 2366 } 2367 if (val > 0x10FFFF) 2368 outofrange = val; 2369 2370 ptr++; 2371 cur = *ptr; 2372 } 2373 if (cur == ';') 2374 ptr++; 2375 } else { 2376 xmlFatalErr(ctxt, XML_ERR_INVALID_CHARREF, NULL); 2377 return(0); 2378 } 2379 *str = ptr; 2380 2381 /* 2382 * [ WFC: Legal Character ] 2383 * Characters referred to using character references must match the 2384 * production for Char. 2385 */ 2386 if ((IS_CHAR(val) && (outofrange == 0))) { 2387 return(val); 2388 } else { 2389 xmlFatalErrMsgInt(ctxt, XML_ERR_INVALID_CHAR, 2390 "xmlParseStringCharRef: invalid xmlChar value %d\n", 2391 val); 2392 } 2393 return(0); 2394 } 2395 2396 /** 2397 * xmlNewBlanksWrapperInputStream: 2398 * @ctxt: an XML parser context 2399 * @entity: an Entity pointer 2400 * 2401 * Create a new input stream for wrapping 2402 * blanks around a PEReference 2403 * 2404 * Returns the new input stream or NULL 2405 */ 2406 2407 static void deallocblankswrapper (xmlChar *str) {xmlFree(str);} 2408 2409 static xmlParserInputPtr 2410 xmlNewBlanksWrapperInputStream(xmlParserCtxtPtr ctxt, xmlEntityPtr entity) { 2411 xmlParserInputPtr input; 2412 xmlChar *buffer; 2413 size_t length; 2414 if (entity == NULL) { 2415 xmlFatalErr(ctxt, XML_ERR_INTERNAL_ERROR, 2416 "xmlNewBlanksWrapperInputStream entity\n"); 2417 return(NULL); 2418 } 2419 if (xmlParserDebugEntities) 2420 xmlGenericError(xmlGenericErrorContext, 2421 "new blanks wrapper for entity: %s\n", entity->name); 2422 input = xmlNewInputStream(ctxt); 2423 if (input == NULL) { 2424 return(NULL); 2425 } 2426 length = xmlStrlen(entity->name) + 5; 2427 buffer = xmlMallocAtomic(length); 2428 if (buffer == NULL) { 2429 xmlErrMemory(ctxt, NULL); 2430 xmlFree(input); 2431 return(NULL); 2432 } 2433 buffer [0] = ' '; 2434 buffer [1] = '%'; 2435 buffer [length-3] = ';'; 2436 buffer [length-2] = ' '; 2437 buffer [length-1] = 0; 2438 memcpy(buffer + 2, entity->name, length - 5); 2439 input->free = deallocblankswrapper; 2440 input->base = buffer; 2441 input->cur = buffer; 2442 input->length = length; 2443 input->end = &buffer[length]; 2444 return(input); 2445 } 2446 2447 /** 2448 * xmlParserHandlePEReference: 2449 * @ctxt: the parser context 2450 * 2451 * [69] PEReference ::= '%' Name ';' 2452 * 2453 * [ WFC: No Recursion ] 2454 * A parsed entity must not contain a recursive 2455 * reference to itself, either directly or indirectly. 2456 * 2457 * [ WFC: Entity Declared ] 2458 * In a document without any DTD, a document with only an internal DTD 2459 * subset which contains no parameter entity references, or a document 2460 * with "standalone='yes'", ... ... The declaration of a parameter 2461 * entity must precede any reference to it... 2462 * 2463 * [ VC: Entity Declared ] 2464 * In a document with an external subset or external parameter entities 2465 * with "standalone='no'", ... ... The declaration of a parameter entity 2466 * must precede any reference to it... 2467 * 2468 * [ WFC: In DTD ] 2469 * Parameter-entity references may only appear in the DTD. 2470 * NOTE: misleading but this is handled. 2471 * 2472 * A PEReference may have been detected in the current input stream 2473 * the handling is done accordingly to 2474 * http://www.w3.org/TR/REC-xml#entproc 2475 * i.e. 2476 * - Included in literal in entity values 2477 * - Included as Parameter Entity reference within DTDs 2478 */ 2479 void 2480 xmlParserHandlePEReference(xmlParserCtxtPtr ctxt) { 2481 const xmlChar *name; 2482 xmlEntityPtr entity = NULL; 2483 xmlParserInputPtr input; 2484 2485 if (RAW != '%') return; 2486 switch(ctxt->instate) { 2487 case XML_PARSER_CDATA_SECTION: 2488 return; 2489 case XML_PARSER_COMMENT: 2490 return; 2491 case XML_PARSER_START_TAG: 2492 return; 2493 case XML_PARSER_END_TAG: 2494 return; 2495 case XML_PARSER_EOF: 2496 xmlFatalErr(ctxt, XML_ERR_PEREF_AT_EOF, NULL); 2497 return; 2498 case XML_PARSER_PROLOG: 2499 case XML_PARSER_START: 2500 case XML_PARSER_MISC: 2501 xmlFatalErr(ctxt, XML_ERR_PEREF_IN_PROLOG, NULL); 2502 return; 2503 case XML_PARSER_ENTITY_DECL: 2504 case XML_PARSER_CONTENT: 2505 case XML_PARSER_ATTRIBUTE_VALUE: 2506 case XML_PARSER_PI: 2507 case XML_PARSER_SYSTEM_LITERAL: 2508 case XML_PARSER_PUBLIC_LITERAL: 2509 /* we just ignore it there */ 2510 return; 2511 case XML_PARSER_EPILOG: 2512 xmlFatalErr(ctxt, XML_ERR_PEREF_IN_EPILOG, NULL); 2513 return; 2514 case XML_PARSER_ENTITY_VALUE: 2515 /* 2516 * NOTE: in the case of entity values, we don't do the 2517 * substitution here since we need the literal 2518 * entity value to be able to save the internal 2519 * subset of the document. 2520 * This will be handled by xmlStringDecodeEntities 2521 */ 2522 return; 2523 case XML_PARSER_DTD: 2524 /* 2525 * [WFC: Well-Formedness Constraint: PEs in Internal Subset] 2526 * In the internal DTD subset, parameter-entity references 2527 * can occur only where markup declarations can occur, not 2528 * within markup declarations. 2529 * In that case this is handled in xmlParseMarkupDecl 2530 */ 2531 if ((ctxt->external == 0) && (ctxt->inputNr == 1)) 2532 return; 2533 if (IS_BLANK_CH(NXT(1)) || NXT(1) == 0) 2534 return; 2535 break; 2536 case XML_PARSER_IGNORE: 2537 return; 2538 } 2539 2540 NEXT; 2541 name = xmlParseName(ctxt); 2542 if (xmlParserDebugEntities) 2543 xmlGenericError(xmlGenericErrorContext, 2544 "PEReference: %s\n", name); 2545 if (name == NULL) { 2546 xmlFatalErr(ctxt, XML_ERR_PEREF_NO_NAME, NULL); 2547 } else { 2548 if (RAW == ';') { 2549 NEXT; 2550 if ((ctxt->sax != NULL) && (ctxt->sax->getParameterEntity != NULL)) 2551 entity = ctxt->sax->getParameterEntity(ctxt->userData, name); 2552 if (ctxt->instate == XML_PARSER_EOF) 2553 return; 2554 if (entity == NULL) { 2555 2556 /* 2557 * [ WFC: Entity Declared ] 2558 * In a document without any DTD, a document with only an 2559 * internal DTD subset which contains no parameter entity 2560 * references, or a document with "standalone='yes'", ... 2561 * ... The declaration of a parameter entity must precede 2562 * any reference to it... 2563 */ 2564 if ((ctxt->standalone == 1) || 2565 ((ctxt->hasExternalSubset == 0) && 2566 (ctxt->hasPErefs == 0))) { 2567 xmlFatalErrMsgStr(ctxt, XML_ERR_UNDECLARED_ENTITY, 2568 "PEReference: %%%s; not found\n", name); 2569 } else { 2570 /* 2571 * [ VC: Entity Declared ] 2572 * In a document with an external subset or external 2573 * parameter entities with "standalone='no'", ... 2574 * ... The declaration of a parameter entity must precede 2575 * any reference to it... 2576 */ 2577 if ((ctxt->validate) && (ctxt->vctxt.error != NULL)) { 2578 xmlValidityError(ctxt, XML_WAR_UNDECLARED_ENTITY, 2579 "PEReference: %%%s; not found\n", 2580 name, NULL); 2581 } else 2582 xmlWarningMsg(ctxt, XML_WAR_UNDECLARED_ENTITY, 2583 "PEReference: %%%s; not found\n", 2584 name, NULL); 2585 ctxt->valid = 0; 2586 } 2587 } else if (ctxt->input->free != deallocblankswrapper) { 2588 input = xmlNewBlanksWrapperInputStream(ctxt, entity); 2589 if (xmlPushInput(ctxt, input) < 0) 2590 return; 2591 } else { 2592 if ((entity->etype == XML_INTERNAL_PARAMETER_ENTITY) || 2593 (entity->etype == XML_EXTERNAL_PARAMETER_ENTITY)) { 2594 xmlChar start[4]; 2595 xmlCharEncoding enc; 2596 2597 /* 2598 * handle the extra spaces added before and after 2599 * c.f. http://www.w3.org/TR/REC-xml#as-PE 2600 * this is done independently. 2601 */ 2602 input = xmlNewEntityInputStream(ctxt, entity); 2603 if (xmlPushInput(ctxt, input) < 0) 2604 return; 2605 2606 /* 2607 * Get the 4 first bytes and decode the charset 2608 * if enc != XML_CHAR_ENCODING_NONE 2609 * plug some encoding conversion routines. 2610 * Note that, since we may have some non-UTF8 2611 * encoding (like UTF16, bug 135229), the 'length' 2612 * is not known, but we can calculate based upon 2613 * the amount of data in the buffer. 2614 */ 2615 GROW 2616 if (ctxt->instate == XML_PARSER_EOF) 2617 return; 2618 if ((ctxt->input->end - ctxt->input->cur)>=4) { 2619 start[0] = RAW; 2620 start[1] = NXT(1); 2621 start[2] = NXT(2); 2622 start[3] = NXT(3); 2623 enc = xmlDetectCharEncoding(start, 4); 2624 if (enc != XML_CHAR_ENCODING_NONE) { 2625 xmlSwitchEncoding(ctxt, enc); 2626 } 2627 } 2628 2629 if ((entity->etype == XML_EXTERNAL_PARAMETER_ENTITY) && 2630 (CMP5(CUR_PTR, '<', '?', 'x', 'm', 'l' )) && 2631 (IS_BLANK_CH(NXT(5)))) { 2632 xmlParseTextDecl(ctxt); 2633 } 2634 } else { 2635 xmlFatalErrMsgStr(ctxt, XML_ERR_ENTITY_IS_PARAMETER, 2636 "PEReference: %s is not a parameter entity\n", 2637 name); 2638 } 2639 } 2640 } else { 2641 xmlFatalErr(ctxt, XML_ERR_PEREF_SEMICOL_MISSING, NULL); 2642 } 2643 } 2644 } 2645 2646 /* 2647 * Macro used to grow the current buffer. 2648 * buffer##_size is expected to be a size_t 2649 * mem_error: is expected to handle memory allocation failures 2650 */ 2651 #define growBuffer(buffer, n) { \ 2652 xmlChar *tmp; \ 2653 size_t new_size = buffer##_size * 2 + n; \ 2654 if (new_size < buffer##_size) goto mem_error; \ 2655 tmp = (xmlChar *) xmlRealloc(buffer, new_size); \ 2656 if (tmp == NULL) goto mem_error; \ 2657 buffer = tmp; \ 2658 buffer##_size = new_size; \ 2659 } 2660 2661 /** 2662 * xmlStringLenDecodeEntities: 2663 * @ctxt: the parser context 2664 * @str: the input string 2665 * @len: the string length 2666 * @what: combination of XML_SUBSTITUTE_REF and XML_SUBSTITUTE_PEREF 2667 * @end: an end marker xmlChar, 0 if none 2668 * @end2: an end marker xmlChar, 0 if none 2669 * @end3: an end marker xmlChar, 0 if none 2670 * 2671 * Takes a entity string content and process to do the adequate substitutions. 2672 * 2673 * [67] Reference ::= EntityRef | CharRef 2674 * 2675 * [69] PEReference ::= '%' Name ';' 2676 * 2677 * Returns A newly allocated string with the substitution done. The caller 2678 * must deallocate it ! 2679 */ 2680 xmlChar * 2681 xmlStringLenDecodeEntities(xmlParserCtxtPtr ctxt, const xmlChar *str, int len, 2682 int what, xmlChar end, xmlChar end2, xmlChar end3) { 2683 xmlChar *buffer = NULL; 2684 size_t buffer_size = 0; 2685 size_t nbchars = 0; 2686 2687 xmlChar *current = NULL; 2688 xmlChar *rep = NULL; 2689 const xmlChar *last; 2690 xmlEntityPtr ent; 2691 int c,l; 2692 2693 if ((ctxt == NULL) || (str == NULL) || (len < 0)) 2694 return(NULL); 2695 last = str + len; 2696 2697 if (((ctxt->depth > 40) && 2698 ((ctxt->options & XML_PARSE_HUGE) == 0)) || 2699 (ctxt->depth > 1024)) { 2700 xmlFatalErr(ctxt, XML_ERR_ENTITY_LOOP, NULL); 2701 return(NULL); 2702 } 2703 2704 /* 2705 * allocate a translation buffer. 2706 */ 2707 buffer_size = XML_PARSER_BIG_BUFFER_SIZE; 2708 buffer = (xmlChar *) xmlMallocAtomic(buffer_size); 2709 if (buffer == NULL) goto mem_error; 2710 2711 /* 2712 * OK loop until we reach one of the ending char or a size limit. 2713 * we are operating on already parsed values. 2714 */ 2715 if (str < last) 2716 c = CUR_SCHAR(str, l); 2717 else 2718 c = 0; 2719 while ((c != 0) && (c != end) && /* non input consuming loop */ 2720 (c != end2) && (c != end3)) { 2721 2722 if (c == 0) break; 2723 if ((c == '&') && (str[1] == '#')) { 2724 int val = xmlParseStringCharRef(ctxt, &str); 2725 if (val != 0) { 2726 COPY_BUF(0,buffer,nbchars,val); 2727 } 2728 if (nbchars + XML_PARSER_BUFFER_SIZE > buffer_size) { 2729 growBuffer(buffer, XML_PARSER_BUFFER_SIZE); 2730 } 2731 } else if ((c == '&') && (what & XML_SUBSTITUTE_REF)) { 2732 if (xmlParserDebugEntities) 2733 xmlGenericError(xmlGenericErrorContext, 2734 "String decoding Entity Reference: %.30s\n", 2735 str); 2736 ent = xmlParseStringEntityRef(ctxt, &str); 2737 if ((ctxt->lastError.code == XML_ERR_ENTITY_LOOP) || 2738 (ctxt->lastError.code == XML_ERR_INTERNAL_ERROR)) 2739 goto int_error; 2740 if (ent != NULL) 2741 ctxt->nbentities += ent->checked / 2; 2742 if ((ent != NULL) && 2743 (ent->etype == XML_INTERNAL_PREDEFINED_ENTITY)) { 2744 if (ent->content != NULL) { 2745 COPY_BUF(0,buffer,nbchars,ent->content[0]); 2746 if (nbchars + XML_PARSER_BUFFER_SIZE > buffer_size) { 2747 growBuffer(buffer, XML_PARSER_BUFFER_SIZE); 2748 } 2749 } else { 2750 xmlFatalErrMsg(ctxt, XML_ERR_INTERNAL_ERROR, 2751 "predefined entity has no content\n"); 2752 } 2753 } else if ((ent != NULL) && (ent->content != NULL)) { 2754 ctxt->depth++; 2755 rep = xmlStringDecodeEntities(ctxt, ent->content, what, 2756 0, 0, 0); 2757 ctxt->depth--; 2758 2759 if (rep != NULL) { 2760 current = rep; 2761 while (*current != 0) { /* non input consuming loop */ 2762 buffer[nbchars++] = *current++; 2763 if (nbchars + XML_PARSER_BUFFER_SIZE > buffer_size) { 2764 if (xmlParserEntityCheck(ctxt, nbchars, ent, 0)) 2765 goto int_error; 2766 growBuffer(buffer, XML_PARSER_BUFFER_SIZE); 2767 } 2768 } 2769 xmlFree(rep); 2770 rep = NULL; 2771 } 2772 } else if (ent != NULL) { 2773 int i = xmlStrlen(ent->name); 2774 const xmlChar *cur = ent->name; 2775 2776 buffer[nbchars++] = '&'; 2777 if (nbchars + i + XML_PARSER_BUFFER_SIZE > buffer_size) { 2778 growBuffer(buffer, i + XML_PARSER_BUFFER_SIZE); 2779 } 2780 for (;i > 0;i--) 2781 buffer[nbchars++] = *cur++; 2782 buffer[nbchars++] = ';'; 2783 } 2784 } else if (c == '%' && (what & XML_SUBSTITUTE_PEREF)) { 2785 if (xmlParserDebugEntities) 2786 xmlGenericError(xmlGenericErrorContext, 2787 "String decoding PE Reference: %.30s\n", str); 2788 ent = xmlParseStringPEReference(ctxt, &str); 2789 if (ctxt->lastError.code == XML_ERR_ENTITY_LOOP) 2790 goto int_error; 2791 if (ent != NULL) 2792 ctxt->nbentities += ent->checked / 2; 2793 if (ent != NULL) { 2794 if (ent->content == NULL) { 2795 xmlLoadEntityContent(ctxt, ent); 2796 } 2797 ctxt->depth++; 2798 rep = xmlStringDecodeEntities(ctxt, ent->content, what, 2799 0, 0, 0); 2800 ctxt->depth--; 2801 if (rep != NULL) { 2802 current = rep; 2803 while (*current != 0) { /* non input consuming loop */ 2804 buffer[nbchars++] = *current++; 2805 if (nbchars + XML_PARSER_BUFFER_SIZE > buffer_size) { 2806 if (xmlParserEntityCheck(ctxt, nbchars, ent, 0)) 2807 goto int_error; 2808 growBuffer(buffer, XML_PARSER_BUFFER_SIZE); 2809 } 2810 } 2811 xmlFree(rep); 2812 rep = NULL; 2813 } 2814 } 2815 } else { 2816 COPY_BUF(l,buffer,nbchars,c); 2817 str += l; 2818 if (nbchars + XML_PARSER_BUFFER_SIZE > buffer_size) { 2819 growBuffer(buffer, XML_PARSER_BUFFER_SIZE); 2820 } 2821 } 2822 if (str < last) 2823 c = CUR_SCHAR(str, l); 2824 else 2825 c = 0; 2826 } 2827 buffer[nbchars] = 0; 2828 return(buffer); 2829 2830 mem_error: 2831 xmlErrMemory(ctxt, NULL); 2832 int_error: 2833 if (rep != NULL) 2834 xmlFree(rep); 2835 if (buffer != NULL) 2836 xmlFree(buffer); 2837 return(NULL); 2838 } 2839 2840 /** 2841 * xmlStringDecodeEntities: 2842 * @ctxt: the parser context 2843 * @str: the input string 2844 * @what: combination of XML_SUBSTITUTE_REF and XML_SUBSTITUTE_PEREF 2845 * @end: an end marker xmlChar, 0 if none 2846 * @end2: an end marker xmlChar, 0 if none 2847 * @end3: an end marker xmlChar, 0 if none 2848 * 2849 * Takes a entity string content and process to do the adequate substitutions. 2850 * 2851 * [67] Reference ::= EntityRef | CharRef 2852 * 2853 * [69] PEReference ::= '%' Name ';' 2854 * 2855 * Returns A newly allocated string with the substitution done. The caller 2856 * must deallocate it ! 2857 */ 2858 xmlChar * 2859 xmlStringDecodeEntities(xmlParserCtxtPtr ctxt, const xmlChar *str, int what, 2860 xmlChar end, xmlChar end2, xmlChar end3) { 2861 if ((ctxt == NULL) || (str == NULL)) return(NULL); 2862 return(xmlStringLenDecodeEntities(ctxt, str, xmlStrlen(str), what, 2863 end, end2, end3)); 2864 } 2865 2866 /************************************************************************ 2867 * * 2868 * Commodity functions, cleanup needed ? * 2869 * * 2870 ************************************************************************/ 2871 2872 /** 2873 * areBlanks: 2874 * @ctxt: an XML parser context 2875 * @str: a xmlChar * 2876 * @len: the size of @str 2877 * @blank_chars: we know the chars are blanks 2878 * 2879 * Is this a sequence of blank chars that one can ignore ? 2880 * 2881 * Returns 1 if ignorable 0 otherwise. 2882 */ 2883 2884 static int areBlanks(xmlParserCtxtPtr ctxt, const xmlChar *str, int len, 2885 int blank_chars) { 2886 int i, ret; 2887 xmlNodePtr lastChild; 2888 2889 /* 2890 * Don't spend time trying to differentiate them, the same callback is 2891 * used ! 2892 */ 2893 if (ctxt->sax->ignorableWhitespace == ctxt->sax->characters) 2894 return(0); 2895 2896 /* 2897 * Check for xml:space value. 2898 */ 2899 if ((ctxt->space == NULL) || (*(ctxt->space) == 1) || 2900 (*(ctxt->space) == -2)) 2901 return(0); 2902 2903 /* 2904 * Check that the string is made of blanks 2905 */ 2906 if (blank_chars == 0) { 2907 for (i = 0;i < len;i++) 2908 if (!(IS_BLANK_CH(str[i]))) return(0); 2909 } 2910 2911 /* 2912 * Look if the element is mixed content in the DTD if available 2913 */ 2914 if (ctxt->node == NULL) return(0); 2915 if (ctxt->myDoc != NULL) { 2916 ret = xmlIsMixedElement(ctxt->myDoc, ctxt->node->name); 2917 if (ret == 0) return(1); 2918 if (ret == 1) return(0); 2919 } 2920 2921 /* 2922 * Otherwise, heuristic :-\ 2923 */ 2924 if ((RAW != '<') && (RAW != 0xD)) return(0); 2925 if ((ctxt->node->children == NULL) && 2926 (RAW == '<') && (NXT(1) == '/')) return(0); 2927 2928 lastChild = xmlGetLastChild(ctxt->node); 2929 if (lastChild == NULL) { 2930 if ((ctxt->node->type != XML_ELEMENT_NODE) && 2931 (ctxt->node->content != NULL)) return(0); 2932 } else if (xmlNodeIsText(lastChild)) 2933 return(0); 2934 else if ((ctxt->node->children != NULL) && 2935 (xmlNodeIsText(ctxt->node->children))) 2936 return(0); 2937 return(1); 2938 } 2939 2940 /************************************************************************ 2941 * * 2942 * Extra stuff for namespace support * 2943 * Relates to http://www.w3.org/TR/WD-xml-names * 2944 * * 2945 ************************************************************************/ 2946 2947 /** 2948 * xmlSplitQName: 2949 * @ctxt: an XML parser context 2950 * @name: an XML parser context 2951 * @prefix: a xmlChar ** 2952 * 2953 * parse an UTF8 encoded XML qualified name string 2954 * 2955 * [NS 5] QName ::= (Prefix ':')? LocalPart 2956 * 2957 * [NS 6] Prefix ::= NCName 2958 * 2959 * [NS 7] LocalPart ::= NCName 2960 * 2961 * Returns the local part, and prefix is updated 2962 * to get the Prefix if any. 2963 */ 2964 2965 xmlChar * 2966 xmlSplitQName(xmlParserCtxtPtr ctxt, const xmlChar *name, xmlChar **prefix) { 2967 xmlChar buf[XML_MAX_NAMELEN + 5]; 2968 xmlChar *buffer = NULL; 2969 int len = 0; 2970 int max = XML_MAX_NAMELEN; 2971 xmlChar *ret = NULL; 2972 const xmlChar *cur = name; 2973 int c; 2974 2975 if (prefix == NULL) return(NULL); 2976 *prefix = NULL; 2977 2978 if (cur == NULL) return(NULL); 2979 2980 #ifndef XML_XML_NAMESPACE 2981 /* xml: prefix is not really a namespace */ 2982 if ((cur[0] == 'x') && (cur[1] == 'm') && 2983 (cur[2] == 'l') && (cur[3] == ':')) 2984 return(xmlStrdup(name)); 2985 #endif 2986 2987 /* nasty but well=formed */ 2988 if (cur[0] == ':') 2989 return(xmlStrdup(name)); 2990 2991 c = *cur++; 2992 while ((c != 0) && (c != ':') && (len < max)) { /* tested bigname.xml */ 2993 buf[len++] = c; 2994 c = *cur++; 2995 } 2996 if (len >= max) { 2997 /* 2998 * Okay someone managed to make a huge name, so he's ready to pay 2999 * for the processing speed. 3000 */ 3001 max = len * 2; 3002 3003 buffer = (xmlChar *) xmlMallocAtomic(max * sizeof(xmlChar)); 3004 if (buffer == NULL) { 3005 xmlErrMemory(ctxt, NULL); 3006 return(NULL); 3007 } 3008 memcpy(buffer, buf, len); 3009 while ((c != 0) && (c != ':')) { /* tested bigname.xml */ 3010 if (len + 10 > max) { 3011 xmlChar *tmp; 3012 3013 max *= 2; 3014 tmp = (xmlChar *) xmlRealloc(buffer, 3015 max * sizeof(xmlChar)); 3016 if (tmp == NULL) { 3017 xmlFree(buffer); 3018 xmlErrMemory(ctxt, NULL); 3019 return(NULL); 3020 } 3021 buffer = tmp; 3022 } 3023 buffer[len++] = c; 3024 c = *cur++; 3025 } 3026 buffer[len] = 0; 3027 } 3028 3029 if ((c == ':') && (*cur == 0)) { 3030 if (buffer != NULL) 3031 xmlFree(buffer); 3032 *prefix = NULL; 3033 return(xmlStrdup(name)); 3034 } 3035 3036 if (buffer == NULL) 3037 ret = xmlStrndup(buf, len); 3038 else { 3039 ret = buffer; 3040 buffer = NULL; 3041 max = XML_MAX_NAMELEN; 3042 } 3043 3044 3045 if (c == ':') { 3046 c = *cur; 3047 *prefix = ret; 3048 if (c == 0) { 3049 return(xmlStrndup(BAD_CAST "", 0)); 3050 } 3051 len = 0; 3052 3053 /* 3054 * Check that the first character is proper to start 3055 * a new name 3056 */ 3057 if (!(((c >= 0x61) && (c <= 0x7A)) || 3058 ((c >= 0x41) && (c <= 0x5A)) || 3059 (c == '_') || (c == ':'))) { 3060 int l; 3061 int first = CUR_SCHAR(cur, l); 3062 3063 if (!IS_LETTER(first) && (first != '_')) { 3064 xmlFatalErrMsgStr(ctxt, XML_NS_ERR_QNAME, 3065 "Name %s is not XML Namespace compliant\n", 3066 name); 3067 } 3068 } 3069 cur++; 3070 3071 while ((c != 0) && (len < max)) { /* tested bigname2.xml */ 3072 buf[len++] = c; 3073 c = *cur++; 3074 } 3075 if (len >= max) { 3076 /* 3077 * Okay someone managed to make a huge name, so he's ready to pay 3078 * for the processing speed. 3079 */ 3080 max = len * 2; 3081 3082 buffer = (xmlChar *) xmlMallocAtomic(max * sizeof(xmlChar)); 3083 if (buffer == NULL) { 3084 xmlErrMemory(ctxt, NULL); 3085 return(NULL); 3086 } 3087 memcpy(buffer, buf, len); 3088 while (c != 0) { /* tested bigname2.xml */ 3089 if (len + 10 > max) { 3090 xmlChar *tmp; 3091 3092 max *= 2; 3093 tmp = (xmlChar *) xmlRealloc(buffer, 3094 max * sizeof(xmlChar)); 3095 if (tmp == NULL) { 3096 xmlErrMemory(ctxt, NULL); 3097 xmlFree(buffer); 3098 return(NULL); 3099 } 3100 buffer = tmp; 3101 } 3102 buffer[len++] = c; 3103 c = *cur++; 3104 } 3105 buffer[len] = 0; 3106 } 3107 3108 if (buffer == NULL) 3109 ret = xmlStrndup(buf, len); 3110 else { 3111 ret = buffer; 3112 } 3113 } 3114 3115 return(ret); 3116 } 3117 3118 /************************************************************************ 3119 * * 3120 * The parser itself * 3121 * Relates to http://www.w3.org/TR/REC-xml * 3122 * * 3123 ************************************************************************/ 3124 3125 /************************************************************************ 3126 * * 3127 * Routines to parse Name, NCName and NmToken * 3128 * * 3129 ************************************************************************/ 3130 #ifdef DEBUG 3131 static unsigned long nbParseName = 0; 3132 static unsigned long nbParseNmToken = 0; 3133 static unsigned long nbParseNCName = 0; 3134 static unsigned long nbParseNCNameComplex = 0; 3135 static unsigned long nbParseNameComplex = 0; 3136 static unsigned long nbParseStringName = 0; 3137 #endif 3138 3139 /* 3140 * The two following functions are related to the change of accepted 3141 * characters for Name and NmToken in the Revision 5 of XML-1.0 3142 * They correspond to the modified production [4] and the new production [4a] 3143 * changes in that revision. Also note that the macros used for the 3144 * productions Letter, Digit, CombiningChar and Extender are not needed 3145 * anymore. 3146 * We still keep compatibility to pre-revision5 parsing semantic if the 3147 * new XML_PARSE_OLD10 option is given to the parser. 3148 */ 3149 static int 3150 xmlIsNameStartChar(xmlParserCtxtPtr ctxt, int c) { 3151 if ((ctxt->options & XML_PARSE_OLD10) == 0) { 3152 /* 3153 * Use the new checks of production [4] [4a] amd [5] of the 3154 * Update 5 of XML-1.0 3155 */ 3156 if ((c != ' ') && (c != '>') && (c != '/') && /* accelerators */ 3157 (((c >= 'a') && (c <= 'z')) || 3158 ((c >= 'A') && (c <= 'Z')) || 3159 (c == '_') || (c == ':') || 3160 ((c >= 0xC0) && (c <= 0xD6)) || 3161 ((c >= 0xD8) && (c <= 0xF6)) || 3162 ((c >= 0xF8) && (c <= 0x2FF)) || 3163 ((c >= 0x370) && (c <= 0x37D)) || 3164 ((c >= 0x37F) && (c <= 0x1FFF)) || 3165 ((c >= 0x200C) && (c <= 0x200D)) || 3166 ((c >= 0x2070) && (c <= 0x218F)) || 3167 ((c >= 0x2C00) && (c <= 0x2FEF)) || 3168 ((c >= 0x3001) && (c <= 0xD7FF)) || 3169 ((c >= 0xF900) && (c <= 0xFDCF)) || 3170 ((c >= 0xFDF0) && (c <= 0xFFFD)) || 3171 ((c >= 0x10000) && (c <= 0xEFFFF)))) 3172 return(1); 3173 } else { 3174 if (IS_LETTER(c) || (c == '_') || (c == ':')) 3175 return(1); 3176 } 3177 return(0); 3178 } 3179 3180 static int 3181 xmlIsNameChar(xmlParserCtxtPtr ctxt, int c) { 3182 if ((ctxt->options & XML_PARSE_OLD10) == 0) { 3183 /* 3184 * Use the new checks of production [4] [4a] amd [5] of the 3185 * Update 5 of XML-1.0 3186 */ 3187 if ((c != ' ') && (c != '>') && (c != '/') && /* accelerators */ 3188 (((c >= 'a') && (c <= 'z')) || 3189 ((c >= 'A') && (c <= 'Z')) || 3190 ((c >= '0') && (c <= '9')) || /* !start */ 3191 (c == '_') || (c == ':') || 3192 (c == '-') || (c == '.') || (c == 0xB7) || /* !start */ 3193 ((c >= 0xC0) && (c <= 0xD6)) || 3194 ((c >= 0xD8) && (c <= 0xF6)) || 3195 ((c >= 0xF8) && (c <= 0x2FF)) || 3196 ((c >= 0x300) && (c <= 0x36F)) || /* !start */ 3197 ((c >= 0x370) && (c <= 0x37D)) || 3198 ((c >= 0x37F) && (c <= 0x1FFF)) || 3199 ((c >= 0x200C) && (c <= 0x200D)) || 3200 ((c >= 0x203F) && (c <= 0x2040)) || /* !start */ 3201 ((c >= 0x2070) && (c <= 0x218F)) || 3202 ((c >= 0x2C00) && (c <= 0x2FEF)) || 3203 ((c >= 0x3001) && (c <= 0xD7FF)) || 3204 ((c >= 0xF900) && (c <= 0xFDCF)) || 3205 ((c >= 0xFDF0) && (c <= 0xFFFD)) || 3206 ((c >= 0x10000) && (c <= 0xEFFFF)))) 3207 return(1); 3208 } else { 3209 if ((IS_LETTER(c)) || (IS_DIGIT(c)) || 3210 (c == '.') || (c == '-') || 3211 (c == '_') || (c == ':') || 3212 (IS_COMBINING(c)) || 3213 (IS_EXTENDER(c))) 3214 return(1); 3215 } 3216 return(0); 3217 } 3218 3219 static xmlChar * xmlParseAttValueInternal(xmlParserCtxtPtr ctxt, 3220 int *len, int *alloc, int normalize); 3221 3222 static const xmlChar * 3223 xmlParseNameComplex(xmlParserCtxtPtr ctxt) { 3224 int len = 0, l; 3225 int c; 3226 int count = 0; 3227 3228 #ifdef DEBUG 3229 nbParseNameComplex++; 3230 #endif 3231 3232 /* 3233 * Handler for more complex cases 3234 */ 3235 GROW; 3236 if (ctxt->instate == XML_PARSER_EOF) 3237 return(NULL); 3238 c = CUR_CHAR(l); 3239 if ((ctxt->options & XML_PARSE_OLD10) == 0) { 3240 /* 3241 * Use the new checks of production [4] [4a] amd [5] of the 3242 * Update 5 of XML-1.0 3243 */ 3244 if ((c == ' ') || (c == '>') || (c == '/') || /* accelerators */ 3245 (!(((c >= 'a') && (c <= 'z')) || 3246 ((c >= 'A') && (c <= 'Z')) || 3247 (c == '_') || (c == ':') || 3248 ((c >= 0xC0) && (c <= 0xD6)) || 3249 ((c >= 0xD8) && (c <= 0xF6)) || 3250 ((c >= 0xF8) && (c <= 0x2FF)) || 3251 ((c >= 0x370) && (c <= 0x37D)) || 3252 ((c >= 0x37F) && (c <= 0x1FFF)) || 3253 ((c >= 0x200C) && (c <= 0x200D)) || 3254 ((c >= 0x2070) && (c <= 0x218F)) || 3255 ((c >= 0x2C00) && (c <= 0x2FEF)) || 3256 ((c >= 0x3001) && (c <= 0xD7FF)) || 3257 ((c >= 0xF900) && (c <= 0xFDCF)) || 3258 ((c >= 0xFDF0) && (c <= 0xFFFD)) || 3259 ((c >= 0x10000) && (c <= 0xEFFFF))))) { 3260 return(NULL); 3261 } 3262 len += l; 3263 NEXTL(l); 3264 c = CUR_CHAR(l); 3265 while ((c != ' ') && (c != '>') && (c != '/') && /* accelerators */ 3266 (((c >= 'a') && (c <= 'z')) || 3267 ((c >= 'A') && (c <= 'Z')) || 3268 ((c >= '0') && (c <= '9')) || /* !start */ 3269 (c == '_') || (c == ':') || 3270 (c == '-') || (c == '.') || (c == 0xB7) || /* !start */ 3271 ((c >= 0xC0) && (c <= 0xD6)) || 3272 ((c >= 0xD8) && (c <= 0xF6)) || 3273 ((c >= 0xF8) && (c <= 0x2FF)) || 3274 ((c >= 0x300) && (c <= 0x36F)) || /* !start */ 3275 ((c >= 0x370) && (c <= 0x37D)) || 3276 ((c >= 0x37F) && (c <= 0x1FFF)) || 3277 ((c >= 0x200C) && (c <= 0x200D)) || 3278 ((c >= 0x203F) && (c <= 0x2040)) || /* !start */ 3279 ((c >= 0x2070) && (c <= 0x218F)) || 3280 ((c >= 0x2C00) && (c <= 0x2FEF)) || 3281 ((c >= 0x3001) && (c <= 0xD7FF)) || 3282 ((c >= 0xF900) && (c <= 0xFDCF)) || 3283 ((c >= 0xFDF0) && (c <= 0xFFFD)) || 3284 ((c >= 0x10000) && (c <= 0xEFFFF)) 3285 )) { 3286 if (count++ > XML_PARSER_CHUNK_SIZE) { 3287 count = 0; 3288 GROW; 3289 if (ctxt->instate == XML_PARSER_EOF) 3290 return(NULL); 3291 } 3292 len += l; 3293 NEXTL(l); 3294 c = CUR_CHAR(l); 3295 } 3296 } else { 3297 if ((c == ' ') || (c == '>') || (c == '/') || /* accelerators */ 3298 (!IS_LETTER(c) && (c != '_') && 3299 (c != ':'))) { 3300 return(NULL); 3301 } 3302 len += l; 3303 NEXTL(l); 3304 c = CUR_CHAR(l); 3305 3306 while ((c != ' ') && (c != '>') && (c != '/') && /* test bigname.xml */ 3307 ((IS_LETTER(c)) || (IS_DIGIT(c)) || 3308 (c == '.') || (c == '-') || 3309 (c == '_') || (c == ':') || 3310 (IS_COMBINING(c)) || 3311 (IS_EXTENDER(c)))) { 3312 if (count++ > XML_PARSER_CHUNK_SIZE) { 3313 count = 0; 3314 GROW; 3315 if (ctxt->instate == XML_PARSER_EOF) 3316 return(NULL); 3317 } 3318 len += l; 3319 NEXTL(l); 3320 c = CUR_CHAR(l); 3321 if (c == 0) { 3322 count = 0; 3323 GROW; 3324 if (ctxt->instate == XML_PARSER_EOF) 3325 return(NULL); 3326 c = CUR_CHAR(l); 3327 } 3328 } 3329 } 3330 if ((len > XML_MAX_NAME_LENGTH) && 3331 ((ctxt->options & XML_PARSE_HUGE) == 0)) { 3332 xmlFatalErr(ctxt, XML_ERR_NAME_TOO_LONG, "Name"); 3333 return(NULL); 3334 } 3335 if ((*ctxt->input->cur == '\n') && (ctxt->input->cur[-1] == '\r')) 3336 return(xmlDictLookup(ctxt->dict, ctxt->input->cur - (len + 1), len)); 3337 return(xmlDictLookup(ctxt->dict, ctxt->input->cur - len, len)); 3338 } 3339 3340 /** 3341 * xmlParseName: 3342 * @ctxt: an XML parser context 3343 * 3344 * parse an XML name. 3345 * 3346 * [4] NameChar ::= Letter | Digit | '.' | '-' | '_' | ':' | 3347 * CombiningChar | Extender 3348 * 3349 * [5] Name ::= (Letter | '_' | ':') (NameChar)* 3350 * 3351 * [6] Names ::= Name (#x20 Name)* 3352 * 3353 * Returns the Name parsed or NULL 3354 */ 3355 3356 const xmlChar * 3357 xmlParseName(xmlParserCtxtPtr ctxt) { 3358 const xmlChar *in; 3359 const xmlChar *ret; 3360 int count = 0; 3361 3362 GROW; 3363 3364 #ifdef DEBUG 3365 nbParseName++; 3366 #endif 3367 3368 /* 3369 * Accelerator for simple ASCII names 3370 */ 3371 in = ctxt->input->cur; 3372 if (((*in >= 0x61) && (*in <= 0x7A)) || 3373 ((*in >= 0x41) && (*in <= 0x5A)) || 3374 (*in == '_') || (*in == ':')) { 3375 in++; 3376 while (((*in >= 0x61) && (*in <= 0x7A)) || 3377 ((*in >= 0x41) && (*in <= 0x5A)) || 3378 ((*in >= 0x30) && (*in <= 0x39)) || 3379 (*in == '_') || (*in == '-') || 3380 (*in == ':') || (*in == '.')) 3381 in++; 3382 if ((*in > 0) && (*in < 0x80)) { 3383 count = in - ctxt->input->cur; 3384 if ((count > XML_MAX_NAME_LENGTH) && 3385 ((ctxt->options & XML_PARSE_HUGE) == 0)) { 3386 xmlFatalErr(ctxt, XML_ERR_NAME_TOO_LONG, "Name"); 3387 return(NULL); 3388 } 3389 ret = xmlDictLookup(ctxt->dict, ctxt->input->cur, count); 3390 ctxt->input->cur = in; 3391 ctxt->nbChars += count; 3392 ctxt->input->col += count; 3393 if (ret == NULL) 3394 xmlErrMemory(ctxt, NULL); 3395 return(ret); 3396 } 3397 } 3398 /* accelerator for special cases */ 3399 return(xmlParseNameComplex(ctxt)); 3400 } 3401 3402 static const xmlChar * 3403 xmlParseNCNameComplex(xmlParserCtxtPtr ctxt) { 3404 int len = 0, l; 3405 int c; 3406 int count = 0; 3407 3408 #ifdef DEBUG 3409 nbParseNCNameComplex++; 3410 #endif 3411 3412 /* 3413 * Handler for more complex cases 3414 */ 3415 GROW; 3416 c = CUR_CHAR(l); 3417 if ((c == ' ') || (c == '>') || (c == '/') || /* accelerators */ 3418 (!xmlIsNameStartChar(ctxt, c) || (c == ':'))) { 3419 return(NULL); 3420 } 3421 3422 while ((c != ' ') && (c != '>') && (c != '/') && /* test bigname.xml */ 3423 (xmlIsNameChar(ctxt, c) && (c != ':'))) { 3424 if (count++ > XML_PARSER_CHUNK_SIZE) { 3425 if ((len > XML_MAX_NAME_LENGTH) && 3426 ((ctxt->options & XML_PARSE_HUGE) == 0)) { 3427 xmlFatalErr(ctxt, XML_ERR_NAME_TOO_LONG, "NCName"); 3428 return(NULL); 3429 } 3430 count = 0; 3431 GROW; 3432 if (ctxt->instate == XML_PARSER_EOF) 3433 return(NULL); 3434 } 3435 len += l; 3436 NEXTL(l); 3437 c = CUR_CHAR(l); 3438 if (c == 0) { 3439 count = 0; 3440 GROW; 3441 if (ctxt->instate == XML_PARSER_EOF) 3442 return(NULL); 3443 c = CUR_CHAR(l); 3444 } 3445 } 3446 if ((len > XML_MAX_NAME_LENGTH) && 3447 ((ctxt->options & XML_PARSE_HUGE) == 0)) { 3448 xmlFatalErr(ctxt, XML_ERR_NAME_TOO_LONG, "NCName"); 3449 return(NULL); 3450 } 3451 return(xmlDictLookup(ctxt->dict, ctxt->input->cur - len, len)); 3452 } 3453 3454 /** 3455 * xmlParseNCName: 3456 * @ctxt: an XML parser context 3457 * @len: length of the string parsed 3458 * 3459 * parse an XML name. 3460 * 3461 * [4NS] NCNameChar ::= Letter | Digit | '.' | '-' | '_' | 3462 * CombiningChar | Extender 3463 * 3464 * [5NS] NCName ::= (Letter | '_') (NCNameChar)* 3465 * 3466 * Returns the Name parsed or NULL 3467 */ 3468 3469 static const xmlChar * 3470 xmlParseNCName(xmlParserCtxtPtr ctxt) { 3471 const xmlChar *in; 3472 const xmlChar *ret; 3473 int count = 0; 3474 3475 #ifdef DEBUG 3476 nbParseNCName++; 3477 #endif 3478 3479 /* 3480 * Accelerator for simple ASCII names 3481 */ 3482 in = ctxt->input->cur; 3483 if (((*in >= 0x61) && (*in <= 0x7A)) || 3484 ((*in >= 0x41) && (*in <= 0x5A)) || 3485 (*in == '_')) { 3486 in++; 3487 while (((*in >= 0x61) && (*in <= 0x7A)) || 3488 ((*in >= 0x41) && (*in <= 0x5A)) || 3489 ((*in >= 0x30) && (*in <= 0x39)) || 3490 (*in == '_') || (*in == '-') || 3491 (*in == '.')) 3492 in++; 3493 if ((*in > 0) && (*in < 0x80)) { 3494 count = in - ctxt->input->cur; 3495 if ((count > XML_MAX_NAME_LENGTH) && 3496 ((ctxt->options & XML_PARSE_HUGE) == 0)) { 3497 xmlFatalErr(ctxt, XML_ERR_NAME_TOO_LONG, "NCName"); 3498 return(NULL); 3499 } 3500 ret = xmlDictLookup(ctxt->dict, ctxt->input->cur, count); 3501 ctxt->input->cur = in; 3502 ctxt->nbChars += count; 3503 ctxt->input->col += count; 3504 if (ret == NULL) { 3505 xmlErrMemory(ctxt, NULL); 3506 } 3507 return(ret); 3508 } 3509 } 3510 return(xmlParseNCNameComplex(ctxt)); 3511 } 3512 3513 /** 3514 * xmlParseNameAndCompare: 3515 * @ctxt: an XML parser context 3516 * 3517 * parse an XML name and compares for match 3518 * (specialized for endtag parsing) 3519 * 3520 * Returns NULL for an illegal name, (xmlChar*) 1 for success 3521 * and the name for mismatch 3522 */ 3523 3524 static const xmlChar * 3525 xmlParseNameAndCompare(xmlParserCtxtPtr ctxt, xmlChar const *other) { 3526 register const xmlChar *cmp = other; 3527 register const xmlChar *in; 3528 const xmlChar *ret; 3529 3530 GROW; 3531 if (ctxt->instate == XML_PARSER_EOF) 3532 return(NULL); 3533 3534 in = ctxt->input->cur; 3535 while (*in != 0 && *in == *cmp) { 3536 ++in; 3537 ++cmp; 3538 ctxt->input->col++; 3539 } 3540 if (*cmp == 0 && (*in == '>' || IS_BLANK_CH (*in))) { 3541 /* success */ 3542 ctxt->input->cur = in; 3543 return (const xmlChar*) 1; 3544 } 3545 /* failure (or end of input buffer), check with full function */ 3546 ret = xmlParseName (ctxt); 3547 /* strings coming from the dictionnary direct compare possible */ 3548 if (ret == other) { 3549 return (const xmlChar*) 1; 3550 } 3551 return ret; 3552 } 3553 3554 /** 3555 * xmlParseStringName: 3556 * @ctxt: an XML parser context 3557 * @str: a pointer to the string pointer (IN/OUT) 3558 * 3559 * parse an XML name. 3560 * 3561 * [4] NameChar ::= Letter | Digit | '.' | '-' | '_' | ':' | 3562 * CombiningChar | Extender 3563 * 3564 * [5] Name ::= (Letter | '_' | ':') (NameChar)* 3565 * 3566 * [6] Names ::= Name (#x20 Name)* 3567 * 3568 * Returns the Name parsed or NULL. The @str pointer 3569 * is updated to the current location in the string. 3570 */ 3571 3572 static xmlChar * 3573 xmlParseStringName(xmlParserCtxtPtr ctxt, const xmlChar** str) { 3574 xmlChar buf[XML_MAX_NAMELEN + 5]; 3575 const xmlChar *cur = *str; 3576 int len = 0, l; 3577 int c; 3578 3579 #ifdef DEBUG 3580 nbParseStringName++; 3581 #endif 3582 3583 c = CUR_SCHAR(cur, l); 3584 if (!xmlIsNameStartChar(ctxt, c)) { 3585 return(NULL); 3586 } 3587 3588 COPY_BUF(l,buf,len,c); 3589 cur += l; 3590 c = CUR_SCHAR(cur, l); 3591 while (xmlIsNameChar(ctxt, c)) { 3592 COPY_BUF(l,buf,len,c); 3593 cur += l; 3594 c = CUR_SCHAR(cur, l); 3595 if (len >= XML_MAX_NAMELEN) { /* test bigentname.xml */ 3596 /* 3597 * Okay someone managed to make a huge name, so he's ready to pay 3598 * for the processing speed. 3599 */ 3600 xmlChar *buffer; 3601 int max = len * 2; 3602 3603 buffer = (xmlChar *) xmlMallocAtomic(max * sizeof(xmlChar)); 3604 if (buffer == NULL) { 3605 xmlErrMemory(ctxt, NULL); 3606 return(NULL); 3607 } 3608 memcpy(buffer, buf, len); 3609 while (xmlIsNameChar(ctxt, c)) { 3610 if (len + 10 > max) { 3611 xmlChar *tmp; 3612 3613 if ((len > XML_MAX_NAME_LENGTH) && 3614 ((ctxt->options & XML_PARSE_HUGE) == 0)) { 3615 xmlFatalErr(ctxt, XML_ERR_NAME_TOO_LONG, "NCName"); 3616 xmlFree(buffer); 3617 return(NULL); 3618 } 3619 max *= 2; 3620 tmp = (xmlChar *) xmlRealloc(buffer, 3621 max * sizeof(xmlChar)); 3622 if (tmp == NULL) { 3623 xmlErrMemory(ctxt, NULL); 3624 xmlFree(buffer); 3625 return(NULL); 3626 } 3627 buffer = tmp; 3628 } 3629 COPY_BUF(l,buffer,len,c); 3630 cur += l; 3631 c = CUR_SCHAR(cur, l); 3632 } 3633 buffer[len] = 0; 3634 *str = cur; 3635 return(buffer); 3636 } 3637 } 3638 if ((len > XML_MAX_NAME_LENGTH) && 3639 ((ctxt->options & XML_PARSE_HUGE) == 0)) { 3640 xmlFatalErr(ctxt, XML_ERR_NAME_TOO_LONG, "NCName"); 3641 return(NULL); 3642 } 3643 *str = cur; 3644 return(xmlStrndup(buf, len)); 3645 } 3646 3647 /** 3648 * xmlParseNmtoken: 3649 * @ctxt: an XML parser context 3650 * 3651 * parse an XML Nmtoken. 3652 * 3653 * [7] Nmtoken ::= (NameChar)+ 3654 * 3655 * [8] Nmtokens ::= Nmtoken (#x20 Nmtoken)* 3656 * 3657 * Returns the Nmtoken parsed or NULL 3658 */ 3659 3660 xmlChar * 3661 xmlParseNmtoken(xmlParserCtxtPtr ctxt) { 3662 xmlChar buf[XML_MAX_NAMELEN + 5]; 3663 int len = 0, l; 3664 int c; 3665 int count = 0; 3666 3667 #ifdef DEBUG 3668 nbParseNmToken++; 3669 #endif 3670 3671 GROW; 3672 if (ctxt->instate == XML_PARSER_EOF) 3673 return(NULL); 3674 c = CUR_CHAR(l); 3675 3676 while (xmlIsNameChar(ctxt, c)) { 3677 if (count++ > XML_PARSER_CHUNK_SIZE) { 3678 count = 0; 3679 GROW; 3680 } 3681 COPY_BUF(l,buf,len,c); 3682 NEXTL(l); 3683 c = CUR_CHAR(l); 3684 if (c == 0) { 3685 count = 0; 3686 GROW; 3687 if (ctxt->instate == XML_PARSER_EOF) 3688 return(NULL); 3689 c = CUR_CHAR(l); 3690 } 3691 if (len >= XML_MAX_NAMELEN) { 3692 /* 3693 * Okay someone managed to make a huge token, so he's ready to pay 3694 * for the processing speed. 3695 */ 3696 xmlChar *buffer; 3697 int max = len * 2; 3698 3699 buffer = (xmlChar *) xmlMallocAtomic(max * sizeof(xmlChar)); 3700 if (buffer == NULL) { 3701 xmlErrMemory(ctxt, NULL); 3702 return(NULL); 3703 } 3704 memcpy(buffer, buf, len); 3705 while (xmlIsNameChar(ctxt, c)) { 3706 if (count++ > XML_PARSER_CHUNK_SIZE) { 3707 count = 0; 3708 GROW; 3709 if (ctxt->instate == XML_PARSER_EOF) { 3710 xmlFree(buffer); 3711 return(NULL); 3712 } 3713 } 3714 if (len + 10 > max) { 3715 xmlChar *tmp; 3716 3717 if ((max > XML_MAX_NAME_LENGTH) && 3718 ((ctxt->options & XML_PARSE_HUGE) == 0)) { 3719 xmlFatalErr(ctxt, XML_ERR_NAME_TOO_LONG, "NmToken"); 3720 xmlFree(buffer); 3721 return(NULL); 3722 } 3723 max *= 2; 3724 tmp = (xmlChar *) xmlRealloc(buffer, 3725 max * sizeof(xmlChar)); 3726 if (tmp == NULL) { 3727 xmlErrMemory(ctxt, NULL); 3728 xmlFree(buffer); 3729 return(NULL); 3730 } 3731 buffer = tmp; 3732 } 3733 COPY_BUF(l,buffer,len,c); 3734 NEXTL(l); 3735 c = CUR_CHAR(l); 3736 } 3737 buffer[len] = 0; 3738 return(buffer); 3739 } 3740 } 3741 if (len == 0) 3742 return(NULL); 3743 if ((len > XML_MAX_NAME_LENGTH) && 3744 ((ctxt->options & XML_PARSE_HUGE) == 0)) { 3745 xmlFatalErr(ctxt, XML_ERR_NAME_TOO_LONG, "NmToken"); 3746 return(NULL); 3747 } 3748 return(xmlStrndup(buf, len)); 3749 } 3750 3751 /** 3752 * xmlParseEntityValue: 3753 * @ctxt: an XML parser context 3754 * @orig: if non-NULL store a copy of the original entity value 3755 * 3756 * parse a value for ENTITY declarations 3757 * 3758 * [9] EntityValue ::= '"' ([^%&"] | PEReference | Reference)* '"' | 3759 * "'" ([^%&'] | PEReference | Reference)* "'" 3760 * 3761 * Returns the EntityValue parsed with reference substituted or NULL 3762 */ 3763 3764 xmlChar * 3765 xmlParseEntityValue(xmlParserCtxtPtr ctxt, xmlChar **orig) { 3766 xmlChar *buf = NULL; 3767 int len = 0; 3768 int size = XML_PARSER_BUFFER_SIZE; 3769 int c, l; 3770 xmlChar stop; 3771 xmlChar *ret = NULL; 3772 const xmlChar *cur = NULL; 3773 xmlParserInputPtr input; 3774 3775 if (RAW == '"') stop = '"'; 3776 else if (RAW == '\'') stop = '\''; 3777 else { 3778 xmlFatalErr(ctxt, XML_ERR_ENTITY_NOT_STARTED, NULL); 3779 return(NULL); 3780 } 3781 buf = (xmlChar *) xmlMallocAtomic(size * sizeof(xmlChar)); 3782 if (buf == NULL) { 3783 xmlErrMemory(ctxt, NULL); 3784 return(NULL); 3785 } 3786 3787 /* 3788 * The content of the entity definition is copied in a buffer. 3789 */ 3790 3791 ctxt->instate = XML_PARSER_ENTITY_VALUE; 3792 input = ctxt->input; 3793 GROW; 3794 if (ctxt->instate == XML_PARSER_EOF) { 3795 xmlFree(buf); 3796 return(NULL); 3797 } 3798 NEXT; 3799 c = CUR_CHAR(l); 3800 /* 3801 * NOTE: 4.4.5 Included in Literal 3802 * When a parameter entity reference appears in a literal entity 3803 * value, ... a single or double quote character in the replacement 3804 * text is always treated as a normal data character and will not 3805 * terminate the literal. 3806 * In practice it means we stop the loop only when back at parsing 3807 * the initial entity and the quote is found 3808 */ 3809 while (((IS_CHAR(c)) && ((c != stop) || /* checked */ 3810 (ctxt->input != input))) && (ctxt->instate != XML_PARSER_EOF)) { 3811 if (len + 5 >= size) { 3812 xmlChar *tmp; 3813 3814 size *= 2; 3815 tmp = (xmlChar *) xmlRealloc(buf, size * sizeof(xmlChar)); 3816 if (tmp == NULL) { 3817 xmlErrMemory(ctxt, NULL); 3818 xmlFree(buf); 3819 return(NULL); 3820 } 3821 buf = tmp; 3822 } 3823 COPY_BUF(l,buf,len,c); 3824 NEXTL(l); 3825 /* 3826 * Pop-up of finished entities. 3827 */ 3828 while ((RAW == 0) && (ctxt->inputNr > 1)) /* non input consuming */ 3829 xmlPopInput(ctxt); 3830 3831 GROW; 3832 c = CUR_CHAR(l); 3833 if (c == 0) { 3834 GROW; 3835 c = CUR_CHAR(l); 3836 } 3837 } 3838 buf[len] = 0; 3839 if (ctxt->instate == XML_PARSER_EOF) { 3840 xmlFree(buf); 3841 return(NULL); 3842 } 3843 3844 /* 3845 * Raise problem w.r.t. '&' and '%' being used in non-entities 3846 * reference constructs. Note Charref will be handled in 3847 * xmlStringDecodeEntities() 3848 */ 3849 cur = buf; 3850 while (*cur != 0) { /* non input consuming */ 3851 if ((*cur == '%') || ((*cur == '&') && (cur[1] != '#'))) { 3852 xmlChar *name; 3853 xmlChar tmp = *cur; 3854 3855 cur++; 3856 name = xmlParseStringName(ctxt, &cur); 3857 if ((name == NULL) || (*cur != ';')) { 3858 xmlFatalErrMsgInt(ctxt, XML_ERR_ENTITY_CHAR_ERROR, 3859 "EntityValue: '%c' forbidden except for entities references\n", 3860 tmp); 3861 } 3862 if ((tmp == '%') && (ctxt->inSubset == 1) && 3863 (ctxt->inputNr == 1)) { 3864 xmlFatalErr(ctxt, XML_ERR_ENTITY_PE_INTERNAL, NULL); 3865 } 3866 if (name != NULL) 3867 xmlFree(name); 3868 if (*cur == 0) 3869 break; 3870 } 3871 cur++; 3872 } 3873 3874 /* 3875 * Then PEReference entities are substituted. 3876 */ 3877 if (c != stop) { 3878 xmlFatalErr(ctxt, XML_ERR_ENTITY_NOT_FINISHED, NULL); 3879 xmlFree(buf); 3880 } else { 3881 NEXT; 3882 /* 3883 * NOTE: 4.4.7 Bypassed 3884 * When a general entity reference appears in the EntityValue in 3885 * an entity declaration, it is bypassed and left as is. 3886 * so XML_SUBSTITUTE_REF is not set here. 3887 */ 3888 ret = xmlStringDecodeEntities(ctxt, buf, XML_SUBSTITUTE_PEREF, 3889 0, 0, 0); 3890 if (orig != NULL) 3891 *orig = buf; 3892 else 3893 xmlFree(buf); 3894 } 3895 3896 return(ret); 3897 } 3898 3899 /** 3900 * xmlParseAttValueComplex: 3901 * @ctxt: an XML parser context 3902 * @len: the resulting attribute len 3903 * @normalize: wether to apply the inner normalization 3904 * 3905 * parse a value for an attribute, this is the fallback function 3906 * of xmlParseAttValue() when the attribute parsing requires handling 3907 * of non-ASCII characters, or normalization compaction. 3908 * 3909 * Returns the AttValue parsed or NULL. The value has to be freed by the caller. 3910 */ 3911 static xmlChar * 3912 xmlParseAttValueComplex(xmlParserCtxtPtr ctxt, int *attlen, int normalize) { 3913 xmlChar limit = 0; 3914 xmlChar *buf = NULL; 3915 xmlChar *rep = NULL; 3916 size_t len = 0; 3917 size_t buf_size = 0; 3918 int c, l, in_space = 0; 3919 xmlChar *current = NULL; 3920 xmlEntityPtr ent; 3921 3922 if (NXT(0) == '"') { 3923 ctxt->instate = XML_PARSER_ATTRIBUTE_VALUE; 3924 limit = '"'; 3925 NEXT; 3926 } else if (NXT(0) == '\'') { 3927 limit = '\''; 3928 ctxt->instate = XML_PARSER_ATTRIBUTE_VALUE; 3929 NEXT; 3930 } else { 3931 xmlFatalErr(ctxt, XML_ERR_ATTRIBUTE_NOT_STARTED, NULL); 3932 return(NULL); 3933 } 3934 3935 /* 3936 * allocate a translation buffer. 3937 */ 3938 buf_size = XML_PARSER_BUFFER_SIZE; 3939 buf = (xmlChar *) xmlMallocAtomic(buf_size); 3940 if (buf == NULL) goto mem_error; 3941 3942 /* 3943 * OK loop until we reach one of the ending char or a size limit. 3944 */ 3945 c = CUR_CHAR(l); 3946 while (((NXT(0) != limit) && /* checked */ 3947 (IS_CHAR(c)) && (c != '<')) && 3948 (ctxt->instate != XML_PARSER_EOF)) { 3949 /* 3950 * Impose a reasonable limit on attribute size, unless XML_PARSE_HUGE 3951 * special option is given 3952 */ 3953 if ((len > XML_MAX_TEXT_LENGTH) && 3954 ((ctxt->options & XML_PARSE_HUGE) == 0)) { 3955 xmlFatalErrMsg(ctxt, XML_ERR_ATTRIBUTE_NOT_FINISHED, 3956 "AttValue length too long\n"); 3957 goto mem_error; 3958 } 3959 if (c == 0) break; 3960 if (c == '&') { 3961 in_space = 0; 3962 if (NXT(1) == '#') { 3963 int val = xmlParseCharRef(ctxt); 3964 3965 if (val == '&') { 3966 if (ctxt->replaceEntities) { 3967 if (len + 10 > buf_size) { 3968 growBuffer(buf, 10); 3969 } 3970 buf[len++] = '&'; 3971 } else { 3972 /* 3973 * The reparsing will be done in xmlStringGetNodeList() 3974 * called by the attribute() function in SAX.c 3975 */ 3976 if (len + 10 > buf_size) { 3977 growBuffer(buf, 10); 3978 } 3979 buf[len++] = '&'; 3980 buf[len++] = '#'; 3981 buf[len++] = '3'; 3982 buf[len++] = '8'; 3983 buf[len++] = ';'; 3984 } 3985 } else if (val != 0) { 3986 if (len + 10 > buf_size) { 3987 growBuffer(buf, 10); 3988 } 3989 len += xmlCopyChar(0, &buf[len], val); 3990 } 3991 } else { 3992 ent = xmlParseEntityRef(ctxt); 3993 ctxt->nbentities++; 3994 if (ent != NULL) 3995 ctxt->nbentities += ent->owner; 3996 if ((ent != NULL) && 3997 (ent->etype == XML_INTERNAL_PREDEFINED_ENTITY)) { 3998 if (len + 10 > buf_size) { 3999 growBuffer(buf, 10); 4000 } 4001 if ((ctxt->replaceEntities == 0) && 4002 (ent->content[0] == '&')) { 4003 buf[len++] = '&'; 4004 buf[len++] = '#'; 4005 buf[len++] = '3'; 4006 buf[len++] = '8'; 4007 buf[len++] = ';'; 4008 } else { 4009 buf[len++] = ent->content[0]; 4010 } 4011 } else if ((ent != NULL) && 4012 (ctxt->replaceEntities != 0)) { 4013 if (ent->etype != XML_INTERNAL_PREDEFINED_ENTITY) { 4014 rep = xmlStringDecodeEntities(ctxt, ent->content, 4015 XML_SUBSTITUTE_REF, 4016 0, 0, 0); 4017 if (rep != NULL) { 4018 current = rep; 4019 while (*current != 0) { /* non input consuming */ 4020 if ((*current == 0xD) || (*current == 0xA) || 4021 (*current == 0x9)) { 4022 buf[len++] = 0x20; 4023 current++; 4024 } else 4025 buf[len++] = *current++; 4026 if (len + 10 > buf_size) { 4027 growBuffer(buf, 10); 4028 } 4029 } 4030 xmlFree(rep); 4031 rep = NULL; 4032 } 4033 } else { 4034 if (len + 10 > buf_size) { 4035 growBuffer(buf, 10); 4036 } 4037 if (ent->content != NULL) 4038 buf[len++] = ent->content[0]; 4039 } 4040 } else if (ent != NULL) { 4041 int i = xmlStrlen(ent->name); 4042 const xmlChar *cur = ent->name; 4043 4044 /* 4045 * This may look absurd but is needed to detect 4046 * entities problems 4047 */ 4048 if ((ent->etype != XML_INTERNAL_PREDEFINED_ENTITY) && 4049 (ent->content != NULL) && (ent->checked == 0)) { 4050 unsigned long oldnbent = ctxt->nbentities; 4051 4052 rep = xmlStringDecodeEntities(ctxt, ent->content, 4053 XML_SUBSTITUTE_REF, 0, 0, 0); 4054 4055 ent->checked = (ctxt->nbentities - oldnbent + 1) * 2; 4056 if (rep != NULL) { 4057 if (xmlStrchr(rep, '<')) 4058 ent->checked |= 1; 4059 xmlFree(rep); 4060 rep = NULL; 4061 } 4062 } 4063 4064 /* 4065 * Just output the reference 4066 */ 4067 buf[len++] = '&'; 4068 while (len + i + 10 > buf_size) { 4069 growBuffer(buf, i + 10); 4070 } 4071 for (;i > 0;i--) 4072 buf[len++] = *cur++; 4073 buf[len++] = ';'; 4074 } 4075 } 4076 } else { 4077 if ((c == 0x20) || (c == 0xD) || (c == 0xA) || (c == 0x9)) { 4078 if ((len != 0) || (!normalize)) { 4079 if ((!normalize) || (!in_space)) { 4080 COPY_BUF(l,buf,len,0x20); 4081 while (len + 10 > buf_size) { 4082 growBuffer(buf, 10); 4083 } 4084 } 4085 in_space = 1; 4086 } 4087 } else { 4088 in_space = 0; 4089 COPY_BUF(l,buf,len,c); 4090 if (len + 10 > buf_size) { 4091 growBuffer(buf, 10); 4092 } 4093 } 4094 NEXTL(l); 4095 } 4096 GROW; 4097 c = CUR_CHAR(l); 4098 } 4099 if (ctxt->instate == XML_PARSER_EOF) 4100 goto error; 4101 4102 if ((in_space) && (normalize)) { 4103 while ((len > 0) && (buf[len - 1] == 0x20)) len--; 4104 } 4105 buf[len] = 0; 4106 if (RAW == '<') { 4107 xmlFatalErr(ctxt, XML_ERR_LT_IN_ATTRIBUTE, NULL); 4108 } else if (RAW != limit) { 4109 if ((c != 0) && (!IS_CHAR(c))) { 4110 xmlFatalErrMsg(ctxt, XML_ERR_INVALID_CHAR, 4111 "invalid character in attribute value\n"); 4112 } else { 4113 xmlFatalErrMsg(ctxt, XML_ERR_ATTRIBUTE_NOT_FINISHED, 4114 "AttValue: ' expected\n"); 4115 } 4116 } else 4117 NEXT; 4118 4119 /* 4120 * There we potentially risk an overflow, don't allow attribute value of 4121 * length more than INT_MAX it is a very reasonnable assumption ! 4122 */ 4123 if (len >= INT_MAX) { 4124 xmlFatalErrMsg(ctxt, XML_ERR_ATTRIBUTE_NOT_FINISHED, 4125 "AttValue length too long\n"); 4126 goto mem_error; 4127 } 4128 4129 if (attlen != NULL) *attlen = (int) len; 4130 return(buf); 4131 4132 mem_error: 4133 xmlErrMemory(ctxt, NULL); 4134 error: 4135 if (buf != NULL) 4136 xmlFree(buf); 4137 if (rep != NULL) 4138 xmlFree(rep); 4139 return(NULL); 4140 } 4141 4142 /** 4143 * xmlParseAttValue: 4144 * @ctxt: an XML parser context 4145 * 4146 * parse a value for an attribute 4147 * Note: the parser won't do substitution of entities here, this 4148 * will be handled later in xmlStringGetNodeList 4149 * 4150 * [10] AttValue ::= '"' ([^<&"] | Reference)* '"' | 4151 * "'" ([^<&'] | Reference)* "'" 4152 * 4153 * 3.3.3 Attribute-Value Normalization: 4154 * Before the value of an attribute is passed to the application or 4155 * checked for validity, the XML processor must normalize it as follows: 4156 * - a character reference is processed by appending the referenced 4157 * character to the attribute value 4158 * - an entity reference is processed by recursively processing the 4159 * replacement text of the entity 4160 * - a whitespace character (#x20, #xD, #xA, #x9) is processed by 4161 * appending #x20 to the normalized value, except that only a single 4162 * #x20 is appended for a "#xD#xA" sequence that is part of an external 4163 * parsed entity or the literal entity value of an internal parsed entity 4164 * - other characters are processed by appending them to the normalized value 4165 * If the declared value is not CDATA, then the XML processor must further 4166 * process the normalized attribute value by discarding any leading and 4167 * trailing space (#x20) characters, and by replacing sequences of space 4168 * (#x20) characters by a single space (#x20) character. 4169 * All attributes for which no declaration has been read should be treated 4170 * by a non-validating parser as if declared CDATA. 4171 * 4172 * Returns the AttValue parsed or NULL. The value has to be freed by the caller. 4173 */ 4174 4175 4176 xmlChar * 4177 xmlParseAttValue(xmlParserCtxtPtr ctxt) { 4178 if ((ctxt == NULL) || (ctxt->input == NULL)) return(NULL); 4179 return(xmlParseAttValueInternal(ctxt, NULL, NULL, 0)); 4180 } 4181 4182 /** 4183 * xmlParseSystemLiteral: 4184 * @ctxt: an XML parser context 4185 * 4186 * parse an XML Literal 4187 * 4188 * [11] SystemLiteral ::= ('"' [^"]* '"') | ("'" [^']* "'") 4189 * 4190 * Returns the SystemLiteral parsed or NULL 4191 */ 4192 4193 xmlChar * 4194 xmlParseSystemLiteral(xmlParserCtxtPtr ctxt) { 4195 xmlChar *buf = NULL; 4196 int len = 0; 4197 int size = XML_PARSER_BUFFER_SIZE; 4198 int cur, l; 4199 xmlChar stop; 4200 int state = ctxt->instate; 4201 int count = 0; 4202 4203 SHRINK; 4204 if (RAW == '"') { 4205 NEXT; 4206 stop = '"'; 4207 } else if (RAW == '\'') { 4208 NEXT; 4209 stop = '\''; 4210 } else { 4211 xmlFatalErr(ctxt, XML_ERR_LITERAL_NOT_STARTED, NULL); 4212 return(NULL); 4213 } 4214 4215 buf = (xmlChar *) xmlMallocAtomic(size * sizeof(xmlChar)); 4216 if (buf == NULL) { 4217 xmlErrMemory(ctxt, NULL); 4218 return(NULL); 4219 } 4220 ctxt->instate = XML_PARSER_SYSTEM_LITERAL; 4221 cur = CUR_CHAR(l); 4222 while ((IS_CHAR(cur)) && (cur != stop)) { /* checked */ 4223 if (len + 5 >= size) { 4224 xmlChar *tmp; 4225 4226 if ((size > XML_MAX_NAME_LENGTH) && 4227 ((ctxt->options & XML_PARSE_HUGE) == 0)) { 4228 xmlFatalErr(ctxt, XML_ERR_NAME_TOO_LONG, "SystemLiteral"); 4229 xmlFree(buf); 4230 ctxt->instate = (xmlParserInputState) state; 4231 return(NULL); 4232 } 4233 size *= 2; 4234 tmp = (xmlChar *) xmlRealloc(buf, size * sizeof(xmlChar)); 4235 if (tmp == NULL) { 4236 xmlFree(buf); 4237 xmlErrMemory(ctxt, NULL); 4238 ctxt->instate = (xmlParserInputState) state; 4239 return(NULL); 4240 } 4241 buf = tmp; 4242 } 4243 count++; 4244 if (count > 50) { 4245 GROW; 4246 count = 0; 4247 if (ctxt->instate == XML_PARSER_EOF) { 4248 xmlFree(buf); 4249 return(NULL); 4250 } 4251 } 4252 COPY_BUF(l,buf,len,cur); 4253 NEXTL(l); 4254 cur = CUR_CHAR(l); 4255 if (cur == 0) { 4256 GROW; 4257 SHRINK; 4258 cur = CUR_CHAR(l); 4259 } 4260 } 4261 buf[len] = 0; 4262 ctxt->instate = (xmlParserInputState) state; 4263 if (!IS_CHAR(cur)) { 4264 xmlFatalErr(ctxt, XML_ERR_LITERAL_NOT_FINISHED, NULL); 4265 } else { 4266 NEXT; 4267 } 4268 return(buf); 4269 } 4270 4271 /** 4272 * xmlParsePubidLiteral: 4273 * @ctxt: an XML parser context 4274 * 4275 * parse an XML public literal 4276 * 4277 * [12] PubidLiteral ::= '"' PubidChar* '"' | "'" (PubidChar - "'")* "'" 4278 * 4279 * Returns the PubidLiteral parsed or NULL. 4280 */ 4281 4282 xmlChar * 4283 xmlParsePubidLiteral(xmlParserCtxtPtr ctxt) { 4284 xmlChar *buf = NULL; 4285 int len = 0; 4286 int size = XML_PARSER_BUFFER_SIZE; 4287 xmlChar cur; 4288 xmlChar stop; 4289 int count = 0; 4290 xmlParserInputState oldstate = ctxt->instate; 4291 4292 SHRINK; 4293 if (RAW == '"') { 4294 NEXT; 4295 stop = '"'; 4296 } else if (RAW == '\'') { 4297 NEXT; 4298 stop = '\''; 4299 } else { 4300 xmlFatalErr(ctxt, XML_ERR_LITERAL_NOT_STARTED, NULL); 4301 return(NULL); 4302 } 4303 buf = (xmlChar *) xmlMallocAtomic(size * sizeof(xmlChar)); 4304 if (buf == NULL) { 4305 xmlErrMemory(ctxt, NULL); 4306 return(NULL); 4307 } 4308 ctxt->instate = XML_PARSER_PUBLIC_LITERAL; 4309 cur = CUR; 4310 while ((IS_PUBIDCHAR_CH(cur)) && (cur != stop)) { /* checked */ 4311 if (len + 1 >= size) { 4312 xmlChar *tmp; 4313 4314 if ((size > XML_MAX_NAME_LENGTH) && 4315 ((ctxt->options & XML_PARSE_HUGE) == 0)) { 4316 xmlFatalErr(ctxt, XML_ERR_NAME_TOO_LONG, "Public ID"); 4317 xmlFree(buf); 4318 return(NULL); 4319 } 4320 size *= 2; 4321 tmp = (xmlChar *) xmlRealloc(buf, size * sizeof(xmlChar)); 4322 if (tmp == NULL) { 4323 xmlErrMemory(ctxt, NULL); 4324 xmlFree(buf); 4325 return(NULL); 4326 } 4327 buf = tmp; 4328 } 4329 buf[len++] = cur; 4330 count++; 4331 if (count > 50) { 4332 GROW; 4333 count = 0; 4334 if (ctxt->instate == XML_PARSER_EOF) { 4335 xmlFree(buf); 4336 return(NULL); 4337 } 4338 } 4339 NEXT; 4340 cur = CUR; 4341 if (cur == 0) { 4342 GROW; 4343 SHRINK; 4344 cur = CUR; 4345 } 4346 } 4347 buf[len] = 0; 4348 if (cur != stop) { 4349 xmlFatalErr(ctxt, XML_ERR_LITERAL_NOT_FINISHED, NULL); 4350 } else { 4351 NEXT; 4352 } 4353 ctxt->instate = oldstate; 4354 return(buf); 4355 } 4356 4357 static void xmlParseCharDataComplex(xmlParserCtxtPtr ctxt, int cdata); 4358 4359 /* 4360 * used for the test in the inner loop of the char data testing 4361 */ 4362 static const unsigned char test_char_data[256] = { 4363 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 4364 0x00, 0x09, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, /* 0x9, CR/LF separated */ 4365 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 4366 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 4367 0x20, 0x21, 0x22, 0x23, 0x24, 0x25, 0x00, 0x27, /* & */ 4368 0x28, 0x29, 0x2A, 0x2B, 0x2C, 0x2D, 0x2E, 0x2F, 4369 0x30, 0x31, 0x32, 0x33, 0x34, 0x35, 0x36, 0x37, 4370 0x38, 0x39, 0x3A, 0x3B, 0x00, 0x3D, 0x3E, 0x3F, /* < */ 4371 0x40, 0x41, 0x42, 0x43, 0x44, 0x45, 0x46, 0x47, 4372 0x48, 0x49, 0x4A, 0x4B, 0x4C, 0x4D, 0x4E, 0x4F, 4373 0x50, 0x51, 0x52, 0x53, 0x54, 0x55, 0x56, 0x57, 4374 0x58, 0x59, 0x5A, 0x5B, 0x5C, 0x00, 0x5E, 0x5F, /* ] */ 4375 0x60, 0x61, 0x62, 0x63, 0x64, 0x65, 0x66, 0x67, 4376 0x68, 0x69, 0x6A, 0x6B, 0x6C, 0x6D, 0x6E, 0x6F, 4377 0x70, 0x71, 0x72, 0x73, 0x74, 0x75, 0x76, 0x77, 4378 0x78, 0x79, 0x7A, 0x7B, 0x7C, 0x7D, 0x7E, 0x7F, 4379 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, /* non-ascii */ 4380 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 4381 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 4382 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 4383 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 4384 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 4385 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 4386 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 4387 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 4388 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 4389 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 4390 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 4391 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 4392 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 4393 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 4394 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 4395 }; 4396 4397 /** 4398 * xmlParseCharData: 4399 * @ctxt: an XML parser context 4400 * @cdata: int indicating whether we are within a CDATA section 4401 * 4402 * parse a CharData section. 4403 * if we are within a CDATA section ']]>' marks an end of section. 4404 * 4405 * The right angle bracket (>) may be represented using the string ">", 4406 * and must, for compatibility, be escaped using ">" or a character 4407 * reference when it appears in the string "]]>" in content, when that 4408 * string is not marking the end of a CDATA section. 4409 * 4410 * [14] CharData ::= [^<&]* - ([^<&]* ']]>' [^<&]*) 4411 */ 4412 4413 void 4414 xmlParseCharData(xmlParserCtxtPtr ctxt, int cdata) { 4415 const xmlChar *in; 4416 int nbchar = 0; 4417 int line = ctxt->input->line; 4418 int col = ctxt->input->col; 4419 int ccol; 4420 4421 SHRINK; 4422 GROW; 4423 /* 4424 * Accelerated common case where input don't need to be 4425 * modified before passing it to the handler. 4426 */ 4427 if (!cdata) { 4428 in = ctxt->input->cur; 4429 do { 4430 get_more_space: 4431 while (*in == 0x20) { in++; ctxt->input->col++; } 4432 if (*in == 0xA) { 4433 do { 4434 ctxt->input->line++; ctxt->input->col = 1; 4435 in++; 4436 } while (*in == 0xA); 4437 goto get_more_space; 4438 } 4439 if (*in == '<') { 4440 nbchar = in - ctxt->input->cur; 4441 if (nbchar > 0) { 4442 const xmlChar *tmp = ctxt->input->cur; 4443 ctxt->input->cur = in; 4444 4445 if ((ctxt->sax != NULL) && 4446 (ctxt->sax->ignorableWhitespace != 4447 ctxt->sax->characters)) { 4448 if (areBlanks(ctxt, tmp, nbchar, 1)) { 4449 if (ctxt->sax->ignorableWhitespace != NULL) 4450 ctxt->sax->ignorableWhitespace(ctxt->userData, 4451 tmp, nbchar); 4452 } else { 4453 if (ctxt->sax->characters != NULL) 4454 ctxt->sax->characters(ctxt->userData, 4455 tmp, nbchar); 4456 if (*ctxt->space == -1) 4457 *ctxt->space = -2; 4458 } 4459 } else if ((ctxt->sax != NULL) && 4460 (ctxt->sax->characters != NULL)) { 4461 ctxt->sax->characters(ctxt->userData, 4462 tmp, nbchar); 4463 } 4464 } 4465 return; 4466 } 4467 4468 get_more: 4469 ccol = ctxt->input->col; 4470 while (test_char_data[*in]) { 4471 in++; 4472 ccol++; 4473 } 4474 ctxt->input->col = ccol; 4475 if (*in == 0xA) { 4476 do { 4477 ctxt->input->line++; ctxt->input->col = 1; 4478 in++; 4479 } while (*in == 0xA); 4480 goto get_more; 4481 } 4482 if (*in == ']') { 4483 if ((in[1] == ']') && (in[2] == '>')) { 4484 xmlFatalErr(ctxt, XML_ERR_MISPLACED_CDATA_END, NULL); 4485 ctxt->input->cur = in; 4486 return; 4487 } 4488 in++; 4489 ctxt->input->col++; 4490 goto get_more; 4491 } 4492 nbchar = in - ctxt->input->cur; 4493 if (nbchar > 0) { 4494 if ((ctxt->sax != NULL) && 4495 (ctxt->sax->ignorableWhitespace != 4496 ctxt->sax->characters) && 4497 (IS_BLANK_CH(*ctxt->input->cur))) { 4498 const xmlChar *tmp = ctxt->input->cur; 4499 ctxt->input->cur = in; 4500 4501 if (areBlanks(ctxt, tmp, nbchar, 0)) { 4502 if (ctxt->sax->ignorableWhitespace != NULL) 4503 ctxt->sax->ignorableWhitespace(ctxt->userData, 4504 tmp, nbchar); 4505 } else { 4506 if (ctxt->sax->characters != NULL) 4507 ctxt->sax->characters(ctxt->userData, 4508 tmp, nbchar); 4509 if (*ctxt->space == -1) 4510 *ctxt->space = -2; 4511 } 4512 line = ctxt->input->line; 4513 col = ctxt->input->col; 4514 } else if (ctxt->sax != NULL) { 4515 if (ctxt->sax->characters != NULL) 4516 ctxt->sax->characters(ctxt->userData, 4517 ctxt->input->cur, nbchar); 4518 line = ctxt->input->line; 4519 col = ctxt->input->col; 4520 } 4521 /* something really bad happened in the SAX callback */ 4522 if (ctxt->instate != XML_PARSER_CONTENT) 4523 return; 4524 } 4525 ctxt->input->cur = in; 4526 if (*in == 0xD) { 4527 in++; 4528 if (*in == 0xA) { 4529 ctxt->input->cur = in; 4530 in++; 4531 ctxt->input->line++; ctxt->input->col = 1; 4532 continue; /* while */ 4533 } 4534 in--; 4535 } 4536 if (*in == '<') { 4537 return; 4538 } 4539 if (*in == '&') { 4540 return; 4541 } 4542 SHRINK; 4543 GROW; 4544 if (ctxt->instate == XML_PARSER_EOF) 4545 return; 4546 in = ctxt->input->cur; 4547 } while (((*in >= 0x20) && (*in <= 0x7F)) || (*in == 0x09)); 4548 nbchar = 0; 4549 } 4550 ctxt->input->line = line; 4551 ctxt->input->col = col; 4552 xmlParseCharDataComplex(ctxt, cdata); 4553 } 4554 4555 /** 4556 * xmlParseCharDataComplex: 4557 * @ctxt: an XML parser context 4558 * @cdata: int indicating whether we are within a CDATA section 4559 * 4560 * parse a CharData section.this is the fallback function 4561 * of xmlParseCharData() when the parsing requires handling 4562 * of non-ASCII characters. 4563 */ 4564 static void 4565 xmlParseCharDataComplex(xmlParserCtxtPtr ctxt, int cdata) { 4566 xmlChar buf[XML_PARSER_BIG_BUFFER_SIZE + 5]; 4567 int nbchar = 0; 4568 int cur, l; 4569 int count = 0; 4570 4571 SHRINK; 4572 GROW; 4573 cur = CUR_CHAR(l); 4574 while ((cur != '<') && /* checked */ 4575 (cur != '&') && 4576 (IS_CHAR(cur))) /* test also done in xmlCurrentChar() */ { 4577 if ((cur == ']') && (NXT(1) == ']') && 4578 (NXT(2) == '>')) { 4579 if (cdata) break; 4580 else { 4581 xmlFatalErr(ctxt, XML_ERR_MISPLACED_CDATA_END, NULL); 4582 } 4583 } 4584 COPY_BUF(l,buf,nbchar,cur); 4585 if (nbchar >= XML_PARSER_BIG_BUFFER_SIZE) { 4586 buf[nbchar] = 0; 4587 4588 /* 4589 * OK the segment is to be consumed as chars. 4590 */ 4591 if ((ctxt->sax != NULL) && (!ctxt->disableSAX)) { 4592 if (areBlanks(ctxt, buf, nbchar, 0)) { 4593 if (ctxt->sax->ignorableWhitespace != NULL) 4594 ctxt->sax->ignorableWhitespace(ctxt->userData, 4595 buf, nbchar); 4596 } else { 4597 if (ctxt->sax->characters != NULL) 4598 ctxt->sax->characters(ctxt->userData, buf, nbchar); 4599 if ((ctxt->sax->characters != 4600 ctxt->sax->ignorableWhitespace) && 4601 (*ctxt->space == -1)) 4602 *ctxt->space = -2; 4603 } 4604 } 4605 nbchar = 0; 4606 /* something really bad happened in the SAX callback */ 4607 if (ctxt->instate != XML_PARSER_CONTENT) 4608 return; 4609 } 4610 count++; 4611 if (count > 50) { 4612 GROW; 4613 count = 0; 4614 if (ctxt->instate == XML_PARSER_EOF) 4615 return; 4616 } 4617 NEXTL(l); 4618 cur = CUR_CHAR(l); 4619 } 4620 if (nbchar != 0) { 4621 buf[nbchar] = 0; 4622 /* 4623 * OK the segment is to be consumed as chars. 4624 */ 4625 if ((ctxt->sax != NULL) && (!ctxt->disableSAX)) { 4626 if (areBlanks(ctxt, buf, nbchar, 0)) { 4627 if (ctxt->sax->ignorableWhitespace != NULL) 4628 ctxt->sax->ignorableWhitespace(ctxt->userData, buf, nbchar); 4629 } else { 4630 if (ctxt->sax->characters != NULL) 4631 ctxt->sax->characters(ctxt->userData, buf, nbchar); 4632 if ((ctxt->sax->characters != ctxt->sax->ignorableWhitespace) && 4633 (*ctxt->space == -1)) 4634 *ctxt->space = -2; 4635 } 4636 } 4637 } 4638 if ((cur != 0) && (!IS_CHAR(cur))) { 4639 /* Generate the error and skip the offending character */ 4640 xmlFatalErrMsgInt(ctxt, XML_ERR_INVALID_CHAR, 4641 "PCDATA invalid Char value %d\n", 4642 cur); 4643 NEXTL(l); 4644 } 4645 } 4646 4647 /** 4648 * xmlParseExternalID: 4649 * @ctxt: an XML parser context 4650 * @publicID: a xmlChar** receiving PubidLiteral 4651 * @strict: indicate whether we should restrict parsing to only 4652 * production [75], see NOTE below 4653 * 4654 * Parse an External ID or a Public ID 4655 * 4656 * NOTE: Productions [75] and [83] interact badly since [75] can generate 4657 * 'PUBLIC' S PubidLiteral S SystemLiteral 4658 * 4659 * [75] ExternalID ::= 'SYSTEM' S SystemLiteral 4660 * | 'PUBLIC' S PubidLiteral S SystemLiteral 4661 * 4662 * [83] PublicID ::= 'PUBLIC' S PubidLiteral 4663 * 4664 * Returns the function returns SystemLiteral and in the second 4665 * case publicID receives PubidLiteral, is strict is off 4666 * it is possible to return NULL and have publicID set. 4667 */ 4668 4669 xmlChar * 4670 xmlParseExternalID(xmlParserCtxtPtr ctxt, xmlChar **publicID, int strict) { 4671 xmlChar *URI = NULL; 4672 4673 SHRINK; 4674 4675 *publicID = NULL; 4676 if (CMP6(CUR_PTR, 'S', 'Y', 'S', 'T', 'E', 'M')) { 4677 SKIP(6); 4678 if (!IS_BLANK_CH(CUR)) { 4679 xmlFatalErrMsg(ctxt, XML_ERR_SPACE_REQUIRED, 4680 "Space required after 'SYSTEM'\n"); 4681 } 4682 SKIP_BLANKS; 4683 URI = xmlParseSystemLiteral(ctxt); 4684 if (URI == NULL) { 4685 xmlFatalErr(ctxt, XML_ERR_URI_REQUIRED, NULL); 4686 } 4687 } else if (CMP6(CUR_PTR, 'P', 'U', 'B', 'L', 'I', 'C')) { 4688 SKIP(6); 4689 if (!IS_BLANK_CH(CUR)) { 4690 xmlFatalErrMsg(ctxt, XML_ERR_SPACE_REQUIRED, 4691 "Space required after 'PUBLIC'\n"); 4692 } 4693 SKIP_BLANKS; 4694 *publicID = xmlParsePubidLiteral(ctxt); 4695 if (*publicID == NULL) { 4696 xmlFatalErr(ctxt, XML_ERR_PUBID_REQUIRED, NULL); 4697 } 4698 if (strict) { 4699 /* 4700 * We don't handle [83] so "S SystemLiteral" is required. 4701 */ 4702 if (!IS_BLANK_CH(CUR)) { 4703 xmlFatalErrMsg(ctxt, XML_ERR_SPACE_REQUIRED, 4704 "Space required after the Public Identifier\n"); 4705 } 4706 } else { 4707 /* 4708 * We handle [83] so we return immediately, if 4709 * "S SystemLiteral" is not detected. From a purely parsing 4710 * point of view that's a nice mess. 4711 */ 4712 const xmlChar *ptr; 4713 GROW; 4714 4715 ptr = CUR_PTR; 4716 if (!IS_BLANK_CH(*ptr)) return(NULL); 4717 4718 while (IS_BLANK_CH(*ptr)) ptr++; /* TODO: dangerous, fix ! */ 4719 if ((*ptr != '\'') && (*ptr != '"')) return(NULL); 4720 } 4721 SKIP_BLANKS; 4722 URI = xmlParseSystemLiteral(ctxt); 4723 if (URI == NULL) { 4724 xmlFatalErr(ctxt, XML_ERR_URI_REQUIRED, NULL); 4725 } 4726 } 4727 return(URI); 4728 } 4729 4730 /** 4731 * xmlParseCommentComplex: 4732 * @ctxt: an XML parser context 4733 * @buf: the already parsed part of the buffer 4734 * @len: number of bytes filles in the buffer 4735 * @size: allocated size of the buffer 4736 * 4737 * Skip an XML (SGML) comment <!-- .... --> 4738 * The spec says that "For compatibility, the string "--" (double-hyphen) 4739 * must not occur within comments. " 4740 * This is the slow routine in case the accelerator for ascii didn't work 4741 * 4742 * [15] Comment ::= '<!--' ((Char - '-') | ('-' (Char - '-')))* '-->' 4743 */ 4744 static void 4745 xmlParseCommentComplex(xmlParserCtxtPtr ctxt, xmlChar *buf, 4746 size_t len, size_t size) { 4747 int q, ql; 4748 int r, rl; 4749 int cur, l; 4750 size_t count = 0; 4751 int inputid; 4752 4753 inputid = ctxt->input->id; 4754 4755 if (buf == NULL) { 4756 len = 0; 4757 size = XML_PARSER_BUFFER_SIZE; 4758 buf = (xmlChar *) xmlMallocAtomic(size * sizeof(xmlChar)); 4759 if (buf == NULL) { 4760 xmlErrMemory(ctxt, NULL); 4761 return; 4762 } 4763 } 4764 GROW; /* Assure there's enough input data */ 4765 q = CUR_CHAR(ql); 4766 if (q == 0) 4767 goto not_terminated; 4768 if (!IS_CHAR(q)) { 4769 xmlFatalErrMsgInt(ctxt, XML_ERR_INVALID_CHAR, 4770 "xmlParseComment: invalid xmlChar value %d\n", 4771 q); 4772 xmlFree (buf); 4773 return; 4774 } 4775 NEXTL(ql); 4776 r = CUR_CHAR(rl); 4777 if (r == 0) 4778 goto not_terminated; 4779 if (!IS_CHAR(r)) { 4780 xmlFatalErrMsgInt(ctxt, XML_ERR_INVALID_CHAR, 4781 "xmlParseComment: invalid xmlChar value %d\n", 4782 q); 4783 xmlFree (buf); 4784 return; 4785 } 4786 NEXTL(rl); 4787 cur = CUR_CHAR(l); 4788 if (cur == 0) 4789 goto not_terminated; 4790 while (IS_CHAR(cur) && /* checked */ 4791 ((cur != '>') || 4792 (r != '-') || (q != '-'))) { 4793 if ((r == '-') && (q == '-')) { 4794 xmlFatalErr(ctxt, XML_ERR_HYPHEN_IN_COMMENT, NULL); 4795 } 4796 if ((len > XML_MAX_TEXT_LENGTH) && 4797 ((ctxt->options & XML_PARSE_HUGE) == 0)) { 4798 xmlFatalErrMsgStr(ctxt, XML_ERR_COMMENT_NOT_FINISHED, 4799 "Comment too big found", NULL); 4800 xmlFree (buf); 4801 return; 4802 } 4803 if (len + 5 >= size) { 4804 xmlChar *new_buf; 4805 size_t new_size; 4806 4807 new_size = size * 2; 4808 new_buf = (xmlChar *) xmlRealloc(buf, new_size); 4809 if (new_buf == NULL) { 4810 xmlFree (buf); 4811 xmlErrMemory(ctxt, NULL); 4812 return; 4813 } 4814 buf = new_buf; 4815 size = new_size; 4816 } 4817 COPY_BUF(ql,buf,len,q); 4818 q = r; 4819 ql = rl; 4820 r = cur; 4821 rl = l; 4822 4823 count++; 4824 if (count > 50) { 4825 GROW; 4826 count = 0; 4827 if (ctxt->instate == XML_PARSER_EOF) { 4828 xmlFree(buf); 4829 return; 4830 } 4831 } 4832 NEXTL(l); 4833 cur = CUR_CHAR(l); 4834 if (cur == 0) { 4835 SHRINK; 4836 GROW; 4837 cur = CUR_CHAR(l); 4838 } 4839 } 4840 buf[len] = 0; 4841 if (cur == 0) { 4842 xmlFatalErrMsgStr(ctxt, XML_ERR_COMMENT_NOT_FINISHED, 4843 "Comment not terminated \n<!--%.50s\n", buf); 4844 } else if (!IS_CHAR(cur)) { 4845 xmlFatalErrMsgInt(ctxt, XML_ERR_INVALID_CHAR, 4846 "xmlParseComment: invalid xmlChar value %d\n", 4847 cur); 4848 } else { 4849 if (inputid != ctxt->input->id) { 4850 xmlFatalErrMsg(ctxt, XML_ERR_ENTITY_BOUNDARY, 4851 "Comment doesn't start and stop in the same entity\n"); 4852 } 4853 NEXT; 4854 if ((ctxt->sax != NULL) && (ctxt->sax->comment != NULL) && 4855 (!ctxt->disableSAX)) 4856 ctxt->sax->comment(ctxt->userData, buf); 4857 } 4858 xmlFree(buf); 4859 return; 4860 not_terminated: 4861 xmlFatalErrMsgStr(ctxt, XML_ERR_COMMENT_NOT_FINISHED, 4862 "Comment not terminated\n", NULL); 4863 xmlFree(buf); 4864 return; 4865 } 4866 4867 /** 4868 * xmlParseComment: 4869 * @ctxt: an XML parser context 4870 * 4871 * Skip an XML (SGML) comment <!-- .... --> 4872 * The spec says that "For compatibility, the string "--" (double-hyphen) 4873 * must not occur within comments. " 4874 * 4875 * [15] Comment ::= '<!--' ((Char - '-') | ('-' (Char - '-')))* '-->' 4876 */ 4877 void 4878 xmlParseComment(xmlParserCtxtPtr ctxt) { 4879 xmlChar *buf = NULL; 4880 size_t size = XML_PARSER_BUFFER_SIZE; 4881 size_t len = 0; 4882 xmlParserInputState state; 4883 const xmlChar *in; 4884 size_t nbchar = 0; 4885 int ccol; 4886 int inputid; 4887 4888 /* 4889 * Check that there is a comment right here. 4890 */ 4891 if ((RAW != '<') || (NXT(1) != '!') || 4892 (NXT(2) != '-') || (NXT(3) != '-')) return; 4893 state = ctxt->instate; 4894 ctxt->instate = XML_PARSER_COMMENT; 4895 inputid = ctxt->input->id; 4896 SKIP(4); 4897 SHRINK; 4898 GROW; 4899 4900 /* 4901 * Accelerated common case where input don't need to be 4902 * modified before passing it to the handler. 4903 */ 4904 in = ctxt->input->cur; 4905 do { 4906 if (*in == 0xA) { 4907 do { 4908 ctxt->input->line++; ctxt->input->col = 1; 4909 in++; 4910 } while (*in == 0xA); 4911 } 4912 get_more: 4913 ccol = ctxt->input->col; 4914 while (((*in > '-') && (*in <= 0x7F)) || 4915 ((*in >= 0x20) && (*in < '-')) || 4916 (*in == 0x09)) { 4917 in++; 4918 ccol++; 4919 } 4920 ctxt->input->col = ccol; 4921 if (*in == 0xA) { 4922 do { 4923 ctxt->input->line++; ctxt->input->col = 1; 4924 in++; 4925 } while (*in == 0xA); 4926 goto get_more; 4927 } 4928 nbchar = in - ctxt->input->cur; 4929 /* 4930 * save current set of data 4931 */ 4932 if (nbchar > 0) { 4933 if ((ctxt->sax != NULL) && 4934 (ctxt->sax->comment != NULL)) { 4935 if (buf == NULL) { 4936 if ((*in == '-') && (in[1] == '-')) 4937 size = nbchar + 1; 4938 else 4939 size = XML_PARSER_BUFFER_SIZE + nbchar; 4940 buf = (xmlChar *) xmlMallocAtomic(size * sizeof(xmlChar)); 4941 if (buf == NULL) { 4942 xmlErrMemory(ctxt, NULL); 4943 ctxt->instate = state; 4944 return; 4945 } 4946 len = 0; 4947 } else if (len + nbchar + 1 >= size) { 4948 xmlChar *new_buf; 4949 size += len + nbchar + XML_PARSER_BUFFER_SIZE; 4950 new_buf = (xmlChar *) xmlRealloc(buf, 4951 size * sizeof(xmlChar)); 4952 if (new_buf == NULL) { 4953 xmlFree (buf); 4954 xmlErrMemory(ctxt, NULL); 4955 ctxt->instate = state; 4956 return; 4957 } 4958 buf = new_buf; 4959 } 4960 memcpy(&buf[len], ctxt->input->cur, nbchar); 4961 len += nbchar; 4962 buf[len] = 0; 4963 } 4964 } 4965 if ((len > XML_MAX_TEXT_LENGTH) && 4966 ((ctxt->options & XML_PARSE_HUGE) == 0)) { 4967 xmlFatalErrMsgStr(ctxt, XML_ERR_COMMENT_NOT_FINISHED, 4968 "Comment too big found", NULL); 4969 xmlFree (buf); 4970 return; 4971 } 4972 ctxt->input->cur = in; 4973 if (*in == 0xA) { 4974 in++; 4975 ctxt->input->line++; ctxt->input->col = 1; 4976 } 4977 if (*in == 0xD) { 4978 in++; 4979 if (*in == 0xA) { 4980 ctxt->input->cur = in; 4981 in++; 4982 ctxt->input->line++; ctxt->input->col = 1; 4983 continue; /* while */ 4984 } 4985 in--; 4986 } 4987 SHRINK; 4988 GROW; 4989 if (ctxt->instate == XML_PARSER_EOF) { 4990 xmlFree(buf); 4991 return; 4992 } 4993 in = ctxt->input->cur; 4994 if (*in == '-') { 4995 if (in[1] == '-') { 4996 if (in[2] == '>') { 4997 if (ctxt->input->id != inputid) { 4998 xmlFatalErrMsg(ctxt, XML_ERR_ENTITY_BOUNDARY, 4999 "comment doesn't start and stop in the same entity\n"); 5000 } 5001 SKIP(3); 5002 if ((ctxt->sax != NULL) && (ctxt->sax->comment != NULL) && 5003 (!ctxt->disableSAX)) { 5004 if (buf != NULL) 5005 ctxt->sax->comment(ctxt->userData, buf); 5006 else 5007 ctxt->sax->comment(ctxt->userData, BAD_CAST ""); 5008 } 5009 if (buf != NULL) 5010 xmlFree(buf); 5011 if (ctxt->instate != XML_PARSER_EOF) 5012 ctxt->instate = state; 5013 return; 5014 } 5015 if (buf != NULL) { 5016 xmlFatalErrMsgStr(ctxt, XML_ERR_HYPHEN_IN_COMMENT, 5017 "Double hyphen within comment: " 5018 "<!--%.50s\n", 5019 buf); 5020 } else 5021 xmlFatalErrMsgStr(ctxt, XML_ERR_HYPHEN_IN_COMMENT, 5022 "Double hyphen within comment\n", NULL); 5023 in++; 5024 ctxt->input->col++; 5025 } 5026 in++; 5027 ctxt->input->col++; 5028 goto get_more; 5029 } 5030 } while (((*in >= 0x20) && (*in <= 0x7F)) || (*in == 0x09)); 5031 xmlParseCommentComplex(ctxt, buf, len, size); 5032 ctxt->instate = state; 5033 return; 5034 } 5035 5036 5037 /** 5038 * xmlParsePITarget: 5039 * @ctxt: an XML parser context 5040 * 5041 * parse the name of a PI 5042 * 5043 * [17] PITarget ::= Name - (('X' | 'x') ('M' | 'm') ('L' | 'l')) 5044 * 5045 * Returns the PITarget name or NULL 5046 */ 5047 5048 const xmlChar * 5049 xmlParsePITarget(xmlParserCtxtPtr ctxt) { 5050 const xmlChar *name; 5051 5052 name = xmlParseName(ctxt); 5053 if ((name != NULL) && 5054 ((name[0] == 'x') || (name[0] == 'X')) && 5055 ((name[1] == 'm') || (name[1] == 'M')) && 5056 ((name[2] == 'l') || (name[2] == 'L'))) { 5057 int i; 5058 if ((name[0] == 'x') && (name[1] == 'm') && 5059 (name[2] == 'l') && (name[3] == 0)) { 5060 xmlFatalErrMsg(ctxt, XML_ERR_RESERVED_XML_NAME, 5061 "XML declaration allowed only at the start of the document\n"); 5062 return(name); 5063 } else if (name[3] == 0) { 5064 xmlFatalErr(ctxt, XML_ERR_RESERVED_XML_NAME, NULL); 5065 return(name); 5066 } 5067 for (i = 0;;i++) { 5068 if (xmlW3CPIs[i] == NULL) break; 5069 if (xmlStrEqual(name, (const xmlChar *)xmlW3CPIs[i])) 5070 return(name); 5071 } 5072 xmlWarningMsg(ctxt, XML_ERR_RESERVED_XML_NAME, 5073 "xmlParsePITarget: invalid name prefix 'xml'\n", 5074 NULL, NULL); 5075 } 5076 if ((name != NULL) && (xmlStrchr(name, ':') != NULL)) { 5077 xmlNsErr(ctxt, XML_NS_ERR_COLON, 5078 "colon are forbidden from PI names '%s'\n", name, NULL, NULL); 5079 } 5080 return(name); 5081 } 5082 5083 #ifdef LIBXML_CATALOG_ENABLED 5084 /** 5085 * xmlParseCatalogPI: 5086 * @ctxt: an XML parser context 5087 * @catalog: the PI value string 5088 * 5089 * parse an XML Catalog Processing Instruction. 5090 * 5091 * <?oasis-xml-catalog catalog="http://example.com/catalog.xml"?> 5092 * 5093 * Occurs only if allowed by the user and if happening in the Misc 5094 * part of the document before any doctype informations 5095 * This will add the given catalog to the parsing context in order 5096 * to be used if there is a resolution need further down in the document 5097 */ 5098 5099 static void 5100 xmlParseCatalogPI(xmlParserCtxtPtr ctxt, const xmlChar *catalog) { 5101 xmlChar *URL = NULL; 5102 const xmlChar *tmp, *base; 5103 xmlChar marker; 5104 5105 tmp = catalog; 5106 while (IS_BLANK_CH(*tmp)) tmp++; 5107 if (xmlStrncmp(tmp, BAD_CAST"catalog", 7)) 5108 goto error; 5109 tmp += 7; 5110 while (IS_BLANK_CH(*tmp)) tmp++; 5111 if (*tmp != '=') { 5112 return; 5113 } 5114 tmp++; 5115 while (IS_BLANK_CH(*tmp)) tmp++; 5116 marker = *tmp; 5117 if ((marker != '\'') && (marker != '"')) 5118 goto error; 5119 tmp++; 5120 base = tmp; 5121 while ((*tmp != 0) && (*tmp != marker)) tmp++; 5122 if (*tmp == 0) 5123 goto error; 5124 URL = xmlStrndup(base, tmp - base); 5125 tmp++; 5126 while (IS_BLANK_CH(*tmp)) tmp++; 5127 if (*tmp != 0) 5128 goto error; 5129 5130 if (URL != NULL) { 5131 ctxt->catalogs = xmlCatalogAddLocal(ctxt->catalogs, URL); 5132 xmlFree(URL); 5133 } 5134 return; 5135 5136 error: 5137 xmlWarningMsg(ctxt, XML_WAR_CATALOG_PI, 5138 "Catalog PI syntax error: %s\n", 5139 catalog, NULL); 5140 if (URL != NULL) 5141 xmlFree(URL); 5142 } 5143 #endif 5144 5145 /** 5146 * xmlParsePI: 5147 * @ctxt: an XML parser context 5148 * 5149 * parse an XML Processing Instruction. 5150 * 5151 * [16] PI ::= '<?' PITarget (S (Char* - (Char* '?>' Char*)))? '?>' 5152 * 5153 * The processing is transfered to SAX once parsed. 5154 */ 5155 5156 void 5157 xmlParsePI(xmlParserCtxtPtr ctxt) { 5158 xmlChar *buf = NULL; 5159 size_t len = 0; 5160 size_t size = XML_PARSER_BUFFER_SIZE; 5161 int cur, l; 5162 const xmlChar *target; 5163 xmlParserInputState state; 5164 int count = 0; 5165 5166 if ((RAW == '<') && (NXT(1) == '?')) { 5167 xmlParserInputPtr input = ctxt->input; 5168 state = ctxt->instate; 5169 ctxt->instate = XML_PARSER_PI; 5170 /* 5171 * this is a Processing Instruction. 5172 */ 5173 SKIP(2); 5174 SHRINK; 5175 5176 /* 5177 * Parse the target name and check for special support like 5178 * namespace. 5179 */ 5180 target = xmlParsePITarget(ctxt); 5181 if (target != NULL) { 5182 if ((RAW == '?') && (NXT(1) == '>')) { 5183 if (input != ctxt->input) { 5184 xmlFatalErrMsg(ctxt, XML_ERR_ENTITY_BOUNDARY, 5185 "PI declaration doesn't start and stop in the same entity\n"); 5186 } 5187 SKIP(2); 5188 5189 /* 5190 * SAX: PI detected. 5191 */ 5192 if ((ctxt->sax) && (!ctxt->disableSAX) && 5193 (ctxt->sax->processingInstruction != NULL)) 5194 ctxt->sax->processingInstruction(ctxt->userData, 5195 target, NULL); 5196 if (ctxt->instate != XML_PARSER_EOF) 5197 ctxt->instate = state; 5198 return; 5199 } 5200 buf = (xmlChar *) xmlMallocAtomic(size * sizeof(xmlChar)); 5201 if (buf == NULL) { 5202 xmlErrMemory(ctxt, NULL); 5203 ctxt->instate = state; 5204 return; 5205 } 5206 cur = CUR; 5207 if (!IS_BLANK(cur)) { 5208 xmlFatalErrMsgStr(ctxt, XML_ERR_SPACE_REQUIRED, 5209 "ParsePI: PI %s space expected\n", target); 5210 } 5211 SKIP_BLANKS; 5212 cur = CUR_CHAR(l); 5213 while (IS_CHAR(cur) && /* checked */ 5214 ((cur != '?') || (NXT(1) != '>'))) { 5215 if (len + 5 >= size) { 5216 xmlChar *tmp; 5217 size_t new_size = size * 2; 5218 tmp = (xmlChar *) xmlRealloc(buf, new_size); 5219 if (tmp == NULL) { 5220 xmlErrMemory(ctxt, NULL); 5221 xmlFree(buf); 5222 ctxt->instate = state; 5223 return; 5224 } 5225 buf = tmp; 5226 size = new_size; 5227 } 5228 count++; 5229 if (count > 50) { 5230 GROW; 5231 if (ctxt->instate == XML_PARSER_EOF) { 5232 xmlFree(buf); 5233 return; 5234 } 5235 count = 0; 5236 if ((len > XML_MAX_TEXT_LENGTH) && 5237 ((ctxt->options & XML_PARSE_HUGE) == 0)) { 5238 xmlFatalErrMsgStr(ctxt, XML_ERR_PI_NOT_FINISHED, 5239 "PI %s too big found", target); 5240 xmlFree(buf); 5241 ctxt->instate = state; 5242 return; 5243 } 5244 } 5245 COPY_BUF(l,buf,len,cur); 5246 NEXTL(l); 5247 cur = CUR_CHAR(l); 5248 if (cur == 0) { 5249 SHRINK; 5250 GROW; 5251 cur = CUR_CHAR(l); 5252 } 5253 } 5254 if ((len > XML_MAX_TEXT_LENGTH) && 5255 ((ctxt->options & XML_PARSE_HUGE) == 0)) { 5256 xmlFatalErrMsgStr(ctxt, XML_ERR_PI_NOT_FINISHED, 5257 "PI %s too big found", target); 5258 xmlFree(buf); 5259 ctxt->instate = state; 5260 return; 5261 } 5262 buf[len] = 0; 5263 if (cur != '?') { 5264 xmlFatalErrMsgStr(ctxt, XML_ERR_PI_NOT_FINISHED, 5265 "ParsePI: PI %s never end ...\n", target); 5266 } else { 5267 if (input != ctxt->input) { 5268 xmlFatalErrMsg(ctxt, XML_ERR_SPACE_REQUIRED, 5269 "PI declaration doesn't start and stop in the same entity\n"); 5270 } 5271 SKIP(2); 5272 5273 #ifdef LIBXML_CATALOG_ENABLED 5274 if (((state == XML_PARSER_MISC) || 5275 (state == XML_PARSER_START)) && 5276 (xmlStrEqual(target, XML_CATALOG_PI))) { 5277 xmlCatalogAllow allow = xmlCatalogGetDefaults(); 5278 if ((allow == XML_CATA_ALLOW_DOCUMENT) || 5279 (allow == XML_CATA_ALLOW_ALL)) 5280 xmlParseCatalogPI(ctxt, buf); 5281 } 5282 #endif 5283 5284 5285 /* 5286 * SAX: PI detected. 5287 */ 5288 if ((ctxt->sax) && (!ctxt->disableSAX) && 5289 (ctxt->sax->processingInstruction != NULL)) 5290 ctxt->sax->processingInstruction(ctxt->userData, 5291 target, buf); 5292 } 5293 xmlFree(buf); 5294 } else { 5295 xmlFatalErr(ctxt, XML_ERR_PI_NOT_STARTED, NULL); 5296 } 5297 if (ctxt->instate != XML_PARSER_EOF) 5298 ctxt->instate = state; 5299 } 5300 } 5301 5302 /** 5303 * xmlParseNotationDecl: 5304 * @ctxt: an XML parser context 5305 * 5306 * parse a notation declaration 5307 * 5308 * [82] NotationDecl ::= '<!NOTATION' S Name S (ExternalID | PublicID) S? '>' 5309 * 5310 * Hence there is actually 3 choices: 5311 * 'PUBLIC' S PubidLiteral 5312 * 'PUBLIC' S PubidLiteral S SystemLiteral 5313 * and 'SYSTEM' S SystemLiteral 5314 * 5315 * See the NOTE on xmlParseExternalID(). 5316 */ 5317 5318 void 5319 xmlParseNotationDecl(xmlParserCtxtPtr ctxt) { 5320 const xmlChar *name; 5321 xmlChar *Pubid; 5322 xmlChar *Systemid; 5323 5324 if (CMP10(CUR_PTR, '<', '!', 'N', 'O', 'T', 'A', 'T', 'I', 'O', 'N')) { 5325 xmlParserInputPtr input = ctxt->input; 5326 SHRINK; 5327 SKIP(10); 5328 if (!IS_BLANK_CH(CUR)) { 5329 xmlFatalErrMsg(ctxt, XML_ERR_SPACE_REQUIRED, 5330 "Space required after '<!NOTATION'\n"); 5331 return; 5332 } 5333 SKIP_BLANKS; 5334 5335 name = xmlParseName(ctxt); 5336 if (name == NULL) { 5337 xmlFatalErr(ctxt, XML_ERR_NOTATION_NOT_STARTED, NULL); 5338 return; 5339 } 5340 if (!IS_BLANK_CH(CUR)) { 5341 xmlFatalErrMsg(ctxt, XML_ERR_SPACE_REQUIRED, 5342 "Space required after the NOTATION name'\n"); 5343 return; 5344 } 5345 if (xmlStrchr(name, ':') != NULL) { 5346 xmlNsErr(ctxt, XML_NS_ERR_COLON, 5347 "colon are forbidden from notation names '%s'\n", 5348 name, NULL, NULL); 5349 } 5350 SKIP_BLANKS; 5351 5352 /* 5353 * Parse the IDs. 5354 */ 5355 Systemid = xmlParseExternalID(ctxt, &Pubid, 0); 5356 SKIP_BLANKS; 5357 5358 if (RAW == '>') { 5359 if (input != ctxt->input) { 5360 xmlFatalErrMsg(ctxt, XML_ERR_SPACE_REQUIRED, 5361 "Notation declaration doesn't start and stop in the same entity\n"); 5362 } 5363 NEXT; 5364 if ((ctxt->sax != NULL) && (!ctxt->disableSAX) && 5365 (ctxt->sax->notationDecl != NULL)) 5366 ctxt->sax->notationDecl(ctxt->userData, name, Pubid, Systemid); 5367 } else { 5368 xmlFatalErr(ctxt, XML_ERR_NOTATION_NOT_FINISHED, NULL); 5369 } 5370 if (Systemid != NULL) xmlFree(Systemid); 5371 if (Pubid != NULL) xmlFree(Pubid); 5372 } 5373 } 5374 5375 /** 5376 * xmlParseEntityDecl: 5377 * @ctxt: an XML parser context 5378 * 5379 * parse <!ENTITY declarations 5380 * 5381 * [70] EntityDecl ::= GEDecl | PEDecl 5382 * 5383 * [71] GEDecl ::= '<!ENTITY' S Name S EntityDef S? '>' 5384 * 5385 * [72] PEDecl ::= '<!ENTITY' S '%' S Name S PEDef S? '>' 5386 * 5387 * [73] EntityDef ::= EntityValue | (ExternalID NDataDecl?) 5388 * 5389 * [74] PEDef ::= EntityValue | ExternalID 5390 * 5391 * [76] NDataDecl ::= S 'NDATA' S Name 5392 * 5393 * [ VC: Notation Declared ] 5394 * The Name must match the declared name of a notation. 5395 */ 5396 5397 void 5398 xmlParseEntityDecl(xmlParserCtxtPtr ctxt) { 5399 const xmlChar *name = NULL; 5400 xmlChar *value = NULL; 5401 xmlChar *URI = NULL, *literal = NULL; 5402 const xmlChar *ndata = NULL; 5403 int isParameter = 0; 5404 xmlChar *orig = NULL; 5405 int skipped; 5406 5407 /* GROW; done in the caller */ 5408 if (CMP8(CUR_PTR, '<', '!', 'E', 'N', 'T', 'I', 'T', 'Y')) { 5409 xmlParserInputPtr input = ctxt->input; 5410 SHRINK; 5411 SKIP(8); 5412 skipped = SKIP_BLANKS; 5413 if (skipped == 0) { 5414 xmlFatalErrMsg(ctxt, XML_ERR_SPACE_REQUIRED, 5415 "Space required after '<!ENTITY'\n"); 5416 } 5417 5418 if (RAW == '%') { 5419 NEXT; 5420 skipped = SKIP_BLANKS; 5421 if (skipped == 0) { 5422 xmlFatalErrMsg(ctxt, XML_ERR_SPACE_REQUIRED, 5423 "Space required after '%'\n"); 5424 } 5425 isParameter = 1; 5426 } 5427 5428 name = xmlParseName(ctxt); 5429 if (name == NULL) { 5430 xmlFatalErrMsg(ctxt, XML_ERR_NAME_REQUIRED, 5431 "xmlParseEntityDecl: no name\n"); 5432 return; 5433 } 5434 if (xmlStrchr(name, ':') != NULL) { 5435 xmlNsErr(ctxt, XML_NS_ERR_COLON, 5436 "colon are forbidden from entities names '%s'\n", 5437 name, NULL, NULL); 5438 } 5439 skipped = SKIP_BLANKS; 5440 if (skipped == 0) { 5441 xmlFatalErrMsg(ctxt, XML_ERR_SPACE_REQUIRED, 5442 "Space required after the entity name\n"); 5443 } 5444 5445 ctxt->instate = XML_PARSER_ENTITY_DECL; 5446 /* 5447 * handle the various case of definitions... 5448 */ 5449 if (isParameter) { 5450 if ((RAW == '"') || (RAW == '\'')) { 5451 value = xmlParseEntityValue(ctxt, &orig); 5452 if (value) { 5453 if ((ctxt->sax != NULL) && 5454 (!ctxt->disableSAX) && (ctxt->sax->entityDecl != NULL)) 5455 ctxt->sax->entityDecl(ctxt->userData, name, 5456 XML_INTERNAL_PARAMETER_ENTITY, 5457 NULL, NULL, value); 5458 } 5459 } else { 5460 URI = xmlParseExternalID(ctxt, &literal, 1); 5461 if ((URI == NULL) && (literal == NULL)) { 5462 xmlFatalErr(ctxt, XML_ERR_VALUE_REQUIRED, NULL); 5463 } 5464 if (URI) { 5465 xmlURIPtr uri; 5466 5467 uri = xmlParseURI((const char *) URI); 5468 if (uri == NULL) { 5469 xmlErrMsgStr(ctxt, XML_ERR_INVALID_URI, 5470 "Invalid URI: %s\n", URI); 5471 /* 5472 * This really ought to be a well formedness error 5473 * but the XML Core WG decided otherwise c.f. issue 5474 * E26 of the XML erratas. 5475 */ 5476 } else { 5477 if (uri->fragment != NULL) { 5478 /* 5479 * Okay this is foolish to block those but not 5480 * invalid URIs. 5481 */ 5482 xmlFatalErr(ctxt, XML_ERR_URI_FRAGMENT, NULL); 5483 } else { 5484 if ((ctxt->sax != NULL) && 5485 (!ctxt->disableSAX) && 5486 (ctxt->sax->entityDecl != NULL)) 5487 ctxt->sax->entityDecl(ctxt->userData, name, 5488 XML_EXTERNAL_PARAMETER_ENTITY, 5489 literal, URI, NULL); 5490 } 5491 xmlFreeURI(uri); 5492 } 5493 } 5494 } 5495 } else { 5496 if ((RAW == '"') || (RAW == '\'')) { 5497 value = xmlParseEntityValue(ctxt, &orig); 5498 if ((ctxt->sax != NULL) && 5499 (!ctxt->disableSAX) && (ctxt->sax->entityDecl != NULL)) 5500 ctxt->sax->entityDecl(ctxt->userData, name, 5501 XML_INTERNAL_GENERAL_ENTITY, 5502 NULL, NULL, value); 5503 /* 5504 * For expat compatibility in SAX mode. 5505 */ 5506 if ((ctxt->myDoc == NULL) || 5507 (xmlStrEqual(ctxt->myDoc->version, SAX_COMPAT_MODE))) { 5508 if (ctxt->myDoc == NULL) { 5509 ctxt->myDoc = xmlNewDoc(SAX_COMPAT_MODE); 5510 if (ctxt->myDoc == NULL) { 5511 xmlErrMemory(ctxt, "New Doc failed"); 5512 return; 5513 } 5514 ctxt->myDoc->properties = XML_DOC_INTERNAL; 5515 } 5516 if (ctxt->myDoc->intSubset == NULL) 5517 ctxt->myDoc->intSubset = xmlNewDtd(ctxt->myDoc, 5518 BAD_CAST "fake", NULL, NULL); 5519 5520 xmlSAX2EntityDecl(ctxt, name, XML_INTERNAL_GENERAL_ENTITY, 5521 NULL, NULL, value); 5522 } 5523 } else { 5524 URI = xmlParseExternalID(ctxt, &literal, 1); 5525 if ((URI == NULL) && (literal == NULL)) { 5526 xmlFatalErr(ctxt, XML_ERR_VALUE_REQUIRED, NULL); 5527 } 5528 if (URI) { 5529 xmlURIPtr uri; 5530 5531 uri = xmlParseURI((const char *)URI); 5532 if (uri == NULL) { 5533 xmlErrMsgStr(ctxt, XML_ERR_INVALID_URI, 5534 "Invalid URI: %s\n", URI); 5535 /* 5536 * This really ought to be a well formedness error 5537 * but the XML Core WG decided otherwise c.f. issue 5538 * E26 of the XML erratas. 5539 */ 5540 } else { 5541 if (uri->fragment != NULL) { 5542 /* 5543 * Okay this is foolish to block those but not 5544 * invalid URIs. 5545 */ 5546 xmlFatalErr(ctxt, XML_ERR_URI_FRAGMENT, NULL); 5547 } 5548 xmlFreeURI(uri); 5549 } 5550 } 5551 if ((RAW != '>') && (!IS_BLANK_CH(CUR))) { 5552 xmlFatalErrMsg(ctxt, XML_ERR_SPACE_REQUIRED, 5553 "Space required before 'NDATA'\n"); 5554 } 5555 SKIP_BLANKS; 5556 if (CMP5(CUR_PTR, 'N', 'D', 'A', 'T', 'A')) { 5557 SKIP(5); 5558 if (!IS_BLANK_CH(CUR)) { 5559 xmlFatalErrMsg(ctxt, XML_ERR_SPACE_REQUIRED, 5560 "Space required after 'NDATA'\n"); 5561 } 5562 SKIP_BLANKS; 5563 ndata = xmlParseName(ctxt); 5564 if ((ctxt->sax != NULL) && (!ctxt->disableSAX) && 5565 (ctxt->sax->unparsedEntityDecl != NULL)) 5566 ctxt->sax->unparsedEntityDecl(ctxt->userData, name, 5567 literal, URI, ndata); 5568 } else { 5569 if ((ctxt->sax != NULL) && 5570 (!ctxt->disableSAX) && (ctxt->sax->entityDecl != NULL)) 5571 ctxt->sax->entityDecl(ctxt->userData, name, 5572 XML_EXTERNAL_GENERAL_PARSED_ENTITY, 5573 literal, URI, NULL); 5574 /* 5575 * For expat compatibility in SAX mode. 5576 * assuming the entity repalcement was asked for 5577 */ 5578 if ((ctxt->replaceEntities != 0) && 5579 ((ctxt->myDoc == NULL) || 5580 (xmlStrEqual(ctxt->myDoc->version, SAX_COMPAT_MODE)))) { 5581 if (ctxt->myDoc == NULL) { 5582 ctxt->myDoc = xmlNewDoc(SAX_COMPAT_MODE); 5583 if (ctxt->myDoc == NULL) { 5584 xmlErrMemory(ctxt, "New Doc failed"); 5585 return; 5586 } 5587 ctxt->myDoc->properties = XML_DOC_INTERNAL; 5588 } 5589 5590 if (ctxt->myDoc->intSubset == NULL) 5591 ctxt->myDoc->intSubset = xmlNewDtd(ctxt->myDoc, 5592 BAD_CAST "fake", NULL, NULL); 5593 xmlSAX2EntityDecl(ctxt, name, 5594 XML_EXTERNAL_GENERAL_PARSED_ENTITY, 5595 literal, URI, NULL); 5596 } 5597 } 5598 } 5599 } 5600 if (ctxt->instate == XML_PARSER_EOF) 5601 return; 5602 SKIP_BLANKS; 5603 if (RAW != '>') { 5604 xmlFatalErrMsgStr(ctxt, XML_ERR_ENTITY_NOT_FINISHED, 5605 "xmlParseEntityDecl: entity %s not terminated\n", name); 5606 } else { 5607 if (input != ctxt->input) { 5608 xmlFatalErrMsg(ctxt, XML_ERR_ENTITY_BOUNDARY, 5609 "Entity declaration doesn't start and stop in the same entity\n"); 5610 } 5611 NEXT; 5612 } 5613 if (orig != NULL) { 5614 /* 5615 * Ugly mechanism to save the raw entity value. 5616 */ 5617 xmlEntityPtr cur = NULL; 5618 5619 if (isParameter) { 5620 if ((ctxt->sax != NULL) && 5621 (ctxt->sax->getParameterEntity != NULL)) 5622 cur = ctxt->sax->getParameterEntity(ctxt->userData, name); 5623 } else { 5624 if ((ctxt->sax != NULL) && 5625 (ctxt->sax->getEntity != NULL)) 5626 cur = ctxt->sax->getEntity(ctxt->userData, name); 5627 if ((cur == NULL) && (ctxt->userData==ctxt)) { 5628 cur = xmlSAX2GetEntity(ctxt, name); 5629 } 5630 } 5631 if (cur != NULL) { 5632 if (cur->orig != NULL) 5633 xmlFree(orig); 5634 else 5635 cur->orig = orig; 5636 } else 5637 xmlFree(orig); 5638 } 5639 if (value != NULL) xmlFree(value); 5640 if (URI != NULL) xmlFree(URI); 5641 if (literal != NULL) xmlFree(literal); 5642 } 5643 } 5644 5645 /** 5646 * xmlParseDefaultDecl: 5647 * @ctxt: an XML parser context 5648 * @value: Receive a possible fixed default value for the attribute 5649 * 5650 * Parse an attribute default declaration 5651 * 5652 * [60] DefaultDecl ::= '#REQUIRED' | '#IMPLIED' | (('#FIXED' S)? AttValue) 5653 * 5654 * [ VC: Required Attribute ] 5655 * if the default declaration is the keyword #REQUIRED, then the 5656 * attribute must be specified for all elements of the type in the 5657 * attribute-list declaration. 5658 * 5659 * [ VC: Attribute Default Legal ] 5660 * The declared default value must meet the lexical constraints of 5661 * the declared attribute type c.f. xmlValidateAttributeDecl() 5662 * 5663 * [ VC: Fixed Attribute Default ] 5664 * if an attribute has a default value declared with the #FIXED 5665 * keyword, instances of that attribute must match the default value. 5666 * 5667 * [ WFC: No < in Attribute Values ] 5668 * handled in xmlParseAttValue() 5669 * 5670 * returns: XML_ATTRIBUTE_NONE, XML_ATTRIBUTE_REQUIRED, XML_ATTRIBUTE_IMPLIED 5671 * or XML_ATTRIBUTE_FIXED. 5672 */ 5673 5674 int 5675 xmlParseDefaultDecl(xmlParserCtxtPtr ctxt, xmlChar **value) { 5676 int val; 5677 xmlChar *ret; 5678 5679 *value = NULL; 5680 if (CMP9(CUR_PTR, '#', 'R', 'E', 'Q', 'U', 'I', 'R', 'E', 'D')) { 5681 SKIP(9); 5682 return(XML_ATTRIBUTE_REQUIRED); 5683 } 5684 if (CMP8(CUR_PTR, '#', 'I', 'M', 'P', 'L', 'I', 'E', 'D')) { 5685 SKIP(8); 5686 return(XML_ATTRIBUTE_IMPLIED); 5687 } 5688 val = XML_ATTRIBUTE_NONE; 5689 if (CMP6(CUR_PTR, '#', 'F', 'I', 'X', 'E', 'D')) { 5690 SKIP(6); 5691 val = XML_ATTRIBUTE_FIXED; 5692 if (!IS_BLANK_CH(CUR)) { 5693 xmlFatalErrMsg(ctxt, XML_ERR_SPACE_REQUIRED, 5694 "Space required after '#FIXED'\n"); 5695 } 5696 SKIP_BLANKS; 5697 } 5698 ret = xmlParseAttValue(ctxt); 5699 ctxt->instate = XML_PARSER_DTD; 5700 if (ret == NULL) { 5701 xmlFatalErrMsg(ctxt, (xmlParserErrors)ctxt->errNo, 5702 "Attribute default value declaration error\n"); 5703 } else 5704 *value = ret; 5705 return(val); 5706 } 5707 5708 /** 5709 * xmlParseNotationType: 5710 * @ctxt: an XML parser context 5711 * 5712 * parse an Notation attribute type. 5713 * 5714 * Note: the leading 'NOTATION' S part has already being parsed... 5715 * 5716 * [58] NotationType ::= 'NOTATION' S '(' S? Name (S? '|' S? Name)* S? ')' 5717 * 5718 * [ VC: Notation Attributes ] 5719 * Values of this type must match one of the notation names included 5720 * in the declaration; all notation names in the declaration must be declared. 5721 * 5722 * Returns: the notation attribute tree built while parsing 5723 */ 5724 5725 xmlEnumerationPtr 5726 xmlParseNotationType(xmlParserCtxtPtr ctxt) { 5727 const xmlChar *name; 5728 xmlEnumerationPtr ret = NULL, last = NULL, cur, tmp; 5729 5730 if (RAW != '(') { 5731 xmlFatalErr(ctxt, XML_ERR_NOTATION_NOT_STARTED, NULL); 5732 return(NULL); 5733 } 5734 SHRINK; 5735 do { 5736 NEXT; 5737 SKIP_BLANKS; 5738 name = xmlParseName(ctxt); 5739 if (name == NULL) { 5740 xmlFatalErrMsg(ctxt, XML_ERR_NAME_REQUIRED, 5741 "Name expected in NOTATION declaration\n"); 5742 xmlFreeEnumeration(ret); 5743 return(NULL); 5744 } 5745 tmp = ret; 5746 while (tmp != NULL) { 5747 if (xmlStrEqual(name, tmp->name)) { 5748 xmlValidityError(ctxt, XML_DTD_DUP_TOKEN, 5749 "standalone: attribute notation value token %s duplicated\n", 5750 name, NULL); 5751 if (!xmlDictOwns(ctxt->dict, name)) 5752 xmlFree((xmlChar *) name); 5753 break; 5754 } 5755 tmp = tmp->next; 5756 } 5757 if (tmp == NULL) { 5758 cur = xmlCreateEnumeration(name); 5759 if (cur == NULL) { 5760 xmlFreeEnumeration(ret); 5761 return(NULL); 5762 } 5763 if (last == NULL) ret = last = cur; 5764 else { 5765 last->next = cur; 5766 last = cur; 5767 } 5768 } 5769 SKIP_BLANKS; 5770 } while (RAW == '|'); 5771 if (RAW != ')') { 5772 xmlFatalErr(ctxt, XML_ERR_NOTATION_NOT_FINISHED, NULL); 5773 xmlFreeEnumeration(ret); 5774 return(NULL); 5775 } 5776 NEXT; 5777 return(ret); 5778 } 5779 5780 /** 5781 * xmlParseEnumerationType: 5782 * @ctxt: an XML parser context 5783 * 5784 * parse an Enumeration attribute type. 5785 * 5786 * [59] Enumeration ::= '(' S? Nmtoken (S? '|' S? Nmtoken)* S? ')' 5787 * 5788 * [ VC: Enumeration ] 5789 * Values of this type must match one of the Nmtoken tokens in 5790 * the declaration 5791 * 5792 * Returns: the enumeration attribute tree built while parsing 5793 */ 5794 5795 xmlEnumerationPtr 5796 xmlParseEnumerationType(xmlParserCtxtPtr ctxt) { 5797 xmlChar *name; 5798 xmlEnumerationPtr ret = NULL, last = NULL, cur, tmp; 5799 5800 if (RAW != '(') { 5801 xmlFatalErr(ctxt, XML_ERR_ATTLIST_NOT_STARTED, NULL); 5802 return(NULL); 5803 } 5804 SHRINK; 5805 do { 5806 NEXT; 5807 SKIP_BLANKS; 5808 name = xmlParseNmtoken(ctxt); 5809 if (name == NULL) { 5810 xmlFatalErr(ctxt, XML_ERR_NMTOKEN_REQUIRED, NULL); 5811 return(ret); 5812 } 5813 tmp = ret; 5814 while (tmp != NULL) { 5815 if (xmlStrEqual(name, tmp->name)) { 5816 xmlValidityError(ctxt, XML_DTD_DUP_TOKEN, 5817 "standalone: attribute enumeration value token %s duplicated\n", 5818 name, NULL); 5819 if (!xmlDictOwns(ctxt->dict, name)) 5820 xmlFree(name); 5821 break; 5822 } 5823 tmp = tmp->next; 5824 } 5825 if (tmp == NULL) { 5826 cur = xmlCreateEnumeration(name); 5827 if (!xmlDictOwns(ctxt->dict, name)) 5828 xmlFree(name); 5829 if (cur == NULL) { 5830 xmlFreeEnumeration(ret); 5831 return(NULL); 5832 } 5833 if (last == NULL) ret = last = cur; 5834 else { 5835 last->next = cur; 5836 last = cur; 5837 } 5838 } 5839 SKIP_BLANKS; 5840 } while (RAW == '|'); 5841 if (RAW != ')') { 5842 xmlFatalErr(ctxt, XML_ERR_ATTLIST_NOT_FINISHED, NULL); 5843 return(ret); 5844 } 5845 NEXT; 5846 return(ret); 5847 } 5848 5849 /** 5850 * xmlParseEnumeratedType: 5851 * @ctxt: an XML parser context 5852 * @tree: the enumeration tree built while parsing 5853 * 5854 * parse an Enumerated attribute type. 5855 * 5856 * [57] EnumeratedType ::= NotationType | Enumeration 5857 * 5858 * [58] NotationType ::= 'NOTATION' S '(' S? Name (S? '|' S? Name)* S? ')' 5859 * 5860 * 5861 * Returns: XML_ATTRIBUTE_ENUMERATION or XML_ATTRIBUTE_NOTATION 5862 */ 5863 5864 int 5865 xmlParseEnumeratedType(xmlParserCtxtPtr ctxt, xmlEnumerationPtr *tree) { 5866 if (CMP8(CUR_PTR, 'N', 'O', 'T', 'A', 'T', 'I', 'O', 'N')) { 5867 SKIP(8); 5868 if (!IS_BLANK_CH(CUR)) { 5869 xmlFatalErrMsg(ctxt, XML_ERR_SPACE_REQUIRED, 5870 "Space required after 'NOTATION'\n"); 5871 return(0); 5872 } 5873 SKIP_BLANKS; 5874 *tree = xmlParseNotationType(ctxt); 5875 if (*tree == NULL) return(0); 5876 return(XML_ATTRIBUTE_NOTATION); 5877 } 5878 *tree = xmlParseEnumerationType(ctxt); 5879 if (*tree == NULL) return(0); 5880 return(XML_ATTRIBUTE_ENUMERATION); 5881 } 5882 5883 /** 5884 * xmlParseAttributeType: 5885 * @ctxt: an XML parser context 5886 * @tree: the enumeration tree built while parsing 5887 * 5888 * parse the Attribute list def for an element 5889 * 5890 * [54] AttType ::= StringType | TokenizedType | EnumeratedType 5891 * 5892 * [55] StringType ::= 'CDATA' 5893 * 5894 * [56] TokenizedType ::= 'ID' | 'IDREF' | 'IDREFS' | 'ENTITY' | 5895 * 'ENTITIES' | 'NMTOKEN' | 'NMTOKENS' 5896 * 5897 * Validity constraints for attribute values syntax are checked in 5898 * xmlValidateAttributeValue() 5899 * 5900 * [ VC: ID ] 5901 * Values of type ID must match the Name production. A name must not 5902 * appear more than once in an XML document as a value of this type; 5903 * i.e., ID values must uniquely identify the elements which bear them. 5904 * 5905 * [ VC: One ID per Element Type ] 5906 * No element type may have more than one ID attribute specified. 5907 * 5908 * [ VC: ID Attribute Default ] 5909 * An ID attribute must have a declared default of #IMPLIED or #REQUIRED. 5910 * 5911 * [ VC: IDREF ] 5912 * Values of type IDREF must match the Name production, and values 5913 * of type IDREFS must match Names; each IDREF Name must match the value 5914 * of an ID attribute on some element in the XML document; i.e. IDREF 5915 * values must match the value of some ID attribute. 5916 * 5917 * [ VC: Entity Name ] 5918 * Values of type ENTITY must match the Name production, values 5919 * of type ENTITIES must match Names; each Entity Name must match the 5920 * name of an unparsed entity declared in the DTD. 5921 * 5922 * [ VC: Name Token ] 5923 * Values of type NMTOKEN must match the Nmtoken production; values 5924 * of type NMTOKENS must match Nmtokens. 5925 * 5926 * Returns the attribute type 5927 */ 5928 int 5929 xmlParseAttributeType(xmlParserCtxtPtr ctxt, xmlEnumerationPtr *tree) { 5930 SHRINK; 5931 if (CMP5(CUR_PTR, 'C', 'D', 'A', 'T', 'A')) { 5932 SKIP(5); 5933 return(XML_ATTRIBUTE_CDATA); 5934 } else if (CMP6(CUR_PTR, 'I', 'D', 'R', 'E', 'F', 'S')) { 5935 SKIP(6); 5936 return(XML_ATTRIBUTE_IDREFS); 5937 } else if (CMP5(CUR_PTR, 'I', 'D', 'R', 'E', 'F')) { 5938 SKIP(5); 5939 return(XML_ATTRIBUTE_IDREF); 5940 } else if ((RAW == 'I') && (NXT(1) == 'D')) { 5941 SKIP(2); 5942 return(XML_ATTRIBUTE_ID); 5943 } else if (CMP6(CUR_PTR, 'E', 'N', 'T', 'I', 'T', 'Y')) { 5944 SKIP(6); 5945 return(XML_ATTRIBUTE_ENTITY); 5946 } else if (CMP8(CUR_PTR, 'E', 'N', 'T', 'I', 'T', 'I', 'E', 'S')) { 5947 SKIP(8); 5948 return(XML_ATTRIBUTE_ENTITIES); 5949 } else if (CMP8(CUR_PTR, 'N', 'M', 'T', 'O', 'K', 'E', 'N', 'S')) { 5950 SKIP(8); 5951 return(XML_ATTRIBUTE_NMTOKENS); 5952 } else if (CMP7(CUR_PTR, 'N', 'M', 'T', 'O', 'K', 'E', 'N')) { 5953 SKIP(7); 5954 return(XML_ATTRIBUTE_NMTOKEN); 5955 } 5956 return(xmlParseEnumeratedType(ctxt, tree)); 5957 } 5958 5959 /** 5960 * xmlParseAttributeListDecl: 5961 * @ctxt: an XML parser context 5962 * 5963 * : parse the Attribute list def for an element 5964 * 5965 * [52] AttlistDecl ::= '<!ATTLIST' S Name AttDef* S? '>' 5966 * 5967 * [53] AttDef ::= S Name S AttType S DefaultDecl 5968 * 5969 */ 5970 void 5971 xmlParseAttributeListDecl(xmlParserCtxtPtr ctxt) { 5972 const xmlChar *elemName; 5973 const xmlChar *attrName; 5974 xmlEnumerationPtr tree; 5975 5976 if (CMP9(CUR_PTR, '<', '!', 'A', 'T', 'T', 'L', 'I', 'S', 'T')) { 5977 xmlParserInputPtr input = ctxt->input; 5978 5979 SKIP(9); 5980 if (!IS_BLANK_CH(CUR)) { 5981 xmlFatalErrMsg(ctxt, XML_ERR_SPACE_REQUIRED, 5982 "Space required after '<!ATTLIST'\n"); 5983 } 5984 SKIP_BLANKS; 5985 elemName = xmlParseName(ctxt); 5986 if (elemName == NULL) { 5987 xmlFatalErrMsg(ctxt, XML_ERR_NAME_REQUIRED, 5988 "ATTLIST: no name for Element\n"); 5989 return; 5990 } 5991 SKIP_BLANKS; 5992 GROW; 5993 while ((RAW != '>') && (ctxt->instate != XML_PARSER_EOF)) { 5994 const xmlChar *check = CUR_PTR; 5995 int type; 5996 int def; 5997 xmlChar *defaultValue = NULL; 5998 5999 GROW; 6000 tree = NULL; 6001 attrName = xmlParseName(ctxt); 6002 if (attrName == NULL) { 6003 xmlFatalErrMsg(ctxt, XML_ERR_NAME_REQUIRED, 6004 "ATTLIST: no name for Attribute\n"); 6005 break; 6006 } 6007 GROW; 6008 if (!IS_BLANK_CH(CUR)) { 6009 xmlFatalErrMsg(ctxt, XML_ERR_SPACE_REQUIRED, 6010 "Space required after the attribute name\n"); 6011 break; 6012 } 6013 SKIP_BLANKS; 6014 6015 type = xmlParseAttributeType(ctxt, &tree); 6016 if (type <= 0) { 6017 break; 6018 } 6019 6020 GROW; 6021 if (!IS_BLANK_CH(CUR)) { 6022 xmlFatalErrMsg(ctxt, XML_ERR_SPACE_REQUIRED, 6023 "Space required after the attribute type\n"); 6024 if (tree != NULL) 6025 xmlFreeEnumeration(tree); 6026 break; 6027 } 6028 SKIP_BLANKS; 6029 6030 def = xmlParseDefaultDecl(ctxt, &defaultValue); 6031 if (def <= 0) { 6032 if (defaultValue != NULL) 6033 xmlFree(defaultValue); 6034 if (tree != NULL) 6035 xmlFreeEnumeration(tree); 6036 break; 6037 } 6038 if ((type != XML_ATTRIBUTE_CDATA) && (defaultValue != NULL)) 6039 xmlAttrNormalizeSpace(defaultValue, defaultValue); 6040 6041 GROW; 6042 if (RAW != '>') { 6043 if (!IS_BLANK_CH(CUR)) { 6044 xmlFatalErrMsg(ctxt, XML_ERR_SPACE_REQUIRED, 6045 "Space required after the attribute default value\n"); 6046 if (defaultValue != NULL) 6047 xmlFree(defaultValue); 6048 if (tree != NULL) 6049 xmlFreeEnumeration(tree); 6050 break; 6051 } 6052 SKIP_BLANKS; 6053 } 6054 if (check == CUR_PTR) { 6055 xmlFatalErr(ctxt, XML_ERR_INTERNAL_ERROR, 6056 "in xmlParseAttributeListDecl\n"); 6057 if (defaultValue != NULL) 6058 xmlFree(defaultValue); 6059 if (tree != NULL) 6060 xmlFreeEnumeration(tree); 6061 break; 6062 } 6063 if ((ctxt->sax != NULL) && (!ctxt->disableSAX) && 6064 (ctxt->sax->attributeDecl != NULL)) 6065 ctxt->sax->attributeDecl(ctxt->userData, elemName, attrName, 6066 type, def, defaultValue, tree); 6067 else if (tree != NULL) 6068 xmlFreeEnumeration(tree); 6069 6070 if ((ctxt->sax2) && (defaultValue != NULL) && 6071 (def != XML_ATTRIBUTE_IMPLIED) && 6072 (def != XML_ATTRIBUTE_REQUIRED)) { 6073 xmlAddDefAttrs(ctxt, elemName, attrName, defaultValue); 6074 } 6075 if (ctxt->sax2) { 6076 xmlAddSpecialAttr(ctxt, elemName, attrName, type); 6077 } 6078 if (defaultValue != NULL) 6079 xmlFree(defaultValue); 6080 GROW; 6081 } 6082 if (RAW == '>') { 6083 if (input != ctxt->input) { 6084 xmlValidityError(ctxt, XML_ERR_ENTITY_BOUNDARY, 6085 "Attribute list declaration doesn't start and stop in the same entity\n", 6086 NULL, NULL); 6087 } 6088 NEXT; 6089 } 6090 } 6091 } 6092 6093 /** 6094 * xmlParseElementMixedContentDecl: 6095 * @ctxt: an XML parser context 6096 * @inputchk: the input used for the current entity, needed for boundary checks 6097 * 6098 * parse the declaration for a Mixed Element content 6099 * The leading '(' and spaces have been skipped in xmlParseElementContentDecl 6100 * 6101 * [51] Mixed ::= '(' S? '#PCDATA' (S? '|' S? Name)* S? ')*' | 6102 * '(' S? '#PCDATA' S? ')' 6103 * 6104 * [ VC: Proper Group/PE Nesting ] applies to [51] too (see [49]) 6105 * 6106 * [ VC: No Duplicate Types ] 6107 * The same name must not appear more than once in a single 6108 * mixed-content declaration. 6109 * 6110 * returns: the list of the xmlElementContentPtr describing the element choices 6111 */ 6112 xmlElementContentPtr 6113 xmlParseElementMixedContentDecl(xmlParserCtxtPtr ctxt, int inputchk) { 6114 xmlElementContentPtr ret = NULL, cur = NULL, n; 6115 const xmlChar *elem = NULL; 6116 6117 GROW; 6118 if (CMP7(CUR_PTR, '#', 'P', 'C', 'D', 'A', 'T', 'A')) { 6119 SKIP(7); 6120 SKIP_BLANKS; 6121 SHRINK; 6122 if (RAW == ')') { 6123 if ((ctxt->validate) && (ctxt->input->id != inputchk)) { 6124 xmlValidityError(ctxt, XML_ERR_ENTITY_BOUNDARY, 6125 "Element content declaration doesn't start and stop in the same entity\n", 6126 NULL, NULL); 6127 } 6128 NEXT; 6129 ret = xmlNewDocElementContent(ctxt->myDoc, NULL, XML_ELEMENT_CONTENT_PCDATA); 6130 if (ret == NULL) 6131 return(NULL); 6132 if (RAW == '*') { 6133 ret->ocur = XML_ELEMENT_CONTENT_MULT; 6134 NEXT; 6135 } 6136 return(ret); 6137 } 6138 if ((RAW == '(') || (RAW == '|')) { 6139 ret = cur = xmlNewDocElementContent(ctxt->myDoc, NULL, XML_ELEMENT_CONTENT_PCDATA); 6140 if (ret == NULL) return(NULL); 6141 } 6142 while ((RAW == '|') && (ctxt->instate != XML_PARSER_EOF)) { 6143 NEXT; 6144 if (elem == NULL) { 6145 ret = xmlNewDocElementContent(ctxt->myDoc, NULL, XML_ELEMENT_CONTENT_OR); 6146 if (ret == NULL) return(NULL); 6147 ret->c1 = cur; 6148 if (cur != NULL) 6149 cur->parent = ret; 6150 cur = ret; 6151 } else { 6152 n = xmlNewDocElementContent(ctxt->myDoc, NULL, XML_ELEMENT_CONTENT_OR); 6153 if (n == NULL) return(NULL); 6154 n->c1 = xmlNewDocElementContent(ctxt->myDoc, elem, XML_ELEMENT_CONTENT_ELEMENT); 6155 if (n->c1 != NULL) 6156 n->c1->parent = n; 6157 cur->c2 = n; 6158 if (n != NULL) 6159 n->parent = cur; 6160 cur = n; 6161 } 6162 SKIP_BLANKS; 6163 elem = xmlParseName(ctxt); 6164 if (elem == NULL) { 6165 xmlFatalErrMsg(ctxt, XML_ERR_NAME_REQUIRED, 6166 "xmlParseElementMixedContentDecl : Name expected\n"); 6167 xmlFreeDocElementContent(ctxt->myDoc, cur); 6168 return(NULL); 6169 } 6170 SKIP_BLANKS; 6171 GROW; 6172 } 6173 if ((RAW == ')') && (NXT(1) == '*')) { 6174 if (elem != NULL) { 6175 cur->c2 = xmlNewDocElementContent(ctxt->myDoc, elem, 6176 XML_ELEMENT_CONTENT_ELEMENT); 6177 if (cur->c2 != NULL) 6178 cur->c2->parent = cur; 6179 } 6180 if (ret != NULL) 6181 ret->ocur = XML_ELEMENT_CONTENT_MULT; 6182 if ((ctxt->validate) && (ctxt->input->id != inputchk)) { 6183 xmlValidityError(ctxt, XML_ERR_ENTITY_BOUNDARY, 6184 "Element content declaration doesn't start and stop in the same entity\n", 6185 NULL, NULL); 6186 } 6187 SKIP(2); 6188 } else { 6189 xmlFreeDocElementContent(ctxt->myDoc, ret); 6190 xmlFatalErr(ctxt, XML_ERR_MIXED_NOT_STARTED, NULL); 6191 return(NULL); 6192 } 6193 6194 } else { 6195 xmlFatalErr(ctxt, XML_ERR_PCDATA_REQUIRED, NULL); 6196 } 6197 return(ret); 6198 } 6199 6200 /** 6201 * xmlParseElementChildrenContentDeclPriv: 6202 * @ctxt: an XML parser context 6203 * @inputchk: the input used for the current entity, needed for boundary checks 6204 * @depth: the level of recursion 6205 * 6206 * parse the declaration for a Mixed Element content 6207 * The leading '(' and spaces have been skipped in xmlParseElementContentDecl 6208 * 6209 * 6210 * [47] children ::= (choice | seq) ('?' | '*' | '+')? 6211 * 6212 * [48] cp ::= (Name | choice | seq) ('?' | '*' | '+')? 6213 * 6214 * [49] choice ::= '(' S? cp ( S? '|' S? cp )* S? ')' 6215 * 6216 * [50] seq ::= '(' S? cp ( S? ',' S? cp )* S? ')' 6217 * 6218 * [ VC: Proper Group/PE Nesting ] applies to [49] and [50] 6219 * TODO Parameter-entity replacement text must be properly nested 6220 * with parenthesized groups. That is to say, if either of the 6221 * opening or closing parentheses in a choice, seq, or Mixed 6222 * construct is contained in the replacement text for a parameter 6223 * entity, both must be contained in the same replacement text. For 6224 * interoperability, if a parameter-entity reference appears in a 6225 * choice, seq, or Mixed construct, its replacement text should not 6226 * be empty, and neither the first nor last non-blank character of 6227 * the replacement text should be a connector (| or ,). 6228 * 6229 * Returns the tree of xmlElementContentPtr describing the element 6230 * hierarchy. 6231 */ 6232 static xmlElementContentPtr 6233 xmlParseElementChildrenContentDeclPriv(xmlParserCtxtPtr ctxt, int inputchk, 6234 int depth) { 6235 xmlElementContentPtr ret = NULL, cur = NULL, last = NULL, op = NULL; 6236 const xmlChar *elem; 6237 xmlChar type = 0; 6238 6239 if (((depth > 128) && ((ctxt->options & XML_PARSE_HUGE) == 0)) || 6240 (depth > 2048)) { 6241 xmlFatalErrMsgInt(ctxt, XML_ERR_ELEMCONTENT_NOT_FINISHED, 6242 "xmlParseElementChildrenContentDecl : depth %d too deep, use XML_PARSE_HUGE\n", 6243 depth); 6244 return(NULL); 6245 } 6246 SKIP_BLANKS; 6247 GROW; 6248 if (RAW == '(') { 6249 int inputid = ctxt->input->id; 6250 6251 /* Recurse on first child */ 6252 NEXT; 6253 SKIP_BLANKS; 6254 cur = ret = xmlParseElementChildrenContentDeclPriv(ctxt, inputid, 6255 depth + 1); 6256 SKIP_BLANKS; 6257 GROW; 6258 } else { 6259 elem = xmlParseName(ctxt); 6260 if (elem == NULL) { 6261 xmlFatalErr(ctxt, XML_ERR_ELEMCONTENT_NOT_STARTED, NULL); 6262 return(NULL); 6263 } 6264 cur = ret = xmlNewDocElementContent(ctxt->myDoc, elem, XML_ELEMENT_CONTENT_ELEMENT); 6265 if (cur == NULL) { 6266 xmlErrMemory(ctxt, NULL); 6267 return(NULL); 6268 } 6269 GROW; 6270 if (RAW == '?') { 6271 cur->ocur = XML_ELEMENT_CONTENT_OPT; 6272 NEXT; 6273 } else if (RAW == '*') { 6274 cur->ocur = XML_ELEMENT_CONTENT_MULT; 6275 NEXT; 6276 } else if (RAW == '+') { 6277 cur->ocur = XML_ELEMENT_CONTENT_PLUS; 6278 NEXT; 6279 } else { 6280 cur->ocur = XML_ELEMENT_CONTENT_ONCE; 6281 } 6282 GROW; 6283 } 6284 SKIP_BLANKS; 6285 SHRINK; 6286 while ((RAW != ')') && (ctxt->instate != XML_PARSER_EOF)) { 6287 /* 6288 * Each loop we parse one separator and one element. 6289 */ 6290 if (RAW == ',') { 6291 if (type == 0) type = CUR; 6292 6293 /* 6294 * Detect "Name | Name , Name" error 6295 */ 6296 else if (type != CUR) { 6297 xmlFatalErrMsgInt(ctxt, XML_ERR_SEPARATOR_REQUIRED, 6298 "xmlParseElementChildrenContentDecl : '%c' expected\n", 6299 type); 6300 if ((last != NULL) && (last != ret)) 6301 xmlFreeDocElementContent(ctxt->myDoc, last); 6302 if (ret != NULL) 6303 xmlFreeDocElementContent(ctxt->myDoc, ret); 6304 return(NULL); 6305 } 6306 NEXT; 6307 6308 op = xmlNewDocElementContent(ctxt->myDoc, NULL, XML_ELEMENT_CONTENT_SEQ); 6309 if (op == NULL) { 6310 if ((last != NULL) && (last != ret)) 6311 xmlFreeDocElementContent(ctxt->myDoc, last); 6312 xmlFreeDocElementContent(ctxt->myDoc, ret); 6313 return(NULL); 6314 } 6315 if (last == NULL) { 6316 op->c1 = ret; 6317 if (ret != NULL) 6318 ret->parent = op; 6319 ret = cur = op; 6320 } else { 6321 cur->c2 = op; 6322 if (op != NULL) 6323 op->parent = cur; 6324 op->c1 = last; 6325 if (last != NULL) 6326 last->parent = op; 6327 cur =op; 6328 last = NULL; 6329 } 6330 } else if (RAW == '|') { 6331 if (type == 0) type = CUR; 6332 6333 /* 6334 * Detect "Name , Name | Name" error 6335 */ 6336 else if (type != CUR) { 6337 xmlFatalErrMsgInt(ctxt, XML_ERR_SEPARATOR_REQUIRED, 6338 "xmlParseElementChildrenContentDecl : '%c' expected\n", 6339 type); 6340 if ((last != NULL) && (last != ret)) 6341 xmlFreeDocElementContent(ctxt->myDoc, last); 6342 if (ret != NULL) 6343 xmlFreeDocElementContent(ctxt->myDoc, ret); 6344 return(NULL); 6345 } 6346 NEXT; 6347 6348 op = xmlNewDocElementContent(ctxt->myDoc, NULL, XML_ELEMENT_CONTENT_OR); 6349 if (op == NULL) { 6350 if ((last != NULL) && (last != ret)) 6351 xmlFreeDocElementContent(ctxt->myDoc, last); 6352 if (ret != NULL) 6353 xmlFreeDocElementContent(ctxt->myDoc, ret); 6354 return(NULL); 6355 } 6356 if (last == NULL) { 6357 op->c1 = ret; 6358 if (ret != NULL) 6359 ret->parent = op; 6360 ret = cur = op; 6361 } else { 6362 cur->c2 = op; 6363 if (op != NULL) 6364 op->parent = cur; 6365 op->c1 = last; 6366 if (last != NULL) 6367 last->parent = op; 6368 cur =op; 6369 last = NULL; 6370 } 6371 } else { 6372 xmlFatalErr(ctxt, XML_ERR_ELEMCONTENT_NOT_FINISHED, NULL); 6373 if ((last != NULL) && (last != ret)) 6374 xmlFreeDocElementContent(ctxt->myDoc, last); 6375 if (ret != NULL) 6376 xmlFreeDocElementContent(ctxt->myDoc, ret); 6377 return(NULL); 6378 } 6379 GROW; 6380 SKIP_BLANKS; 6381 GROW; 6382 if (RAW == '(') { 6383 int inputid = ctxt->input->id; 6384 /* Recurse on second child */ 6385 NEXT; 6386 SKIP_BLANKS; 6387 last = xmlParseElementChildrenContentDeclPriv(ctxt, inputid, 6388 depth + 1); 6389 SKIP_BLANKS; 6390 } else { 6391 elem = xmlParseName(ctxt); 6392 if (elem == NULL) { 6393 xmlFatalErr(ctxt, XML_ERR_ELEMCONTENT_NOT_STARTED, NULL); 6394 if (ret != NULL) 6395 xmlFreeDocElementContent(ctxt->myDoc, ret); 6396 return(NULL); 6397 } 6398 last = xmlNewDocElementContent(ctxt->myDoc, elem, XML_ELEMENT_CONTENT_ELEMENT); 6399 if (last == NULL) { 6400 if (ret != NULL) 6401 xmlFreeDocElementContent(ctxt->myDoc, ret); 6402 return(NULL); 6403 } 6404 if (RAW == '?') { 6405 last->ocur = XML_ELEMENT_CONTENT_OPT; 6406 NEXT; 6407 } else if (RAW == '*') { 6408 last->ocur = XML_ELEMENT_CONTENT_MULT; 6409 NEXT; 6410 } else if (RAW == '+') { 6411 last->ocur = XML_ELEMENT_CONTENT_PLUS; 6412 NEXT; 6413 } else { 6414 last->ocur = XML_ELEMENT_CONTENT_ONCE; 6415 } 6416 } 6417 SKIP_BLANKS; 6418 GROW; 6419 } 6420 if ((cur != NULL) && (last != NULL)) { 6421 cur->c2 = last; 6422 if (last != NULL) 6423 last->parent = cur; 6424 } 6425 if ((ctxt->validate) && (ctxt->input->id != inputchk)) { 6426 xmlValidityError(ctxt, XML_ERR_ENTITY_BOUNDARY, 6427 "Element content declaration doesn't start and stop in the same entity\n", 6428 NULL, NULL); 6429 } 6430 NEXT; 6431 if (RAW == '?') { 6432 if (ret != NULL) { 6433 if ((ret->ocur == XML_ELEMENT_CONTENT_PLUS) || 6434 (ret->ocur == XML_ELEMENT_CONTENT_MULT)) 6435 ret->ocur = XML_ELEMENT_CONTENT_MULT; 6436 else 6437 ret->ocur = XML_ELEMENT_CONTENT_OPT; 6438 } 6439 NEXT; 6440 } else if (RAW == '*') { 6441 if (ret != NULL) { 6442 ret->ocur = XML_ELEMENT_CONTENT_MULT; 6443 cur = ret; 6444 /* 6445 * Some normalization: 6446 * (a | b* | c?)* == (a | b | c)* 6447 */ 6448 while ((cur != NULL) && (cur->type == XML_ELEMENT_CONTENT_OR)) { 6449 if ((cur->c1 != NULL) && 6450 ((cur->c1->ocur == XML_ELEMENT_CONTENT_OPT) || 6451 (cur->c1->ocur == XML_ELEMENT_CONTENT_MULT))) 6452 cur->c1->ocur = XML_ELEMENT_CONTENT_ONCE; 6453 if ((cur->c2 != NULL) && 6454 ((cur->c2->ocur == XML_ELEMENT_CONTENT_OPT) || 6455 (cur->c2->ocur == XML_ELEMENT_CONTENT_MULT))) 6456 cur->c2->ocur = XML_ELEMENT_CONTENT_ONCE; 6457 cur = cur->c2; 6458 } 6459 } 6460 NEXT; 6461 } else if (RAW == '+') { 6462 if (ret != NULL) { 6463 int found = 0; 6464 6465 if ((ret->ocur == XML_ELEMENT_CONTENT_OPT) || 6466 (ret->ocur == XML_ELEMENT_CONTENT_MULT)) 6467 ret->ocur = XML_ELEMENT_CONTENT_MULT; 6468 else 6469 ret->ocur = XML_ELEMENT_CONTENT_PLUS; 6470 /* 6471 * Some normalization: 6472 * (a | b*)+ == (a | b)* 6473 * (a | b?)+ == (a | b)* 6474 */ 6475 while ((cur != NULL) && (cur->type == XML_ELEMENT_CONTENT_OR)) { 6476 if ((cur->c1 != NULL) && 6477 ((cur->c1->ocur == XML_ELEMENT_CONTENT_OPT) || 6478 (cur->c1->ocur == XML_ELEMENT_CONTENT_MULT))) { 6479 cur->c1->ocur = XML_ELEMENT_CONTENT_ONCE; 6480 found = 1; 6481 } 6482 if ((cur->c2 != NULL) && 6483 ((cur->c2->ocur == XML_ELEMENT_CONTENT_OPT) || 6484 (cur->c2->ocur == XML_ELEMENT_CONTENT_MULT))) { 6485 cur->c2->ocur = XML_ELEMENT_CONTENT_ONCE; 6486 found = 1; 6487 } 6488 cur = cur->c2; 6489 } 6490 if (found) 6491 ret->ocur = XML_ELEMENT_CONTENT_MULT; 6492 } 6493 NEXT; 6494 } 6495 return(ret); 6496 } 6497 6498 /** 6499 * xmlParseElementChildrenContentDecl: 6500 * @ctxt: an XML parser context 6501 * @inputchk: the input used for the current entity, needed for boundary checks 6502 * 6503 * parse the declaration for a Mixed Element content 6504 * The leading '(' and spaces have been skipped in xmlParseElementContentDecl 6505 * 6506 * [47] children ::= (choice | seq) ('?' | '*' | '+')? 6507 * 6508 * [48] cp ::= (Name | choice | seq) ('?' | '*' | '+')? 6509 * 6510 * [49] choice ::= '(' S? cp ( S? '|' S? cp )* S? ')' 6511 * 6512 * [50] seq ::= '(' S? cp ( S? ',' S? cp )* S? ')' 6513 * 6514 * [ VC: Proper Group/PE Nesting ] applies to [49] and [50] 6515 * TODO Parameter-entity replacement text must be properly nested 6516 * with parenthesized groups. That is to say, if either of the 6517 * opening or closing parentheses in a choice, seq, or Mixed 6518 * construct is contained in the replacement text for a parameter 6519 * entity, both must be contained in the same replacement text. For 6520 * interoperability, if a parameter-entity reference appears in a 6521 * choice, seq, or Mixed construct, its replacement text should not 6522 * be empty, and neither the first nor last non-blank character of 6523 * the replacement text should be a connector (| or ,). 6524 * 6525 * Returns the tree of xmlElementContentPtr describing the element 6526 * hierarchy. 6527 */ 6528 xmlElementContentPtr 6529 xmlParseElementChildrenContentDecl(xmlParserCtxtPtr ctxt, int inputchk) { 6530 /* stub left for API/ABI compat */ 6531 return(xmlParseElementChildrenContentDeclPriv(ctxt, inputchk, 1)); 6532 } 6533 6534 /** 6535 * xmlParseElementContentDecl: 6536 * @ctxt: an XML parser context 6537 * @name: the name of the element being defined. 6538 * @result: the Element Content pointer will be stored here if any 6539 * 6540 * parse the declaration for an Element content either Mixed or Children, 6541 * the cases EMPTY and ANY are handled directly in xmlParseElementDecl 6542 * 6543 * [46] contentspec ::= 'EMPTY' | 'ANY' | Mixed | children 6544 * 6545 * returns: the type of element content XML_ELEMENT_TYPE_xxx 6546 */ 6547 6548 int 6549 xmlParseElementContentDecl(xmlParserCtxtPtr ctxt, const xmlChar *name, 6550 xmlElementContentPtr *result) { 6551 6552 xmlElementContentPtr tree = NULL; 6553 int inputid = ctxt->input->id; 6554 int res; 6555 6556 *result = NULL; 6557 6558 if (RAW != '(') { 6559 xmlFatalErrMsgStr(ctxt, XML_ERR_ELEMCONTENT_NOT_STARTED, 6560 "xmlParseElementContentDecl : %s '(' expected\n", name); 6561 return(-1); 6562 } 6563 NEXT; 6564 GROW; 6565 if (ctxt->instate == XML_PARSER_EOF) 6566 return(-1); 6567 SKIP_BLANKS; 6568 if (CMP7(CUR_PTR, '#', 'P', 'C', 'D', 'A', 'T', 'A')) { 6569 tree = xmlParseElementMixedContentDecl(ctxt, inputid); 6570 res = XML_ELEMENT_TYPE_MIXED; 6571 } else { 6572 tree = xmlParseElementChildrenContentDeclPriv(ctxt, inputid, 1); 6573 res = XML_ELEMENT_TYPE_ELEMENT; 6574 } 6575 SKIP_BLANKS; 6576 *result = tree; 6577 return(res); 6578 } 6579 6580 /** 6581 * xmlParseElementDecl: 6582 * @ctxt: an XML parser context 6583 * 6584 * parse an Element declaration. 6585 * 6586 * [45] elementdecl ::= '<!ELEMENT' S Name S contentspec S? '>' 6587 * 6588 * [ VC: Unique Element Type Declaration ] 6589 * No element type may be declared more than once 6590 * 6591 * Returns the type of the element, or -1 in case of error 6592 */ 6593 int 6594 xmlParseElementDecl(xmlParserCtxtPtr ctxt) { 6595 const xmlChar *name; 6596 int ret = -1; 6597 xmlElementContentPtr content = NULL; 6598 6599 /* GROW; done in the caller */ 6600 if (CMP9(CUR_PTR, '<', '!', 'E', 'L', 'E', 'M', 'E', 'N', 'T')) { 6601 xmlParserInputPtr input = ctxt->input; 6602 6603 SKIP(9); 6604 if (!IS_BLANK_CH(CUR)) { 6605 xmlFatalErrMsg(ctxt, XML_ERR_SPACE_REQUIRED, 6606 "Space required after 'ELEMENT'\n"); 6607 } 6608 SKIP_BLANKS; 6609 name = xmlParseName(ctxt); 6610 if (name == NULL) { 6611 xmlFatalErrMsg(ctxt, XML_ERR_NAME_REQUIRED, 6612 "xmlParseElementDecl: no name for Element\n"); 6613 return(-1); 6614 } 6615 while ((RAW == 0) && (ctxt->inputNr > 1)) 6616 xmlPopInput(ctxt); 6617 if (!IS_BLANK_CH(CUR)) { 6618 xmlFatalErrMsg(ctxt, XML_ERR_SPACE_REQUIRED, 6619 "Space required after the element name\n"); 6620 } 6621 SKIP_BLANKS; 6622 if (CMP5(CUR_PTR, 'E', 'M', 'P', 'T', 'Y')) { 6623 SKIP(5); 6624 /* 6625 * Element must always be empty. 6626 */ 6627 ret = XML_ELEMENT_TYPE_EMPTY; 6628 } else if ((RAW == 'A') && (NXT(1) == 'N') && 6629 (NXT(2) == 'Y')) { 6630 SKIP(3); 6631 /* 6632 * Element is a generic container. 6633 */ 6634 ret = XML_ELEMENT_TYPE_ANY; 6635 } else if (RAW == '(') { 6636 ret = xmlParseElementContentDecl(ctxt, name, &content); 6637 } else { 6638 /* 6639 * [ WFC: PEs in Internal Subset ] error handling. 6640 */ 6641 if ((RAW == '%') && (ctxt->external == 0) && 6642 (ctxt->inputNr == 1)) { 6643 xmlFatalErrMsg(ctxt, XML_ERR_PEREF_IN_INT_SUBSET, 6644 "PEReference: forbidden within markup decl in internal subset\n"); 6645 } else { 6646 xmlFatalErrMsg(ctxt, XML_ERR_ELEMCONTENT_NOT_STARTED, 6647 "xmlParseElementDecl: 'EMPTY', 'ANY' or '(' expected\n"); 6648 } 6649 return(-1); 6650 } 6651 6652 SKIP_BLANKS; 6653 /* 6654 * Pop-up of finished entities. 6655 */ 6656 while ((RAW == 0) && (ctxt->inputNr > 1)) 6657 xmlPopInput(ctxt); 6658 SKIP_BLANKS; 6659 6660 if (RAW != '>') { 6661 xmlFatalErr(ctxt, XML_ERR_GT_REQUIRED, NULL); 6662 if (content != NULL) { 6663 xmlFreeDocElementContent(ctxt->myDoc, content); 6664 } 6665 } else { 6666 if (input != ctxt->input) { 6667 xmlFatalErrMsg(ctxt, XML_ERR_ENTITY_BOUNDARY, 6668 "Element declaration doesn't start and stop in the same entity\n"); 6669 } 6670 6671 NEXT; 6672 if ((ctxt->sax != NULL) && (!ctxt->disableSAX) && 6673 (ctxt->sax->elementDecl != NULL)) { 6674 if (content != NULL) 6675 content->parent = NULL; 6676 ctxt->sax->elementDecl(ctxt->userData, name, ret, 6677 content); 6678 if ((content != NULL) && (content->parent == NULL)) { 6679 /* 6680 * this is a trick: if xmlAddElementDecl is called, 6681 * instead of copying the full tree it is plugged directly 6682 * if called from the parser. Avoid duplicating the 6683 * interfaces or change the API/ABI 6684 */ 6685 xmlFreeDocElementContent(ctxt->myDoc, content); 6686 } 6687 } else if (content != NULL) { 6688 xmlFreeDocElementContent(ctxt->myDoc, content); 6689 } 6690 } 6691 } 6692 return(ret); 6693 } 6694 6695 /** 6696 * xmlParseConditionalSections 6697 * @ctxt: an XML parser context 6698 * 6699 * [61] conditionalSect ::= includeSect | ignoreSect 6700 * [62] includeSect ::= '<![' S? 'INCLUDE' S? '[' extSubsetDecl ']]>' 6701 * [63] ignoreSect ::= '<![' S? 'IGNORE' S? '[' ignoreSectContents* ']]>' 6702 * [64] ignoreSectContents ::= Ignore ('<![' ignoreSectContents ']]>' Ignore)* 6703 * [65] Ignore ::= Char* - (Char* ('<![' | ']]>') Char*) 6704 */ 6705 6706 static void 6707 xmlParseConditionalSections(xmlParserCtxtPtr ctxt) { 6708 int id = ctxt->input->id; 6709 6710 SKIP(3); 6711 SKIP_BLANKS; 6712 if (CMP7(CUR_PTR, 'I', 'N', 'C', 'L', 'U', 'D', 'E')) { 6713 SKIP(7); 6714 SKIP_BLANKS; 6715 if (RAW != '[') { 6716 xmlFatalErr(ctxt, XML_ERR_CONDSEC_INVALID, NULL); 6717 } else { 6718 if (ctxt->input->id != id) { 6719 xmlValidityError(ctxt, XML_ERR_ENTITY_BOUNDARY, 6720 "All markup of the conditional section is not in the same entity\n", 6721 NULL, NULL); 6722 } 6723 NEXT; 6724 } 6725 if (xmlParserDebugEntities) { 6726 if ((ctxt->input != NULL) && (ctxt->input->filename)) 6727 xmlGenericError(xmlGenericErrorContext, 6728 "%s(%d): ", ctxt->input->filename, 6729 ctxt->input->line); 6730 xmlGenericError(xmlGenericErrorContext, 6731 "Entering INCLUDE Conditional Section\n"); 6732 } 6733 6734 while (((RAW != 0) && ((RAW != ']') || (NXT(1) != ']') || 6735 (NXT(2) != '>'))) && (ctxt->instate != XML_PARSER_EOF)) { 6736 const xmlChar *check = CUR_PTR; 6737 unsigned int cons = ctxt->input->consumed; 6738 6739 if ((RAW == '<') && (NXT(1) == '!') && (NXT(2) == '[')) { 6740 xmlParseConditionalSections(ctxt); 6741 } else if (IS_BLANK_CH(CUR)) { 6742 NEXT; 6743 } else if (RAW == '%') { 6744 xmlParsePEReference(ctxt); 6745 } else 6746 xmlParseMarkupDecl(ctxt); 6747 6748 /* 6749 * Pop-up of finished entities. 6750 */ 6751 while ((RAW == 0) && (ctxt->inputNr > 1)) 6752 xmlPopInput(ctxt); 6753 6754 if ((CUR_PTR == check) && (cons == ctxt->input->consumed)) { 6755 xmlFatalErr(ctxt, XML_ERR_EXT_SUBSET_NOT_FINISHED, NULL); 6756 break; 6757 } 6758 } 6759 if (xmlParserDebugEntities) { 6760 if ((ctxt->input != NULL) && (ctxt->input->filename)) 6761 xmlGenericError(xmlGenericErrorContext, 6762 "%s(%d): ", ctxt->input->filename, 6763 ctxt->input->line); 6764 xmlGenericError(xmlGenericErrorContext, 6765 "Leaving INCLUDE Conditional Section\n"); 6766 } 6767 6768 } else if (CMP6(CUR_PTR, 'I', 'G', 'N', 'O', 'R', 'E')) { 6769 int state; 6770 xmlParserInputState instate; 6771 int depth = 0; 6772 6773 SKIP(6); 6774 SKIP_BLANKS; 6775 if (RAW != '[') { 6776 xmlFatalErr(ctxt, XML_ERR_CONDSEC_INVALID, NULL); 6777 } else { 6778 if (ctxt->input->id != id) { 6779 xmlValidityError(ctxt, XML_ERR_ENTITY_BOUNDARY, 6780 "All markup of the conditional section is not in the same entity\n", 6781 NULL, NULL); 6782 } 6783 NEXT; 6784 } 6785 if (xmlParserDebugEntities) { 6786 if ((ctxt->input != NULL) && (ctxt->input->filename)) 6787 xmlGenericError(xmlGenericErrorContext, 6788 "%s(%d): ", ctxt->input->filename, 6789 ctxt->input->line); 6790 xmlGenericError(xmlGenericErrorContext, 6791 "Entering IGNORE Conditional Section\n"); 6792 } 6793 6794 /* 6795 * Parse up to the end of the conditional section 6796 * But disable SAX event generating DTD building in the meantime 6797 */ 6798 state = ctxt->disableSAX; 6799 instate = ctxt->instate; 6800 if (ctxt->recovery == 0) ctxt->disableSAX = 1; 6801 ctxt->instate = XML_PARSER_IGNORE; 6802 6803 while (((depth >= 0) && (RAW != 0)) && 6804 (ctxt->instate != XML_PARSER_EOF)) { 6805 if ((RAW == '<') && (NXT(1) == '!') && (NXT(2) == '[')) { 6806 depth++; 6807 SKIP(3); 6808 continue; 6809 } 6810 if ((RAW == ']') && (NXT(1) == ']') && (NXT(2) == '>')) { 6811 if (--depth >= 0) SKIP(3); 6812 continue; 6813 } 6814 NEXT; 6815 continue; 6816 } 6817 6818 ctxt->disableSAX = state; 6819 ctxt->instate = instate; 6820 6821 if (xmlParserDebugEntities) { 6822 if ((ctxt->input != NULL) && (ctxt->input->filename)) 6823 xmlGenericError(xmlGenericErrorContext, 6824 "%s(%d): ", ctxt->input->filename, 6825 ctxt->input->line); 6826 xmlGenericError(xmlGenericErrorContext, 6827 "Leaving IGNORE Conditional Section\n"); 6828 } 6829 6830 } else { 6831 xmlFatalErr(ctxt, XML_ERR_CONDSEC_INVALID_KEYWORD, NULL); 6832 } 6833 6834 if (RAW == 0) 6835 SHRINK; 6836 6837 if (RAW == 0) { 6838 xmlFatalErr(ctxt, XML_ERR_CONDSEC_NOT_FINISHED, NULL); 6839 } else { 6840 if (ctxt->input->id != id) { 6841 xmlValidityError(ctxt, XML_ERR_ENTITY_BOUNDARY, 6842 "All markup of the conditional section is not in the same entity\n", 6843 NULL, NULL); 6844 } 6845 SKIP(3); 6846 } 6847 } 6848 6849 /** 6850 * xmlParseMarkupDecl: 6851 * @ctxt: an XML parser context 6852 * 6853 * parse Markup declarations 6854 * 6855 * [29] markupdecl ::= elementdecl | AttlistDecl | EntityDecl | 6856 * NotationDecl | PI | Comment 6857 * 6858 * [ VC: Proper Declaration/PE Nesting ] 6859 * Parameter-entity replacement text must be properly nested with 6860 * markup declarations. That is to say, if either the first character 6861 * or the last character of a markup declaration (markupdecl above) is 6862 * contained in the replacement text for a parameter-entity reference, 6863 * both must be contained in the same replacement text. 6864 * 6865 * [ WFC: PEs in Internal Subset ] 6866 * In the internal DTD subset, parameter-entity references can occur 6867 * only where markup declarations can occur, not within markup declarations. 6868 * (This does not apply to references that occur in external parameter 6869 * entities or to the external subset.) 6870 */ 6871 void 6872 xmlParseMarkupDecl(xmlParserCtxtPtr ctxt) { 6873 GROW; 6874 if (CUR == '<') { 6875 if (NXT(1) == '!') { 6876 switch (NXT(2)) { 6877 case 'E': 6878 if (NXT(3) == 'L') 6879 xmlParseElementDecl(ctxt); 6880 else if (NXT(3) == 'N') 6881 xmlParseEntityDecl(ctxt); 6882 break; 6883 case 'A': 6884 xmlParseAttributeListDecl(ctxt); 6885 break; 6886 case 'N': 6887 xmlParseNotationDecl(ctxt); 6888 break; 6889 case '-': 6890 xmlParseComment(ctxt); 6891 break; 6892 default: 6893 /* there is an error but it will be detected later */ 6894 break; 6895 } 6896 } else if (NXT(1) == '?') { 6897 xmlParsePI(ctxt); 6898 } 6899 } 6900 /* 6901 * This is only for internal subset. On external entities, 6902 * the replacement is done before parsing stage 6903 */ 6904 if ((ctxt->external == 0) && (ctxt->inputNr == 1)) 6905 xmlParsePEReference(ctxt); 6906 6907 /* 6908 * Conditional sections are allowed from entities included 6909 * by PE References in the internal subset. 6910 */ 6911 if ((ctxt->external == 0) && (ctxt->inputNr > 1)) { 6912 if ((RAW == '<') && (NXT(1) == '!') && (NXT(2) == '[')) { 6913 xmlParseConditionalSections(ctxt); 6914 } 6915 } 6916 6917 ctxt->instate = XML_PARSER_DTD; 6918 } 6919 6920 /** 6921 * xmlParseTextDecl: 6922 * @ctxt: an XML parser context 6923 * 6924 * parse an XML declaration header for external entities 6925 * 6926 * [77] TextDecl ::= '<?xml' VersionInfo? EncodingDecl S? '?>' 6927 */ 6928 6929 void 6930 xmlParseTextDecl(xmlParserCtxtPtr ctxt) { 6931 xmlChar *version; 6932 const xmlChar *encoding; 6933 6934 /* 6935 * We know that '<?xml' is here. 6936 */ 6937 if ((CMP5(CUR_PTR, '<', '?', 'x', 'm', 'l')) && (IS_BLANK_CH(NXT(5)))) { 6938 SKIP(5); 6939 } else { 6940 xmlFatalErr(ctxt, XML_ERR_XMLDECL_NOT_STARTED, NULL); 6941 return; 6942 } 6943 6944 if (!IS_BLANK_CH(CUR)) { 6945 xmlFatalErrMsg(ctxt, XML_ERR_SPACE_REQUIRED, 6946 "Space needed after '<?xml'\n"); 6947 } 6948 SKIP_BLANKS; 6949 6950 /* 6951 * We may have the VersionInfo here. 6952 */ 6953 version = xmlParseVersionInfo(ctxt); 6954 if (version == NULL) 6955 version = xmlCharStrdup(XML_DEFAULT_VERSION); 6956 else { 6957 if (!IS_BLANK_CH(CUR)) { 6958 xmlFatalErrMsg(ctxt, XML_ERR_SPACE_REQUIRED, 6959 "Space needed here\n"); 6960 } 6961 } 6962 ctxt->input->version = version; 6963 6964 /* 6965 * We must have the encoding declaration 6966 */ 6967 encoding = xmlParseEncodingDecl(ctxt); 6968 if (ctxt->errNo == XML_ERR_UNSUPPORTED_ENCODING) { 6969 /* 6970 * The XML REC instructs us to stop parsing right here 6971 */ 6972 return; 6973 } 6974 if ((encoding == NULL) && (ctxt->errNo == XML_ERR_OK)) { 6975 xmlFatalErrMsg(ctxt, XML_ERR_MISSING_ENCODING, 6976 "Missing encoding in text declaration\n"); 6977 } 6978 6979 SKIP_BLANKS; 6980 if ((RAW == '?') && (NXT(1) == '>')) { 6981 SKIP(2); 6982 } else if (RAW == '>') { 6983 /* Deprecated old WD ... */ 6984 xmlFatalErr(ctxt, XML_ERR_XMLDECL_NOT_FINISHED, NULL); 6985 NEXT; 6986 } else { 6987 xmlFatalErr(ctxt, XML_ERR_XMLDECL_NOT_FINISHED, NULL); 6988 MOVETO_ENDTAG(CUR_PTR); 6989 NEXT; 6990 } 6991 } 6992 6993 /** 6994 * xmlParseExternalSubset: 6995 * @ctxt: an XML parser context 6996 * @ExternalID: the external identifier 6997 * @SystemID: the system identifier (or URL) 6998 * 6999 * parse Markup declarations from an external subset 7000 * 7001 * [30] extSubset ::= textDecl? extSubsetDecl 7002 * 7003 * [31] extSubsetDecl ::= (markupdecl | conditionalSect | PEReference | S) * 7004 */ 7005 void 7006 xmlParseExternalSubset(xmlParserCtxtPtr ctxt, const xmlChar *ExternalID, 7007 const xmlChar *SystemID) { 7008 xmlDetectSAX2(ctxt); 7009 GROW; 7010 7011 if ((ctxt->encoding == NULL) && 7012 (ctxt->input->end - ctxt->input->cur >= 4)) { 7013 xmlChar start[4]; 7014 xmlCharEncoding enc; 7015 7016 start[0] = RAW; 7017 start[1] = NXT(1); 7018 start[2] = NXT(2); 7019 start[3] = NXT(3); 7020 enc = xmlDetectCharEncoding(start, 4); 7021 if (enc != XML_CHAR_ENCODING_NONE) 7022 xmlSwitchEncoding(ctxt, enc); 7023 } 7024 7025 if (CMP5(CUR_PTR, '<', '?', 'x', 'm', 'l')) { 7026 xmlParseTextDecl(ctxt); 7027 if (ctxt->errNo == XML_ERR_UNSUPPORTED_ENCODING) { 7028 /* 7029 * The XML REC instructs us to stop parsing right here 7030 */ 7031 ctxt->instate = XML_PARSER_EOF; 7032 return; 7033 } 7034 } 7035 if (ctxt->myDoc == NULL) { 7036 ctxt->myDoc = xmlNewDoc(BAD_CAST "1.0"); 7037 if (ctxt->myDoc == NULL) { 7038 xmlErrMemory(ctxt, "New Doc failed"); 7039 return; 7040 } 7041 ctxt->myDoc->properties = XML_DOC_INTERNAL; 7042 } 7043 if ((ctxt->myDoc != NULL) && (ctxt->myDoc->intSubset == NULL)) 7044 xmlCreateIntSubset(ctxt->myDoc, NULL, ExternalID, SystemID); 7045 7046 ctxt->instate = XML_PARSER_DTD; 7047 ctxt->external = 1; 7048 while (((RAW == '<') && (NXT(1) == '?')) || 7049 ((RAW == '<') && (NXT(1) == '!')) || 7050 (RAW == '%') || IS_BLANK_CH(CUR)) { 7051 const xmlChar *check = CUR_PTR; 7052 unsigned int cons = ctxt->input->consumed; 7053 7054 GROW; 7055 if ((RAW == '<') && (NXT(1) == '!') && (NXT(2) == '[')) { 7056 xmlParseConditionalSections(ctxt); 7057 } else if (IS_BLANK_CH(CUR)) { 7058 NEXT; 7059 } else if (RAW == '%') { 7060 xmlParsePEReference(ctxt); 7061 } else 7062 xmlParseMarkupDecl(ctxt); 7063 7064 /* 7065 * Pop-up of finished entities. 7066 */ 7067 while ((RAW == 0) && (ctxt->inputNr > 1)) 7068 xmlPopInput(ctxt); 7069 7070 if ((CUR_PTR == check) && (cons == ctxt->input->consumed)) { 7071 xmlFatalErr(ctxt, XML_ERR_EXT_SUBSET_NOT_FINISHED, NULL); 7072 break; 7073 } 7074 } 7075 7076 if (RAW != 0) { 7077 xmlFatalErr(ctxt, XML_ERR_EXT_SUBSET_NOT_FINISHED, NULL); 7078 } 7079 7080 } 7081 7082 /** 7083 * xmlParseReference: 7084 * @ctxt: an XML parser context 7085 * 7086 * parse and handle entity references in content, depending on the SAX 7087 * interface, this may end-up in a call to character() if this is a 7088 * CharRef, a predefined entity, if there is no reference() callback. 7089 * or if the parser was asked to switch to that mode. 7090 * 7091 * [67] Reference ::= EntityRef | CharRef 7092 */ 7093 void 7094 xmlParseReference(xmlParserCtxtPtr ctxt) { 7095 xmlEntityPtr ent; 7096 xmlChar *val; 7097 int was_checked; 7098 xmlNodePtr list = NULL; 7099 xmlParserErrors ret = XML_ERR_OK; 7100 7101 7102 if (RAW != '&') 7103 return; 7104 7105 /* 7106 * Simple case of a CharRef 7107 */ 7108 if (NXT(1) == '#') { 7109 int i = 0; 7110 xmlChar out[10]; 7111 int hex = NXT(2); 7112 int value = xmlParseCharRef(ctxt); 7113 7114 if (value == 0) 7115 return; 7116 if (ctxt->charset != XML_CHAR_ENCODING_UTF8) { 7117 /* 7118 * So we are using non-UTF-8 buffers 7119 * Check that the char fit on 8bits, if not 7120 * generate a CharRef. 7121 */ 7122 if (value <= 0xFF) { 7123 out[0] = value; 7124 out[1] = 0; 7125 if ((ctxt->sax != NULL) && (ctxt->sax->characters != NULL) && 7126 (!ctxt->disableSAX)) 7127 ctxt->sax->characters(ctxt->userData, out, 1); 7128 } else { 7129 if ((hex == 'x') || (hex == 'X')) 7130 snprintf((char *)out, sizeof(out), "#x%X", value); 7131 else 7132 snprintf((char *)out, sizeof(out), "#%d", value); 7133 if ((ctxt->sax != NULL) && (ctxt->sax->reference != NULL) && 7134 (!ctxt->disableSAX)) 7135 ctxt->sax->reference(ctxt->userData, out); 7136 } 7137 } else { 7138 /* 7139 * Just encode the value in UTF-8 7140 */ 7141 COPY_BUF(0 ,out, i, value); 7142 out[i] = 0; 7143 if ((ctxt->sax != NULL) && (ctxt->sax->characters != NULL) && 7144 (!ctxt->disableSAX)) 7145 ctxt->sax->characters(ctxt->userData, out, i); 7146 } 7147 return; 7148 } 7149 7150 /* 7151 * We are seeing an entity reference 7152 */ 7153 ent = xmlParseEntityRef(ctxt); 7154 if (ent == NULL) return; 7155 if (!ctxt->wellFormed) 7156 return; 7157 was_checked = ent->checked; 7158 7159 /* special case of predefined entities */ 7160 if ((ent->name == NULL) || 7161 (ent->etype == XML_INTERNAL_PREDEFINED_ENTITY)) { 7162 val = ent->content; 7163 if (val == NULL) return; 7164 /* 7165 * inline the entity. 7166 */ 7167 if ((ctxt->sax != NULL) && (ctxt->sax->characters != NULL) && 7168 (!ctxt->disableSAX)) 7169 ctxt->sax->characters(ctxt->userData, val, xmlStrlen(val)); 7170 return; 7171 } 7172 7173 /* 7174 * The first reference to the entity trigger a parsing phase 7175 * where the ent->children is filled with the result from 7176 * the parsing. 7177 * Note: external parsed entities will not be loaded, it is not 7178 * required for a non-validating parser, unless the parsing option 7179 * of validating, or substituting entities were given. Doing so is 7180 * far more secure as the parser will only process data coming from 7181 * the document entity by default. 7182 */ 7183 if ((ent->checked == 0) && 7184 ((ent->etype != XML_EXTERNAL_GENERAL_PARSED_ENTITY) || 7185 (ctxt->options & (XML_PARSE_NOENT | XML_PARSE_DTDVALID)))) { 7186 unsigned long oldnbent = ctxt->nbentities; 7187 7188 /* 7189 * This is a bit hackish but this seems the best 7190 * way to make sure both SAX and DOM entity support 7191 * behaves okay. 7192 */ 7193 void *user_data; 7194 if (ctxt->userData == ctxt) 7195 user_data = NULL; 7196 else 7197 user_data = ctxt->userData; 7198 7199 /* 7200 * Check that this entity is well formed 7201 * 4.3.2: An internal general parsed entity is well-formed 7202 * if its replacement text matches the production labeled 7203 * content. 7204 */ 7205 if (ent->etype == XML_INTERNAL_GENERAL_ENTITY) { 7206 ctxt->depth++; 7207 ret = xmlParseBalancedChunkMemoryInternal(ctxt, ent->content, 7208 user_data, &list); 7209 ctxt->depth--; 7210 7211 } else if (ent->etype == XML_EXTERNAL_GENERAL_PARSED_ENTITY) { 7212 ctxt->depth++; 7213 ret = xmlParseExternalEntityPrivate(ctxt->myDoc, ctxt, ctxt->sax, 7214 user_data, ctxt->depth, ent->URI, 7215 ent->ExternalID, &list); 7216 ctxt->depth--; 7217 } else { 7218 ret = XML_ERR_ENTITY_PE_INTERNAL; 7219 xmlErrMsgStr(ctxt, XML_ERR_INTERNAL_ERROR, 7220 "invalid entity type found\n", NULL); 7221 } 7222 7223 /* 7224 * Store the number of entities needing parsing for this entity 7225 * content and do checkings 7226 */ 7227 ent->checked = (ctxt->nbentities - oldnbent + 1) * 2; 7228 if ((ent->content != NULL) && (xmlStrchr(ent->content, '<'))) 7229 ent->checked |= 1; 7230 if (ret == XML_ERR_ENTITY_LOOP) { 7231 xmlFatalErr(ctxt, XML_ERR_ENTITY_LOOP, NULL); 7232 xmlFreeNodeList(list); 7233 return; 7234 } 7235 if (xmlParserEntityCheck(ctxt, 0, ent, 0)) { 7236 xmlFreeNodeList(list); 7237 return; 7238 } 7239 7240 if ((ret == XML_ERR_OK) && (list != NULL)) { 7241 if (((ent->etype == XML_INTERNAL_GENERAL_ENTITY) || 7242 (ent->etype == XML_EXTERNAL_GENERAL_PARSED_ENTITY))&& 7243 (ent->children == NULL)) { 7244 ent->children = list; 7245 if (ctxt->replaceEntities) { 7246 /* 7247 * Prune it directly in the generated document 7248 * except for single text nodes. 7249 */ 7250 if (((list->type == XML_TEXT_NODE) && 7251 (list->next == NULL)) || 7252 (ctxt->parseMode == XML_PARSE_READER)) { 7253 list->parent = (xmlNodePtr) ent; 7254 list = NULL; 7255 ent->owner = 1; 7256 } else { 7257 ent->owner = 0; 7258 while (list != NULL) { 7259 list->parent = (xmlNodePtr) ctxt->node; 7260 list->doc = ctxt->myDoc; 7261 if (list->next == NULL) 7262 ent->last = list; 7263 list = list->next; 7264 } 7265 list = ent->children; 7266 #ifdef LIBXML_LEGACY_ENABLED 7267 if (ent->etype == XML_EXTERNAL_GENERAL_PARSED_ENTITY) 7268 xmlAddEntityReference(ent, list, NULL); 7269 #endif /* LIBXML_LEGACY_ENABLED */ 7270 } 7271 } else { 7272 ent->owner = 1; 7273 while (list != NULL) { 7274 list->parent = (xmlNodePtr) ent; 7275 xmlSetTreeDoc(list, ent->doc); 7276 if (list->next == NULL) 7277 ent->last = list; 7278 list = list->next; 7279 } 7280 } 7281 } else { 7282 xmlFreeNodeList(list); 7283 list = NULL; 7284 } 7285 } else if ((ret != XML_ERR_OK) && 7286 (ret != XML_WAR_UNDECLARED_ENTITY)) { 7287 xmlFatalErrMsgStr(ctxt, XML_ERR_UNDECLARED_ENTITY, 7288 "Entity '%s' failed to parse\n", ent->name); 7289 } else if (list != NULL) { 7290 xmlFreeNodeList(list); 7291 list = NULL; 7292 } 7293 if (ent->checked == 0) 7294 ent->checked = 2; 7295 } else if (ent->checked != 1) { 7296 ctxt->nbentities += ent->checked / 2; 7297 } 7298 7299 /* 7300 * Now that the entity content has been gathered 7301 * provide it to the application, this can take different forms based 7302 * on the parsing modes. 7303 */ 7304 if (ent->children == NULL) { 7305 /* 7306 * Probably running in SAX mode and the callbacks don't 7307 * build the entity content. So unless we already went 7308 * though parsing for first checking go though the entity 7309 * content to generate callbacks associated to the entity 7310 */ 7311 if (was_checked != 0) { 7312 void *user_data; 7313 /* 7314 * This is a bit hackish but this seems the best 7315 * way to make sure both SAX and DOM entity support 7316 * behaves okay. 7317 */ 7318 if (ctxt->userData == ctxt) 7319 user_data = NULL; 7320 else 7321 user_data = ctxt->userData; 7322 7323 if (ent->etype == XML_INTERNAL_GENERAL_ENTITY) { 7324 ctxt->depth++; 7325 ret = xmlParseBalancedChunkMemoryInternal(ctxt, 7326 ent->content, user_data, NULL); 7327 ctxt->depth--; 7328 } else if (ent->etype == 7329 XML_EXTERNAL_GENERAL_PARSED_ENTITY) { 7330 ctxt->depth++; 7331 ret = xmlParseExternalEntityPrivate(ctxt->myDoc, ctxt, 7332 ctxt->sax, user_data, ctxt->depth, 7333 ent->URI, ent->ExternalID, NULL); 7334 ctxt->depth--; 7335 } else { 7336 ret = XML_ERR_ENTITY_PE_INTERNAL; 7337 xmlErrMsgStr(ctxt, XML_ERR_INTERNAL_ERROR, 7338 "invalid entity type found\n", NULL); 7339 } 7340 if (ret == XML_ERR_ENTITY_LOOP) { 7341 xmlFatalErr(ctxt, XML_ERR_ENTITY_LOOP, NULL); 7342 return; 7343 } 7344 } 7345 if ((ctxt->sax != NULL) && (ctxt->sax->reference != NULL) && 7346 (ctxt->replaceEntities == 0) && (!ctxt->disableSAX)) { 7347 /* 7348 * Entity reference callback comes second, it's somewhat 7349 * superfluous but a compatibility to historical behaviour 7350 */ 7351 ctxt->sax->reference(ctxt->userData, ent->name); 7352 } 7353 return; 7354 } 7355 7356 /* 7357 * If we didn't get any children for the entity being built 7358 */ 7359 if ((ctxt->sax != NULL) && (ctxt->sax->reference != NULL) && 7360 (ctxt->replaceEntities == 0) && (!ctxt->disableSAX)) { 7361 /* 7362 * Create a node. 7363 */ 7364 ctxt->sax->reference(ctxt->userData, ent->name); 7365 return; 7366 } 7367 7368 if ((ctxt->replaceEntities) || (ent->children == NULL)) { 7369 /* 7370 * There is a problem on the handling of _private for entities 7371 * (bug 155816): Should we copy the content of the field from 7372 * the entity (possibly overwriting some value set by the user 7373 * when a copy is created), should we leave it alone, or should 7374 * we try to take care of different situations? The problem 7375 * is exacerbated by the usage of this field by the xmlReader. 7376 * To fix this bug, we look at _private on the created node 7377 * and, if it's NULL, we copy in whatever was in the entity. 7378 * If it's not NULL we leave it alone. This is somewhat of a 7379 * hack - maybe we should have further tests to determine 7380 * what to do. 7381 */ 7382 if ((ctxt->node != NULL) && (ent->children != NULL)) { 7383 /* 7384 * Seems we are generating the DOM content, do 7385 * a simple tree copy for all references except the first 7386 * In the first occurrence list contains the replacement. 7387 */ 7388 if (((list == NULL) && (ent->owner == 0)) || 7389 (ctxt->parseMode == XML_PARSE_READER)) { 7390 xmlNodePtr nw = NULL, cur, firstChild = NULL; 7391 7392 /* 7393 * We are copying here, make sure there is no abuse 7394 */ 7395 ctxt->sizeentcopy += ent->length; 7396 if (xmlParserEntityCheck(ctxt, 0, ent, ctxt->sizeentcopy)) 7397 return; 7398 7399 /* 7400 * when operating on a reader, the entities definitions 7401 * are always owning the entities subtree. 7402 if (ctxt->parseMode == XML_PARSE_READER) 7403 ent->owner = 1; 7404 */ 7405 7406 cur = ent->children; 7407 while (cur != NULL) { 7408 nw = xmlDocCopyNode(cur, ctxt->myDoc, 1); 7409 if (nw != NULL) { 7410 if (nw->_private == NULL) 7411 nw->_private = cur->_private; 7412 if (firstChild == NULL){ 7413 firstChild = nw; 7414 } 7415 nw = xmlAddChild(ctxt->node, nw); 7416 } 7417 if (cur == ent->last) { 7418 /* 7419 * needed to detect some strange empty 7420 * node cases in the reader tests 7421 */ 7422 if ((ctxt->parseMode == XML_PARSE_READER) && 7423 (nw != NULL) && 7424 (nw->type == XML_ELEMENT_NODE) && 7425 (nw->children == NULL)) 7426 nw->extra = 1; 7427 7428 break; 7429 } 7430 cur = cur->next; 7431 } 7432 #ifdef LIBXML_LEGACY_ENABLED 7433 if (ent->etype == XML_EXTERNAL_GENERAL_PARSED_ENTITY) 7434 xmlAddEntityReference(ent, firstChild, nw); 7435 #endif /* LIBXML_LEGACY_ENABLED */ 7436 } else if ((list == NULL) || (ctxt->inputNr > 0)) { 7437 xmlNodePtr nw = NULL, cur, next, last, 7438 firstChild = NULL; 7439 7440 /* 7441 * We are copying here, make sure there is no abuse 7442 */ 7443 ctxt->sizeentcopy += ent->length; 7444 if (xmlParserEntityCheck(ctxt, 0, ent, ctxt->sizeentcopy)) 7445 return; 7446 7447 /* 7448 * Copy the entity child list and make it the new 7449 * entity child list. The goal is to make sure any 7450 * ID or REF referenced will be the one from the 7451 * document content and not the entity copy. 7452 */ 7453 cur = ent->children; 7454 ent->children = NULL; 7455 last = ent->last; 7456 ent->last = NULL; 7457 while (cur != NULL) { 7458 next = cur->next; 7459 cur->next = NULL; 7460 cur->parent = NULL; 7461 nw = xmlDocCopyNode(cur, ctxt->myDoc, 1); 7462 if (nw != NULL) { 7463 if (nw->_private == NULL) 7464 nw->_private = cur->_private; 7465 if (firstChild == NULL){ 7466 firstChild = cur; 7467 } 7468 xmlAddChild((xmlNodePtr) ent, nw); 7469 xmlAddChild(ctxt->node, cur); 7470 } 7471 if (cur == last) 7472 break; 7473 cur = next; 7474 } 7475 if (ent->owner == 0) 7476 ent->owner = 1; 7477 #ifdef LIBXML_LEGACY_ENABLED 7478 if (ent->etype == XML_EXTERNAL_GENERAL_PARSED_ENTITY) 7479 xmlAddEntityReference(ent, firstChild, nw); 7480 #endif /* LIBXML_LEGACY_ENABLED */ 7481 } else { 7482 const xmlChar *nbktext; 7483 7484 /* 7485 * the name change is to avoid coalescing of the 7486 * node with a possible previous text one which 7487 * would make ent->children a dangling pointer 7488 */ 7489 nbktext = xmlDictLookup(ctxt->dict, BAD_CAST "nbktext", 7490 -1); 7491 if (ent->children->type == XML_TEXT_NODE) 7492 ent->children->name = nbktext; 7493 if ((ent->last != ent->children) && 7494 (ent->last->type == XML_TEXT_NODE)) 7495 ent->last->name = nbktext; 7496 xmlAddChildList(ctxt->node, ent->children); 7497 } 7498 7499 /* 7500 * This is to avoid a nasty side effect, see 7501 * characters() in SAX.c 7502 */ 7503 ctxt->nodemem = 0; 7504 ctxt->nodelen = 0; 7505 return; 7506 } 7507 } 7508 } 7509 7510 /** 7511 * xmlParseEntityRef: 7512 * @ctxt: an XML parser context 7513 * 7514 * parse ENTITY references declarations 7515 * 7516 * [68] EntityRef ::= '&' Name ';' 7517 * 7518 * [ WFC: Entity Declared ] 7519 * In a document without any DTD, a document with only an internal DTD 7520 * subset which contains no parameter entity references, or a document 7521 * with "standalone='yes'", the Name given in the entity reference 7522 * must match that in an entity declaration, except that well-formed 7523 * documents need not declare any of the following entities: amp, lt, 7524 * gt, apos, quot. The declaration of a parameter entity must precede 7525 * any reference to it. Similarly, the declaration of a general entity 7526 * must precede any reference to it which appears in a default value in an 7527 * attribute-list declaration. Note that if entities are declared in the 7528 * external subset or in external parameter entities, a non-validating 7529 * processor is not obligated to read and process their declarations; 7530 * for such documents, the rule that an entity must be declared is a 7531 * well-formedness constraint only if standalone='yes'. 7532 * 7533 * [ WFC: Parsed Entity ] 7534 * An entity reference must not contain the name of an unparsed entity 7535 * 7536 * Returns the xmlEntityPtr if found, or NULL otherwise. 7537 */ 7538 xmlEntityPtr 7539 xmlParseEntityRef(xmlParserCtxtPtr ctxt) { 7540 const xmlChar *name; 7541 xmlEntityPtr ent = NULL; 7542 7543 GROW; 7544 if (ctxt->instate == XML_PARSER_EOF) 7545 return(NULL); 7546 7547 if (RAW != '&') 7548 return(NULL); 7549 NEXT; 7550 name = xmlParseName(ctxt); 7551 if (name == NULL) { 7552 xmlFatalErrMsg(ctxt, XML_ERR_NAME_REQUIRED, 7553 "xmlParseEntityRef: no name\n"); 7554 return(NULL); 7555 } 7556 if (RAW != ';') { 7557 xmlFatalErr(ctxt, XML_ERR_ENTITYREF_SEMICOL_MISSING, NULL); 7558 return(NULL); 7559 } 7560 NEXT; 7561 7562 /* 7563 * Predefined entities override any extra definition 7564 */ 7565 if ((ctxt->options & XML_PARSE_OLDSAX) == 0) { 7566 ent = xmlGetPredefinedEntity(name); 7567 if (ent != NULL) 7568 return(ent); 7569 } 7570 7571 /* 7572 * Increase the number of entity references parsed 7573 */ 7574 ctxt->nbentities++; 7575 7576 /* 7577 * Ask first SAX for entity resolution, otherwise try the 7578 * entities which may have stored in the parser context. 7579 */ 7580 if (ctxt->sax != NULL) { 7581 if (ctxt->sax->getEntity != NULL) 7582 ent = ctxt->sax->getEntity(ctxt->userData, name); 7583 if ((ctxt->wellFormed == 1 ) && (ent == NULL) && 7584 (ctxt->options & XML_PARSE_OLDSAX)) 7585 ent = xmlGetPredefinedEntity(name); 7586 if ((ctxt->wellFormed == 1 ) && (ent == NULL) && 7587 (ctxt->userData==ctxt)) { 7588 ent = xmlSAX2GetEntity(ctxt, name); 7589 } 7590 } 7591 if (ctxt->instate == XML_PARSER_EOF) 7592 return(NULL); 7593 /* 7594 * [ WFC: Entity Declared ] 7595 * In a document without any DTD, a document with only an 7596 * internal DTD subset which contains no parameter entity 7597 * references, or a document with "standalone='yes'", the 7598 * Name given in the entity reference must match that in an 7599 * entity declaration, except that well-formed documents 7600 * need not declare any of the following entities: amp, lt, 7601 * gt, apos, quot. 7602 * The declaration of a parameter entity must precede any 7603 * reference to it. 7604 * Similarly, the declaration of a general entity must 7605 * precede any reference to it which appears in a default 7606 * value in an attribute-list declaration. Note that if 7607 * entities are declared in the external subset or in 7608 * external parameter entities, a non-validating processor 7609 * is not obligated to read and process their declarations; 7610 * for such documents, the rule that an entity must be 7611 * declared is a well-formedness constraint only if 7612 * standalone='yes'. 7613 */ 7614 if (ent == NULL) { 7615 if ((ctxt->standalone == 1) || 7616 ((ctxt->hasExternalSubset == 0) && 7617 (ctxt->hasPErefs == 0))) { 7618 xmlFatalErrMsgStr(ctxt, XML_ERR_UNDECLARED_ENTITY, 7619 "Entity '%s' not defined\n", name); 7620 } else { 7621 xmlErrMsgStr(ctxt, XML_WAR_UNDECLARED_ENTITY, 7622 "Entity '%s' not defined\n", name); 7623 if ((ctxt->inSubset == 0) && 7624 (ctxt->sax != NULL) && 7625 (ctxt->sax->reference != NULL)) { 7626 ctxt->sax->reference(ctxt->userData, name); 7627 } 7628 } 7629 ctxt->valid = 0; 7630 } 7631 7632 /* 7633 * [ WFC: Parsed Entity ] 7634 * An entity reference must not contain the name of an 7635 * unparsed entity 7636 */ 7637 else if (ent->etype == XML_EXTERNAL_GENERAL_UNPARSED_ENTITY) { 7638 xmlFatalErrMsgStr(ctxt, XML_ERR_UNPARSED_ENTITY, 7639 "Entity reference to unparsed entity %s\n", name); 7640 } 7641 7642 /* 7643 * [ WFC: No External Entity References ] 7644 * Attribute values cannot contain direct or indirect 7645 * entity references to external entities. 7646 */ 7647 else if ((ctxt->instate == XML_PARSER_ATTRIBUTE_VALUE) && 7648 (ent->etype == XML_EXTERNAL_GENERAL_PARSED_ENTITY)) { 7649 xmlFatalErrMsgStr(ctxt, XML_ERR_ENTITY_IS_EXTERNAL, 7650 "Attribute references external entity '%s'\n", name); 7651 } 7652 /* 7653 * [ WFC: No < in Attribute Values ] 7654 * The replacement text of any entity referred to directly or 7655 * indirectly in an attribute value (other than "<") must 7656 * not contain a <. 7657 */ 7658 else if ((ctxt->instate == XML_PARSER_ATTRIBUTE_VALUE) && 7659 (ent != NULL) && 7660 (ent->etype != XML_INTERNAL_PREDEFINED_ENTITY)) { 7661 if ((ent->checked & 1) || ((ent->checked == 0) && 7662 (ent->content != NULL) &&(xmlStrchr(ent->content, '<')))) { 7663 xmlFatalErrMsgStr(ctxt, XML_ERR_LT_IN_ATTRIBUTE, 7664 "'<' in entity '%s' is not allowed in attributes values\n", name); 7665 } 7666 } 7667 7668 /* 7669 * Internal check, no parameter entities here ... 7670 */ 7671 else { 7672 switch (ent->etype) { 7673 case XML_INTERNAL_PARAMETER_ENTITY: 7674 case XML_EXTERNAL_PARAMETER_ENTITY: 7675 xmlFatalErrMsgStr(ctxt, XML_ERR_ENTITY_IS_PARAMETER, 7676 "Attempt to reference the parameter entity '%s'\n", 7677 name); 7678 break; 7679 default: 7680 break; 7681 } 7682 } 7683 7684 /* 7685 * [ WFC: No Recursion ] 7686 * A parsed entity must not contain a recursive reference 7687 * to itself, either directly or indirectly. 7688 * Done somewhere else 7689 */ 7690 return(ent); 7691 } 7692 7693 /** 7694 * xmlParseStringEntityRef: 7695 * @ctxt: an XML parser context 7696 * @str: a pointer to an index in the string 7697 * 7698 * parse ENTITY references declarations, but this version parses it from 7699 * a string value. 7700 * 7701 * [68] EntityRef ::= '&' Name ';' 7702 * 7703 * [ WFC: Entity Declared ] 7704 * In a document without any DTD, a document with only an internal DTD 7705 * subset which contains no parameter entity references, or a document 7706 * with "standalone='yes'", the Name given in the entity reference 7707 * must match that in an entity declaration, except that well-formed 7708 * documents need not declare any of the following entities: amp, lt, 7709 * gt, apos, quot. The declaration of a parameter entity must precede 7710 * any reference to it. Similarly, the declaration of a general entity 7711 * must precede any reference to it which appears in a default value in an 7712 * attribute-list declaration. Note that if entities are declared in the 7713 * external subset or in external parameter entities, a non-validating 7714 * processor is not obligated to read and process their declarations; 7715 * for such documents, the rule that an entity must be declared is a 7716 * well-formedness constraint only if standalone='yes'. 7717 * 7718 * [ WFC: Parsed Entity ] 7719 * An entity reference must not contain the name of an unparsed entity 7720 * 7721 * Returns the xmlEntityPtr if found, or NULL otherwise. The str pointer 7722 * is updated to the current location in the string. 7723 */ 7724 static xmlEntityPtr 7725 xmlParseStringEntityRef(xmlParserCtxtPtr ctxt, const xmlChar ** str) { 7726 xmlChar *name; 7727 const xmlChar *ptr; 7728 xmlChar cur; 7729 xmlEntityPtr ent = NULL; 7730 7731 if ((str == NULL) || (*str == NULL)) 7732 return(NULL); 7733 ptr = *str; 7734 cur = *ptr; 7735 if (cur != '&') 7736 return(NULL); 7737 7738 ptr++; 7739 name = xmlParseStringName(ctxt, &ptr); 7740 if (name == NULL) { 7741 xmlFatalErrMsg(ctxt, XML_ERR_NAME_REQUIRED, 7742 "xmlParseStringEntityRef: no name\n"); 7743 *str = ptr; 7744 return(NULL); 7745 } 7746 if (*ptr != ';') { 7747 xmlFatalErr(ctxt, XML_ERR_ENTITYREF_SEMICOL_MISSING, NULL); 7748 xmlFree(name); 7749 *str = ptr; 7750 return(NULL); 7751 } 7752 ptr++; 7753 7754 7755 /* 7756 * Predefined entites override any extra definition 7757 */ 7758 if ((ctxt->options & XML_PARSE_OLDSAX) == 0) { 7759 ent = xmlGetPredefinedEntity(name); 7760 if (ent != NULL) { 7761 xmlFree(name); 7762 *str = ptr; 7763 return(ent); 7764 } 7765 } 7766 7767 /* 7768 * Increate the number of entity references parsed 7769 */ 7770 ctxt->nbentities++; 7771 7772 /* 7773 * Ask first SAX for entity resolution, otherwise try the 7774 * entities which may have stored in the parser context. 7775 */ 7776 if (ctxt->sax != NULL) { 7777 if (ctxt->sax->getEntity != NULL) 7778 ent = ctxt->sax->getEntity(ctxt->userData, name); 7779 if ((ent == NULL) && (ctxt->options & XML_PARSE_OLDSAX)) 7780 ent = xmlGetPredefinedEntity(name); 7781 if ((ent == NULL) && (ctxt->userData==ctxt)) { 7782 ent = xmlSAX2GetEntity(ctxt, name); 7783 } 7784 } 7785 if (ctxt->instate == XML_PARSER_EOF) { 7786 xmlFree(name); 7787 return(NULL); 7788 } 7789 7790 /* 7791 * [ WFC: Entity Declared ] 7792 * In a document without any DTD, a document with only an 7793 * internal DTD subset which contains no parameter entity 7794 * references, or a document with "standalone='yes'", the 7795 * Name given in the entity reference must match that in an 7796 * entity declaration, except that well-formed documents 7797 * need not declare any of the following entities: amp, lt, 7798 * gt, apos, quot. 7799 * The declaration of a parameter entity must precede any 7800 * reference to it. 7801 * Similarly, the declaration of a general entity must 7802 * precede any reference to it which appears in a default 7803 * value in an attribute-list declaration. Note that if 7804 * entities are declared in the external subset or in 7805 * external parameter entities, a non-validating processor 7806 * is not obligated to read and process their declarations; 7807 * for such documents, the rule that an entity must be 7808 * declared is a well-formedness constraint only if 7809 * standalone='yes'. 7810 */ 7811 if (ent == NULL) { 7812 if ((ctxt->standalone == 1) || 7813 ((ctxt->hasExternalSubset == 0) && 7814 (ctxt->hasPErefs == 0))) { 7815 xmlFatalErrMsgStr(ctxt, XML_ERR_UNDECLARED_ENTITY, 7816 "Entity '%s' not defined\n", name); 7817 } else { 7818 xmlErrMsgStr(ctxt, XML_WAR_UNDECLARED_ENTITY, 7819 "Entity '%s' not defined\n", 7820 name); 7821 } 7822 /* TODO ? check regressions ctxt->valid = 0; */ 7823 } 7824 7825 /* 7826 * [ WFC: Parsed Entity ] 7827 * An entity reference must not contain the name of an 7828 * unparsed entity 7829 */ 7830 else if (ent->etype == XML_EXTERNAL_GENERAL_UNPARSED_ENTITY) { 7831 xmlFatalErrMsgStr(ctxt, XML_ERR_UNPARSED_ENTITY, 7832 "Entity reference to unparsed entity %s\n", name); 7833 } 7834 7835 /* 7836 * [ WFC: No External Entity References ] 7837 * Attribute values cannot contain direct or indirect 7838 * entity references to external entities. 7839 */ 7840 else if ((ctxt->instate == XML_PARSER_ATTRIBUTE_VALUE) && 7841 (ent->etype == XML_EXTERNAL_GENERAL_PARSED_ENTITY)) { 7842 xmlFatalErrMsgStr(ctxt, XML_ERR_ENTITY_IS_EXTERNAL, 7843 "Attribute references external entity '%s'\n", name); 7844 } 7845 /* 7846 * [ WFC: No < in Attribute Values ] 7847 * The replacement text of any entity referred to directly or 7848 * indirectly in an attribute value (other than "<") must 7849 * not contain a <. 7850 */ 7851 else if ((ctxt->instate == XML_PARSER_ATTRIBUTE_VALUE) && 7852 (ent != NULL) && (ent->content != NULL) && 7853 (ent->etype != XML_INTERNAL_PREDEFINED_ENTITY) && 7854 (xmlStrchr(ent->content, '<'))) { 7855 xmlFatalErrMsgStr(ctxt, XML_ERR_LT_IN_ATTRIBUTE, 7856 "'<' in entity '%s' is not allowed in attributes values\n", 7857 name); 7858 } 7859 7860 /* 7861 * Internal check, no parameter entities here ... 7862 */ 7863 else { 7864 switch (ent->etype) { 7865 case XML_INTERNAL_PARAMETER_ENTITY: 7866 case XML_EXTERNAL_PARAMETER_ENTITY: 7867 xmlFatalErrMsgStr(ctxt, XML_ERR_ENTITY_IS_PARAMETER, 7868 "Attempt to reference the parameter entity '%s'\n", 7869 name); 7870 break; 7871 default: 7872 break; 7873 } 7874 } 7875 7876 /* 7877 * [ WFC: No Recursion ] 7878 * A parsed entity must not contain a recursive reference 7879 * to itself, either directly or indirectly. 7880 * Done somewhere else 7881 */ 7882 7883 xmlFree(name); 7884 *str = ptr; 7885 return(ent); 7886 } 7887 7888 /** 7889 * xmlParsePEReference: 7890 * @ctxt: an XML parser context 7891 * 7892 * parse PEReference declarations 7893 * The entity content is handled directly by pushing it's content as 7894 * a new input stream. 7895 * 7896 * [69] PEReference ::= '%' Name ';' 7897 * 7898 * [ WFC: No Recursion ] 7899 * A parsed entity must not contain a recursive 7900 * reference to itself, either directly or indirectly. 7901 * 7902 * [ WFC: Entity Declared ] 7903 * In a document without any DTD, a document with only an internal DTD 7904 * subset which contains no parameter entity references, or a document 7905 * with "standalone='yes'", ... ... The declaration of a parameter 7906 * entity must precede any reference to it... 7907 * 7908 * [ VC: Entity Declared ] 7909 * In a document with an external subset or external parameter entities 7910 * with "standalone='no'", ... ... The declaration of a parameter entity 7911 * must precede any reference to it... 7912 * 7913 * [ WFC: In DTD ] 7914 * Parameter-entity references may only appear in the DTD. 7915 * NOTE: misleading but this is handled. 7916 */ 7917 void 7918 xmlParsePEReference(xmlParserCtxtPtr ctxt) 7919 { 7920 const xmlChar *name; 7921 xmlEntityPtr entity = NULL; 7922 xmlParserInputPtr input; 7923 7924 if (RAW != '%') 7925 return; 7926 NEXT; 7927 name = xmlParseName(ctxt); 7928 if (name == NULL) { 7929 xmlFatalErrMsg(ctxt, XML_ERR_NAME_REQUIRED, 7930 "xmlParsePEReference: no name\n"); 7931 return; 7932 } 7933 if (RAW != ';') { 7934 xmlFatalErr(ctxt, XML_ERR_ENTITYREF_SEMICOL_MISSING, NULL); 7935 return; 7936 } 7937 7938 NEXT; 7939 7940 /* 7941 * Increate the number of entity references parsed 7942 */ 7943 ctxt->nbentities++; 7944 7945 /* 7946 * Request the entity from SAX 7947 */ 7948 if ((ctxt->sax != NULL) && 7949 (ctxt->sax->getParameterEntity != NULL)) 7950 entity = ctxt->sax->getParameterEntity(ctxt->userData, name); 7951 if (ctxt->instate == XML_PARSER_EOF) 7952 return; 7953 if (entity == NULL) { 7954 /* 7955 * [ WFC: Entity Declared ] 7956 * In a document without any DTD, a document with only an 7957 * internal DTD subset which contains no parameter entity 7958 * references, or a document with "standalone='yes'", ... 7959 * ... The declaration of a parameter entity must precede 7960 * any reference to it... 7961 */ 7962 if ((ctxt->standalone == 1) || 7963 ((ctxt->hasExternalSubset == 0) && 7964 (ctxt->hasPErefs == 0))) { 7965 xmlFatalErrMsgStr(ctxt, XML_ERR_UNDECLARED_ENTITY, 7966 "PEReference: %%%s; not found\n", 7967 name); 7968 } else { 7969 /* 7970 * [ VC: Entity Declared ] 7971 * In a document with an external subset or external 7972 * parameter entities with "standalone='no'", ... 7973 * ... The declaration of a parameter entity must 7974 * precede any reference to it... 7975 */ 7976 xmlWarningMsg(ctxt, XML_WAR_UNDECLARED_ENTITY, 7977 "PEReference: %%%s; not found\n", 7978 name, NULL); 7979 ctxt->valid = 0; 7980 } 7981 } else { 7982 /* 7983 * Internal checking in case the entity quest barfed 7984 */ 7985 if ((entity->etype != XML_INTERNAL_PARAMETER_ENTITY) && 7986 (entity->etype != XML_EXTERNAL_PARAMETER_ENTITY)) { 7987 xmlWarningMsg(ctxt, XML_WAR_UNDECLARED_ENTITY, 7988 "Internal: %%%s; is not a parameter entity\n", 7989 name, NULL); 7990 } else if (ctxt->input->free != deallocblankswrapper) { 7991 input = xmlNewBlanksWrapperInputStream(ctxt, entity); 7992 if (xmlPushInput(ctxt, input) < 0) 7993 return; 7994 } else { 7995 /* 7996 * TODO !!! 7997 * handle the extra spaces added before and after 7998 * c.f. http://www.w3.org/TR/REC-xml#as-PE 7999 */ 8000 input = xmlNewEntityInputStream(ctxt, entity); 8001 if (xmlPushInput(ctxt, input) < 0) 8002 return; 8003 if ((entity->etype == XML_EXTERNAL_PARAMETER_ENTITY) && 8004 (CMP5(CUR_PTR, '<', '?', 'x', 'm', 'l')) && 8005 (IS_BLANK_CH(NXT(5)))) { 8006 xmlParseTextDecl(ctxt); 8007 if (ctxt->errNo == 8008 XML_ERR_UNSUPPORTED_ENCODING) { 8009 /* 8010 * The XML REC instructs us to stop parsing 8011 * right here 8012 */ 8013 ctxt->instate = XML_PARSER_EOF; 8014 return; 8015 } 8016 } 8017 } 8018 } 8019 ctxt->hasPErefs = 1; 8020 } 8021 8022 /** 8023 * xmlLoadEntityContent: 8024 * @ctxt: an XML parser context 8025 * @entity: an unloaded system entity 8026 * 8027 * Load the original content of the given system entity from the 8028 * ExternalID/SystemID given. This is to be used for Included in Literal 8029 * http://www.w3.org/TR/REC-xml/#inliteral processing of entities references 8030 * 8031 * Returns 0 in case of success and -1 in case of failure 8032 */ 8033 static int 8034 xmlLoadEntityContent(xmlParserCtxtPtr ctxt, xmlEntityPtr entity) { 8035 xmlParserInputPtr input; 8036 xmlBufferPtr buf; 8037 int l, c; 8038 int count = 0; 8039 8040 if ((ctxt == NULL) || (entity == NULL) || 8041 ((entity->etype != XML_EXTERNAL_PARAMETER_ENTITY) && 8042 (entity->etype != XML_EXTERNAL_GENERAL_PARSED_ENTITY)) || 8043 (entity->content != NULL)) { 8044 xmlFatalErr(ctxt, XML_ERR_INTERNAL_ERROR, 8045 "xmlLoadEntityContent parameter error"); 8046 return(-1); 8047 } 8048 8049 if (xmlParserDebugEntities) 8050 xmlGenericError(xmlGenericErrorContext, 8051 "Reading %s entity content input\n", entity->name); 8052 8053 buf = xmlBufferCreate(); 8054 if (buf == NULL) { 8055 xmlFatalErr(ctxt, XML_ERR_INTERNAL_ERROR, 8056 "xmlLoadEntityContent parameter error"); 8057 return(-1); 8058 } 8059 8060 input = xmlNewEntityInputStream(ctxt, entity); 8061 if (input == NULL) { 8062 xmlFatalErr(ctxt, XML_ERR_INTERNAL_ERROR, 8063 "xmlLoadEntityContent input error"); 8064 xmlBufferFree(buf); 8065 return(-1); 8066 } 8067 8068 /* 8069 * Push the entity as the current input, read char by char 8070 * saving to the buffer until the end of the entity or an error 8071 */ 8072 if (xmlPushInput(ctxt, input) < 0) { 8073 xmlBufferFree(buf); 8074 return(-1); 8075 } 8076 8077 GROW; 8078 c = CUR_CHAR(l); 8079 while ((ctxt->input == input) && (ctxt->input->cur < ctxt->input->end) && 8080 (IS_CHAR(c))) { 8081 xmlBufferAdd(buf, ctxt->input->cur, l); 8082 if (count++ > XML_PARSER_CHUNK_SIZE) { 8083 count = 0; 8084 GROW; 8085 if (ctxt->instate == XML_PARSER_EOF) { 8086 xmlBufferFree(buf); 8087 return(-1); 8088 } 8089 } 8090 NEXTL(l); 8091 c = CUR_CHAR(l); 8092 if (c == 0) { 8093 count = 0; 8094 GROW; 8095 if (ctxt->instate == XML_PARSER_EOF) { 8096 xmlBufferFree(buf); 8097 return(-1); 8098 } 8099 c = CUR_CHAR(l); 8100 } 8101 } 8102 8103 if ((ctxt->input == input) && (ctxt->input->cur >= ctxt->input->end)) { 8104 xmlPopInput(ctxt); 8105 } else if (!IS_CHAR(c)) { 8106 xmlFatalErrMsgInt(ctxt, XML_ERR_INVALID_CHAR, 8107 "xmlLoadEntityContent: invalid char value %d\n", 8108 c); 8109 xmlBufferFree(buf); 8110 return(-1); 8111 } 8112 entity->content = buf->content; 8113 buf->content = NULL; 8114 xmlBufferFree(buf); 8115 8116 return(0); 8117 } 8118 8119 /** 8120 * xmlParseStringPEReference: 8121 * @ctxt: an XML parser context 8122 * @str: a pointer to an index in the string 8123 * 8124 * parse PEReference declarations 8125 * 8126 * [69] PEReference ::= '%' Name ';' 8127 * 8128 * [ WFC: No Recursion ] 8129 * A parsed entity must not contain a recursive 8130 * reference to itself, either directly or indirectly. 8131 * 8132 * [ WFC: Entity Declared ] 8133 * In a document without any DTD, a document with only an internal DTD 8134 * subset which contains no parameter entity references, or a document 8135 * with "standalone='yes'", ... ... The declaration of a parameter 8136 * entity must precede any reference to it... 8137 * 8138 * [ VC: Entity Declared ] 8139 * In a document with an external subset or external parameter entities 8140 * with "standalone='no'", ... ... The declaration of a parameter entity 8141 * must precede any reference to it... 8142 * 8143 * [ WFC: In DTD ] 8144 * Parameter-entity references may only appear in the DTD. 8145 * NOTE: misleading but this is handled. 8146 * 8147 * Returns the string of the entity content. 8148 * str is updated to the current value of the index 8149 */ 8150 static xmlEntityPtr 8151 xmlParseStringPEReference(xmlParserCtxtPtr ctxt, const xmlChar **str) { 8152 const xmlChar *ptr; 8153 xmlChar cur; 8154 xmlChar *name; 8155 xmlEntityPtr entity = NULL; 8156 8157 if ((str == NULL) || (*str == NULL)) return(NULL); 8158 ptr = *str; 8159 cur = *ptr; 8160 if (cur != '%') 8161 return(NULL); 8162 ptr++; 8163 name = xmlParseStringName(ctxt, &ptr); 8164 if (name == NULL) { 8165 xmlFatalErrMsg(ctxt, XML_ERR_NAME_REQUIRED, 8166 "xmlParseStringPEReference: no name\n"); 8167 *str = ptr; 8168 return(NULL); 8169 } 8170 cur = *ptr; 8171 if (cur != ';') { 8172 xmlFatalErr(ctxt, XML_ERR_ENTITYREF_SEMICOL_MISSING, NULL); 8173 xmlFree(name); 8174 *str = ptr; 8175 return(NULL); 8176 } 8177 ptr++; 8178 8179 /* 8180 * Increate the number of entity references parsed 8181 */ 8182 ctxt->nbentities++; 8183 8184 /* 8185 * Request the entity from SAX 8186 */ 8187 if ((ctxt->sax != NULL) && 8188 (ctxt->sax->getParameterEntity != NULL)) 8189 entity = ctxt->sax->getParameterEntity(ctxt->userData, name); 8190 if (ctxt->instate == XML_PARSER_EOF) { 8191 xmlFree(name); 8192 return(NULL); 8193 } 8194 if (entity == NULL) { 8195 /* 8196 * [ WFC: Entity Declared ] 8197 * In a document without any DTD, a document with only an 8198 * internal DTD subset which contains no parameter entity 8199 * references, or a document with "standalone='yes'", ... 8200 * ... The declaration of a parameter entity must precede 8201 * any reference to it... 8202 */ 8203 if ((ctxt->standalone == 1) || 8204 ((ctxt->hasExternalSubset == 0) && (ctxt->hasPErefs == 0))) { 8205 xmlFatalErrMsgStr(ctxt, XML_ERR_UNDECLARED_ENTITY, 8206 "PEReference: %%%s; not found\n", name); 8207 } else { 8208 /* 8209 * [ VC: Entity Declared ] 8210 * In a document with an external subset or external 8211 * parameter entities with "standalone='no'", ... 8212 * ... The declaration of a parameter entity must 8213 * precede any reference to it... 8214 */ 8215 xmlWarningMsg(ctxt, XML_WAR_UNDECLARED_ENTITY, 8216 "PEReference: %%%s; not found\n", 8217 name, NULL); 8218 ctxt->valid = 0; 8219 } 8220 } else { 8221 /* 8222 * Internal checking in case the entity quest barfed 8223 */ 8224 if ((entity->etype != XML_INTERNAL_PARAMETER_ENTITY) && 8225 (entity->etype != XML_EXTERNAL_PARAMETER_ENTITY)) { 8226 xmlWarningMsg(ctxt, XML_WAR_UNDECLARED_ENTITY, 8227 "%%%s; is not a parameter entity\n", 8228 name, NULL); 8229 } 8230 } 8231 ctxt->hasPErefs = 1; 8232 xmlFree(name); 8233 *str = ptr; 8234 return(entity); 8235 } 8236 8237 /** 8238 * xmlParseDocTypeDecl: 8239 * @ctxt: an XML parser context 8240 * 8241 * parse a DOCTYPE declaration 8242 * 8243 * [28] doctypedecl ::= '<!DOCTYPE' S Name (S ExternalID)? S? 8244 * ('[' (markupdecl | PEReference | S)* ']' S?)? '>' 8245 * 8246 * [ VC: Root Element Type ] 8247 * The Name in the document type declaration must match the element 8248 * type of the root element. 8249 */ 8250 8251 void 8252 xmlParseDocTypeDecl(xmlParserCtxtPtr ctxt) { 8253 const xmlChar *name = NULL; 8254 xmlChar *ExternalID = NULL; 8255 xmlChar *URI = NULL; 8256 8257 /* 8258 * We know that '<!DOCTYPE' has been detected. 8259 */ 8260 SKIP(9); 8261 8262 SKIP_BLANKS; 8263 8264 /* 8265 * Parse the DOCTYPE name. 8266 */ 8267 name = xmlParseName(ctxt); 8268 if (name == NULL) { 8269 xmlFatalErrMsg(ctxt, XML_ERR_NAME_REQUIRED, 8270 "xmlParseDocTypeDecl : no DOCTYPE name !\n"); 8271 } 8272 ctxt->intSubName = name; 8273 8274 SKIP_BLANKS; 8275 8276 /* 8277 * Check for SystemID and ExternalID 8278 */ 8279 URI = xmlParseExternalID(ctxt, &ExternalID, 1); 8280 8281 if ((URI != NULL) || (ExternalID != NULL)) { 8282 ctxt->hasExternalSubset = 1; 8283 } 8284 ctxt->extSubURI = URI; 8285 ctxt->extSubSystem = ExternalID; 8286 8287 SKIP_BLANKS; 8288 8289 /* 8290 * Create and update the internal subset. 8291 */ 8292 if ((ctxt->sax != NULL) && (ctxt->sax->internalSubset != NULL) && 8293 (!ctxt->disableSAX)) 8294 ctxt->sax->internalSubset(ctxt->userData, name, ExternalID, URI); 8295 if (ctxt->instate == XML_PARSER_EOF) 8296 return; 8297 8298 /* 8299 * Is there any internal subset declarations ? 8300 * they are handled separately in xmlParseInternalSubset() 8301 */ 8302 if (RAW == '[') 8303 return; 8304 8305 /* 8306 * We should be at the end of the DOCTYPE declaration. 8307 */ 8308 if (RAW != '>') { 8309 xmlFatalErr(ctxt, XML_ERR_DOCTYPE_NOT_FINISHED, NULL); 8310 } 8311 NEXT; 8312 } 8313 8314 /** 8315 * xmlParseInternalSubset: 8316 * @ctxt: an XML parser context 8317 * 8318 * parse the internal subset declaration 8319 * 8320 * [28 end] ('[' (markupdecl | PEReference | S)* ']' S?)? '>' 8321 */ 8322 8323 static void 8324 xmlParseInternalSubset(xmlParserCtxtPtr ctxt) { 8325 /* 8326 * Is there any DTD definition ? 8327 */ 8328 if (RAW == '[') { 8329 ctxt->instate = XML_PARSER_DTD; 8330 NEXT; 8331 /* 8332 * Parse the succession of Markup declarations and 8333 * PEReferences. 8334 * Subsequence (markupdecl | PEReference | S)* 8335 */ 8336 while ((RAW != ']') && (ctxt->instate != XML_PARSER_EOF)) { 8337 const xmlChar *check = CUR_PTR; 8338 unsigned int cons = ctxt->input->consumed; 8339 8340 SKIP_BLANKS; 8341 xmlParseMarkupDecl(ctxt); 8342 xmlParsePEReference(ctxt); 8343 8344 /* 8345 * Pop-up of finished entities. 8346 */ 8347 while ((RAW == 0) && (ctxt->inputNr > 1)) 8348 xmlPopInput(ctxt); 8349 8350 if ((CUR_PTR == check) && (cons == ctxt->input->consumed)) { 8351 xmlFatalErr(ctxt, XML_ERR_INTERNAL_ERROR, 8352 "xmlParseInternalSubset: error detected in Markup declaration\n"); 8353 break; 8354 } 8355 } 8356 if (RAW == ']') { 8357 NEXT; 8358 SKIP_BLANKS; 8359 } 8360 } 8361 8362 /* 8363 * We should be at the end of the DOCTYPE declaration. 8364 */ 8365 if (RAW != '>') { 8366 xmlFatalErr(ctxt, XML_ERR_DOCTYPE_NOT_FINISHED, NULL); 8367 } 8368 NEXT; 8369 } 8370 8371 #ifdef LIBXML_SAX1_ENABLED 8372 /** 8373 * xmlParseAttribute: 8374 * @ctxt: an XML parser context 8375 * @value: a xmlChar ** used to store the value of the attribute 8376 * 8377 * parse an attribute 8378 * 8379 * [41] Attribute ::= Name Eq AttValue 8380 * 8381 * [ WFC: No External Entity References ] 8382 * Attribute values cannot contain direct or indirect entity references 8383 * to external entities. 8384 * 8385 * [ WFC: No < in Attribute Values ] 8386 * The replacement text of any entity referred to directly or indirectly in 8387 * an attribute value (other than "<") must not contain a <. 8388 * 8389 * [ VC: Attribute Value Type ] 8390 * The attribute must have been declared; the value must be of the type 8391 * declared for it. 8392 * 8393 * [25] Eq ::= S? '=' S? 8394 * 8395 * With namespace: 8396 * 8397 * [NS 11] Attribute ::= QName Eq AttValue 8398 * 8399 * Also the case QName == xmlns:??? is handled independently as a namespace 8400 * definition. 8401 * 8402 * Returns the attribute name, and the value in *value. 8403 */ 8404 8405 const xmlChar * 8406 xmlParseAttribute(xmlParserCtxtPtr ctxt, xmlChar **value) { 8407 const xmlChar *name; 8408 xmlChar *val; 8409 8410 *value = NULL; 8411 GROW; 8412 name = xmlParseName(ctxt); 8413 if (name == NULL) { 8414 xmlFatalErrMsg(ctxt, XML_ERR_NAME_REQUIRED, 8415 "error parsing attribute name\n"); 8416 return(NULL); 8417 } 8418 8419 /* 8420 * read the value 8421 */ 8422 SKIP_BLANKS; 8423 if (RAW == '=') { 8424 NEXT; 8425 SKIP_BLANKS; 8426 val = xmlParseAttValue(ctxt); 8427 ctxt->instate = XML_PARSER_CONTENT; 8428 } else { 8429 xmlFatalErrMsgStr(ctxt, XML_ERR_ATTRIBUTE_WITHOUT_VALUE, 8430 "Specification mandate value for attribute %s\n", name); 8431 return(NULL); 8432 } 8433 8434 /* 8435 * Check that xml:lang conforms to the specification 8436 * No more registered as an error, just generate a warning now 8437 * since this was deprecated in XML second edition 8438 */ 8439 if ((ctxt->pedantic) && (xmlStrEqual(name, BAD_CAST "xml:lang"))) { 8440 if (!xmlCheckLanguageID(val)) { 8441 xmlWarningMsg(ctxt, XML_WAR_LANG_VALUE, 8442 "Malformed value for xml:lang : %s\n", 8443 val, NULL); 8444 } 8445 } 8446 8447 /* 8448 * Check that xml:space conforms to the specification 8449 */ 8450 if (xmlStrEqual(name, BAD_CAST "xml:space")) { 8451 if (xmlStrEqual(val, BAD_CAST "default")) 8452 *(ctxt->space) = 0; 8453 else if (xmlStrEqual(val, BAD_CAST "preserve")) 8454 *(ctxt->space) = 1; 8455 else { 8456 xmlWarningMsg(ctxt, XML_WAR_SPACE_VALUE, 8457 "Invalid value \"%s\" for xml:space : \"default\" or \"preserve\" expected\n", 8458 val, NULL); 8459 } 8460 } 8461 8462 *value = val; 8463 return(name); 8464 } 8465 8466 /** 8467 * xmlParseStartTag: 8468 * @ctxt: an XML parser context 8469 * 8470 * parse a start of tag either for rule element or 8471 * EmptyElement. In both case we don't parse the tag closing chars. 8472 * 8473 * [40] STag ::= '<' Name (S Attribute)* S? '>' 8474 * 8475 * [ WFC: Unique Att Spec ] 8476 * No attribute name may appear more than once in the same start-tag or 8477 * empty-element tag. 8478 * 8479 * [44] EmptyElemTag ::= '<' Name (S Attribute)* S? '/>' 8480 * 8481 * [ WFC: Unique Att Spec ] 8482 * No attribute name may appear more than once in the same start-tag or 8483 * empty-element tag. 8484 * 8485 * With namespace: 8486 * 8487 * [NS 8] STag ::= '<' QName (S Attribute)* S? '>' 8488 * 8489 * [NS 10] EmptyElement ::= '<' QName (S Attribute)* S? '/>' 8490 * 8491 * Returns the element name parsed 8492 */ 8493 8494 const xmlChar * 8495 xmlParseStartTag(xmlParserCtxtPtr ctxt) { 8496 const xmlChar *name; 8497 const xmlChar *attname; 8498 xmlChar *attvalue; 8499 const xmlChar **atts = ctxt->atts; 8500 int nbatts = 0; 8501 int maxatts = ctxt->maxatts; 8502 int i; 8503 8504 if (RAW != '<') return(NULL); 8505 NEXT1; 8506 8507 name = xmlParseName(ctxt); 8508 if (name == NULL) { 8509 xmlFatalErrMsg(ctxt, XML_ERR_NAME_REQUIRED, 8510 "xmlParseStartTag: invalid element name\n"); 8511 return(NULL); 8512 } 8513 8514 /* 8515 * Now parse the attributes, it ends up with the ending 8516 * 8517 * (S Attribute)* S? 8518 */ 8519 SKIP_BLANKS; 8520 GROW; 8521 8522 while (((RAW != '>') && 8523 ((RAW != '/') || (NXT(1) != '>')) && 8524 (IS_BYTE_CHAR(RAW))) && (ctxt->instate != XML_PARSER_EOF)) { 8525 const xmlChar *q = CUR_PTR; 8526 unsigned int cons = ctxt->input->consumed; 8527 8528 attname = xmlParseAttribute(ctxt, &attvalue); 8529 if ((attname != NULL) && (attvalue != NULL)) { 8530 /* 8531 * [ WFC: Unique Att Spec ] 8532 * No attribute name may appear more than once in the same 8533 * start-tag or empty-element tag. 8534 */ 8535 for (i = 0; i < nbatts;i += 2) { 8536 if (xmlStrEqual(atts[i], attname)) { 8537 xmlErrAttributeDup(ctxt, NULL, attname); 8538 xmlFree(attvalue); 8539 goto failed; 8540 } 8541 } 8542 /* 8543 * Add the pair to atts 8544 */ 8545 if (atts == NULL) { 8546 maxatts = 22; /* allow for 10 attrs by default */ 8547 atts = (const xmlChar **) 8548 xmlMalloc(maxatts * sizeof(xmlChar *)); 8549 if (atts == NULL) { 8550 xmlErrMemory(ctxt, NULL); 8551 if (attvalue != NULL) 8552 xmlFree(attvalue); 8553 goto failed; 8554 } 8555 ctxt->atts = atts; 8556 ctxt->maxatts = maxatts; 8557 } else if (nbatts + 4 > maxatts) { 8558 const xmlChar **n; 8559 8560 maxatts *= 2; 8561 n = (const xmlChar **) xmlRealloc((void *) atts, 8562 maxatts * sizeof(const xmlChar *)); 8563 if (n == NULL) { 8564 xmlErrMemory(ctxt, NULL); 8565 if (attvalue != NULL) 8566 xmlFree(attvalue); 8567 goto failed; 8568 } 8569 atts = n; 8570 ctxt->atts = atts; 8571 ctxt->maxatts = maxatts; 8572 } 8573 atts[nbatts++] = attname; 8574 atts[nbatts++] = attvalue; 8575 atts[nbatts] = NULL; 8576 atts[nbatts + 1] = NULL; 8577 } else { 8578 if (attvalue != NULL) 8579 xmlFree(attvalue); 8580 } 8581 8582 failed: 8583 8584 GROW 8585 if ((RAW == '>') || (((RAW == '/') && (NXT(1) == '>')))) 8586 break; 8587 if (!IS_BLANK_CH(RAW)) { 8588 xmlFatalErrMsg(ctxt, XML_ERR_SPACE_REQUIRED, 8589 "attributes construct error\n"); 8590 } 8591 SKIP_BLANKS; 8592 if ((cons == ctxt->input->consumed) && (q == CUR_PTR) && 8593 (attname == NULL) && (attvalue == NULL)) { 8594 xmlFatalErrMsg(ctxt, XML_ERR_INTERNAL_ERROR, 8595 "xmlParseStartTag: problem parsing attributes\n"); 8596 break; 8597 } 8598 SHRINK; 8599 GROW; 8600 } 8601 8602 /* 8603 * SAX: Start of Element ! 8604 */ 8605 if ((ctxt->sax != NULL) && (ctxt->sax->startElement != NULL) && 8606 (!ctxt->disableSAX)) { 8607 if (nbatts > 0) 8608 ctxt->sax->startElement(ctxt->userData, name, atts); 8609 else 8610 ctxt->sax->startElement(ctxt->userData, name, NULL); 8611 } 8612 8613 if (atts != NULL) { 8614 /* Free only the content strings */ 8615 for (i = 1;i < nbatts;i+=2) 8616 if (atts[i] != NULL) 8617 xmlFree((xmlChar *) atts[i]); 8618 } 8619 return(name); 8620 } 8621 8622 /** 8623 * xmlParseEndTag1: 8624 * @ctxt: an XML parser context 8625 * @line: line of the start tag 8626 * @nsNr: number of namespaces on the start tag 8627 * 8628 * parse an end of tag 8629 * 8630 * [42] ETag ::= '</' Name S? '>' 8631 * 8632 * With namespace 8633 * 8634 * [NS 9] ETag ::= '</' QName S? '>' 8635 */ 8636 8637 static void 8638 xmlParseEndTag1(xmlParserCtxtPtr ctxt, int line) { 8639 const xmlChar *name; 8640 8641 GROW; 8642 if ((RAW != '<') || (NXT(1) != '/')) { 8643 xmlFatalErrMsg(ctxt, XML_ERR_LTSLASH_REQUIRED, 8644 "xmlParseEndTag: '</' not found\n"); 8645 return; 8646 } 8647 SKIP(2); 8648 8649 name = xmlParseNameAndCompare(ctxt,ctxt->name); 8650 8651 /* 8652 * We should definitely be at the ending "S? '>'" part 8653 */ 8654 GROW; 8655 SKIP_BLANKS; 8656 if ((!IS_BYTE_CHAR(RAW)) || (RAW != '>')) { 8657 xmlFatalErr(ctxt, XML_ERR_GT_REQUIRED, NULL); 8658 } else 8659 NEXT1; 8660 8661 /* 8662 * [ WFC: Element Type Match ] 8663 * The Name in an element's end-tag must match the element type in the 8664 * start-tag. 8665 * 8666 */ 8667 if (name != (xmlChar*)1) { 8668 if (name == NULL) name = BAD_CAST "unparseable"; 8669 xmlFatalErrMsgStrIntStr(ctxt, XML_ERR_TAG_NAME_MISMATCH, 8670 "Opening and ending tag mismatch: %s line %d and %s\n", 8671 ctxt->name, line, name); 8672 } 8673 8674 /* 8675 * SAX: End of Tag 8676 */ 8677 if ((ctxt->sax != NULL) && (ctxt->sax->endElement != NULL) && 8678 (!ctxt->disableSAX)) 8679 ctxt->sax->endElement(ctxt->userData, ctxt->name); 8680 8681 namePop(ctxt); 8682 spacePop(ctxt); 8683 return; 8684 } 8685 8686 /** 8687 * xmlParseEndTag: 8688 * @ctxt: an XML parser context 8689 * 8690 * parse an end of tag 8691 * 8692 * [42] ETag ::= '</' Name S? '>' 8693 * 8694 * With namespace 8695 * 8696 * [NS 9] ETag ::= '</' QName S? '>' 8697 */ 8698 8699 void 8700 xmlParseEndTag(xmlParserCtxtPtr ctxt) { 8701 xmlParseEndTag1(ctxt, 0); 8702 } 8703 #endif /* LIBXML_SAX1_ENABLED */ 8704 8705 /************************************************************************ 8706 * * 8707 * SAX 2 specific operations * 8708 * * 8709 ************************************************************************/ 8710 8711 /* 8712 * xmlGetNamespace: 8713 * @ctxt: an XML parser context 8714 * @prefix: the prefix to lookup 8715 * 8716 * Lookup the namespace name for the @prefix (which ca be NULL) 8717 * The prefix must come from the @ctxt->dict dictionnary 8718 * 8719 * Returns the namespace name or NULL if not bound 8720 */ 8721 static const xmlChar * 8722 xmlGetNamespace(xmlParserCtxtPtr ctxt, const xmlChar *prefix) { 8723 int i; 8724 8725 if (prefix == ctxt->str_xml) return(ctxt->str_xml_ns); 8726 for (i = ctxt->nsNr - 2;i >= 0;i-=2) 8727 if (ctxt->nsTab[i] == prefix) { 8728 if ((prefix == NULL) && (*ctxt->nsTab[i + 1] == 0)) 8729 return(NULL); 8730 return(ctxt->nsTab[i + 1]); 8731 } 8732 return(NULL); 8733 } 8734 8735 /** 8736 * xmlParseQName: 8737 * @ctxt: an XML parser context 8738 * @prefix: pointer to store the prefix part 8739 * 8740 * parse an XML Namespace QName 8741 * 8742 * [6] QName ::= (Prefix ':')? LocalPart 8743 * [7] Prefix ::= NCName 8744 * [8] LocalPart ::= NCName 8745 * 8746 * Returns the Name parsed or NULL 8747 */ 8748 8749 static const xmlChar * 8750 xmlParseQName(xmlParserCtxtPtr ctxt, const xmlChar **prefix) { 8751 const xmlChar *l, *p; 8752 8753 GROW; 8754 8755 l = xmlParseNCName(ctxt); 8756 if (l == NULL) { 8757 if (CUR == ':') { 8758 l = xmlParseName(ctxt); 8759 if (l != NULL) { 8760 xmlNsErr(ctxt, XML_NS_ERR_QNAME, 8761 "Failed to parse QName '%s'\n", l, NULL, NULL); 8762 *prefix = NULL; 8763 return(l); 8764 } 8765 } 8766 return(NULL); 8767 } 8768 if (CUR == ':') { 8769 NEXT; 8770 p = l; 8771 l = xmlParseNCName(ctxt); 8772 if (l == NULL) { 8773 xmlChar *tmp; 8774 8775 xmlNsErr(ctxt, XML_NS_ERR_QNAME, 8776 "Failed to parse QName '%s:'\n", p, NULL, NULL); 8777 l = xmlParseNmtoken(ctxt); 8778 if (l == NULL) 8779 tmp = xmlBuildQName(BAD_CAST "", p, NULL, 0); 8780 else { 8781 tmp = xmlBuildQName(l, p, NULL, 0); 8782 xmlFree((char *)l); 8783 } 8784 p = xmlDictLookup(ctxt->dict, tmp, -1); 8785 if (tmp != NULL) xmlFree(tmp); 8786 *prefix = NULL; 8787 return(p); 8788 } 8789 if (CUR == ':') { 8790 xmlChar *tmp; 8791 8792 xmlNsErr(ctxt, XML_NS_ERR_QNAME, 8793 "Failed to parse QName '%s:%s:'\n", p, l, NULL); 8794 NEXT; 8795 tmp = (xmlChar *) xmlParseName(ctxt); 8796 if (tmp != NULL) { 8797 tmp = xmlBuildQName(tmp, l, NULL, 0); 8798 l = xmlDictLookup(ctxt->dict, tmp, -1); 8799 if (tmp != NULL) xmlFree(tmp); 8800 *prefix = p; 8801 return(l); 8802 } 8803 tmp = xmlBuildQName(BAD_CAST "", l, NULL, 0); 8804 l = xmlDictLookup(ctxt->dict, tmp, -1); 8805 if (tmp != NULL) xmlFree(tmp); 8806 *prefix = p; 8807 return(l); 8808 } 8809 *prefix = p; 8810 } else 8811 *prefix = NULL; 8812 return(l); 8813 } 8814 8815 /** 8816 * xmlParseQNameAndCompare: 8817 * @ctxt: an XML parser context 8818 * @name: the localname 8819 * @prefix: the prefix, if any. 8820 * 8821 * parse an XML name and compares for match 8822 * (specialized for endtag parsing) 8823 * 8824 * Returns NULL for an illegal name, (xmlChar*) 1 for success 8825 * and the name for mismatch 8826 */ 8827 8828 static const xmlChar * 8829 xmlParseQNameAndCompare(xmlParserCtxtPtr ctxt, xmlChar const *name, 8830 xmlChar const *prefix) { 8831 const xmlChar *cmp; 8832 const xmlChar *in; 8833 const xmlChar *ret; 8834 const xmlChar *prefix2; 8835 8836 if (prefix == NULL) return(xmlParseNameAndCompare(ctxt, name)); 8837 8838 GROW; 8839 in = ctxt->input->cur; 8840 8841 cmp = prefix; 8842 while (*in != 0 && *in == *cmp) { 8843 ++in; 8844 ++cmp; 8845 } 8846 if ((*cmp == 0) && (*in == ':')) { 8847 in++; 8848 cmp = name; 8849 while (*in != 0 && *in == *cmp) { 8850 ++in; 8851 ++cmp; 8852 } 8853 if (*cmp == 0 && (*in == '>' || IS_BLANK_CH (*in))) { 8854 /* success */ 8855 ctxt->input->cur = in; 8856 return((const xmlChar*) 1); 8857 } 8858 } 8859 /* 8860 * all strings coms from the dictionary, equality can be done directly 8861 */ 8862 ret = xmlParseQName (ctxt, &prefix2); 8863 if ((ret == name) && (prefix == prefix2)) 8864 return((const xmlChar*) 1); 8865 return ret; 8866 } 8867 8868 /** 8869 * xmlParseAttValueInternal: 8870 * @ctxt: an XML parser context 8871 * @len: attribute len result 8872 * @alloc: whether the attribute was reallocated as a new string 8873 * @normalize: if 1 then further non-CDATA normalization must be done 8874 * 8875 * parse a value for an attribute. 8876 * NOTE: if no normalization is needed, the routine will return pointers 8877 * directly from the data buffer. 8878 * 8879 * 3.3.3 Attribute-Value Normalization: 8880 * Before the value of an attribute is passed to the application or 8881 * checked for validity, the XML processor must normalize it as follows: 8882 * - a character reference is processed by appending the referenced 8883 * character to the attribute value 8884 * - an entity reference is processed by recursively processing the 8885 * replacement text of the entity 8886 * - a whitespace character (#x20, #xD, #xA, #x9) is processed by 8887 * appending #x20 to the normalized value, except that only a single 8888 * #x20 is appended for a "#xD#xA" sequence that is part of an external 8889 * parsed entity or the literal entity value of an internal parsed entity 8890 * - other characters are processed by appending them to the normalized value 8891 * If the declared value is not CDATA, then the XML processor must further 8892 * process the normalized attribute value by discarding any leading and 8893 * trailing space (#x20) characters, and by replacing sequences of space 8894 * (#x20) characters by a single space (#x20) character. 8895 * All attributes for which no declaration has been read should be treated 8896 * by a non-validating parser as if declared CDATA. 8897 * 8898 * Returns the AttValue parsed or NULL. The value has to be freed by the 8899 * caller if it was copied, this can be detected by val[*len] == 0. 8900 */ 8901 8902 static xmlChar * 8903 xmlParseAttValueInternal(xmlParserCtxtPtr ctxt, int *len, int *alloc, 8904 int normalize) 8905 { 8906 xmlChar limit = 0; 8907 const xmlChar *in = NULL, *start, *end, *last; 8908 xmlChar *ret = NULL; 8909 8910 GROW; 8911 in = (xmlChar *) CUR_PTR; 8912 if (*in != '"' && *in != '\'') { 8913 xmlFatalErr(ctxt, XML_ERR_ATTRIBUTE_NOT_STARTED, NULL); 8914 return (NULL); 8915 } 8916 ctxt->instate = XML_PARSER_ATTRIBUTE_VALUE; 8917 8918 /* 8919 * try to handle in this routine the most common case where no 8920 * allocation of a new string is required and where content is 8921 * pure ASCII. 8922 */ 8923 limit = *in++; 8924 end = ctxt->input->end; 8925 start = in; 8926 if (in >= end) { 8927 const xmlChar *oldbase = ctxt->input->base; 8928 GROW; 8929 if (oldbase != ctxt->input->base) { 8930 long delta = ctxt->input->base - oldbase; 8931 start = start + delta; 8932 in = in + delta; 8933 } 8934 end = ctxt->input->end; 8935 } 8936 if (normalize) { 8937 /* 8938 * Skip any leading spaces 8939 */ 8940 while ((in < end) && (*in != limit) && 8941 ((*in == 0x20) || (*in == 0x9) || 8942 (*in == 0xA) || (*in == 0xD))) { 8943 in++; 8944 start = in; 8945 if (in >= end) { 8946 const xmlChar *oldbase = ctxt->input->base; 8947 GROW; 8948 if (ctxt->instate == XML_PARSER_EOF) 8949 return(NULL); 8950 if (oldbase != ctxt->input->base) { 8951 long delta = ctxt->input->base - oldbase; 8952 start = start + delta; 8953 in = in + delta; 8954 } 8955 end = ctxt->input->end; 8956 if (((in - start) > XML_MAX_TEXT_LENGTH) && 8957 ((ctxt->options & XML_PARSE_HUGE) == 0)) { 8958 xmlFatalErrMsg(ctxt, XML_ERR_ATTRIBUTE_NOT_FINISHED, 8959 "AttValue length too long\n"); 8960 return(NULL); 8961 } 8962 } 8963 } 8964 while ((in < end) && (*in != limit) && (*in >= 0x20) && 8965 (*in <= 0x7f) && (*in != '&') && (*in != '<')) { 8966 if ((*in++ == 0x20) && (*in == 0x20)) break; 8967 if (in >= end) { 8968 const xmlChar *oldbase = ctxt->input->base; 8969 GROW; 8970 if (ctxt->instate == XML_PARSER_EOF) 8971 return(NULL); 8972 if (oldbase != ctxt->input->base) { 8973 long delta = ctxt->input->base - oldbase; 8974 start = start + delta; 8975 in = in + delta; 8976 } 8977 end = ctxt->input->end; 8978 if (((in - start) > XML_MAX_TEXT_LENGTH) && 8979 ((ctxt->options & XML_PARSE_HUGE) == 0)) { 8980 xmlFatalErrMsg(ctxt, XML_ERR_ATTRIBUTE_NOT_FINISHED, 8981 "AttValue length too long\n"); 8982 return(NULL); 8983 } 8984 } 8985 } 8986 last = in; 8987 /* 8988 * skip the trailing blanks 8989 */ 8990 while ((last[-1] == 0x20) && (last > start)) last--; 8991 while ((in < end) && (*in != limit) && 8992 ((*in == 0x20) || (*in == 0x9) || 8993 (*in == 0xA) || (*in == 0xD))) { 8994 in++; 8995 if (in >= end) { 8996 const xmlChar *oldbase = ctxt->input->base; 8997 GROW; 8998 if (ctxt->instate == XML_PARSER_EOF) 8999 return(NULL); 9000 if (oldbase != ctxt->input->base) { 9001 long delta = ctxt->input->base - oldbase; 9002 start = start + delta; 9003 in = in + delta; 9004 last = last + delta; 9005 } 9006 end = ctxt->input->end; 9007 if (((in - start) > XML_MAX_TEXT_LENGTH) && 9008 ((ctxt->options & XML_PARSE_HUGE) == 0)) { 9009 xmlFatalErrMsg(ctxt, XML_ERR_ATTRIBUTE_NOT_FINISHED, 9010 "AttValue length too long\n"); 9011 return(NULL); 9012 } 9013 } 9014 } 9015 if (((in - start) > XML_MAX_TEXT_LENGTH) && 9016 ((ctxt->options & XML_PARSE_HUGE) == 0)) { 9017 xmlFatalErrMsg(ctxt, XML_ERR_ATTRIBUTE_NOT_FINISHED, 9018 "AttValue length too long\n"); 9019 return(NULL); 9020 } 9021 if (*in != limit) goto need_complex; 9022 } else { 9023 while ((in < end) && (*in != limit) && (*in >= 0x20) && 9024 (*in <= 0x7f) && (*in != '&') && (*in != '<')) { 9025 in++; 9026 if (in >= end) { 9027 const xmlChar *oldbase = ctxt->input->base; 9028 GROW; 9029 if (ctxt->instate == XML_PARSER_EOF) 9030 return(NULL); 9031 if (oldbase != ctxt->input->base) { 9032 long delta = ctxt->input->base - oldbase; 9033 start = start + delta; 9034 in = in + delta; 9035 } 9036 end = ctxt->input->end; 9037 if (((in - start) > XML_MAX_TEXT_LENGTH) && 9038 ((ctxt->options & XML_PARSE_HUGE) == 0)) { 9039 xmlFatalErrMsg(ctxt, XML_ERR_ATTRIBUTE_NOT_FINISHED, 9040 "AttValue length too long\n"); 9041 return(NULL); 9042 } 9043 } 9044 } 9045 last = in; 9046 if (((in - start) > XML_MAX_TEXT_LENGTH) && 9047 ((ctxt->options & XML_PARSE_HUGE) == 0)) { 9048 xmlFatalErrMsg(ctxt, XML_ERR_ATTRIBUTE_NOT_FINISHED, 9049 "AttValue length too long\n"); 9050 return(NULL); 9051 } 9052 if (*in != limit) goto need_complex; 9053 } 9054 in++; 9055 if (len != NULL) { 9056 *len = last - start; 9057 ret = (xmlChar *) start; 9058 } else { 9059 if (alloc) *alloc = 1; 9060 ret = xmlStrndup(start, last - start); 9061 } 9062 CUR_PTR = in; 9063 if (alloc) *alloc = 0; 9064 return ret; 9065 need_complex: 9066 if (alloc) *alloc = 1; 9067 return xmlParseAttValueComplex(ctxt, len, normalize); 9068 } 9069 9070 /** 9071 * xmlParseAttribute2: 9072 * @ctxt: an XML parser context 9073 * @pref: the element prefix 9074 * @elem: the element name 9075 * @prefix: a xmlChar ** used to store the value of the attribute prefix 9076 * @value: a xmlChar ** used to store the value of the attribute 9077 * @len: an int * to save the length of the attribute 9078 * @alloc: an int * to indicate if the attribute was allocated 9079 * 9080 * parse an attribute in the new SAX2 framework. 9081 * 9082 * Returns the attribute name, and the value in *value, . 9083 */ 9084 9085 static const xmlChar * 9086 xmlParseAttribute2(xmlParserCtxtPtr ctxt, 9087 const xmlChar * pref, const xmlChar * elem, 9088 const xmlChar ** prefix, xmlChar ** value, 9089 int *len, int *alloc) 9090 { 9091 const xmlChar *name; 9092 xmlChar *val, *internal_val = NULL; 9093 int normalize = 0; 9094 9095 *value = NULL; 9096 GROW; 9097 name = xmlParseQName(ctxt, prefix); 9098 if (name == NULL) { 9099 xmlFatalErrMsg(ctxt, XML_ERR_NAME_REQUIRED, 9100 "error parsing attribute name\n"); 9101 return (NULL); 9102 } 9103 9104 /* 9105 * get the type if needed 9106 */ 9107 if (ctxt->attsSpecial != NULL) { 9108 int type; 9109 9110 type = (int) (long) xmlHashQLookup2(ctxt->attsSpecial, 9111 pref, elem, *prefix, name); 9112 if (type != 0) 9113 normalize = 1; 9114 } 9115 9116 /* 9117 * read the value 9118 */ 9119 SKIP_BLANKS; 9120 if (RAW == '=') { 9121 NEXT; 9122 SKIP_BLANKS; 9123 val = xmlParseAttValueInternal(ctxt, len, alloc, normalize); 9124 if (normalize) { 9125 /* 9126 * Sometimes a second normalisation pass for spaces is needed 9127 * but that only happens if charrefs or entities refernces 9128 * have been used in the attribute value, i.e. the attribute 9129 * value have been extracted in an allocated string already. 9130 */ 9131 if (*alloc) { 9132 const xmlChar *val2; 9133 9134 val2 = xmlAttrNormalizeSpace2(ctxt, val, len); 9135 if ((val2 != NULL) && (val2 != val)) { 9136 xmlFree(val); 9137 val = (xmlChar *) val2; 9138 } 9139 } 9140 } 9141 ctxt->instate = XML_PARSER_CONTENT; 9142 } else { 9143 xmlFatalErrMsgStr(ctxt, XML_ERR_ATTRIBUTE_WITHOUT_VALUE, 9144 "Specification mandate value for attribute %s\n", 9145 name); 9146 return (NULL); 9147 } 9148 9149 if (*prefix == ctxt->str_xml) { 9150 /* 9151 * Check that xml:lang conforms to the specification 9152 * No more registered as an error, just generate a warning now 9153 * since this was deprecated in XML second edition 9154 */ 9155 if ((ctxt->pedantic) && (xmlStrEqual(name, BAD_CAST "lang"))) { 9156 internal_val = xmlStrndup(val, *len); 9157 if (!xmlCheckLanguageID(internal_val)) { 9158 xmlWarningMsg(ctxt, XML_WAR_LANG_VALUE, 9159 "Malformed value for xml:lang : %s\n", 9160 internal_val, NULL); 9161 } 9162 } 9163 9164 /* 9165 * Check that xml:space conforms to the specification 9166 */ 9167 if (xmlStrEqual(name, BAD_CAST "space")) { 9168 internal_val = xmlStrndup(val, *len); 9169 if (xmlStrEqual(internal_val, BAD_CAST "default")) 9170 *(ctxt->space) = 0; 9171 else if (xmlStrEqual(internal_val, BAD_CAST "preserve")) 9172 *(ctxt->space) = 1; 9173 else { 9174 xmlWarningMsg(ctxt, XML_WAR_SPACE_VALUE, 9175 "Invalid value \"%s\" for xml:space : \"default\" or \"preserve\" expected\n", 9176 internal_val, NULL); 9177 } 9178 } 9179 if (internal_val) { 9180 xmlFree(internal_val); 9181 } 9182 } 9183 9184 *value = val; 9185 return (name); 9186 } 9187 /** 9188 * xmlParseStartTag2: 9189 * @ctxt: an XML parser context 9190 * 9191 * parse a start of tag either for rule element or 9192 * EmptyElement. In both case we don't parse the tag closing chars. 9193 * This routine is called when running SAX2 parsing 9194 * 9195 * [40] STag ::= '<' Name (S Attribute)* S? '>' 9196 * 9197 * [ WFC: Unique Att Spec ] 9198 * No attribute name may appear more than once in the same start-tag or 9199 * empty-element tag. 9200 * 9201 * [44] EmptyElemTag ::= '<' Name (S Attribute)* S? '/>' 9202 * 9203 * [ WFC: Unique Att Spec ] 9204 * No attribute name may appear more than once in the same start-tag or 9205 * empty-element tag. 9206 * 9207 * With namespace: 9208 * 9209 * [NS 8] STag ::= '<' QName (S Attribute)* S? '>' 9210 * 9211 * [NS 10] EmptyElement ::= '<' QName (S Attribute)* S? '/>' 9212 * 9213 * Returns the element name parsed 9214 */ 9215 9216 static const xmlChar * 9217 xmlParseStartTag2(xmlParserCtxtPtr ctxt, const xmlChar **pref, 9218 const xmlChar **URI, int *tlen) { 9219 const xmlChar *localname; 9220 const xmlChar *prefix; 9221 const xmlChar *attname; 9222 const xmlChar *aprefix; 9223 const xmlChar *nsname; 9224 xmlChar *attvalue; 9225 const xmlChar **atts = ctxt->atts; 9226 int maxatts = ctxt->maxatts; 9227 int nratts, nbatts, nbdef; 9228 int i, j, nbNs, attval, oldline, oldcol; 9229 const xmlChar *base; 9230 unsigned long cur; 9231 int nsNr = ctxt->nsNr; 9232 9233 if (RAW != '<') return(NULL); 9234 NEXT1; 9235 9236 /* 9237 * NOTE: it is crucial with the SAX2 API to never call SHRINK beyond that 9238 * point since the attribute values may be stored as pointers to 9239 * the buffer and calling SHRINK would destroy them ! 9240 * The Shrinking is only possible once the full set of attribute 9241 * callbacks have been done. 9242 */ 9243 reparse: 9244 SHRINK; 9245 base = ctxt->input->base; 9246 cur = ctxt->input->cur - ctxt->input->base; 9247 oldline = ctxt->input->line; 9248 oldcol = ctxt->input->col; 9249 nbatts = 0; 9250 nratts = 0; 9251 nbdef = 0; 9252 nbNs = 0; 9253 attval = 0; 9254 /* Forget any namespaces added during an earlier parse of this element. */ 9255 ctxt->nsNr = nsNr; 9256 9257 localname = xmlParseQName(ctxt, &prefix); 9258 if (localname == NULL) { 9259 xmlFatalErrMsg(ctxt, XML_ERR_NAME_REQUIRED, 9260 "StartTag: invalid element name\n"); 9261 return(NULL); 9262 } 9263 *tlen = ctxt->input->cur - ctxt->input->base - cur; 9264 9265 /* 9266 * Now parse the attributes, it ends up with the ending 9267 * 9268 * (S Attribute)* S? 9269 */ 9270 SKIP_BLANKS; 9271 GROW; 9272 if (ctxt->input->base != base) goto base_changed; 9273 9274 while (((RAW != '>') && 9275 ((RAW != '/') || (NXT(1) != '>')) && 9276 (IS_BYTE_CHAR(RAW))) && (ctxt->instate != XML_PARSER_EOF)) { 9277 const xmlChar *q = CUR_PTR; 9278 unsigned int cons = ctxt->input->consumed; 9279 int len = -1, alloc = 0; 9280 9281 attname = xmlParseAttribute2(ctxt, prefix, localname, 9282 &aprefix, &attvalue, &len, &alloc); 9283 if (ctxt->input->base != base) { 9284 if ((attvalue != NULL) && (alloc != 0)) 9285 xmlFree(attvalue); 9286 attvalue = NULL; 9287 goto base_changed; 9288 } 9289 if ((attname != NULL) && (attvalue != NULL)) { 9290 if (len < 0) len = xmlStrlen(attvalue); 9291 if ((attname == ctxt->str_xmlns) && (aprefix == NULL)) { 9292 const xmlChar *URL = xmlDictLookup(ctxt->dict, attvalue, len); 9293 xmlURIPtr uri; 9294 9295 if (*URL != 0) { 9296 uri = xmlParseURI((const char *) URL); 9297 if (uri == NULL) { 9298 xmlNsErr(ctxt, XML_WAR_NS_URI, 9299 "xmlns: '%s' is not a valid URI\n", 9300 URL, NULL, NULL); 9301 } else { 9302 if (uri->scheme == NULL) { 9303 xmlNsWarn(ctxt, XML_WAR_NS_URI_RELATIVE, 9304 "xmlns: URI %s is not absolute\n", 9305 URL, NULL, NULL); 9306 } 9307 xmlFreeURI(uri); 9308 } 9309 if (URL == ctxt->str_xml_ns) { 9310 if (attname != ctxt->str_xml) { 9311 xmlNsErr(ctxt, XML_NS_ERR_XML_NAMESPACE, 9312 "xml namespace URI cannot be the default namespace\n", 9313 NULL, NULL, NULL); 9314 } 9315 goto skip_default_ns; 9316 } 9317 if ((len == 29) && 9318 (xmlStrEqual(URL, 9319 BAD_CAST "http://www.w3.org/2000/xmlns/"))) { 9320 xmlNsErr(ctxt, XML_NS_ERR_XML_NAMESPACE, 9321 "reuse of the xmlns namespace name is forbidden\n", 9322 NULL, NULL, NULL); 9323 goto skip_default_ns; 9324 } 9325 } 9326 /* 9327 * check that it's not a defined namespace 9328 */ 9329 for (j = 1;j <= nbNs;j++) 9330 if (ctxt->nsTab[ctxt->nsNr - 2 * j] == NULL) 9331 break; 9332 if (j <= nbNs) 9333 xmlErrAttributeDup(ctxt, NULL, attname); 9334 else 9335 if (nsPush(ctxt, NULL, URL) > 0) nbNs++; 9336 skip_default_ns: 9337 if (alloc != 0) xmlFree(attvalue); 9338 SKIP_BLANKS; 9339 continue; 9340 } 9341 if (aprefix == ctxt->str_xmlns) { 9342 const xmlChar *URL = xmlDictLookup(ctxt->dict, attvalue, len); 9343 xmlURIPtr uri; 9344 9345 if (attname == ctxt->str_xml) { 9346 if (URL != ctxt->str_xml_ns) { 9347 xmlNsErr(ctxt, XML_NS_ERR_XML_NAMESPACE, 9348 "xml namespace prefix mapped to wrong URI\n", 9349 NULL, NULL, NULL); 9350 } 9351 /* 9352 * Do not keep a namespace definition node 9353 */ 9354 goto skip_ns; 9355 } 9356 if (URL == ctxt->str_xml_ns) { 9357 if (attname != ctxt->str_xml) { 9358 xmlNsErr(ctxt, XML_NS_ERR_XML_NAMESPACE, 9359 "xml namespace URI mapped to wrong prefix\n", 9360 NULL, NULL, NULL); 9361 } 9362 goto skip_ns; 9363 } 9364 if (attname == ctxt->str_xmlns) { 9365 xmlNsErr(ctxt, XML_NS_ERR_XML_NAMESPACE, 9366 "redefinition of the xmlns prefix is forbidden\n", 9367 NULL, NULL, NULL); 9368 goto skip_ns; 9369 } 9370 if ((len == 29) && 9371 (xmlStrEqual(URL, 9372 BAD_CAST "http://www.w3.org/2000/xmlns/"))) { 9373 xmlNsErr(ctxt, XML_NS_ERR_XML_NAMESPACE, 9374 "reuse of the xmlns namespace name is forbidden\n", 9375 NULL, NULL, NULL); 9376 goto skip_ns; 9377 } 9378 if ((URL == NULL) || (URL[0] == 0)) { 9379 xmlNsErr(ctxt, XML_NS_ERR_XML_NAMESPACE, 9380 "xmlns:%s: Empty XML namespace is not allowed\n", 9381 attname, NULL, NULL); 9382 goto skip_ns; 9383 } else { 9384 uri = xmlParseURI((const char *) URL); 9385 if (uri == NULL) { 9386 xmlNsErr(ctxt, XML_WAR_NS_URI, 9387 "xmlns:%s: '%s' is not a valid URI\n", 9388 attname, URL, NULL); 9389 } else { 9390 if ((ctxt->pedantic) && (uri->scheme == NULL)) { 9391 xmlNsWarn(ctxt, XML_WAR_NS_URI_RELATIVE, 9392 "xmlns:%s: URI %s is not absolute\n", 9393 attname, URL, NULL); 9394 } 9395 xmlFreeURI(uri); 9396 } 9397 } 9398 9399 /* 9400 * check that it's not a defined namespace 9401 */ 9402 for (j = 1;j <= nbNs;j++) 9403 if (ctxt->nsTab[ctxt->nsNr - 2 * j] == attname) 9404 break; 9405 if (j <= nbNs) 9406 xmlErrAttributeDup(ctxt, aprefix, attname); 9407 else 9408 if (nsPush(ctxt, attname, URL) > 0) nbNs++; 9409 skip_ns: 9410 if (alloc != 0) xmlFree(attvalue); 9411 SKIP_BLANKS; 9412 if (ctxt->input->base != base) goto base_changed; 9413 continue; 9414 } 9415 9416 /* 9417 * Add the pair to atts 9418 */ 9419 if ((atts == NULL) || (nbatts + 5 > maxatts)) { 9420 if (xmlCtxtGrowAttrs(ctxt, nbatts + 5) < 0) { 9421 if (attvalue[len] == 0) 9422 xmlFree(attvalue); 9423 goto failed; 9424 } 9425 maxatts = ctxt->maxatts; 9426 atts = ctxt->atts; 9427 } 9428 ctxt->attallocs[nratts++] = alloc; 9429 atts[nbatts++] = attname; 9430 atts[nbatts++] = aprefix; 9431 atts[nbatts++] = NULL; /* the URI will be fetched later */ 9432 atts[nbatts++] = attvalue; 9433 attvalue += len; 9434 atts[nbatts++] = attvalue; 9435 /* 9436 * tag if some deallocation is needed 9437 */ 9438 if (alloc != 0) attval = 1; 9439 } else { 9440 if ((attvalue != NULL) && (attvalue[len] == 0)) 9441 xmlFree(attvalue); 9442 } 9443 9444 failed: 9445 9446 GROW 9447 if (ctxt->instate == XML_PARSER_EOF) 9448 break; 9449 if (ctxt->input->base != base) goto base_changed; 9450 if ((RAW == '>') || (((RAW == '/') && (NXT(1) == '>')))) 9451 break; 9452 if (!IS_BLANK_CH(RAW)) { 9453 xmlFatalErrMsg(ctxt, XML_ERR_SPACE_REQUIRED, 9454 "attributes construct error\n"); 9455 break; 9456 } 9457 SKIP_BLANKS; 9458 if ((cons == ctxt->input->consumed) && (q == CUR_PTR) && 9459 (attname == NULL) && (attvalue == NULL)) { 9460 xmlFatalErr(ctxt, XML_ERR_INTERNAL_ERROR, 9461 "xmlParseStartTag: problem parsing attributes\n"); 9462 break; 9463 } 9464 GROW; 9465 if (ctxt->input->base != base) goto base_changed; 9466 } 9467 9468 /* 9469 * The attributes defaulting 9470 */ 9471 if (ctxt->attsDefault != NULL) { 9472 xmlDefAttrsPtr defaults; 9473 9474 defaults = xmlHashLookup2(ctxt->attsDefault, localname, prefix); 9475 if (defaults != NULL) { 9476 for (i = 0;i < defaults->nbAttrs;i++) { 9477 attname = defaults->values[5 * i]; 9478 aprefix = defaults->values[5 * i + 1]; 9479 9480 /* 9481 * special work for namespaces defaulted defs 9482 */ 9483 if ((attname == ctxt->str_xmlns) && (aprefix == NULL)) { 9484 /* 9485 * check that it's not a defined namespace 9486 */ 9487 for (j = 1;j <= nbNs;j++) 9488 if (ctxt->nsTab[ctxt->nsNr - 2 * j] == NULL) 9489 break; 9490 if (j <= nbNs) continue; 9491 9492 nsname = xmlGetNamespace(ctxt, NULL); 9493 if (nsname != defaults->values[5 * i + 2]) { 9494 if (nsPush(ctxt, NULL, 9495 defaults->values[5 * i + 2]) > 0) 9496 nbNs++; 9497 } 9498 } else if (aprefix == ctxt->str_xmlns) { 9499 /* 9500 * check that it's not a defined namespace 9501 */ 9502 for (j = 1;j <= nbNs;j++) 9503 if (ctxt->nsTab[ctxt->nsNr - 2 * j] == attname) 9504 break; 9505 if (j <= nbNs) continue; 9506 9507 nsname = xmlGetNamespace(ctxt, attname); 9508 if (nsname != defaults->values[2]) { 9509 if (nsPush(ctxt, attname, 9510 defaults->values[5 * i + 2]) > 0) 9511 nbNs++; 9512 } 9513 } else { 9514 /* 9515 * check that it's not a defined attribute 9516 */ 9517 for (j = 0;j < nbatts;j+=5) { 9518 if ((attname == atts[j]) && (aprefix == atts[j+1])) 9519 break; 9520 } 9521 if (j < nbatts) continue; 9522 9523 if ((atts == NULL) || (nbatts + 5 > maxatts)) { 9524 if (xmlCtxtGrowAttrs(ctxt, nbatts + 5) < 0) { 9525 return(NULL); 9526 } 9527 maxatts = ctxt->maxatts; 9528 atts = ctxt->atts; 9529 } 9530 atts[nbatts++] = attname; 9531 atts[nbatts++] = aprefix; 9532 if (aprefix == NULL) 9533 atts[nbatts++] = NULL; 9534 else 9535 atts[nbatts++] = xmlGetNamespace(ctxt, aprefix); 9536 atts[nbatts++] = defaults->values[5 * i + 2]; 9537 atts[nbatts++] = defaults->values[5 * i + 3]; 9538 if ((ctxt->standalone == 1) && 9539 (defaults->values[5 * i + 4] != NULL)) { 9540 xmlValidityError(ctxt, XML_DTD_STANDALONE_DEFAULTED, 9541 "standalone: attribute %s on %s defaulted from external subset\n", 9542 attname, localname); 9543 } 9544 nbdef++; 9545 } 9546 } 9547 } 9548 } 9549 9550 /* 9551 * The attributes checkings 9552 */ 9553 for (i = 0; i < nbatts;i += 5) { 9554 /* 9555 * The default namespace does not apply to attribute names. 9556 */ 9557 if (atts[i + 1] != NULL) { 9558 nsname = xmlGetNamespace(ctxt, atts[i + 1]); 9559 if (nsname == NULL) { 9560 xmlNsErr(ctxt, XML_NS_ERR_UNDEFINED_NAMESPACE, 9561 "Namespace prefix %s for %s on %s is not defined\n", 9562 atts[i + 1], atts[i], localname); 9563 } 9564 atts[i + 2] = nsname; 9565 } else 9566 nsname = NULL; 9567 /* 9568 * [ WFC: Unique Att Spec ] 9569 * No attribute name may appear more than once in the same 9570 * start-tag or empty-element tag. 9571 * As extended by the Namespace in XML REC. 9572 */ 9573 for (j = 0; j < i;j += 5) { 9574 if (atts[i] == atts[j]) { 9575 if (atts[i+1] == atts[j+1]) { 9576 xmlErrAttributeDup(ctxt, atts[i+1], atts[i]); 9577 break; 9578 } 9579 if ((nsname != NULL) && (atts[j + 2] == nsname)) { 9580 xmlNsErr(ctxt, XML_NS_ERR_ATTRIBUTE_REDEFINED, 9581 "Namespaced Attribute %s in '%s' redefined\n", 9582 atts[i], nsname, NULL); 9583 break; 9584 } 9585 } 9586 } 9587 } 9588 9589 nsname = xmlGetNamespace(ctxt, prefix); 9590 if ((prefix != NULL) && (nsname == NULL)) { 9591 xmlNsErr(ctxt, XML_NS_ERR_UNDEFINED_NAMESPACE, 9592 "Namespace prefix %s on %s is not defined\n", 9593 prefix, localname, NULL); 9594 } 9595 *pref = prefix; 9596 *URI = nsname; 9597 9598 /* 9599 * SAX: Start of Element ! 9600 */ 9601 if ((ctxt->sax != NULL) && (ctxt->sax->startElementNs != NULL) && 9602 (!ctxt->disableSAX)) { 9603 if (nbNs > 0) 9604 ctxt->sax->startElementNs(ctxt->userData, localname, prefix, 9605 nsname, nbNs, &ctxt->nsTab[ctxt->nsNr - 2 * nbNs], 9606 nbatts / 5, nbdef, atts); 9607 else 9608 ctxt->sax->startElementNs(ctxt->userData, localname, prefix, 9609 nsname, 0, NULL, nbatts / 5, nbdef, atts); 9610 } 9611 9612 /* 9613 * Free up attribute allocated strings if needed 9614 */ 9615 if (attval != 0) { 9616 for (i = 3,j = 0; j < nratts;i += 5,j++) 9617 if ((ctxt->attallocs[j] != 0) && (atts[i] != NULL)) 9618 xmlFree((xmlChar *) atts[i]); 9619 } 9620 9621 return(localname); 9622 9623 base_changed: 9624 /* 9625 * the attribute strings are valid iif the base didn't changed 9626 */ 9627 if (attval != 0) { 9628 for (i = 3,j = 0; j < nratts;i += 5,j++) 9629 if ((ctxt->attallocs[j] != 0) && (atts[i] != NULL)) 9630 xmlFree((xmlChar *) atts[i]); 9631 } 9632 ctxt->input->cur = ctxt->input->base + cur; 9633 ctxt->input->line = oldline; 9634 ctxt->input->col = oldcol; 9635 if (ctxt->wellFormed == 1) { 9636 goto reparse; 9637 } 9638 return(NULL); 9639 } 9640 9641 /** 9642 * xmlParseEndTag2: 9643 * @ctxt: an XML parser context 9644 * @line: line of the start tag 9645 * @nsNr: number of namespaces on the start tag 9646 * 9647 * parse an end of tag 9648 * 9649 * [42] ETag ::= '</' Name S? '>' 9650 * 9651 * With namespace 9652 * 9653 * [NS 9] ETag ::= '</' QName S? '>' 9654 */ 9655 9656 static void 9657 xmlParseEndTag2(xmlParserCtxtPtr ctxt, const xmlChar *prefix, 9658 const xmlChar *URI, int line, int nsNr, int tlen) { 9659 const xmlChar *name; 9660 9661 GROW; 9662 if ((RAW != '<') || (NXT(1) != '/')) { 9663 xmlFatalErr(ctxt, XML_ERR_LTSLASH_REQUIRED, NULL); 9664 return; 9665 } 9666 SKIP(2); 9667 9668 if ((tlen > 0) && (xmlStrncmp(ctxt->input->cur, ctxt->name, tlen) == 0)) { 9669 if (ctxt->input->cur[tlen] == '>') { 9670 ctxt->input->cur += tlen + 1; 9671 goto done; 9672 } 9673 ctxt->input->cur += tlen; 9674 name = (xmlChar*)1; 9675 } else { 9676 if (prefix == NULL) 9677 name = xmlParseNameAndCompare(ctxt, ctxt->name); 9678 else 9679 name = xmlParseQNameAndCompare(ctxt, ctxt->name, prefix); 9680 } 9681 9682 /* 9683 * We should definitely be at the ending "S? '>'" part 9684 */ 9685 GROW; 9686 if (ctxt->instate == XML_PARSER_EOF) 9687 return; 9688 SKIP_BLANKS; 9689 if ((!IS_BYTE_CHAR(RAW)) || (RAW != '>')) { 9690 xmlFatalErr(ctxt, XML_ERR_GT_REQUIRED, NULL); 9691 } else 9692 NEXT1; 9693 9694 /* 9695 * [ WFC: Element Type Match ] 9696 * The Name in an element's end-tag must match the element type in the 9697 * start-tag. 9698 * 9699 */ 9700 if (name != (xmlChar*)1) { 9701 if (name == NULL) name = BAD_CAST "unparseable"; 9702 if ((line == 0) && (ctxt->node != NULL)) 9703 line = ctxt->node->line; 9704 xmlFatalErrMsgStrIntStr(ctxt, XML_ERR_TAG_NAME_MISMATCH, 9705 "Opening and ending tag mismatch: %s line %d and %s\n", 9706 ctxt->name, line, name); 9707 } 9708 9709 /* 9710 * SAX: End of Tag 9711 */ 9712 done: 9713 if ((ctxt->sax != NULL) && (ctxt->sax->endElementNs != NULL) && 9714 (!ctxt->disableSAX)) 9715 ctxt->sax->endElementNs(ctxt->userData, ctxt->name, prefix, URI); 9716 9717 spacePop(ctxt); 9718 if (nsNr != 0) 9719 nsPop(ctxt, nsNr); 9720 return; 9721 } 9722 9723 /** 9724 * xmlParseCDSect: 9725 * @ctxt: an XML parser context 9726 * 9727 * Parse escaped pure raw content. 9728 * 9729 * [18] CDSect ::= CDStart CData CDEnd 9730 * 9731 * [19] CDStart ::= '<![CDATA[' 9732 * 9733 * [20] Data ::= (Char* - (Char* ']]>' Char*)) 9734 * 9735 * [21] CDEnd ::= ']]>' 9736 */ 9737 void 9738 xmlParseCDSect(xmlParserCtxtPtr ctxt) { 9739 xmlChar *buf = NULL; 9740 int len = 0; 9741 int size = XML_PARSER_BUFFER_SIZE; 9742 int r, rl; 9743 int s, sl; 9744 int cur, l; 9745 int count = 0; 9746 9747 /* Check 2.6.0 was NXT(0) not RAW */ 9748 if (CMP9(CUR_PTR, '<', '!', '[', 'C', 'D', 'A', 'T', 'A', '[')) { 9749 SKIP(9); 9750 } else 9751 return; 9752 9753 ctxt->instate = XML_PARSER_CDATA_SECTION; 9754 r = CUR_CHAR(rl); 9755 if (!IS_CHAR(r)) { 9756 xmlFatalErr(ctxt, XML_ERR_CDATA_NOT_FINISHED, NULL); 9757 ctxt->instate = XML_PARSER_CONTENT; 9758 return; 9759 } 9760 NEXTL(rl); 9761 s = CUR_CHAR(sl); 9762 if (!IS_CHAR(s)) { 9763 xmlFatalErr(ctxt, XML_ERR_CDATA_NOT_FINISHED, NULL); 9764 ctxt->instate = XML_PARSER_CONTENT; 9765 return; 9766 } 9767 NEXTL(sl); 9768 cur = CUR_CHAR(l); 9769 buf = (xmlChar *) xmlMallocAtomic(size * sizeof(xmlChar)); 9770 if (buf == NULL) { 9771 xmlErrMemory(ctxt, NULL); 9772 return; 9773 } 9774 while (IS_CHAR(cur) && 9775 ((r != ']') || (s != ']') || (cur != '>'))) { 9776 if (len + 5 >= size) { 9777 xmlChar *tmp; 9778 9779 if ((size > XML_MAX_TEXT_LENGTH) && 9780 ((ctxt->options & XML_PARSE_HUGE) == 0)) { 9781 xmlFatalErrMsgStr(ctxt, XML_ERR_CDATA_NOT_FINISHED, 9782 "CData section too big found", NULL); 9783 xmlFree (buf); 9784 return; 9785 } 9786 tmp = (xmlChar *) xmlRealloc(buf, size * 2 * sizeof(xmlChar)); 9787 if (tmp == NULL) { 9788 xmlFree(buf); 9789 xmlErrMemory(ctxt, NULL); 9790 return; 9791 } 9792 buf = tmp; 9793 size *= 2; 9794 } 9795 COPY_BUF(rl,buf,len,r); 9796 r = s; 9797 rl = sl; 9798 s = cur; 9799 sl = l; 9800 count++; 9801 if (count > 50) { 9802 GROW; 9803 if (ctxt->instate == XML_PARSER_EOF) { 9804 xmlFree(buf); 9805 return; 9806 } 9807 count = 0; 9808 } 9809 NEXTL(l); 9810 cur = CUR_CHAR(l); 9811 } 9812 buf[len] = 0; 9813 ctxt->instate = XML_PARSER_CONTENT; 9814 if (cur != '>') { 9815 xmlFatalErrMsgStr(ctxt, XML_ERR_CDATA_NOT_FINISHED, 9816 "CData section not finished\n%.50s\n", buf); 9817 xmlFree(buf); 9818 return; 9819 } 9820 NEXTL(l); 9821 9822 /* 9823 * OK the buffer is to be consumed as cdata. 9824 */ 9825 if ((ctxt->sax != NULL) && (!ctxt->disableSAX)) { 9826 if (ctxt->sax->cdataBlock != NULL) 9827 ctxt->sax->cdataBlock(ctxt->userData, buf, len); 9828 else if (ctxt->sax->characters != NULL) 9829 ctxt->sax->characters(ctxt->userData, buf, len); 9830 } 9831 xmlFree(buf); 9832 } 9833 9834 /** 9835 * xmlParseContent: 9836 * @ctxt: an XML parser context 9837 * 9838 * Parse a content: 9839 * 9840 * [43] content ::= (element | CharData | Reference | CDSect | PI | Comment)* 9841 */ 9842 9843 void 9844 xmlParseContent(xmlParserCtxtPtr ctxt) { 9845 GROW; 9846 while ((RAW != 0) && 9847 ((RAW != '<') || (NXT(1) != '/')) && 9848 (ctxt->instate != XML_PARSER_EOF)) { 9849 const xmlChar *test = CUR_PTR; 9850 unsigned int cons = ctxt->input->consumed; 9851 const xmlChar *cur = ctxt->input->cur; 9852 9853 /* 9854 * First case : a Processing Instruction. 9855 */ 9856 if ((*cur == '<') && (cur[1] == '?')) { 9857 xmlParsePI(ctxt); 9858 } 9859 9860 /* 9861 * Second case : a CDSection 9862 */ 9863 /* 2.6.0 test was *cur not RAW */ 9864 else if (CMP9(CUR_PTR, '<', '!', '[', 'C', 'D', 'A', 'T', 'A', '[')) { 9865 xmlParseCDSect(ctxt); 9866 } 9867 9868 /* 9869 * Third case : a comment 9870 */ 9871 else if ((*cur == '<') && (NXT(1) == '!') && 9872 (NXT(2) == '-') && (NXT(3) == '-')) { 9873 xmlParseComment(ctxt); 9874 ctxt->instate = XML_PARSER_CONTENT; 9875 } 9876 9877 /* 9878 * Fourth case : a sub-element. 9879 */ 9880 else if (*cur == '<') { 9881 xmlParseElement(ctxt); 9882 } 9883 9884 /* 9885 * Fifth case : a reference. If if has not been resolved, 9886 * parsing returns it's Name, create the node 9887 */ 9888 9889 else if (*cur == '&') { 9890 xmlParseReference(ctxt); 9891 } 9892 9893 /* 9894 * Last case, text. Note that References are handled directly. 9895 */ 9896 else { 9897 xmlParseCharData(ctxt, 0); 9898 } 9899 9900 GROW; 9901 /* 9902 * Pop-up of finished entities. 9903 */ 9904 while ((RAW == 0) && (ctxt->inputNr > 1)) 9905 xmlPopInput(ctxt); 9906 SHRINK; 9907 9908 if ((cons == ctxt->input->consumed) && (test == CUR_PTR)) { 9909 xmlFatalErr(ctxt, XML_ERR_INTERNAL_ERROR, 9910 "detected an error in element content\n"); 9911 ctxt->instate = XML_PARSER_EOF; 9912 break; 9913 } 9914 } 9915 } 9916 9917 /** 9918 * xmlParseElement: 9919 * @ctxt: an XML parser context 9920 * 9921 * parse an XML element, this is highly recursive 9922 * 9923 * [39] element ::= EmptyElemTag | STag content ETag 9924 * 9925 * [ WFC: Element Type Match ] 9926 * The Name in an element's end-tag must match the element type in the 9927 * start-tag. 9928 * 9929 */ 9930 9931 void 9932 xmlParseElement(xmlParserCtxtPtr ctxt) { 9933 const xmlChar *name; 9934 const xmlChar *prefix = NULL; 9935 const xmlChar *URI = NULL; 9936 xmlParserNodeInfo node_info; 9937 int line, tlen = 0; 9938 xmlNodePtr ret; 9939 int nsNr = ctxt->nsNr; 9940 9941 if (((unsigned int) ctxt->nameNr > xmlParserMaxDepth) && 9942 ((ctxt->options & XML_PARSE_HUGE) == 0)) { 9943 xmlFatalErrMsgInt(ctxt, XML_ERR_INTERNAL_ERROR, 9944 "Excessive depth in document: %d use XML_PARSE_HUGE option\n", 9945 xmlParserMaxDepth); 9946 ctxt->instate = XML_PARSER_EOF; 9947 return; 9948 } 9949 9950 /* Capture start position */ 9951 if (ctxt->record_info) { 9952 node_info.begin_pos = ctxt->input->consumed + 9953 (CUR_PTR - ctxt->input->base); 9954 node_info.begin_line = ctxt->input->line; 9955 } 9956 9957 if (ctxt->spaceNr == 0) 9958 spacePush(ctxt, -1); 9959 else if (*ctxt->space == -2) 9960 spacePush(ctxt, -1); 9961 else 9962 spacePush(ctxt, *ctxt->space); 9963 9964 line = ctxt->input->line; 9965 #ifdef LIBXML_SAX1_ENABLED 9966 if (ctxt->sax2) 9967 #endif /* LIBXML_SAX1_ENABLED */ 9968 name = xmlParseStartTag2(ctxt, &prefix, &URI, &tlen); 9969 #ifdef LIBXML_SAX1_ENABLED 9970 else 9971 name = xmlParseStartTag(ctxt); 9972 #endif /* LIBXML_SAX1_ENABLED */ 9973 if (ctxt->instate == XML_PARSER_EOF) 9974 return; 9975 if (name == NULL) { 9976 spacePop(ctxt); 9977 return; 9978 } 9979 namePush(ctxt, name); 9980 ret = ctxt->node; 9981 9982 #ifdef LIBXML_VALID_ENABLED 9983 /* 9984 * [ VC: Root Element Type ] 9985 * The Name in the document type declaration must match the element 9986 * type of the root element. 9987 */ 9988 if (ctxt->validate && ctxt->wellFormed && ctxt->myDoc && 9989 ctxt->node && (ctxt->node == ctxt->myDoc->children)) 9990 ctxt->valid &= xmlValidateRoot(&ctxt->vctxt, ctxt->myDoc); 9991 #endif /* LIBXML_VALID_ENABLED */ 9992 9993 /* 9994 * Check for an Empty Element. 9995 */ 9996 if ((RAW == '/') && (NXT(1) == '>')) { 9997 SKIP(2); 9998 if (ctxt->sax2) { 9999 if ((ctxt->sax != NULL) && (ctxt->sax->endElementNs != NULL) && 10000 (!ctxt->disableSAX)) 10001 ctxt->sax->endElementNs(ctxt->userData, name, prefix, URI); 10002 #ifdef LIBXML_SAX1_ENABLED 10003 } else { 10004 if ((ctxt->sax != NULL) && (ctxt->sax->endElement != NULL) && 10005 (!ctxt->disableSAX)) 10006 ctxt->sax->endElement(ctxt->userData, name); 10007 #endif /* LIBXML_SAX1_ENABLED */ 10008 } 10009 namePop(ctxt); 10010 spacePop(ctxt); 10011 if (nsNr != ctxt->nsNr) 10012 nsPop(ctxt, ctxt->nsNr - nsNr); 10013 if ( ret != NULL && ctxt->record_info ) { 10014 node_info.end_pos = ctxt->input->consumed + 10015 (CUR_PTR - ctxt->input->base); 10016 node_info.end_line = ctxt->input->line; 10017 node_info.node = ret; 10018 xmlParserAddNodeInfo(ctxt, &node_info); 10019 } 10020 return; 10021 } 10022 if (RAW == '>') { 10023 NEXT1; 10024 } else { 10025 xmlFatalErrMsgStrIntStr(ctxt, XML_ERR_GT_REQUIRED, 10026 "Couldn't find end of Start Tag %s line %d\n", 10027 name, line, NULL); 10028 10029 /* 10030 * end of parsing of this node. 10031 */ 10032 nodePop(ctxt); 10033 namePop(ctxt); 10034 spacePop(ctxt); 10035 if (nsNr != ctxt->nsNr) 10036 nsPop(ctxt, ctxt->nsNr - nsNr); 10037 10038 /* 10039 * Capture end position and add node 10040 */ 10041 if ( ret != NULL && ctxt->record_info ) { 10042 node_info.end_pos = ctxt->input->consumed + 10043 (CUR_PTR - ctxt->input->base); 10044 node_info.end_line = ctxt->input->line; 10045 node_info.node = ret; 10046 xmlParserAddNodeInfo(ctxt, &node_info); 10047 } 10048 return; 10049 } 10050 10051 /* 10052 * Parse the content of the element: 10053 */ 10054 xmlParseContent(ctxt); 10055 if (ctxt->instate == XML_PARSER_EOF) 10056 return; 10057 if (!IS_BYTE_CHAR(RAW)) { 10058 xmlFatalErrMsgStrIntStr(ctxt, XML_ERR_TAG_NOT_FINISHED, 10059 "Premature end of data in tag %s line %d\n", 10060 name, line, NULL); 10061 10062 /* 10063 * end of parsing of this node. 10064 */ 10065 nodePop(ctxt); 10066 namePop(ctxt); 10067 spacePop(ctxt); 10068 if (nsNr != ctxt->nsNr) 10069 nsPop(ctxt, ctxt->nsNr - nsNr); 10070 return; 10071 } 10072 10073 /* 10074 * parse the end of tag: '</' should be here. 10075 */ 10076 if (ctxt->sax2) { 10077 xmlParseEndTag2(ctxt, prefix, URI, line, ctxt->nsNr - nsNr, tlen); 10078 namePop(ctxt); 10079 } 10080 #ifdef LIBXML_SAX1_ENABLED 10081 else 10082 xmlParseEndTag1(ctxt, line); 10083 #endif /* LIBXML_SAX1_ENABLED */ 10084 10085 /* 10086 * Capture end position and add node 10087 */ 10088 if ( ret != NULL && ctxt->record_info ) { 10089 node_info.end_pos = ctxt->input->consumed + 10090 (CUR_PTR - ctxt->input->base); 10091 node_info.end_line = ctxt->input->line; 10092 node_info.node = ret; 10093 xmlParserAddNodeInfo(ctxt, &node_info); 10094 } 10095 } 10096 10097 /** 10098 * xmlParseVersionNum: 10099 * @ctxt: an XML parser context 10100 * 10101 * parse the XML version value. 10102 * 10103 * [26] VersionNum ::= '1.' [0-9]+ 10104 * 10105 * In practice allow [0-9].[0-9]+ at that level 10106 * 10107 * Returns the string giving the XML version number, or NULL 10108 */ 10109 xmlChar * 10110 xmlParseVersionNum(xmlParserCtxtPtr ctxt) { 10111 xmlChar *buf = NULL; 10112 int len = 0; 10113 int size = 10; 10114 xmlChar cur; 10115 10116 buf = (xmlChar *) xmlMallocAtomic(size * sizeof(xmlChar)); 10117 if (buf == NULL) { 10118 xmlErrMemory(ctxt, NULL); 10119 return(NULL); 10120 } 10121 cur = CUR; 10122 if (!((cur >= '0') && (cur <= '9'))) { 10123 xmlFree(buf); 10124 return(NULL); 10125 } 10126 buf[len++] = cur; 10127 NEXT; 10128 cur=CUR; 10129 if (cur != '.') { 10130 xmlFree(buf); 10131 return(NULL); 10132 } 10133 buf[len++] = cur; 10134 NEXT; 10135 cur=CUR; 10136 while ((cur >= '0') && (cur <= '9')) { 10137 if (len + 1 >= size) { 10138 xmlChar *tmp; 10139 10140 size *= 2; 10141 tmp = (xmlChar *) xmlRealloc(buf, size * sizeof(xmlChar)); 10142 if (tmp == NULL) { 10143 xmlFree(buf); 10144 xmlErrMemory(ctxt, NULL); 10145 return(NULL); 10146 } 10147 buf = tmp; 10148 } 10149 buf[len++] = cur; 10150 NEXT; 10151 cur=CUR; 10152 } 10153 buf[len] = 0; 10154 return(buf); 10155 } 10156 10157 /** 10158 * xmlParseVersionInfo: 10159 * @ctxt: an XML parser context 10160 * 10161 * parse the XML version. 10162 * 10163 * [24] VersionInfo ::= S 'version' Eq (' VersionNum ' | " VersionNum ") 10164 * 10165 * [25] Eq ::= S? '=' S? 10166 * 10167 * Returns the version string, e.g. "1.0" 10168 */ 10169 10170 xmlChar * 10171 xmlParseVersionInfo(xmlParserCtxtPtr ctxt) { 10172 xmlChar *version = NULL; 10173 10174 if (CMP7(CUR_PTR, 'v', 'e', 'r', 's', 'i', 'o', 'n')) { 10175 SKIP(7); 10176 SKIP_BLANKS; 10177 if (RAW != '=') { 10178 xmlFatalErr(ctxt, XML_ERR_EQUAL_REQUIRED, NULL); 10179 return(NULL); 10180 } 10181 NEXT; 10182 SKIP_BLANKS; 10183 if (RAW == '"') { 10184 NEXT; 10185 version = xmlParseVersionNum(ctxt); 10186 if (RAW != '"') { 10187 xmlFatalErr(ctxt, XML_ERR_STRING_NOT_CLOSED, NULL); 10188 } else 10189 NEXT; 10190 } else if (RAW == '\''){ 10191 NEXT; 10192 version = xmlParseVersionNum(ctxt); 10193 if (RAW != '\'') { 10194 xmlFatalErr(ctxt, XML_ERR_STRING_NOT_CLOSED, NULL); 10195 } else 10196 NEXT; 10197 } else { 10198 xmlFatalErr(ctxt, XML_ERR_STRING_NOT_STARTED, NULL); 10199 } 10200 } 10201 return(version); 10202 } 10203 10204 /** 10205 * xmlParseEncName: 10206 * @ctxt: an XML parser context 10207 * 10208 * parse the XML encoding name 10209 * 10210 * [81] EncName ::= [A-Za-z] ([A-Za-z0-9._] | '-')* 10211 * 10212 * Returns the encoding name value or NULL 10213 */ 10214 xmlChar * 10215 xmlParseEncName(xmlParserCtxtPtr ctxt) { 10216 xmlChar *buf = NULL; 10217 int len = 0; 10218 int size = 10; 10219 xmlChar cur; 10220 10221 cur = CUR; 10222 if (((cur >= 'a') && (cur <= 'z')) || 10223 ((cur >= 'A') && (cur <= 'Z'))) { 10224 buf = (xmlChar *) xmlMallocAtomic(size * sizeof(xmlChar)); 10225 if (buf == NULL) { 10226 xmlErrMemory(ctxt, NULL); 10227 return(NULL); 10228 } 10229 10230 buf[len++] = cur; 10231 NEXT; 10232 cur = CUR; 10233 while (((cur >= 'a') && (cur <= 'z')) || 10234 ((cur >= 'A') && (cur <= 'Z')) || 10235 ((cur >= '0') && (cur <= '9')) || 10236 (cur == '.') || (cur == '_') || 10237 (cur == '-')) { 10238 if (len + 1 >= size) { 10239 xmlChar *tmp; 10240 10241 size *= 2; 10242 tmp = (xmlChar *) xmlRealloc(buf, size * sizeof(xmlChar)); 10243 if (tmp == NULL) { 10244 xmlErrMemory(ctxt, NULL); 10245 xmlFree(buf); 10246 return(NULL); 10247 } 10248 buf = tmp; 10249 } 10250 buf[len++] = cur; 10251 NEXT; 10252 cur = CUR; 10253 if (cur == 0) { 10254 SHRINK; 10255 GROW; 10256 cur = CUR; 10257 } 10258 } 10259 buf[len] = 0; 10260 } else { 10261 xmlFatalErr(ctxt, XML_ERR_ENCODING_NAME, NULL); 10262 } 10263 return(buf); 10264 } 10265 10266 /** 10267 * xmlParseEncodingDecl: 10268 * @ctxt: an XML parser context 10269 * 10270 * parse the XML encoding declaration 10271 * 10272 * [80] EncodingDecl ::= S 'encoding' Eq ('"' EncName '"' | "'" EncName "'") 10273 * 10274 * this setups the conversion filters. 10275 * 10276 * Returns the encoding value or NULL 10277 */ 10278 10279 const xmlChar * 10280 xmlParseEncodingDecl(xmlParserCtxtPtr ctxt) { 10281 xmlChar *encoding = NULL; 10282 10283 SKIP_BLANKS; 10284 if (CMP8(CUR_PTR, 'e', 'n', 'c', 'o', 'd', 'i', 'n', 'g')) { 10285 SKIP(8); 10286 SKIP_BLANKS; 10287 if (RAW != '=') { 10288 xmlFatalErr(ctxt, XML_ERR_EQUAL_REQUIRED, NULL); 10289 return(NULL); 10290 } 10291 NEXT; 10292 SKIP_BLANKS; 10293 if (RAW == '"') { 10294 NEXT; 10295 encoding = xmlParseEncName(ctxt); 10296 if (RAW != '"') { 10297 xmlFatalErr(ctxt, XML_ERR_STRING_NOT_CLOSED, NULL); 10298 } else 10299 NEXT; 10300 } else if (RAW == '\''){ 10301 NEXT; 10302 encoding = xmlParseEncName(ctxt); 10303 if (RAW != '\'') { 10304 xmlFatalErr(ctxt, XML_ERR_STRING_NOT_CLOSED, NULL); 10305 } else 10306 NEXT; 10307 } else { 10308 xmlFatalErr(ctxt, XML_ERR_STRING_NOT_STARTED, NULL); 10309 } 10310 10311 /* 10312 * Non standard parsing, allowing the user to ignore encoding 10313 */ 10314 if (ctxt->options & XML_PARSE_IGNORE_ENC) 10315 return(encoding); 10316 10317 /* 10318 * UTF-16 encoding stwich has already taken place at this stage, 10319 * more over the little-endian/big-endian selection is already done 10320 */ 10321 if ((encoding != NULL) && 10322 ((!xmlStrcasecmp(encoding, BAD_CAST "UTF-16")) || 10323 (!xmlStrcasecmp(encoding, BAD_CAST "UTF16")))) { 10324 /* 10325 * If no encoding was passed to the parser, that we are 10326 * using UTF-16 and no decoder is present i.e. the 10327 * document is apparently UTF-8 compatible, then raise an 10328 * encoding mismatch fatal error 10329 */ 10330 if ((ctxt->encoding == NULL) && 10331 (ctxt->input->buf != NULL) && 10332 (ctxt->input->buf->encoder == NULL)) { 10333 xmlFatalErrMsg(ctxt, XML_ERR_INVALID_ENCODING, 10334 "Document labelled UTF-16 but has UTF-8 content\n"); 10335 } 10336 if (ctxt->encoding != NULL) 10337 xmlFree((xmlChar *) ctxt->encoding); 10338 ctxt->encoding = encoding; 10339 } 10340 /* 10341 * UTF-8 encoding is handled natively 10342 */ 10343 else if ((encoding != NULL) && 10344 ((!xmlStrcasecmp(encoding, BAD_CAST "UTF-8")) || 10345 (!xmlStrcasecmp(encoding, BAD_CAST "UTF8")))) { 10346 if (ctxt->encoding != NULL) 10347 xmlFree((xmlChar *) ctxt->encoding); 10348 ctxt->encoding = encoding; 10349 } 10350 else if (encoding != NULL) { 10351 xmlCharEncodingHandlerPtr handler; 10352 10353 if (ctxt->input->encoding != NULL) 10354 xmlFree((xmlChar *) ctxt->input->encoding); 10355 ctxt->input->encoding = encoding; 10356 10357 handler = xmlFindCharEncodingHandler((const char *) encoding); 10358 if (handler != NULL) { 10359 xmlSwitchToEncoding(ctxt, handler); 10360 } else { 10361 xmlFatalErrMsgStr(ctxt, XML_ERR_UNSUPPORTED_ENCODING, 10362 "Unsupported encoding %s\n", encoding); 10363 return(NULL); 10364 } 10365 } 10366 } 10367 return(encoding); 10368 } 10369 10370 /** 10371 * xmlParseSDDecl: 10372 * @ctxt: an XML parser context 10373 * 10374 * parse the XML standalone declaration 10375 * 10376 * [32] SDDecl ::= S 'standalone' Eq 10377 * (("'" ('yes' | 'no') "'") | ('"' ('yes' | 'no')'"')) 10378 * 10379 * [ VC: Standalone Document Declaration ] 10380 * TODO The standalone document declaration must have the value "no" 10381 * if any external markup declarations contain declarations of: 10382 * - attributes with default values, if elements to which these 10383 * attributes apply appear in the document without specifications 10384 * of values for these attributes, or 10385 * - entities (other than amp, lt, gt, apos, quot), if references 10386 * to those entities appear in the document, or 10387 * - attributes with values subject to normalization, where the 10388 * attribute appears in the document with a value which will change 10389 * as a result of normalization, or 10390 * - element types with element content, if white space occurs directly 10391 * within any instance of those types. 10392 * 10393 * Returns: 10394 * 1 if standalone="yes" 10395 * 0 if standalone="no" 10396 * -2 if standalone attribute is missing or invalid 10397 * (A standalone value of -2 means that the XML declaration was found, 10398 * but no value was specified for the standalone attribute). 10399 */ 10400 10401 int 10402 xmlParseSDDecl(xmlParserCtxtPtr ctxt) { 10403 int standalone = -2; 10404 10405 SKIP_BLANKS; 10406 if (CMP10(CUR_PTR, 's', 't', 'a', 'n', 'd', 'a', 'l', 'o', 'n', 'e')) { 10407 SKIP(10); 10408 SKIP_BLANKS; 10409 if (RAW != '=') { 10410 xmlFatalErr(ctxt, XML_ERR_EQUAL_REQUIRED, NULL); 10411 return(standalone); 10412 } 10413 NEXT; 10414 SKIP_BLANKS; 10415 if (RAW == '\''){ 10416 NEXT; 10417 if ((RAW == 'n') && (NXT(1) == 'o')) { 10418 standalone = 0; 10419 SKIP(2); 10420 } else if ((RAW == 'y') && (NXT(1) == 'e') && 10421 (NXT(2) == 's')) { 10422 standalone = 1; 10423 SKIP(3); 10424 } else { 10425 xmlFatalErr(ctxt, XML_ERR_STANDALONE_VALUE, NULL); 10426 } 10427 if (RAW != '\'') { 10428 xmlFatalErr(ctxt, XML_ERR_STRING_NOT_CLOSED, NULL); 10429 } else 10430 NEXT; 10431 } else if (RAW == '"'){ 10432 NEXT; 10433 if ((RAW == 'n') && (NXT(1) == 'o')) { 10434 standalone = 0; 10435 SKIP(2); 10436 } else if ((RAW == 'y') && (NXT(1) == 'e') && 10437 (NXT(2) == 's')) { 10438 standalone = 1; 10439 SKIP(3); 10440 } else { 10441 xmlFatalErr(ctxt, XML_ERR_STANDALONE_VALUE, NULL); 10442 } 10443 if (RAW != '"') { 10444 xmlFatalErr(ctxt, XML_ERR_STRING_NOT_CLOSED, NULL); 10445 } else 10446 NEXT; 10447 } else { 10448 xmlFatalErr(ctxt, XML_ERR_STRING_NOT_STARTED, NULL); 10449 } 10450 } 10451 return(standalone); 10452 } 10453 10454 /** 10455 * xmlParseXMLDecl: 10456 * @ctxt: an XML parser context 10457 * 10458 * parse an XML declaration header 10459 * 10460 * [23] XMLDecl ::= '<?xml' VersionInfo EncodingDecl? SDDecl? S? '?>' 10461 */ 10462 10463 void 10464 xmlParseXMLDecl(xmlParserCtxtPtr ctxt) { 10465 xmlChar *version; 10466 10467 /* 10468 * This value for standalone indicates that the document has an 10469 * XML declaration but it does not have a standalone attribute. 10470 * It will be overwritten later if a standalone attribute is found. 10471 */ 10472 ctxt->input->standalone = -2; 10473 10474 /* 10475 * We know that '<?xml' is here. 10476 */ 10477 SKIP(5); 10478 10479 if (!IS_BLANK_CH(RAW)) { 10480 xmlFatalErrMsg(ctxt, XML_ERR_SPACE_REQUIRED, 10481 "Blank needed after '<?xml'\n"); 10482 } 10483 SKIP_BLANKS; 10484 10485 /* 10486 * We must have the VersionInfo here. 10487 */ 10488 version = xmlParseVersionInfo(ctxt); 10489 if (version == NULL) { 10490 xmlFatalErr(ctxt, XML_ERR_VERSION_MISSING, NULL); 10491 } else { 10492 if (!xmlStrEqual(version, (const xmlChar *) XML_DEFAULT_VERSION)) { 10493 /* 10494 * Changed here for XML-1.0 5th edition 10495 */ 10496 if (ctxt->options & XML_PARSE_OLD10) { 10497 xmlFatalErrMsgStr(ctxt, XML_ERR_UNKNOWN_VERSION, 10498 "Unsupported version '%s'\n", 10499 version); 10500 } else { 10501 if ((version[0] == '1') && ((version[1] == '.'))) { 10502 xmlWarningMsg(ctxt, XML_WAR_UNKNOWN_VERSION, 10503 "Unsupported version '%s'\n", 10504 version, NULL); 10505 } else { 10506 xmlFatalErrMsgStr(ctxt, XML_ERR_UNKNOWN_VERSION, 10507 "Unsupported version '%s'\n", 10508 version); 10509 } 10510 } 10511 } 10512 if (ctxt->version != NULL) 10513 xmlFree((void *) ctxt->version); 10514 ctxt->version = version; 10515 } 10516 10517 /* 10518 * We may have the encoding declaration 10519 */ 10520 if (!IS_BLANK_CH(RAW)) { 10521 if ((RAW == '?') && (NXT(1) == '>')) { 10522 SKIP(2); 10523 return; 10524 } 10525 xmlFatalErrMsg(ctxt, XML_ERR_SPACE_REQUIRED, "Blank needed here\n"); 10526 } 10527 xmlParseEncodingDecl(ctxt); 10528 if (ctxt->errNo == XML_ERR_UNSUPPORTED_ENCODING) { 10529 /* 10530 * The XML REC instructs us to stop parsing right here 10531 */ 10532 return; 10533 } 10534 10535 /* 10536 * We may have the standalone status. 10537 */ 10538 if ((ctxt->input->encoding != NULL) && (!IS_BLANK_CH(RAW))) { 10539 if ((RAW == '?') && (NXT(1) == '>')) { 10540 SKIP(2); 10541 return; 10542 } 10543 xmlFatalErrMsg(ctxt, XML_ERR_SPACE_REQUIRED, "Blank needed here\n"); 10544 } 10545 10546 /* 10547 * We can grow the input buffer freely at that point 10548 */ 10549 GROW; 10550 10551 SKIP_BLANKS; 10552 ctxt->input->standalone = xmlParseSDDecl(ctxt); 10553 10554 SKIP_BLANKS; 10555 if ((RAW == '?') && (NXT(1) == '>')) { 10556 SKIP(2); 10557 } else if (RAW == '>') { 10558 /* Deprecated old WD ... */ 10559 xmlFatalErr(ctxt, XML_ERR_XMLDECL_NOT_FINISHED, NULL); 10560 NEXT; 10561 } else { 10562 xmlFatalErr(ctxt, XML_ERR_XMLDECL_NOT_FINISHED, NULL); 10563 MOVETO_ENDTAG(CUR_PTR); 10564 NEXT; 10565 } 10566 } 10567 10568 /** 10569 * xmlParseMisc: 10570 * @ctxt: an XML parser context 10571 * 10572 * parse an XML Misc* optional field. 10573 * 10574 * [27] Misc ::= Comment | PI | S 10575 */ 10576 10577 void 10578 xmlParseMisc(xmlParserCtxtPtr ctxt) { 10579 while ((ctxt->instate != XML_PARSER_EOF) && 10580 (((RAW == '<') && (NXT(1) == '?')) || 10581 (CMP4(CUR_PTR, '<', '!', '-', '-')) || 10582 IS_BLANK_CH(CUR))) { 10583 if ((RAW == '<') && (NXT(1) == '?')) { 10584 xmlParsePI(ctxt); 10585 } else if (IS_BLANK_CH(CUR)) { 10586 NEXT; 10587 } else 10588 xmlParseComment(ctxt); 10589 } 10590 } 10591 10592 /** 10593 * xmlParseDocument: 10594 * @ctxt: an XML parser context 10595 * 10596 * parse an XML document (and build a tree if using the standard SAX 10597 * interface). 10598 * 10599 * [1] document ::= prolog element Misc* 10600 * 10601 * [22] prolog ::= XMLDecl? Misc* (doctypedecl Misc*)? 10602 * 10603 * Returns 0, -1 in case of error. the parser context is augmented 10604 * as a result of the parsing. 10605 */ 10606 10607 int 10608 xmlParseDocument(xmlParserCtxtPtr ctxt) { 10609 xmlChar start[4]; 10610 xmlCharEncoding enc; 10611 10612 xmlInitParser(); 10613 10614 if ((ctxt == NULL) || (ctxt->input == NULL)) 10615 return(-1); 10616 10617 GROW; 10618 10619 /* 10620 * SAX: detecting the level. 10621 */ 10622 xmlDetectSAX2(ctxt); 10623 10624 /* 10625 * SAX: beginning of the document processing. 10626 */ 10627 if ((ctxt->sax) && (ctxt->sax->setDocumentLocator)) 10628 ctxt->sax->setDocumentLocator(ctxt->userData, &xmlDefaultSAXLocator); 10629 if (ctxt->instate == XML_PARSER_EOF) 10630 return(-1); 10631 10632 if ((ctxt->encoding == NULL) && 10633 ((ctxt->input->end - ctxt->input->cur) >= 4)) { 10634 /* 10635 * Get the 4 first bytes and decode the charset 10636 * if enc != XML_CHAR_ENCODING_NONE 10637 * plug some encoding conversion routines. 10638 */ 10639 start[0] = RAW; 10640 start[1] = NXT(1); 10641 start[2] = NXT(2); 10642 start[3] = NXT(3); 10643 enc = xmlDetectCharEncoding(&start[0], 4); 10644 if (enc != XML_CHAR_ENCODING_NONE) { 10645 xmlSwitchEncoding(ctxt, enc); 10646 } 10647 } 10648 10649 10650 if (CUR == 0) { 10651 xmlFatalErr(ctxt, XML_ERR_DOCUMENT_EMPTY, NULL); 10652 } 10653 10654 /* 10655 * Check for the XMLDecl in the Prolog. 10656 * do not GROW here to avoid the detected encoder to decode more 10657 * than just the first line, unless the amount of data is really 10658 * too small to hold "<?xml version="1.0" encoding="foo" 10659 */ 10660 if ((ctxt->input->end - ctxt->input->cur) < 35) { 10661 GROW; 10662 } 10663 if ((CMP5(CUR_PTR, '<', '?', 'x', 'm', 'l')) && (IS_BLANK_CH(NXT(5)))) { 10664 10665 /* 10666 * Note that we will switch encoding on the fly. 10667 */ 10668 xmlParseXMLDecl(ctxt); 10669 if (ctxt->errNo == XML_ERR_UNSUPPORTED_ENCODING) { 10670 /* 10671 * The XML REC instructs us to stop parsing right here 10672 */ 10673 return(-1); 10674 } 10675 ctxt->standalone = ctxt->input->standalone; 10676 SKIP_BLANKS; 10677 } else { 10678 ctxt->version = xmlCharStrdup(XML_DEFAULT_VERSION); 10679 } 10680 if ((ctxt->sax) && (ctxt->sax->startDocument) && (!ctxt->disableSAX)) 10681 ctxt->sax->startDocument(ctxt->userData); 10682 if (ctxt->instate == XML_PARSER_EOF) 10683 return(-1); 10684 10685 /* 10686 * The Misc part of the Prolog 10687 */ 10688 GROW; 10689 xmlParseMisc(ctxt); 10690 10691 /* 10692 * Then possibly doc type declaration(s) and more Misc 10693 * (doctypedecl Misc*)? 10694 */ 10695 GROW; 10696 if (CMP9(CUR_PTR, '<', '!', 'D', 'O', 'C', 'T', 'Y', 'P', 'E')) { 10697 10698 ctxt->inSubset = 1; 10699 xmlParseDocTypeDecl(ctxt); 10700 if (RAW == '[') { 10701 ctxt->instate = XML_PARSER_DTD; 10702 xmlParseInternalSubset(ctxt); 10703 if (ctxt->instate == XML_PARSER_EOF) 10704 return(-1); 10705 } 10706 10707 /* 10708 * Create and update the external subset. 10709 */ 10710 ctxt->inSubset = 2; 10711 if ((ctxt->sax != NULL) && (ctxt->sax->externalSubset != NULL) && 10712 (!ctxt->disableSAX)) 10713 ctxt->sax->externalSubset(ctxt->userData, ctxt->intSubName, 10714 ctxt->extSubSystem, ctxt->extSubURI); 10715 if (ctxt->instate == XML_PARSER_EOF) 10716 return(-1); 10717 ctxt->inSubset = 0; 10718 10719 xmlCleanSpecialAttr(ctxt); 10720 10721 ctxt->instate = XML_PARSER_PROLOG; 10722 xmlParseMisc(ctxt); 10723 } 10724 10725 /* 10726 * Time to start parsing the tree itself 10727 */ 10728 GROW; 10729 if (RAW != '<') { 10730 xmlFatalErrMsg(ctxt, XML_ERR_DOCUMENT_EMPTY, 10731 "Start tag expected, '<' not found\n"); 10732 } else { 10733 ctxt->instate = XML_PARSER_CONTENT; 10734 xmlParseElement(ctxt); 10735 ctxt->instate = XML_PARSER_EPILOG; 10736 10737 10738 /* 10739 * The Misc part at the end 10740 */ 10741 xmlParseMisc(ctxt); 10742 10743 if (RAW != 0) { 10744 xmlFatalErr(ctxt, XML_ERR_DOCUMENT_END, NULL); 10745 } 10746 ctxt->instate = XML_PARSER_EOF; 10747 } 10748 10749 /* 10750 * SAX: end of the document processing. 10751 */ 10752 if ((ctxt->sax) && (ctxt->sax->endDocument != NULL)) 10753 ctxt->sax->endDocument(ctxt->userData); 10754 10755 /* 10756 * Remove locally kept entity definitions if the tree was not built 10757 */ 10758 if ((ctxt->myDoc != NULL) && 10759 (xmlStrEqual(ctxt->myDoc->version, SAX_COMPAT_MODE))) { 10760 xmlFreeDoc(ctxt->myDoc); 10761 ctxt->myDoc = NULL; 10762 } 10763 10764 if ((ctxt->wellFormed) && (ctxt->myDoc != NULL)) { 10765 ctxt->myDoc->properties |= XML_DOC_WELLFORMED; 10766 if (ctxt->valid) 10767 ctxt->myDoc->properties |= XML_DOC_DTDVALID; 10768 if (ctxt->nsWellFormed) 10769 ctxt->myDoc->properties |= XML_DOC_NSVALID; 10770 if (ctxt->options & XML_PARSE_OLD10) 10771 ctxt->myDoc->properties |= XML_DOC_OLD10; 10772 } 10773 if (! ctxt->wellFormed) { 10774 ctxt->valid = 0; 10775 return(-1); 10776 } 10777 return(0); 10778 } 10779 10780 /** 10781 * xmlParseExtParsedEnt: 10782 * @ctxt: an XML parser context 10783 * 10784 * parse a general parsed entity 10785 * An external general parsed entity is well-formed if it matches the 10786 * production labeled extParsedEnt. 10787 * 10788 * [78] extParsedEnt ::= TextDecl? content 10789 * 10790 * Returns 0, -1 in case of error. the parser context is augmented 10791 * as a result of the parsing. 10792 */ 10793 10794 int 10795 xmlParseExtParsedEnt(xmlParserCtxtPtr ctxt) { 10796 xmlChar start[4]; 10797 xmlCharEncoding enc; 10798 10799 if ((ctxt == NULL) || (ctxt->input == NULL)) 10800 return(-1); 10801 10802 xmlDefaultSAXHandlerInit(); 10803 10804 xmlDetectSAX2(ctxt); 10805 10806 GROW; 10807 10808 /* 10809 * SAX: beginning of the document processing. 10810 */ 10811 if ((ctxt->sax) && (ctxt->sax->setDocumentLocator)) 10812 ctxt->sax->setDocumentLocator(ctxt->userData, &xmlDefaultSAXLocator); 10813 10814 /* 10815 * Get the 4 first bytes and decode the charset 10816 * if enc != XML_CHAR_ENCODING_NONE 10817 * plug some encoding conversion routines. 10818 */ 10819 if ((ctxt->input->end - ctxt->input->cur) >= 4) { 10820 start[0] = RAW; 10821 start[1] = NXT(1); 10822 start[2] = NXT(2); 10823 start[3] = NXT(3); 10824 enc = xmlDetectCharEncoding(start, 4); 10825 if (enc != XML_CHAR_ENCODING_NONE) { 10826 xmlSwitchEncoding(ctxt, enc); 10827 } 10828 } 10829 10830 10831 if (CUR == 0) { 10832 xmlFatalErr(ctxt, XML_ERR_DOCUMENT_EMPTY, NULL); 10833 } 10834 10835 /* 10836 * Check for the XMLDecl in the Prolog. 10837 */ 10838 GROW; 10839 if ((CMP5(CUR_PTR, '<', '?', 'x', 'm', 'l')) && (IS_BLANK_CH(NXT(5)))) { 10840 10841 /* 10842 * Note that we will switch encoding on the fly. 10843 */ 10844 xmlParseXMLDecl(ctxt); 10845 if (ctxt->errNo == XML_ERR_UNSUPPORTED_ENCODING) { 10846 /* 10847 * The XML REC instructs us to stop parsing right here 10848 */ 10849 return(-1); 10850 } 10851 SKIP_BLANKS; 10852 } else { 10853 ctxt->version = xmlCharStrdup(XML_DEFAULT_VERSION); 10854 } 10855 if ((ctxt->sax) && (ctxt->sax->startDocument) && (!ctxt->disableSAX)) 10856 ctxt->sax->startDocument(ctxt->userData); 10857 if (ctxt->instate == XML_PARSER_EOF) 10858 return(-1); 10859 10860 /* 10861 * Doing validity checking on chunk doesn't make sense 10862 */ 10863 ctxt->instate = XML_PARSER_CONTENT; 10864 ctxt->validate = 0; 10865 ctxt->loadsubset = 0; 10866 ctxt->depth = 0; 10867 10868 xmlParseContent(ctxt); 10869 if (ctxt->instate == XML_PARSER_EOF) 10870 return(-1); 10871 10872 if ((RAW == '<') && (NXT(1) == '/')) { 10873 xmlFatalErr(ctxt, XML_ERR_NOT_WELL_BALANCED, NULL); 10874 } else if (RAW != 0) { 10875 xmlFatalErr(ctxt, XML_ERR_EXTRA_CONTENT, NULL); 10876 } 10877 10878 /* 10879 * SAX: end of the document processing. 10880 */ 10881 if ((ctxt->sax) && (ctxt->sax->endDocument != NULL)) 10882 ctxt->sax->endDocument(ctxt->userData); 10883 10884 if (! ctxt->wellFormed) return(-1); 10885 return(0); 10886 } 10887 10888 #ifdef LIBXML_PUSH_ENABLED 10889 /************************************************************************ 10890 * * 10891 * Progressive parsing interfaces * 10892 * * 10893 ************************************************************************/ 10894 10895 /** 10896 * xmlParseLookupSequence: 10897 * @ctxt: an XML parser context 10898 * @first: the first char to lookup 10899 * @next: the next char to lookup or zero 10900 * @third: the next char to lookup or zero 10901 * 10902 * Try to find if a sequence (first, next, third) or just (first next) or 10903 * (first) is available in the input stream. 10904 * This function has a side effect of (possibly) incrementing ctxt->checkIndex 10905 * to avoid rescanning sequences of bytes, it DOES change the state of the 10906 * parser, do not use liberally. 10907 * 10908 * Returns the index to the current parsing point if the full sequence 10909 * is available, -1 otherwise. 10910 */ 10911 static int 10912 xmlParseLookupSequence(xmlParserCtxtPtr ctxt, xmlChar first, 10913 xmlChar next, xmlChar third) { 10914 int base, len; 10915 xmlParserInputPtr in; 10916 const xmlChar *buf; 10917 10918 in = ctxt->input; 10919 if (in == NULL) return(-1); 10920 base = in->cur - in->base; 10921 if (base < 0) return(-1); 10922 if (ctxt->checkIndex > base) 10923 base = ctxt->checkIndex; 10924 if (in->buf == NULL) { 10925 buf = in->base; 10926 len = in->length; 10927 } else { 10928 buf = xmlBufContent(in->buf->buffer); 10929 len = xmlBufUse(in->buf->buffer); 10930 } 10931 /* take into account the sequence length */ 10932 if (third) len -= 2; 10933 else if (next) len --; 10934 for (;base < len;base++) { 10935 if (buf[base] == first) { 10936 if (third != 0) { 10937 if ((buf[base + 1] != next) || 10938 (buf[base + 2] != third)) continue; 10939 } else if (next != 0) { 10940 if (buf[base + 1] != next) continue; 10941 } 10942 ctxt->checkIndex = 0; 10943 #ifdef DEBUG_PUSH 10944 if (next == 0) 10945 xmlGenericError(xmlGenericErrorContext, 10946 "PP: lookup '%c' found at %d\n", 10947 first, base); 10948 else if (third == 0) 10949 xmlGenericError(xmlGenericErrorContext, 10950 "PP: lookup '%c%c' found at %d\n", 10951 first, next, base); 10952 else 10953 xmlGenericError(xmlGenericErrorContext, 10954 "PP: lookup '%c%c%c' found at %d\n", 10955 first, next, third, base); 10956 #endif 10957 return(base - (in->cur - in->base)); 10958 } 10959 } 10960 ctxt->checkIndex = base; 10961 #ifdef DEBUG_PUSH 10962 if (next == 0) 10963 xmlGenericError(xmlGenericErrorContext, 10964 "PP: lookup '%c' failed\n", first); 10965 else if (third == 0) 10966 xmlGenericError(xmlGenericErrorContext, 10967 "PP: lookup '%c%c' failed\n", first, next); 10968 else 10969 xmlGenericError(xmlGenericErrorContext, 10970 "PP: lookup '%c%c%c' failed\n", first, next, third); 10971 #endif 10972 return(-1); 10973 } 10974 10975 /** 10976 * xmlParseGetLasts: 10977 * @ctxt: an XML parser context 10978 * @lastlt: pointer to store the last '<' from the input 10979 * @lastgt: pointer to store the last '>' from the input 10980 * 10981 * Lookup the last < and > in the current chunk 10982 */ 10983 static void 10984 xmlParseGetLasts(xmlParserCtxtPtr ctxt, const xmlChar **lastlt, 10985 const xmlChar **lastgt) { 10986 const xmlChar *tmp; 10987 10988 if ((ctxt == NULL) || (lastlt == NULL) || (lastgt == NULL)) { 10989 xmlGenericError(xmlGenericErrorContext, 10990 "Internal error: xmlParseGetLasts\n"); 10991 return; 10992 } 10993 if ((ctxt->progressive != 0) && (ctxt->inputNr == 1)) { 10994 tmp = ctxt->input->end; 10995 tmp--; 10996 while ((tmp >= ctxt->input->base) && (*tmp != '<')) tmp--; 10997 if (tmp < ctxt->input->base) { 10998 *lastlt = NULL; 10999 *lastgt = NULL; 11000 } else { 11001 *lastlt = tmp; 11002 tmp++; 11003 while ((tmp < ctxt->input->end) && (*tmp != '>')) { 11004 if (*tmp == '\'') { 11005 tmp++; 11006 while ((tmp < ctxt->input->end) && (*tmp != '\'')) tmp++; 11007 if (tmp < ctxt->input->end) tmp++; 11008 } else if (*tmp == '"') { 11009 tmp++; 11010 while ((tmp < ctxt->input->end) && (*tmp != '"')) tmp++; 11011 if (tmp < ctxt->input->end) tmp++; 11012 } else 11013 tmp++; 11014 } 11015 if (tmp < ctxt->input->end) 11016 *lastgt = tmp; 11017 else { 11018 tmp = *lastlt; 11019 tmp--; 11020 while ((tmp >= ctxt->input->base) && (*tmp != '>')) tmp--; 11021 if (tmp >= ctxt->input->base) 11022 *lastgt = tmp; 11023 else 11024 *lastgt = NULL; 11025 } 11026 } 11027 } else { 11028 *lastlt = NULL; 11029 *lastgt = NULL; 11030 } 11031 } 11032 /** 11033 * xmlCheckCdataPush: 11034 * @cur: pointer to the bock of characters 11035 * @len: length of the block in bytes 11036 * 11037 * Check that the block of characters is okay as SCdata content [20] 11038 * 11039 * Returns the number of bytes to pass if okay, a negative index where an 11040 * UTF-8 error occured otherwise 11041 */ 11042 static int 11043 xmlCheckCdataPush(const xmlChar *utf, int len) { 11044 int ix; 11045 unsigned char c; 11046 int codepoint; 11047 11048 if ((utf == NULL) || (len <= 0)) 11049 return(0); 11050 11051 for (ix = 0; ix < len;) { /* string is 0-terminated */ 11052 c = utf[ix]; 11053 if ((c & 0x80) == 0x00) { /* 1-byte code, starts with 10 */ 11054 if (c >= 0x20) 11055 ix++; 11056 else if ((c == 0xA) || (c == 0xD) || (c == 0x9)) 11057 ix++; 11058 else 11059 return(-ix); 11060 } else if ((c & 0xe0) == 0xc0) {/* 2-byte code, starts with 110 */ 11061 if (ix + 2 > len) return(ix); 11062 if ((utf[ix+1] & 0xc0 ) != 0x80) 11063 return(-ix); 11064 codepoint = (utf[ix] & 0x1f) << 6; 11065 codepoint |= utf[ix+1] & 0x3f; 11066 if (!xmlIsCharQ(codepoint)) 11067 return(-ix); 11068 ix += 2; 11069 } else if ((c & 0xf0) == 0xe0) {/* 3-byte code, starts with 1110 */ 11070 if (ix + 3 > len) return(ix); 11071 if (((utf[ix+1] & 0xc0) != 0x80) || 11072 ((utf[ix+2] & 0xc0) != 0x80)) 11073 return(-ix); 11074 codepoint = (utf[ix] & 0xf) << 12; 11075 codepoint |= (utf[ix+1] & 0x3f) << 6; 11076 codepoint |= utf[ix+2] & 0x3f; 11077 if (!xmlIsCharQ(codepoint)) 11078 return(-ix); 11079 ix += 3; 11080 } else if ((c & 0xf8) == 0xf0) {/* 4-byte code, starts with 11110 */ 11081 if (ix + 4 > len) return(ix); 11082 if (((utf[ix+1] & 0xc0) != 0x80) || 11083 ((utf[ix+2] & 0xc0) != 0x80) || 11084 ((utf[ix+3] & 0xc0) != 0x80)) 11085 return(-ix); 11086 codepoint = (utf[ix] & 0x7) << 18; 11087 codepoint |= (utf[ix+1] & 0x3f) << 12; 11088 codepoint |= (utf[ix+2] & 0x3f) << 6; 11089 codepoint |= utf[ix+3] & 0x3f; 11090 if (!xmlIsCharQ(codepoint)) 11091 return(-ix); 11092 ix += 4; 11093 } else /* unknown encoding */ 11094 return(-ix); 11095 } 11096 return(ix); 11097 } 11098 11099 /** 11100 * xmlParseTryOrFinish: 11101 * @ctxt: an XML parser context 11102 * @terminate: last chunk indicator 11103 * 11104 * Try to progress on parsing 11105 * 11106 * Returns zero if no parsing was possible 11107 */ 11108 static int 11109 xmlParseTryOrFinish(xmlParserCtxtPtr ctxt, int terminate) { 11110 int ret = 0; 11111 int avail, tlen; 11112 xmlChar cur, next; 11113 const xmlChar *lastlt, *lastgt; 11114 11115 if (ctxt->input == NULL) 11116 return(0); 11117 11118 #ifdef DEBUG_PUSH 11119 switch (ctxt->instate) { 11120 case XML_PARSER_EOF: 11121 xmlGenericError(xmlGenericErrorContext, 11122 "PP: try EOF\n"); break; 11123 case XML_PARSER_START: 11124 xmlGenericError(xmlGenericErrorContext, 11125 "PP: try START\n"); break; 11126 case XML_PARSER_MISC: 11127 xmlGenericError(xmlGenericErrorContext, 11128 "PP: try MISC\n");break; 11129 case XML_PARSER_COMMENT: 11130 xmlGenericError(xmlGenericErrorContext, 11131 "PP: try COMMENT\n");break; 11132 case XML_PARSER_PROLOG: 11133 xmlGenericError(xmlGenericErrorContext, 11134 "PP: try PROLOG\n");break; 11135 case XML_PARSER_START_TAG: 11136 xmlGenericError(xmlGenericErrorContext, 11137 "PP: try START_TAG\n");break; 11138 case XML_PARSER_CONTENT: 11139 xmlGenericError(xmlGenericErrorContext, 11140 "PP: try CONTENT\n");break; 11141 case XML_PARSER_CDATA_SECTION: 11142 xmlGenericError(xmlGenericErrorContext, 11143 "PP: try CDATA_SECTION\n");break; 11144 case XML_PARSER_END_TAG: 11145 xmlGenericError(xmlGenericErrorContext, 11146 "PP: try END_TAG\n");break; 11147 case XML_PARSER_ENTITY_DECL: 11148 xmlGenericError(xmlGenericErrorContext, 11149 "PP: try ENTITY_DECL\n");break; 11150 case XML_PARSER_ENTITY_VALUE: 11151 xmlGenericError(xmlGenericErrorContext, 11152 "PP: try ENTITY_VALUE\n");break; 11153 case XML_PARSER_ATTRIBUTE_VALUE: 11154 xmlGenericError(xmlGenericErrorContext, 11155 "PP: try ATTRIBUTE_VALUE\n");break; 11156 case XML_PARSER_DTD: 11157 xmlGenericError(xmlGenericErrorContext, 11158 "PP: try DTD\n");break; 11159 case XML_PARSER_EPILOG: 11160 xmlGenericError(xmlGenericErrorContext, 11161 "PP: try EPILOG\n");break; 11162 case XML_PARSER_PI: 11163 xmlGenericError(xmlGenericErrorContext, 11164 "PP: try PI\n");break; 11165 case XML_PARSER_IGNORE: 11166 xmlGenericError(xmlGenericErrorContext, 11167 "PP: try IGNORE\n");break; 11168 } 11169 #endif 11170 11171 if ((ctxt->input != NULL) && 11172 (ctxt->input->cur - ctxt->input->base > 4096)) { 11173 xmlSHRINK(ctxt); 11174 ctxt->checkIndex = 0; 11175 } 11176 xmlParseGetLasts(ctxt, &lastlt, &lastgt); 11177 11178 while (ctxt->instate != XML_PARSER_EOF) { 11179 if ((ctxt->errNo != XML_ERR_OK) && (ctxt->disableSAX == 1)) 11180 return(0); 11181 11182 11183 /* 11184 * Pop-up of finished entities. 11185 */ 11186 while ((RAW == 0) && (ctxt->inputNr > 1)) 11187 xmlPopInput(ctxt); 11188 11189 if (ctxt->input == NULL) break; 11190 if (ctxt->input->buf == NULL) 11191 avail = ctxt->input->length - 11192 (ctxt->input->cur - ctxt->input->base); 11193 else { 11194 /* 11195 * If we are operating on converted input, try to flush 11196 * remainng chars to avoid them stalling in the non-converted 11197 * buffer. But do not do this in document start where 11198 * encoding="..." may not have been read and we work on a 11199 * guessed encoding. 11200 */ 11201 if ((ctxt->instate != XML_PARSER_START) && 11202 (ctxt->input->buf->raw != NULL) && 11203 (xmlBufIsEmpty(ctxt->input->buf->raw) == 0)) { 11204 size_t base = xmlBufGetInputBase(ctxt->input->buf->buffer, 11205 ctxt->input); 11206 size_t current = ctxt->input->cur - ctxt->input->base; 11207 11208 xmlParserInputBufferPush(ctxt->input->buf, 0, ""); 11209 xmlBufSetInputBaseCur(ctxt->input->buf->buffer, ctxt->input, 11210 base, current); 11211 } 11212 avail = xmlBufUse(ctxt->input->buf->buffer) - 11213 (ctxt->input->cur - ctxt->input->base); 11214 } 11215 if (avail < 1) 11216 goto done; 11217 switch (ctxt->instate) { 11218 case XML_PARSER_EOF: 11219 /* 11220 * Document parsing is done ! 11221 */ 11222 goto done; 11223 case XML_PARSER_START: 11224 if (ctxt->charset == XML_CHAR_ENCODING_NONE) { 11225 xmlChar start[4]; 11226 xmlCharEncoding enc; 11227 11228 /* 11229 * Very first chars read from the document flow. 11230 */ 11231 if (avail < 4) 11232 goto done; 11233 11234 /* 11235 * Get the 4 first bytes and decode the charset 11236 * if enc != XML_CHAR_ENCODING_NONE 11237 * plug some encoding conversion routines, 11238 * else xmlSwitchEncoding will set to (default) 11239 * UTF8. 11240 */ 11241 start[0] = RAW; 11242 start[1] = NXT(1); 11243 start[2] = NXT(2); 11244 start[3] = NXT(3); 11245 enc = xmlDetectCharEncoding(start, 4); 11246 xmlSwitchEncoding(ctxt, enc); 11247 break; 11248 } 11249 11250 if (avail < 2) 11251 goto done; 11252 cur = ctxt->input->cur[0]; 11253 next = ctxt->input->cur[1]; 11254 if (cur == 0) { 11255 if ((ctxt->sax) && (ctxt->sax->setDocumentLocator)) 11256 ctxt->sax->setDocumentLocator(ctxt->userData, 11257 &xmlDefaultSAXLocator); 11258 xmlFatalErr(ctxt, XML_ERR_DOCUMENT_EMPTY, NULL); 11259 ctxt->instate = XML_PARSER_EOF; 11260 #ifdef DEBUG_PUSH 11261 xmlGenericError(xmlGenericErrorContext, 11262 "PP: entering EOF\n"); 11263 #endif 11264 if ((ctxt->sax) && (ctxt->sax->endDocument != NULL)) 11265 ctxt->sax->endDocument(ctxt->userData); 11266 goto done; 11267 } 11268 if ((cur == '<') && (next == '?')) { 11269 /* PI or XML decl */ 11270 if (avail < 5) return(ret); 11271 if ((!terminate) && 11272 (xmlParseLookupSequence(ctxt, '?', '>', 0) < 0)) 11273 return(ret); 11274 if ((ctxt->sax) && (ctxt->sax->setDocumentLocator)) 11275 ctxt->sax->setDocumentLocator(ctxt->userData, 11276 &xmlDefaultSAXLocator); 11277 if ((ctxt->input->cur[2] == 'x') && 11278 (ctxt->input->cur[3] == 'm') && 11279 (ctxt->input->cur[4] == 'l') && 11280 (IS_BLANK_CH(ctxt->input->cur[5]))) { 11281 ret += 5; 11282 #ifdef DEBUG_PUSH 11283 xmlGenericError(xmlGenericErrorContext, 11284 "PP: Parsing XML Decl\n"); 11285 #endif 11286 xmlParseXMLDecl(ctxt); 11287 if (ctxt->errNo == XML_ERR_UNSUPPORTED_ENCODING) { 11288 /* 11289 * The XML REC instructs us to stop parsing right 11290 * here 11291 */ 11292 ctxt->instate = XML_PARSER_EOF; 11293 return(0); 11294 } 11295 ctxt->standalone = ctxt->input->standalone; 11296 if ((ctxt->encoding == NULL) && 11297 (ctxt->input->encoding != NULL)) 11298 ctxt->encoding = xmlStrdup(ctxt->input->encoding); 11299 if ((ctxt->sax) && (ctxt->sax->startDocument) && 11300 (!ctxt->disableSAX)) 11301 ctxt->sax->startDocument(ctxt->userData); 11302 ctxt->instate = XML_PARSER_MISC; 11303 #ifdef DEBUG_PUSH 11304 xmlGenericError(xmlGenericErrorContext, 11305 "PP: entering MISC\n"); 11306 #endif 11307 } else { 11308 ctxt->version = xmlCharStrdup(XML_DEFAULT_VERSION); 11309 if ((ctxt->sax) && (ctxt->sax->startDocument) && 11310 (!ctxt->disableSAX)) 11311 ctxt->sax->startDocument(ctxt->userData); 11312 ctxt->instate = XML_PARSER_MISC; 11313 #ifdef DEBUG_PUSH 11314 xmlGenericError(xmlGenericErrorContext, 11315 "PP: entering MISC\n"); 11316 #endif 11317 } 11318 } else { 11319 if ((ctxt->sax) && (ctxt->sax->setDocumentLocator)) 11320 ctxt->sax->setDocumentLocator(ctxt->userData, 11321 &xmlDefaultSAXLocator); 11322 ctxt->version = xmlCharStrdup(XML_DEFAULT_VERSION); 11323 if (ctxt->version == NULL) { 11324 xmlErrMemory(ctxt, NULL); 11325 break; 11326 } 11327 if ((ctxt->sax) && (ctxt->sax->startDocument) && 11328 (!ctxt->disableSAX)) 11329 ctxt->sax->startDocument(ctxt->userData); 11330 ctxt->instate = XML_PARSER_MISC; 11331 #ifdef DEBUG_PUSH 11332 xmlGenericError(xmlGenericErrorContext, 11333 "PP: entering MISC\n"); 11334 #endif 11335 } 11336 break; 11337 case XML_PARSER_START_TAG: { 11338 const xmlChar *name; 11339 const xmlChar *prefix = NULL; 11340 const xmlChar *URI = NULL; 11341 int nsNr = ctxt->nsNr; 11342 11343 if ((avail < 2) && (ctxt->inputNr == 1)) 11344 goto done; 11345 cur = ctxt->input->cur[0]; 11346 if (cur != '<') { 11347 xmlFatalErr(ctxt, XML_ERR_DOCUMENT_EMPTY, NULL); 11348 ctxt->instate = XML_PARSER_EOF; 11349 if ((ctxt->sax) && (ctxt->sax->endDocument != NULL)) 11350 ctxt->sax->endDocument(ctxt->userData); 11351 goto done; 11352 } 11353 if (!terminate) { 11354 if (ctxt->progressive) { 11355 /* > can be found unescaped in attribute values */ 11356 if ((lastgt == NULL) || (ctxt->input->cur >= lastgt)) 11357 goto done; 11358 } else if (xmlParseLookupSequence(ctxt, '>', 0, 0) < 0) { 11359 goto done; 11360 } 11361 } 11362 if (ctxt->spaceNr == 0) 11363 spacePush(ctxt, -1); 11364 else if (*ctxt->space == -2) 11365 spacePush(ctxt, -1); 11366 else 11367 spacePush(ctxt, *ctxt->space); 11368 #ifdef LIBXML_SAX1_ENABLED 11369 if (ctxt->sax2) 11370 #endif /* LIBXML_SAX1_ENABLED */ 11371 name = xmlParseStartTag2(ctxt, &prefix, &URI, &tlen); 11372 #ifdef LIBXML_SAX1_ENABLED 11373 else 11374 name = xmlParseStartTag(ctxt); 11375 #endif /* LIBXML_SAX1_ENABLED */ 11376 if (ctxt->instate == XML_PARSER_EOF) 11377 goto done; 11378 if (name == NULL) { 11379 spacePop(ctxt); 11380 ctxt->instate = XML_PARSER_EOF; 11381 if ((ctxt->sax) && (ctxt->sax->endDocument != NULL)) 11382 ctxt->sax->endDocument(ctxt->userData); 11383 goto done; 11384 } 11385 #ifdef LIBXML_VALID_ENABLED 11386 /* 11387 * [ VC: Root Element Type ] 11388 * The Name in the document type declaration must match 11389 * the element type of the root element. 11390 */ 11391 if (ctxt->validate && ctxt->wellFormed && ctxt->myDoc && 11392 ctxt->node && (ctxt->node == ctxt->myDoc->children)) 11393 ctxt->valid &= xmlValidateRoot(&ctxt->vctxt, ctxt->myDoc); 11394 #endif /* LIBXML_VALID_ENABLED */ 11395 11396 /* 11397 * Check for an Empty Element. 11398 */ 11399 if ((RAW == '/') && (NXT(1) == '>')) { 11400 SKIP(2); 11401 11402 if (ctxt->sax2) { 11403 if ((ctxt->sax != NULL) && 11404 (ctxt->sax->endElementNs != NULL) && 11405 (!ctxt->disableSAX)) 11406 ctxt->sax->endElementNs(ctxt->userData, name, 11407 prefix, URI); 11408 if (ctxt->nsNr - nsNr > 0) 11409 nsPop(ctxt, ctxt->nsNr - nsNr); 11410 #ifdef LIBXML_SAX1_ENABLED 11411 } else { 11412 if ((ctxt->sax != NULL) && 11413 (ctxt->sax->endElement != NULL) && 11414 (!ctxt->disableSAX)) 11415 ctxt->sax->endElement(ctxt->userData, name); 11416 #endif /* LIBXML_SAX1_ENABLED */ 11417 } 11418 if (ctxt->instate == XML_PARSER_EOF) 11419 goto done; 11420 spacePop(ctxt); 11421 if (ctxt->nameNr == 0) { 11422 ctxt->instate = XML_PARSER_EPILOG; 11423 } else { 11424 ctxt->instate = XML_PARSER_CONTENT; 11425 } 11426 ctxt->progressive = 1; 11427 break; 11428 } 11429 if (RAW == '>') { 11430 NEXT; 11431 } else { 11432 xmlFatalErrMsgStr(ctxt, XML_ERR_GT_REQUIRED, 11433 "Couldn't find end of Start Tag %s\n", 11434 name); 11435 nodePop(ctxt); 11436 spacePop(ctxt); 11437 } 11438 if (ctxt->sax2) 11439 nameNsPush(ctxt, name, prefix, URI, ctxt->nsNr - nsNr); 11440 #ifdef LIBXML_SAX1_ENABLED 11441 else 11442 namePush(ctxt, name); 11443 #endif /* LIBXML_SAX1_ENABLED */ 11444 11445 ctxt->instate = XML_PARSER_CONTENT; 11446 ctxt->progressive = 1; 11447 break; 11448 } 11449 case XML_PARSER_CONTENT: { 11450 const xmlChar *test; 11451 unsigned int cons; 11452 if ((avail < 2) && (ctxt->inputNr == 1)) 11453 goto done; 11454 cur = ctxt->input->cur[0]; 11455 next = ctxt->input->cur[1]; 11456 11457 test = CUR_PTR; 11458 cons = ctxt->input->consumed; 11459 if ((cur == '<') && (next == '/')) { 11460 ctxt->instate = XML_PARSER_END_TAG; 11461 break; 11462 } else if ((cur == '<') && (next == '?')) { 11463 if ((!terminate) && 11464 (xmlParseLookupSequence(ctxt, '?', '>', 0) < 0)) { 11465 ctxt->progressive = XML_PARSER_PI; 11466 goto done; 11467 } 11468 xmlParsePI(ctxt); 11469 ctxt->instate = XML_PARSER_CONTENT; 11470 ctxt->progressive = 1; 11471 } else if ((cur == '<') && (next != '!')) { 11472 ctxt->instate = XML_PARSER_START_TAG; 11473 break; 11474 } else if ((cur == '<') && (next == '!') && 11475 (ctxt->input->cur[2] == '-') && 11476 (ctxt->input->cur[3] == '-')) { 11477 int term; 11478 11479 if (avail < 4) 11480 goto done; 11481 ctxt->input->cur += 4; 11482 term = xmlParseLookupSequence(ctxt, '-', '-', '>'); 11483 ctxt->input->cur -= 4; 11484 if ((!terminate) && (term < 0)) { 11485 ctxt->progressive = XML_PARSER_COMMENT; 11486 goto done; 11487 } 11488 xmlParseComment(ctxt); 11489 ctxt->instate = XML_PARSER_CONTENT; 11490 ctxt->progressive = 1; 11491 } else if ((cur == '<') && (ctxt->input->cur[1] == '!') && 11492 (ctxt->input->cur[2] == '[') && 11493 (ctxt->input->cur[3] == 'C') && 11494 (ctxt->input->cur[4] == 'D') && 11495 (ctxt->input->cur[5] == 'A') && 11496 (ctxt->input->cur[6] == 'T') && 11497 (ctxt->input->cur[7] == 'A') && 11498 (ctxt->input->cur[8] == '[')) { 11499 SKIP(9); 11500 ctxt->instate = XML_PARSER_CDATA_SECTION; 11501 break; 11502 } else if ((cur == '<') && (next == '!') && 11503 (avail < 9)) { 11504 goto done; 11505 } else if (cur == '&') { 11506 if ((!terminate) && 11507 (xmlParseLookupSequence(ctxt, ';', 0, 0) < 0)) 11508 goto done; 11509 xmlParseReference(ctxt); 11510 } else { 11511 /* TODO Avoid the extra copy, handle directly !!! */ 11512 /* 11513 * Goal of the following test is: 11514 * - minimize calls to the SAX 'character' callback 11515 * when they are mergeable 11516 * - handle an problem for isBlank when we only parse 11517 * a sequence of blank chars and the next one is 11518 * not available to check against '<' presence. 11519 * - tries to homogenize the differences in SAX 11520 * callbacks between the push and pull versions 11521 * of the parser. 11522 */ 11523 if ((ctxt->inputNr == 1) && 11524 (avail < XML_PARSER_BIG_BUFFER_SIZE)) { 11525 if (!terminate) { 11526 if (ctxt->progressive) { 11527 if ((lastlt == NULL) || 11528 (ctxt->input->cur > lastlt)) 11529 goto done; 11530 } else if (xmlParseLookupSequence(ctxt, 11531 '<', 0, 0) < 0) { 11532 goto done; 11533 } 11534 } 11535 } 11536 ctxt->checkIndex = 0; 11537 xmlParseCharData(ctxt, 0); 11538 } 11539 /* 11540 * Pop-up of finished entities. 11541 */ 11542 while ((RAW == 0) && (ctxt->inputNr > 1)) 11543 xmlPopInput(ctxt); 11544 if ((cons == ctxt->input->consumed) && (test == CUR_PTR)) { 11545 xmlFatalErr(ctxt, XML_ERR_INTERNAL_ERROR, 11546 "detected an error in element content\n"); 11547 ctxt->instate = XML_PARSER_EOF; 11548 break; 11549 } 11550 break; 11551 } 11552 case XML_PARSER_END_TAG: 11553 if (avail < 2) 11554 goto done; 11555 if (!terminate) { 11556 if (ctxt->progressive) { 11557 /* > can be found unescaped in attribute values */ 11558 if ((lastgt == NULL) || (ctxt->input->cur >= lastgt)) 11559 goto done; 11560 } else if (xmlParseLookupSequence(ctxt, '>', 0, 0) < 0) { 11561 goto done; 11562 } 11563 } 11564 if (ctxt->sax2) { 11565 xmlParseEndTag2(ctxt, 11566 (void *) ctxt->pushTab[ctxt->nameNr * 3 - 3], 11567 (void *) ctxt->pushTab[ctxt->nameNr * 3 - 2], 0, 11568 (int) (long) ctxt->pushTab[ctxt->nameNr * 3 - 1], 0); 11569 nameNsPop(ctxt); 11570 } 11571 #ifdef LIBXML_SAX1_ENABLED 11572 else 11573 xmlParseEndTag1(ctxt, 0); 11574 #endif /* LIBXML_SAX1_ENABLED */ 11575 if (ctxt->instate == XML_PARSER_EOF) { 11576 /* Nothing */ 11577 } else if (ctxt->nameNr == 0) { 11578 ctxt->instate = XML_PARSER_EPILOG; 11579 } else { 11580 ctxt->instate = XML_PARSER_CONTENT; 11581 } 11582 break; 11583 case XML_PARSER_CDATA_SECTION: { 11584 /* 11585 * The Push mode need to have the SAX callback for 11586 * cdataBlock merge back contiguous callbacks. 11587 */ 11588 int base; 11589 11590 base = xmlParseLookupSequence(ctxt, ']', ']', '>'); 11591 if (base < 0) { 11592 if (avail >= XML_PARSER_BIG_BUFFER_SIZE + 2) { 11593 int tmp; 11594 11595 tmp = xmlCheckCdataPush(ctxt->input->cur, 11596 XML_PARSER_BIG_BUFFER_SIZE); 11597 if (tmp < 0) { 11598 tmp = -tmp; 11599 ctxt->input->cur += tmp; 11600 goto encoding_error; 11601 } 11602 if ((ctxt->sax != NULL) && (!ctxt->disableSAX)) { 11603 if (ctxt->sax->cdataBlock != NULL) 11604 ctxt->sax->cdataBlock(ctxt->userData, 11605 ctxt->input->cur, tmp); 11606 else if (ctxt->sax->characters != NULL) 11607 ctxt->sax->characters(ctxt->userData, 11608 ctxt->input->cur, tmp); 11609 } 11610 if (ctxt->instate == XML_PARSER_EOF) 11611 goto done; 11612 SKIPL(tmp); 11613 ctxt->checkIndex = 0; 11614 } 11615 goto done; 11616 } else { 11617 int tmp; 11618 11619 tmp = xmlCheckCdataPush(ctxt->input->cur, base); 11620 if ((tmp < 0) || (tmp != base)) { 11621 tmp = -tmp; 11622 ctxt->input->cur += tmp; 11623 goto encoding_error; 11624 } 11625 if ((ctxt->sax != NULL) && (base == 0) && 11626 (ctxt->sax->cdataBlock != NULL) && 11627 (!ctxt->disableSAX)) { 11628 /* 11629 * Special case to provide identical behaviour 11630 * between pull and push parsers on enpty CDATA 11631 * sections 11632 */ 11633 if ((ctxt->input->cur - ctxt->input->base >= 9) && 11634 (!strncmp((const char *)&ctxt->input->cur[-9], 11635 "<![CDATA[", 9))) 11636 ctxt->sax->cdataBlock(ctxt->userData, 11637 BAD_CAST "", 0); 11638 } else if ((ctxt->sax != NULL) && (base > 0) && 11639 (!ctxt->disableSAX)) { 11640 if (ctxt->sax->cdataBlock != NULL) 11641 ctxt->sax->cdataBlock(ctxt->userData, 11642 ctxt->input->cur, base); 11643 else if (ctxt->sax->characters != NULL) 11644 ctxt->sax->characters(ctxt->userData, 11645 ctxt->input->cur, base); 11646 } 11647 if (ctxt->instate == XML_PARSER_EOF) 11648 goto done; 11649 SKIPL(base + 3); 11650 ctxt->checkIndex = 0; 11651 ctxt->instate = XML_PARSER_CONTENT; 11652 #ifdef DEBUG_PUSH 11653 xmlGenericError(xmlGenericErrorContext, 11654 "PP: entering CONTENT\n"); 11655 #endif 11656 } 11657 break; 11658 } 11659 case XML_PARSER_MISC: 11660 SKIP_BLANKS; 11661 if (ctxt->input->buf == NULL) 11662 avail = ctxt->input->length - 11663 (ctxt->input->cur - ctxt->input->base); 11664 else 11665 avail = xmlBufUse(ctxt->input->buf->buffer) - 11666 (ctxt->input->cur - ctxt->input->base); 11667 if (avail < 2) 11668 goto done; 11669 cur = ctxt->input->cur[0]; 11670 next = ctxt->input->cur[1]; 11671 if ((cur == '<') && (next == '?')) { 11672 if ((!terminate) && 11673 (xmlParseLookupSequence(ctxt, '?', '>', 0) < 0)) { 11674 ctxt->progressive = XML_PARSER_PI; 11675 goto done; 11676 } 11677 #ifdef DEBUG_PUSH 11678 xmlGenericError(xmlGenericErrorContext, 11679 "PP: Parsing PI\n"); 11680 #endif 11681 xmlParsePI(ctxt); 11682 if (ctxt->instate == XML_PARSER_EOF) 11683 goto done; 11684 ctxt->instate = XML_PARSER_MISC; 11685 ctxt->progressive = 1; 11686 ctxt->checkIndex = 0; 11687 } else if ((cur == '<') && (next == '!') && 11688 (ctxt->input->cur[2] == '-') && 11689 (ctxt->input->cur[3] == '-')) { 11690 if ((!terminate) && 11691 (xmlParseLookupSequence(ctxt, '-', '-', '>') < 0)) { 11692 ctxt->progressive = XML_PARSER_COMMENT; 11693 goto done; 11694 } 11695 #ifdef DEBUG_PUSH 11696 xmlGenericError(xmlGenericErrorContext, 11697 "PP: Parsing Comment\n"); 11698 #endif 11699 xmlParseComment(ctxt); 11700 if (ctxt->instate == XML_PARSER_EOF) 11701 goto done; 11702 ctxt->instate = XML_PARSER_MISC; 11703 ctxt->progressive = 1; 11704 ctxt->checkIndex = 0; 11705 } else if ((cur == '<') && (next == '!') && 11706 (ctxt->input->cur[2] == 'D') && 11707 (ctxt->input->cur[3] == 'O') && 11708 (ctxt->input->cur[4] == 'C') && 11709 (ctxt->input->cur[5] == 'T') && 11710 (ctxt->input->cur[6] == 'Y') && 11711 (ctxt->input->cur[7] == 'P') && 11712 (ctxt->input->cur[8] == 'E')) { 11713 if ((!terminate) && 11714 (xmlParseLookupSequence(ctxt, '>', 0, 0) < 0)) { 11715 ctxt->progressive = XML_PARSER_DTD; 11716 goto done; 11717 } 11718 #ifdef DEBUG_PUSH 11719 xmlGenericError(xmlGenericErrorContext, 11720 "PP: Parsing internal subset\n"); 11721 #endif 11722 ctxt->inSubset = 1; 11723 ctxt->progressive = 0; 11724 ctxt->checkIndex = 0; 11725 xmlParseDocTypeDecl(ctxt); 11726 if (ctxt->instate == XML_PARSER_EOF) 11727 goto done; 11728 if (RAW == '[') { 11729 ctxt->instate = XML_PARSER_DTD; 11730 #ifdef DEBUG_PUSH 11731 xmlGenericError(xmlGenericErrorContext, 11732 "PP: entering DTD\n"); 11733 #endif 11734 } else { 11735 /* 11736 * Create and update the external subset. 11737 */ 11738 ctxt->inSubset = 2; 11739 if ((ctxt->sax != NULL) && (!ctxt->disableSAX) && 11740 (ctxt->sax->externalSubset != NULL)) 11741 ctxt->sax->externalSubset(ctxt->userData, 11742 ctxt->intSubName, ctxt->extSubSystem, 11743 ctxt->extSubURI); 11744 ctxt->inSubset = 0; 11745 xmlCleanSpecialAttr(ctxt); 11746 ctxt->instate = XML_PARSER_PROLOG; 11747 #ifdef DEBUG_PUSH 11748 xmlGenericError(xmlGenericErrorContext, 11749 "PP: entering PROLOG\n"); 11750 #endif 11751 } 11752 } else if ((cur == '<') && (next == '!') && 11753 (avail < 9)) { 11754 goto done; 11755 } else { 11756 ctxt->instate = XML_PARSER_START_TAG; 11757 ctxt->progressive = XML_PARSER_START_TAG; 11758 xmlParseGetLasts(ctxt, &lastlt, &lastgt); 11759 #ifdef DEBUG_PUSH 11760 xmlGenericError(xmlGenericErrorContext, 11761 "PP: entering START_TAG\n"); 11762 #endif 11763 } 11764 break; 11765 case XML_PARSER_PROLOG: 11766 SKIP_BLANKS; 11767 if (ctxt->input->buf == NULL) 11768 avail = ctxt->input->length - (ctxt->input->cur - ctxt->input->base); 11769 else 11770 avail = xmlBufUse(ctxt->input->buf->buffer) - 11771 (ctxt->input->cur - ctxt->input->base); 11772 if (avail < 2) 11773 goto done; 11774 cur = ctxt->input->cur[0]; 11775 next = ctxt->input->cur[1]; 11776 if ((cur == '<') && (next == '?')) { 11777 if ((!terminate) && 11778 (xmlParseLookupSequence(ctxt, '?', '>', 0) < 0)) { 11779 ctxt->progressive = XML_PARSER_PI; 11780 goto done; 11781 } 11782 #ifdef DEBUG_PUSH 11783 xmlGenericError(xmlGenericErrorContext, 11784 "PP: Parsing PI\n"); 11785 #endif 11786 xmlParsePI(ctxt); 11787 if (ctxt->instate == XML_PARSER_EOF) 11788 goto done; 11789 ctxt->instate = XML_PARSER_PROLOG; 11790 ctxt->progressive = 1; 11791 } else if ((cur == '<') && (next == '!') && 11792 (ctxt->input->cur[2] == '-') && (ctxt->input->cur[3] == '-')) { 11793 if ((!terminate) && 11794 (xmlParseLookupSequence(ctxt, '-', '-', '>') < 0)) { 11795 ctxt->progressive = XML_PARSER_COMMENT; 11796 goto done; 11797 } 11798 #ifdef DEBUG_PUSH 11799 xmlGenericError(xmlGenericErrorContext, 11800 "PP: Parsing Comment\n"); 11801 #endif 11802 xmlParseComment(ctxt); 11803 if (ctxt->instate == XML_PARSER_EOF) 11804 goto done; 11805 ctxt->instate = XML_PARSER_PROLOG; 11806 ctxt->progressive = 1; 11807 } else if ((cur == '<') && (next == '!') && 11808 (avail < 4)) { 11809 goto done; 11810 } else { 11811 ctxt->instate = XML_PARSER_START_TAG; 11812 if (ctxt->progressive == 0) 11813 ctxt->progressive = XML_PARSER_START_TAG; 11814 xmlParseGetLasts(ctxt, &lastlt, &lastgt); 11815 #ifdef DEBUG_PUSH 11816 xmlGenericError(xmlGenericErrorContext, 11817 "PP: entering START_TAG\n"); 11818 #endif 11819 } 11820 break; 11821 case XML_PARSER_EPILOG: 11822 SKIP_BLANKS; 11823 if (ctxt->input->buf == NULL) 11824 avail = ctxt->input->length - (ctxt->input->cur - ctxt->input->base); 11825 else 11826 avail = xmlBufUse(ctxt->input->buf->buffer) - 11827 (ctxt->input->cur - ctxt->input->base); 11828 if (avail < 2) 11829 goto done; 11830 cur = ctxt->input->cur[0]; 11831 next = ctxt->input->cur[1]; 11832 if ((cur == '<') && (next == '?')) { 11833 if ((!terminate) && 11834 (xmlParseLookupSequence(ctxt, '?', '>', 0) < 0)) { 11835 ctxt->progressive = XML_PARSER_PI; 11836 goto done; 11837 } 11838 #ifdef DEBUG_PUSH 11839 xmlGenericError(xmlGenericErrorContext, 11840 "PP: Parsing PI\n"); 11841 #endif 11842 xmlParsePI(ctxt); 11843 if (ctxt->instate == XML_PARSER_EOF) 11844 goto done; 11845 ctxt->instate = XML_PARSER_EPILOG; 11846 ctxt->progressive = 1; 11847 } else if ((cur == '<') && (next == '!') && 11848 (ctxt->input->cur[2] == '-') && (ctxt->input->cur[3] == '-')) { 11849 if ((!terminate) && 11850 (xmlParseLookupSequence(ctxt, '-', '-', '>') < 0)) { 11851 ctxt->progressive = XML_PARSER_COMMENT; 11852 goto done; 11853 } 11854 #ifdef DEBUG_PUSH 11855 xmlGenericError(xmlGenericErrorContext, 11856 "PP: Parsing Comment\n"); 11857 #endif 11858 xmlParseComment(ctxt); 11859 if (ctxt->instate == XML_PARSER_EOF) 11860 goto done; 11861 ctxt->instate = XML_PARSER_EPILOG; 11862 ctxt->progressive = 1; 11863 } else if ((cur == '<') && (next == '!') && 11864 (avail < 4)) { 11865 goto done; 11866 } else { 11867 xmlFatalErr(ctxt, XML_ERR_DOCUMENT_END, NULL); 11868 ctxt->instate = XML_PARSER_EOF; 11869 #ifdef DEBUG_PUSH 11870 xmlGenericError(xmlGenericErrorContext, 11871 "PP: entering EOF\n"); 11872 #endif 11873 if ((ctxt->sax) && (ctxt->sax->endDocument != NULL)) 11874 ctxt->sax->endDocument(ctxt->userData); 11875 goto done; 11876 } 11877 break; 11878 case XML_PARSER_DTD: { 11879 /* 11880 * Sorry but progressive parsing of the internal subset 11881 * is not expected to be supported. We first check that 11882 * the full content of the internal subset is available and 11883 * the parsing is launched only at that point. 11884 * Internal subset ends up with "']' S? '>'" in an unescaped 11885 * section and not in a ']]>' sequence which are conditional 11886 * sections (whoever argued to keep that crap in XML deserve 11887 * a place in hell !). 11888 */ 11889 int base, i; 11890 xmlChar *buf; 11891 xmlChar quote = 0; 11892 size_t use; 11893 11894 base = ctxt->input->cur - ctxt->input->base; 11895 if (base < 0) return(0); 11896 if (ctxt->checkIndex > base) 11897 base = ctxt->checkIndex; 11898 buf = xmlBufContent(ctxt->input->buf->buffer); 11899 use = xmlBufUse(ctxt->input->buf->buffer); 11900 for (;(unsigned int) base < use; base++) { 11901 if (quote != 0) { 11902 if (buf[base] == quote) 11903 quote = 0; 11904 continue; 11905 } 11906 if ((quote == 0) && (buf[base] == '<')) { 11907 int found = 0; 11908 /* special handling of comments */ 11909 if (((unsigned int) base + 4 < use) && 11910 (buf[base + 1] == '!') && 11911 (buf[base + 2] == '-') && 11912 (buf[base + 3] == '-')) { 11913 for (;(unsigned int) base + 3 < use; base++) { 11914 if ((buf[base] == '-') && 11915 (buf[base + 1] == '-') && 11916 (buf[base + 2] == '>')) { 11917 found = 1; 11918 base += 2; 11919 break; 11920 } 11921 } 11922 if (!found) { 11923 #if 0 11924 fprintf(stderr, "unfinished comment\n"); 11925 #endif 11926 break; /* for */ 11927 } 11928 continue; 11929 } 11930 } 11931 if (buf[base] == '"') { 11932 quote = '"'; 11933 continue; 11934 } 11935 if (buf[base] == '\'') { 11936 quote = '\''; 11937 continue; 11938 } 11939 if (buf[base] == ']') { 11940 #if 0 11941 fprintf(stderr, "%c%c%c%c: ", buf[base], 11942 buf[base + 1], buf[base + 2], buf[base + 3]); 11943 #endif 11944 if ((unsigned int) base +1 >= use) 11945 break; 11946 if (buf[base + 1] == ']') { 11947 /* conditional crap, skip both ']' ! */ 11948 base++; 11949 continue; 11950 } 11951 for (i = 1; (unsigned int) base + i < use; i++) { 11952 if (buf[base + i] == '>') { 11953 #if 0 11954 fprintf(stderr, "found\n"); 11955 #endif 11956 goto found_end_int_subset; 11957 } 11958 if (!IS_BLANK_CH(buf[base + i])) { 11959 #if 0 11960 fprintf(stderr, "not found\n"); 11961 #endif 11962 goto not_end_of_int_subset; 11963 } 11964 } 11965 #if 0 11966 fprintf(stderr, "end of stream\n"); 11967 #endif 11968 break; 11969 11970 } 11971 not_end_of_int_subset: 11972 continue; /* for */ 11973 } 11974 /* 11975 * We didn't found the end of the Internal subset 11976 */ 11977 if (quote == 0) 11978 ctxt->checkIndex = base; 11979 else 11980 ctxt->checkIndex = 0; 11981 #ifdef DEBUG_PUSH 11982 if (next == 0) 11983 xmlGenericError(xmlGenericErrorContext, 11984 "PP: lookup of int subset end filed\n"); 11985 #endif 11986 goto done; 11987 11988 found_end_int_subset: 11989 ctxt->checkIndex = 0; 11990 xmlParseInternalSubset(ctxt); 11991 if (ctxt->instate == XML_PARSER_EOF) 11992 goto done; 11993 ctxt->inSubset = 2; 11994 if ((ctxt->sax != NULL) && (!ctxt->disableSAX) && 11995 (ctxt->sax->externalSubset != NULL)) 11996 ctxt->sax->externalSubset(ctxt->userData, ctxt->intSubName, 11997 ctxt->extSubSystem, ctxt->extSubURI); 11998 ctxt->inSubset = 0; 11999 xmlCleanSpecialAttr(ctxt); 12000 if (ctxt->instate == XML_PARSER_EOF) 12001 goto done; 12002 ctxt->instate = XML_PARSER_PROLOG; 12003 ctxt->checkIndex = 0; 12004 #ifdef DEBUG_PUSH 12005 xmlGenericError(xmlGenericErrorContext, 12006 "PP: entering PROLOG\n"); 12007 #endif 12008 break; 12009 } 12010 case XML_PARSER_COMMENT: 12011 xmlGenericError(xmlGenericErrorContext, 12012 "PP: internal error, state == COMMENT\n"); 12013 ctxt->instate = XML_PARSER_CONTENT; 12014 #ifdef DEBUG_PUSH 12015 xmlGenericError(xmlGenericErrorContext, 12016 "PP: entering CONTENT\n"); 12017 #endif 12018 break; 12019 case XML_PARSER_IGNORE: 12020 xmlGenericError(xmlGenericErrorContext, 12021 "PP: internal error, state == IGNORE"); 12022 ctxt->instate = XML_PARSER_DTD; 12023 #ifdef DEBUG_PUSH 12024 xmlGenericError(xmlGenericErrorContext, 12025 "PP: entering DTD\n"); 12026 #endif 12027 break; 12028 case XML_PARSER_PI: 12029 xmlGenericError(xmlGenericErrorContext, 12030 "PP: internal error, state == PI\n"); 12031 ctxt->instate = XML_PARSER_CONTENT; 12032 #ifdef DEBUG_PUSH 12033 xmlGenericError(xmlGenericErrorContext, 12034 "PP: entering CONTENT\n"); 12035 #endif 12036 break; 12037 case XML_PARSER_ENTITY_DECL: 12038 xmlGenericError(xmlGenericErrorContext, 12039 "PP: internal error, state == ENTITY_DECL\n"); 12040 ctxt->instate = XML_PARSER_DTD; 12041 #ifdef DEBUG_PUSH 12042 xmlGenericError(xmlGenericErrorContext, 12043 "PP: entering DTD\n"); 12044 #endif 12045 break; 12046 case XML_PARSER_ENTITY_VALUE: 12047 xmlGenericError(xmlGenericErrorContext, 12048 "PP: internal error, state == ENTITY_VALUE\n"); 12049 ctxt->instate = XML_PARSER_CONTENT; 12050 #ifdef DEBUG_PUSH 12051 xmlGenericError(xmlGenericErrorContext, 12052 "PP: entering DTD\n"); 12053 #endif 12054 break; 12055 case XML_PARSER_ATTRIBUTE_VALUE: 12056 xmlGenericError(xmlGenericErrorContext, 12057 "PP: internal error, state == ATTRIBUTE_VALUE\n"); 12058 ctxt->instate = XML_PARSER_START_TAG; 12059 #ifdef DEBUG_PUSH 12060 xmlGenericError(xmlGenericErrorContext, 12061 "PP: entering START_TAG\n"); 12062 #endif 12063 break; 12064 case XML_PARSER_SYSTEM_LITERAL: 12065 xmlGenericError(xmlGenericErrorContext, 12066 "PP: internal error, state == SYSTEM_LITERAL\n"); 12067 ctxt->instate = XML_PARSER_START_TAG; 12068 #ifdef DEBUG_PUSH 12069 xmlGenericError(xmlGenericErrorContext, 12070 "PP: entering START_TAG\n"); 12071 #endif 12072 break; 12073 case XML_PARSER_PUBLIC_LITERAL: 12074 xmlGenericError(xmlGenericErrorContext, 12075 "PP: internal error, state == PUBLIC_LITERAL\n"); 12076 ctxt->instate = XML_PARSER_START_TAG; 12077 #ifdef DEBUG_PUSH 12078 xmlGenericError(xmlGenericErrorContext, 12079 "PP: entering START_TAG\n"); 12080 #endif 12081 break; 12082 } 12083 } 12084 done: 12085 #ifdef DEBUG_PUSH 12086 xmlGenericError(xmlGenericErrorContext, "PP: done %d\n", ret); 12087 #endif 12088 return(ret); 12089 encoding_error: 12090 { 12091 char buffer[150]; 12092 12093 snprintf(buffer, 149, "Bytes: 0x%02X 0x%02X 0x%02X 0x%02X\n", 12094 ctxt->input->cur[0], ctxt->input->cur[1], 12095 ctxt->input->cur[2], ctxt->input->cur[3]); 12096 __xmlErrEncoding(ctxt, XML_ERR_INVALID_CHAR, 12097 "Input is not proper UTF-8, indicate encoding !\n%s", 12098 BAD_CAST buffer, NULL); 12099 } 12100 return(0); 12101 } 12102 12103 /** 12104 * xmlParseCheckTransition: 12105 * @ctxt: an XML parser context 12106 * @chunk: a char array 12107 * @size: the size in byte of the chunk 12108 * 12109 * Check depending on the current parser state if the chunk given must be 12110 * processed immediately or one need more data to advance on parsing. 12111 * 12112 * Returns -1 in case of error, 0 if the push is not needed and 1 if needed 12113 */ 12114 static int 12115 xmlParseCheckTransition(xmlParserCtxtPtr ctxt, const char *chunk, int size) { 12116 if ((ctxt == NULL) || (chunk == NULL) || (size < 0)) 12117 return(-1); 12118 if (ctxt->instate == XML_PARSER_START_TAG) { 12119 if (memchr(chunk, '>', size) != NULL) 12120 return(1); 12121 return(0); 12122 } 12123 if (ctxt->progressive == XML_PARSER_COMMENT) { 12124 if (memchr(chunk, '>', size) != NULL) 12125 return(1); 12126 return(0); 12127 } 12128 if (ctxt->instate == XML_PARSER_CDATA_SECTION) { 12129 if (memchr(chunk, '>', size) != NULL) 12130 return(1); 12131 return(0); 12132 } 12133 if (ctxt->progressive == XML_PARSER_PI) { 12134 if (memchr(chunk, '>', size) != NULL) 12135 return(1); 12136 return(0); 12137 } 12138 if (ctxt->instate == XML_PARSER_END_TAG) { 12139 if (memchr(chunk, '>', size) != NULL) 12140 return(1); 12141 return(0); 12142 } 12143 if ((ctxt->progressive == XML_PARSER_DTD) || 12144 (ctxt->instate == XML_PARSER_DTD)) { 12145 if (memchr(chunk, '>', size) != NULL) 12146 return(1); 12147 return(0); 12148 } 12149 return(1); 12150 } 12151 12152 /** 12153 * xmlParseChunk: 12154 * @ctxt: an XML parser context 12155 * @chunk: an char array 12156 * @size: the size in byte of the chunk 12157 * @terminate: last chunk indicator 12158 * 12159 * Parse a Chunk of memory 12160 * 12161 * Returns zero if no error, the xmlParserErrors otherwise. 12162 */ 12163 int 12164 xmlParseChunk(xmlParserCtxtPtr ctxt, const char *chunk, int size, 12165 int terminate) { 12166 int end_in_lf = 0; 12167 int remain = 0; 12168 size_t old_avail = 0; 12169 size_t avail = 0; 12170 12171 if (ctxt == NULL) 12172 return(XML_ERR_INTERNAL_ERROR); 12173 if ((ctxt->errNo != XML_ERR_OK) && (ctxt->disableSAX == 1)) 12174 return(ctxt->errNo); 12175 if (ctxt->instate == XML_PARSER_EOF) 12176 return(-1); 12177 if (ctxt->instate == XML_PARSER_START) 12178 xmlDetectSAX2(ctxt); 12179 if ((size > 0) && (chunk != NULL) && (!terminate) && 12180 (chunk[size - 1] == '\r')) { 12181 end_in_lf = 1; 12182 size--; 12183 } 12184 12185 xmldecl_done: 12186 12187 if ((size > 0) && (chunk != NULL) && (ctxt->input != NULL) && 12188 (ctxt->input->buf != NULL) && (ctxt->instate != XML_PARSER_EOF)) { 12189 size_t base = xmlBufGetInputBase(ctxt->input->buf->buffer, ctxt->input); 12190 size_t cur = ctxt->input->cur - ctxt->input->base; 12191 int res; 12192 12193 old_avail = xmlBufUse(ctxt->input->buf->buffer); 12194 /* 12195 * Specific handling if we autodetected an encoding, we should not 12196 * push more than the first line ... which depend on the encoding 12197 * And only push the rest once the final encoding was detected 12198 */ 12199 if ((ctxt->instate == XML_PARSER_START) && (ctxt->input != NULL) && 12200 (ctxt->input->buf != NULL) && (ctxt->input->buf->encoder != NULL)) { 12201 unsigned int len = 45; 12202 12203 if ((xmlStrcasestr(BAD_CAST ctxt->input->buf->encoder->name, 12204 BAD_CAST "UTF-16")) || 12205 (xmlStrcasestr(BAD_CAST ctxt->input->buf->encoder->name, 12206 BAD_CAST "UTF16"))) 12207 len = 90; 12208 else if ((xmlStrcasestr(BAD_CAST ctxt->input->buf->encoder->name, 12209 BAD_CAST "UCS-4")) || 12210 (xmlStrcasestr(BAD_CAST ctxt->input->buf->encoder->name, 12211 BAD_CAST "UCS4"))) 12212 len = 180; 12213 12214 if (ctxt->input->buf->rawconsumed < len) 12215 len -= ctxt->input->buf->rawconsumed; 12216 12217 /* 12218 * Change size for reading the initial declaration only 12219 * if size is greater than len. Otherwise, memmove in xmlBufferAdd 12220 * will blindly copy extra bytes from memory. 12221 */ 12222 if ((unsigned int) size > len) { 12223 remain = size - len; 12224 size = len; 12225 } else { 12226 remain = 0; 12227 } 12228 } 12229 res = xmlParserInputBufferPush(ctxt->input->buf, size, chunk); 12230 if (res < 0) { 12231 ctxt->errNo = XML_PARSER_EOF; 12232 ctxt->disableSAX = 1; 12233 return (XML_PARSER_EOF); 12234 } 12235 xmlBufSetInputBaseCur(ctxt->input->buf->buffer, ctxt->input, base, cur); 12236 #ifdef DEBUG_PUSH 12237 xmlGenericError(xmlGenericErrorContext, "PP: pushed %d\n", size); 12238 #endif 12239 12240 } else if (ctxt->instate != XML_PARSER_EOF) { 12241 if ((ctxt->input != NULL) && ctxt->input->buf != NULL) { 12242 xmlParserInputBufferPtr in = ctxt->input->buf; 12243 if ((in->encoder != NULL) && (in->buffer != NULL) && 12244 (in->raw != NULL)) { 12245 int nbchars; 12246 size_t base = xmlBufGetInputBase(in->buffer, ctxt->input); 12247 size_t current = ctxt->input->cur - ctxt->input->base; 12248 12249 nbchars = xmlCharEncInput(in, terminate); 12250 if (nbchars < 0) { 12251 /* TODO 2.6.0 */ 12252 xmlGenericError(xmlGenericErrorContext, 12253 "xmlParseChunk: encoder error\n"); 12254 return(XML_ERR_INVALID_ENCODING); 12255 } 12256 xmlBufSetInputBaseCur(in->buffer, ctxt->input, base, current); 12257 } 12258 } 12259 } 12260 if (remain != 0) { 12261 xmlParseTryOrFinish(ctxt, 0); 12262 } else { 12263 if ((ctxt->input != NULL) && (ctxt->input->buf != NULL)) 12264 avail = xmlBufUse(ctxt->input->buf->buffer); 12265 /* 12266 * Depending on the current state it may not be such 12267 * a good idea to try parsing if there is nothing in the chunk 12268 * which would be worth doing a parser state transition and we 12269 * need to wait for more data 12270 */ 12271 if ((terminate) || (avail > XML_MAX_TEXT_LENGTH) || 12272 (old_avail == 0) || (avail == 0) || 12273 (xmlParseCheckTransition(ctxt, 12274 (const char *)&ctxt->input->base[old_avail], 12275 avail - old_avail))) 12276 xmlParseTryOrFinish(ctxt, terminate); 12277 } 12278 if (ctxt->instate == XML_PARSER_EOF) 12279 return(ctxt->errNo); 12280 12281 if ((ctxt->input != NULL) && 12282 (((ctxt->input->end - ctxt->input->cur) > XML_MAX_LOOKUP_LIMIT) || 12283 ((ctxt->input->cur - ctxt->input->base) > XML_MAX_LOOKUP_LIMIT)) && 12284 ((ctxt->options & XML_PARSE_HUGE) == 0)) { 12285 xmlFatalErr(ctxt, XML_ERR_INTERNAL_ERROR, "Huge input lookup"); 12286 ctxt->instate = XML_PARSER_EOF; 12287 } 12288 if ((ctxt->errNo != XML_ERR_OK) && (ctxt->disableSAX == 1)) 12289 return(ctxt->errNo); 12290 12291 if (remain != 0) { 12292 chunk += size; 12293 size = remain; 12294 remain = 0; 12295 goto xmldecl_done; 12296 } 12297 if ((end_in_lf == 1) && (ctxt->input != NULL) && 12298 (ctxt->input->buf != NULL)) { 12299 size_t base = xmlBufGetInputBase(ctxt->input->buf->buffer, 12300 ctxt->input); 12301 size_t current = ctxt->input->cur - ctxt->input->base; 12302 12303 xmlParserInputBufferPush(ctxt->input->buf, 1, "\r"); 12304 12305 xmlBufSetInputBaseCur(ctxt->input->buf->buffer, ctxt->input, 12306 base, current); 12307 } 12308 if (terminate) { 12309 /* 12310 * Check for termination 12311 */ 12312 int cur_avail = 0; 12313 12314 if (ctxt->input != NULL) { 12315 if (ctxt->input->buf == NULL) 12316 cur_avail = ctxt->input->length - 12317 (ctxt->input->cur - ctxt->input->base); 12318 else 12319 cur_avail = xmlBufUse(ctxt->input->buf->buffer) - 12320 (ctxt->input->cur - ctxt->input->base); 12321 } 12322 12323 if ((ctxt->instate != XML_PARSER_EOF) && 12324 (ctxt->instate != XML_PARSER_EPILOG)) { 12325 xmlFatalErr(ctxt, XML_ERR_DOCUMENT_END, NULL); 12326 } 12327 if ((ctxt->instate == XML_PARSER_EPILOG) && (cur_avail > 0)) { 12328 xmlFatalErr(ctxt, XML_ERR_DOCUMENT_END, NULL); 12329 } 12330 if (ctxt->instate != XML_PARSER_EOF) { 12331 if ((ctxt->sax) && (ctxt->sax->endDocument != NULL)) 12332 ctxt->sax->endDocument(ctxt->userData); 12333 } 12334 ctxt->instate = XML_PARSER_EOF; 12335 } 12336 if (ctxt->wellFormed == 0) 12337 return((xmlParserErrors) ctxt->errNo); 12338 else 12339 return(0); 12340 } 12341 12342 /************************************************************************ 12343 * * 12344 * I/O front end functions to the parser * 12345 * * 12346 ************************************************************************/ 12347 12348 /** 12349 * xmlCreatePushParserCtxt: 12350 * @sax: a SAX handler 12351 * @user_data: The user data returned on SAX callbacks 12352 * @chunk: a pointer to an array of chars 12353 * @size: number of chars in the array 12354 * @filename: an optional file name or URI 12355 * 12356 * Create a parser context for using the XML parser in push mode. 12357 * If @buffer and @size are non-NULL, the data is used to detect 12358 * the encoding. The remaining characters will be parsed so they 12359 * don't need to be fed in again through xmlParseChunk. 12360 * To allow content encoding detection, @size should be >= 4 12361 * The value of @filename is used for fetching external entities 12362 * and error/warning reports. 12363 * 12364 * Returns the new parser context or NULL 12365 */ 12366 12367 xmlParserCtxtPtr 12368 xmlCreatePushParserCtxt(xmlSAXHandlerPtr sax, void *user_data, 12369 const char *chunk, int size, const char *filename) { 12370 xmlParserCtxtPtr ctxt; 12371 xmlParserInputPtr inputStream; 12372 xmlParserInputBufferPtr buf; 12373 xmlCharEncoding enc = XML_CHAR_ENCODING_NONE; 12374 12375 /* 12376 * plug some encoding conversion routines 12377 */ 12378 if ((chunk != NULL) && (size >= 4)) 12379 enc = xmlDetectCharEncoding((const xmlChar *) chunk, size); 12380 12381 buf = xmlAllocParserInputBuffer(enc); 12382 if (buf == NULL) return(NULL); 12383 12384 ctxt = xmlNewParserCtxt(); 12385 if (ctxt == NULL) { 12386 xmlErrMemory(NULL, "creating parser: out of memory\n"); 12387 xmlFreeParserInputBuffer(buf); 12388 return(NULL); 12389 } 12390 ctxt->dictNames = 1; 12391 ctxt->pushTab = (void **) xmlMalloc(ctxt->nameMax * 3 * sizeof(xmlChar *)); 12392 if (ctxt->pushTab == NULL) { 12393 xmlErrMemory(ctxt, NULL); 12394 xmlFreeParserInputBuffer(buf); 12395 xmlFreeParserCtxt(ctxt); 12396 return(NULL); 12397 } 12398 if (sax != NULL) { 12399 #ifdef LIBXML_SAX1_ENABLED 12400 if (ctxt->sax != (xmlSAXHandlerPtr) &xmlDefaultSAXHandler) 12401 #endif /* LIBXML_SAX1_ENABLED */ 12402 xmlFree(ctxt->sax); 12403 ctxt->sax = (xmlSAXHandlerPtr) xmlMalloc(sizeof(xmlSAXHandler)); 12404 if (ctxt->sax == NULL) { 12405 xmlErrMemory(ctxt, NULL); 12406 xmlFreeParserInputBuffer(buf); 12407 xmlFreeParserCtxt(ctxt); 12408 return(NULL); 12409 } 12410 memset(ctxt->sax, 0, sizeof(xmlSAXHandler)); 12411 if (sax->initialized == XML_SAX2_MAGIC) 12412 memcpy(ctxt->sax, sax, sizeof(xmlSAXHandler)); 12413 else 12414 memcpy(ctxt->sax, sax, sizeof(xmlSAXHandlerV1)); 12415 if (user_data != NULL) 12416 ctxt->userData = user_data; 12417 } 12418 if (filename == NULL) { 12419 ctxt->directory = NULL; 12420 } else { 12421 ctxt->directory = xmlParserGetDirectory(filename); 12422 } 12423 12424 inputStream = xmlNewInputStream(ctxt); 12425 if (inputStream == NULL) { 12426 xmlFreeParserCtxt(ctxt); 12427 xmlFreeParserInputBuffer(buf); 12428 return(NULL); 12429 } 12430 12431 if (filename == NULL) 12432 inputStream->filename = NULL; 12433 else { 12434 inputStream->filename = (char *) 12435 xmlCanonicPath((const xmlChar *) filename); 12436 if (inputStream->filename == NULL) { 12437 xmlFreeParserCtxt(ctxt); 12438 xmlFreeParserInputBuffer(buf); 12439 return(NULL); 12440 } 12441 } 12442 inputStream->buf = buf; 12443 xmlBufResetInput(inputStream->buf->buffer, inputStream); 12444 inputPush(ctxt, inputStream); 12445 12446 /* 12447 * If the caller didn't provide an initial 'chunk' for determining 12448 * the encoding, we set the context to XML_CHAR_ENCODING_NONE so 12449 * that it can be automatically determined later 12450 */ 12451 if ((size == 0) || (chunk == NULL)) { 12452 ctxt->charset = XML_CHAR_ENCODING_NONE; 12453 } else if ((ctxt->input != NULL) && (ctxt->input->buf != NULL)) { 12454 size_t base = xmlBufGetInputBase(ctxt->input->buf->buffer, ctxt->input); 12455 size_t cur = ctxt->input->cur - ctxt->input->base; 12456 12457 xmlParserInputBufferPush(ctxt->input->buf, size, chunk); 12458 12459 xmlBufSetInputBaseCur(ctxt->input->buf->buffer, ctxt->input, base, cur); 12460 #ifdef DEBUG_PUSH 12461 xmlGenericError(xmlGenericErrorContext, "PP: pushed %d\n", size); 12462 #endif 12463 } 12464 12465 if (enc != XML_CHAR_ENCODING_NONE) { 12466 xmlSwitchEncoding(ctxt, enc); 12467 } 12468 12469 return(ctxt); 12470 } 12471 #endif /* LIBXML_PUSH_ENABLED */ 12472 12473 /** 12474 * xmlStopParser: 12475 * @ctxt: an XML parser context 12476 * 12477 * Blocks further parser processing 12478 */ 12479 void 12480 xmlStopParser(xmlParserCtxtPtr ctxt) { 12481 if (ctxt == NULL) 12482 return; 12483 ctxt->instate = XML_PARSER_EOF; 12484 ctxt->errNo = XML_ERR_USER_STOP; 12485 ctxt->disableSAX = 1; 12486 if (ctxt->input != NULL) { 12487 ctxt->input->cur = BAD_CAST""; 12488 ctxt->input->base = ctxt->input->cur; 12489 } 12490 } 12491 12492 /** 12493 * xmlCreateIOParserCtxt: 12494 * @sax: a SAX handler 12495 * @user_data: The user data returned on SAX callbacks 12496 * @ioread: an I/O read function 12497 * @ioclose: an I/O close function 12498 * @ioctx: an I/O handler 12499 * @enc: the charset encoding if known 12500 * 12501 * Create a parser context for using the XML parser with an existing 12502 * I/O stream 12503 * 12504 * Returns the new parser context or NULL 12505 */ 12506 xmlParserCtxtPtr 12507 xmlCreateIOParserCtxt(xmlSAXHandlerPtr sax, void *user_data, 12508 xmlInputReadCallback ioread, xmlInputCloseCallback ioclose, 12509 void *ioctx, xmlCharEncoding enc) { 12510 xmlParserCtxtPtr ctxt; 12511 xmlParserInputPtr inputStream; 12512 xmlParserInputBufferPtr buf; 12513 12514 if (ioread == NULL) return(NULL); 12515 12516 buf = xmlParserInputBufferCreateIO(ioread, ioclose, ioctx, enc); 12517 if (buf == NULL) { 12518 if (ioclose != NULL) 12519 ioclose(ioctx); 12520 return (NULL); 12521 } 12522 12523 ctxt = xmlNewParserCtxt(); 12524 if (ctxt == NULL) { 12525 xmlFreeParserInputBuffer(buf); 12526 return(NULL); 12527 } 12528 if (sax != NULL) { 12529 #ifdef LIBXML_SAX1_ENABLED 12530 if (ctxt->sax != (xmlSAXHandlerPtr) &xmlDefaultSAXHandler) 12531 #endif /* LIBXML_SAX1_ENABLED */ 12532 xmlFree(ctxt->sax); 12533 ctxt->sax = (xmlSAXHandlerPtr) xmlMalloc(sizeof(xmlSAXHandler)); 12534 if (ctxt->sax == NULL) { 12535 xmlErrMemory(ctxt, NULL); 12536 xmlFreeParserCtxt(ctxt); 12537 return(NULL); 12538 } 12539 memset(ctxt->sax, 0, sizeof(xmlSAXHandler)); 12540 if (sax->initialized == XML_SAX2_MAGIC) 12541 memcpy(ctxt->sax, sax, sizeof(xmlSAXHandler)); 12542 else 12543 memcpy(ctxt->sax, sax, sizeof(xmlSAXHandlerV1)); 12544 if (user_data != NULL) 12545 ctxt->userData = user_data; 12546 } 12547 12548 inputStream = xmlNewIOInputStream(ctxt, buf, enc); 12549 if (inputStream == NULL) { 12550 xmlFreeParserCtxt(ctxt); 12551 return(NULL); 12552 } 12553 inputPush(ctxt, inputStream); 12554 12555 return(ctxt); 12556 } 12557 12558 #ifdef LIBXML_VALID_ENABLED 12559 /************************************************************************ 12560 * * 12561 * Front ends when parsing a DTD * 12562 * * 12563 ************************************************************************/ 12564 12565 /** 12566 * xmlIOParseDTD: 12567 * @sax: the SAX handler block or NULL 12568 * @input: an Input Buffer 12569 * @enc: the charset encoding if known 12570 * 12571 * Load and parse a DTD 12572 * 12573 * Returns the resulting xmlDtdPtr or NULL in case of error. 12574 * @input will be freed by the function in any case. 12575 */ 12576 12577 xmlDtdPtr 12578 xmlIOParseDTD(xmlSAXHandlerPtr sax, xmlParserInputBufferPtr input, 12579 xmlCharEncoding enc) { 12580 xmlDtdPtr ret = NULL; 12581 xmlParserCtxtPtr ctxt; 12582 xmlParserInputPtr pinput = NULL; 12583 xmlChar start[4]; 12584 12585 if (input == NULL) 12586 return(NULL); 12587 12588 ctxt = xmlNewParserCtxt(); 12589 if (ctxt == NULL) { 12590 xmlFreeParserInputBuffer(input); 12591 return(NULL); 12592 } 12593 12594 /* 12595 * Set-up the SAX context 12596 */ 12597 if (sax != NULL) { 12598 if (ctxt->sax != NULL) 12599 xmlFree(ctxt->sax); 12600 ctxt->sax = sax; 12601 ctxt->userData = ctxt; 12602 } 12603 xmlDetectSAX2(ctxt); 12604 12605 /* 12606 * generate a parser input from the I/O handler 12607 */ 12608 12609 pinput = xmlNewIOInputStream(ctxt, input, XML_CHAR_ENCODING_NONE); 12610 if (pinput == NULL) { 12611 if (sax != NULL) ctxt->sax = NULL; 12612 xmlFreeParserInputBuffer(input); 12613 xmlFreeParserCtxt(ctxt); 12614 return(NULL); 12615 } 12616 12617 /* 12618 * plug some encoding conversion routines here. 12619 */ 12620 if (xmlPushInput(ctxt, pinput) < 0) { 12621 if (sax != NULL) ctxt->sax = NULL; 12622 xmlFreeParserCtxt(ctxt); 12623 return(NULL); 12624 } 12625 if (enc != XML_CHAR_ENCODING_NONE) { 12626 xmlSwitchEncoding(ctxt, enc); 12627 } 12628 12629 pinput->filename = NULL; 12630 pinput->line = 1; 12631 pinput->col = 1; 12632 pinput->base = ctxt->input->cur; 12633 pinput->cur = ctxt->input->cur; 12634 pinput->free = NULL; 12635 12636 /* 12637 * let's parse that entity knowing it's an external subset. 12638 */ 12639 ctxt->inSubset = 2; 12640 ctxt->myDoc = xmlNewDoc(BAD_CAST "1.0"); 12641 if (ctxt->myDoc == NULL) { 12642 xmlErrMemory(ctxt, "New Doc failed"); 12643 return(NULL); 12644 } 12645 ctxt->myDoc->properties = XML_DOC_INTERNAL; 12646 ctxt->myDoc->extSubset = xmlNewDtd(ctxt->myDoc, BAD_CAST "none", 12647 BAD_CAST "none", BAD_CAST "none"); 12648 12649 if ((enc == XML_CHAR_ENCODING_NONE) && 12650 ((ctxt->input->end - ctxt->input->cur) >= 4)) { 12651 /* 12652 * Get the 4 first bytes and decode the charset 12653 * if enc != XML_CHAR_ENCODING_NONE 12654 * plug some encoding conversion routines. 12655 */ 12656 start[0] = RAW; 12657 start[1] = NXT(1); 12658 start[2] = NXT(2); 12659 start[3] = NXT(3); 12660 enc = xmlDetectCharEncoding(start, 4); 12661 if (enc != XML_CHAR_ENCODING_NONE) { 12662 xmlSwitchEncoding(ctxt, enc); 12663 } 12664 } 12665 12666 xmlParseExternalSubset(ctxt, BAD_CAST "none", BAD_CAST "none"); 12667 12668 if (ctxt->myDoc != NULL) { 12669 if (ctxt->wellFormed) { 12670 ret = ctxt->myDoc->extSubset; 12671 ctxt->myDoc->extSubset = NULL; 12672 if (ret != NULL) { 12673 xmlNodePtr tmp; 12674 12675 ret->doc = NULL; 12676 tmp = ret->children; 12677 while (tmp != NULL) { 12678 tmp->doc = NULL; 12679 tmp = tmp->next; 12680 } 12681 } 12682 } else { 12683 ret = NULL; 12684 } 12685 xmlFreeDoc(ctxt->myDoc); 12686 ctxt->myDoc = NULL; 12687 } 12688 if (sax != NULL) ctxt->sax = NULL; 12689 xmlFreeParserCtxt(ctxt); 12690 12691 return(ret); 12692 } 12693 12694 /** 12695 * xmlSAXParseDTD: 12696 * @sax: the SAX handler block 12697 * @ExternalID: a NAME* containing the External ID of the DTD 12698 * @SystemID: a NAME* containing the URL to the DTD 12699 * 12700 * Load and parse an external subset. 12701 * 12702 * Returns the resulting xmlDtdPtr or NULL in case of error. 12703 */ 12704 12705 xmlDtdPtr 12706 xmlSAXParseDTD(xmlSAXHandlerPtr sax, const xmlChar *ExternalID, 12707 const xmlChar *SystemID) { 12708 xmlDtdPtr ret = NULL; 12709 xmlParserCtxtPtr ctxt; 12710 xmlParserInputPtr input = NULL; 12711 xmlCharEncoding enc; 12712 xmlChar* systemIdCanonic; 12713 12714 if ((ExternalID == NULL) && (SystemID == NULL)) return(NULL); 12715 12716 ctxt = xmlNewParserCtxt(); 12717 if (ctxt == NULL) { 12718 return(NULL); 12719 } 12720 12721 /* 12722 * Set-up the SAX context 12723 */ 12724 if (sax != NULL) { 12725 if (ctxt->sax != NULL) 12726 xmlFree(ctxt->sax); 12727 ctxt->sax = sax; 12728 ctxt->userData = ctxt; 12729 } 12730 12731 /* 12732 * Canonicalise the system ID 12733 */ 12734 systemIdCanonic = xmlCanonicPath(SystemID); 12735 if ((SystemID != NULL) && (systemIdCanonic == NULL)) { 12736 xmlFreeParserCtxt(ctxt); 12737 return(NULL); 12738 } 12739 12740 /* 12741 * Ask the Entity resolver to load the damn thing 12742 */ 12743 12744 if ((ctxt->sax != NULL) && (ctxt->sax->resolveEntity != NULL)) 12745 input = ctxt->sax->resolveEntity(ctxt->userData, ExternalID, 12746 systemIdCanonic); 12747 if (input == NULL) { 12748 if (sax != NULL) ctxt->sax = NULL; 12749 xmlFreeParserCtxt(ctxt); 12750 if (systemIdCanonic != NULL) 12751 xmlFree(systemIdCanonic); 12752 return(NULL); 12753 } 12754 12755 /* 12756 * plug some encoding conversion routines here. 12757 */ 12758 if (xmlPushInput(ctxt, input) < 0) { 12759 if (sax != NULL) ctxt->sax = NULL; 12760 xmlFreeParserCtxt(ctxt); 12761 if (systemIdCanonic != NULL) 12762 xmlFree(systemIdCanonic); 12763 return(NULL); 12764 } 12765 if ((ctxt->input->end - ctxt->input->cur) >= 4) { 12766 enc = xmlDetectCharEncoding(ctxt->input->cur, 4); 12767 xmlSwitchEncoding(ctxt, enc); 12768 } 12769 12770 if (input->filename == NULL) 12771 input->filename = (char *) systemIdCanonic; 12772 else 12773 xmlFree(systemIdCanonic); 12774 input->line = 1; 12775 input->col = 1; 12776 input->base = ctxt->input->cur; 12777 input->cur = ctxt->input->cur; 12778 input->free = NULL; 12779 12780 /* 12781 * let's parse that entity knowing it's an external subset. 12782 */ 12783 ctxt->inSubset = 2; 12784 ctxt->myDoc = xmlNewDoc(BAD_CAST "1.0"); 12785 if (ctxt->myDoc == NULL) { 12786 xmlErrMemory(ctxt, "New Doc failed"); 12787 if (sax != NULL) ctxt->sax = NULL; 12788 xmlFreeParserCtxt(ctxt); 12789 return(NULL); 12790 } 12791 ctxt->myDoc->properties = XML_DOC_INTERNAL; 12792 ctxt->myDoc->extSubset = xmlNewDtd(ctxt->myDoc, BAD_CAST "none", 12793 ExternalID, SystemID); 12794 xmlParseExternalSubset(ctxt, ExternalID, SystemID); 12795 12796 if (ctxt->myDoc != NULL) { 12797 if (ctxt->wellFormed) { 12798 ret = ctxt->myDoc->extSubset; 12799 ctxt->myDoc->extSubset = NULL; 12800 if (ret != NULL) { 12801 xmlNodePtr tmp; 12802 12803 ret->doc = NULL; 12804 tmp = ret->children; 12805 while (tmp != NULL) { 12806 tmp->doc = NULL; 12807 tmp = tmp->next; 12808 } 12809 } 12810 } else { 12811 ret = NULL; 12812 } 12813 xmlFreeDoc(ctxt->myDoc); 12814 ctxt->myDoc = NULL; 12815 } 12816 if (sax != NULL) ctxt->sax = NULL; 12817 xmlFreeParserCtxt(ctxt); 12818 12819 return(ret); 12820 } 12821 12822 12823 /** 12824 * xmlParseDTD: 12825 * @ExternalID: a NAME* containing the External ID of the DTD 12826 * @SystemID: a NAME* containing the URL to the DTD 12827 * 12828 * Load and parse an external subset. 12829 * 12830 * Returns the resulting xmlDtdPtr or NULL in case of error. 12831 */ 12832 12833 xmlDtdPtr 12834 xmlParseDTD(const xmlChar *ExternalID, const xmlChar *SystemID) { 12835 return(xmlSAXParseDTD(NULL, ExternalID, SystemID)); 12836 } 12837 #endif /* LIBXML_VALID_ENABLED */ 12838 12839 /************************************************************************ 12840 * * 12841 * Front ends when parsing an Entity * 12842 * * 12843 ************************************************************************/ 12844 12845 /** 12846 * xmlParseCtxtExternalEntity: 12847 * @ctx: the existing parsing context 12848 * @URL: the URL for the entity to load 12849 * @ID: the System ID for the entity to load 12850 * @lst: the return value for the set of parsed nodes 12851 * 12852 * Parse an external general entity within an existing parsing context 12853 * An external general parsed entity is well-formed if it matches the 12854 * production labeled extParsedEnt. 12855 * 12856 * [78] extParsedEnt ::= TextDecl? content 12857 * 12858 * Returns 0 if the entity is well formed, -1 in case of args problem and 12859 * the parser error code otherwise 12860 */ 12861 12862 int 12863 xmlParseCtxtExternalEntity(xmlParserCtxtPtr ctx, const xmlChar *URL, 12864 const xmlChar *ID, xmlNodePtr *lst) { 12865 xmlParserCtxtPtr ctxt; 12866 xmlDocPtr newDoc; 12867 xmlNodePtr newRoot; 12868 xmlSAXHandlerPtr oldsax = NULL; 12869 int ret = 0; 12870 xmlChar start[4]; 12871 xmlCharEncoding enc; 12872 12873 if (ctx == NULL) return(-1); 12874 12875 if (((ctx->depth > 40) && ((ctx->options & XML_PARSE_HUGE) == 0)) || 12876 (ctx->depth > 1024)) { 12877 return(XML_ERR_ENTITY_LOOP); 12878 } 12879 12880 if (lst != NULL) 12881 *lst = NULL; 12882 if ((URL == NULL) && (ID == NULL)) 12883 return(-1); 12884 if (ctx->myDoc == NULL) /* @@ relax but check for dereferences */ 12885 return(-1); 12886 12887 ctxt = xmlCreateEntityParserCtxtInternal(URL, ID, NULL, ctx); 12888 if (ctxt == NULL) { 12889 return(-1); 12890 } 12891 12892 oldsax = ctxt->sax; 12893 ctxt->sax = ctx->sax; 12894 xmlDetectSAX2(ctxt); 12895 newDoc = xmlNewDoc(BAD_CAST "1.0"); 12896 if (newDoc == NULL) { 12897 xmlFreeParserCtxt(ctxt); 12898 return(-1); 12899 } 12900 newDoc->properties = XML_DOC_INTERNAL; 12901 if (ctx->myDoc->dict) { 12902 newDoc->dict = ctx->myDoc->dict; 12903 xmlDictReference(newDoc->dict); 12904 } 12905 if (ctx->myDoc != NULL) { 12906 newDoc->intSubset = ctx->myDoc->intSubset; 12907 newDoc->extSubset = ctx->myDoc->extSubset; 12908 } 12909 if (ctx->myDoc->URL != NULL) { 12910 newDoc->URL = xmlStrdup(ctx->myDoc->URL); 12911 } 12912 newRoot = xmlNewDocNode(newDoc, NULL, BAD_CAST "pseudoroot", NULL); 12913 if (newRoot == NULL) { 12914 ctxt->sax = oldsax; 12915 xmlFreeParserCtxt(ctxt); 12916 newDoc->intSubset = NULL; 12917 newDoc->extSubset = NULL; 12918 xmlFreeDoc(newDoc); 12919 return(-1); 12920 } 12921 xmlAddChild((xmlNodePtr) newDoc, newRoot); 12922 nodePush(ctxt, newDoc->children); 12923 if (ctx->myDoc == NULL) { 12924 ctxt->myDoc = newDoc; 12925 } else { 12926 ctxt->myDoc = ctx->myDoc; 12927 newDoc->children->doc = ctx->myDoc; 12928 } 12929 12930 /* 12931 * Get the 4 first bytes and decode the charset 12932 * if enc != XML_CHAR_ENCODING_NONE 12933 * plug some encoding conversion routines. 12934 */ 12935 GROW 12936 if ((ctxt->input->end - ctxt->input->cur) >= 4) { 12937 start[0] = RAW; 12938 start[1] = NXT(1); 12939 start[2] = NXT(2); 12940 start[3] = NXT(3); 12941 enc = xmlDetectCharEncoding(start, 4); 12942 if (enc != XML_CHAR_ENCODING_NONE) { 12943 xmlSwitchEncoding(ctxt, enc); 12944 } 12945 } 12946 12947 /* 12948 * Parse a possible text declaration first 12949 */ 12950 if ((CMP5(CUR_PTR, '<', '?', 'x', 'm', 'l')) && (IS_BLANK_CH(NXT(5)))) { 12951 xmlParseTextDecl(ctxt); 12952 /* 12953 * An XML-1.0 document can't reference an entity not XML-1.0 12954 */ 12955 if ((xmlStrEqual(ctx->version, BAD_CAST "1.0")) && 12956 (!xmlStrEqual(ctxt->input->version, BAD_CAST "1.0"))) { 12957 xmlFatalErrMsg(ctxt, XML_ERR_VERSION_MISMATCH, 12958 "Version mismatch between document and entity\n"); 12959 } 12960 } 12961 12962 /* 12963 * If the user provided its own SAX callbacks then reuse the 12964 * useData callback field, otherwise the expected setup in a 12965 * DOM builder is to have userData == ctxt 12966 */ 12967 if (ctx->userData == ctx) 12968 ctxt->userData = ctxt; 12969 else 12970 ctxt->userData = ctx->userData; 12971 12972 /* 12973 * Doing validity checking on chunk doesn't make sense 12974 */ 12975 ctxt->instate = XML_PARSER_CONTENT; 12976 ctxt->validate = ctx->validate; 12977 ctxt->valid = ctx->valid; 12978 ctxt->loadsubset = ctx->loadsubset; 12979 ctxt->depth = ctx->depth + 1; 12980 ctxt->replaceEntities = ctx->replaceEntities; 12981 if (ctxt->validate) { 12982 ctxt->vctxt.error = ctx->vctxt.error; 12983 ctxt->vctxt.warning = ctx->vctxt.warning; 12984 } else { 12985 ctxt->vctxt.error = NULL; 12986 ctxt->vctxt.warning = NULL; 12987 } 12988 ctxt->vctxt.nodeTab = NULL; 12989 ctxt->vctxt.nodeNr = 0; 12990 ctxt->vctxt.nodeMax = 0; 12991 ctxt->vctxt.node = NULL; 12992 if (ctxt->dict != NULL) xmlDictFree(ctxt->dict); 12993 ctxt->dict = ctx->dict; 12994 ctxt->str_xml = xmlDictLookup(ctxt->dict, BAD_CAST "xml", 3); 12995 ctxt->str_xmlns = xmlDictLookup(ctxt->dict, BAD_CAST "xmlns", 5); 12996 ctxt->str_xml_ns = xmlDictLookup(ctxt->dict, XML_XML_NAMESPACE, 36); 12997 ctxt->dictNames = ctx->dictNames; 12998 ctxt->attsDefault = ctx->attsDefault; 12999 ctxt->attsSpecial = ctx->attsSpecial; 13000 ctxt->linenumbers = ctx->linenumbers; 13001 13002 xmlParseContent(ctxt); 13003 13004 ctx->validate = ctxt->validate; 13005 ctx->valid = ctxt->valid; 13006 if ((RAW == '<') && (NXT(1) == '/')) { 13007 xmlFatalErr(ctxt, XML_ERR_NOT_WELL_BALANCED, NULL); 13008 } else if (RAW != 0) { 13009 xmlFatalErr(ctxt, XML_ERR_EXTRA_CONTENT, NULL); 13010 } 13011 if (ctxt->node != newDoc->children) { 13012 xmlFatalErr(ctxt, XML_ERR_NOT_WELL_BALANCED, NULL); 13013 } 13014 13015 if (!ctxt->wellFormed) { 13016 if (ctxt->errNo == 0) 13017 ret = 1; 13018 else 13019 ret = ctxt->errNo; 13020 } else { 13021 if (lst != NULL) { 13022 xmlNodePtr cur; 13023 13024 /* 13025 * Return the newly created nodeset after unlinking it from 13026 * they pseudo parent. 13027 */ 13028 cur = newDoc->children->children; 13029 *lst = cur; 13030 while (cur != NULL) { 13031 cur->parent = NULL; 13032 cur = cur->next; 13033 } 13034 newDoc->children->children = NULL; 13035 } 13036 ret = 0; 13037 } 13038 ctxt->sax = oldsax; 13039 ctxt->dict = NULL; 13040 ctxt->attsDefault = NULL; 13041 ctxt->attsSpecial = NULL; 13042 xmlFreeParserCtxt(ctxt); 13043 newDoc->intSubset = NULL; 13044 newDoc->extSubset = NULL; 13045 xmlFreeDoc(newDoc); 13046 13047 return(ret); 13048 } 13049 13050 /** 13051 * xmlParseExternalEntityPrivate: 13052 * @doc: the document the chunk pertains to 13053 * @oldctxt: the previous parser context if available 13054 * @sax: the SAX handler bloc (possibly NULL) 13055 * @user_data: The user data returned on SAX callbacks (possibly NULL) 13056 * @depth: Used for loop detection, use 0 13057 * @URL: the URL for the entity to load 13058 * @ID: the System ID for the entity to load 13059 * @list: the return value for the set of parsed nodes 13060 * 13061 * Private version of xmlParseExternalEntity() 13062 * 13063 * Returns 0 if the entity is well formed, -1 in case of args problem and 13064 * the parser error code otherwise 13065 */ 13066 13067 static xmlParserErrors 13068 xmlParseExternalEntityPrivate(xmlDocPtr doc, xmlParserCtxtPtr oldctxt, 13069 xmlSAXHandlerPtr sax, 13070 void *user_data, int depth, const xmlChar *URL, 13071 const xmlChar *ID, xmlNodePtr *list) { 13072 xmlParserCtxtPtr ctxt; 13073 xmlDocPtr newDoc; 13074 xmlNodePtr newRoot; 13075 xmlSAXHandlerPtr oldsax = NULL; 13076 xmlParserErrors ret = XML_ERR_OK; 13077 xmlChar start[4]; 13078 xmlCharEncoding enc; 13079 13080 if (((depth > 40) && 13081 ((oldctxt == NULL) || (oldctxt->options & XML_PARSE_HUGE) == 0)) || 13082 (depth > 1024)) { 13083 return(XML_ERR_ENTITY_LOOP); 13084 } 13085 13086 if (list != NULL) 13087 *list = NULL; 13088 if ((URL == NULL) && (ID == NULL)) 13089 return(XML_ERR_INTERNAL_ERROR); 13090 if (doc == NULL) 13091 return(XML_ERR_INTERNAL_ERROR); 13092 13093 13094 ctxt = xmlCreateEntityParserCtxtInternal(URL, ID, NULL, oldctxt); 13095 if (ctxt == NULL) return(XML_WAR_UNDECLARED_ENTITY); 13096 ctxt->userData = ctxt; 13097 if (oldctxt != NULL) { 13098 ctxt->_private = oldctxt->_private; 13099 ctxt->loadsubset = oldctxt->loadsubset; 13100 ctxt->validate = oldctxt->validate; 13101 ctxt->external = oldctxt->external; 13102 ctxt->record_info = oldctxt->record_info; 13103 ctxt->node_seq.maximum = oldctxt->node_seq.maximum; 13104 ctxt->node_seq.length = oldctxt->node_seq.length; 13105 ctxt->node_seq.buffer = oldctxt->node_seq.buffer; 13106 } else { 13107 /* 13108 * Doing validity checking on chunk without context 13109 * doesn't make sense 13110 */ 13111 ctxt->_private = NULL; 13112 ctxt->validate = 0; 13113 ctxt->external = 2; 13114 ctxt->loadsubset = 0; 13115 } 13116 if (sax != NULL) { 13117 oldsax = ctxt->sax; 13118 ctxt->sax = sax; 13119 if (user_data != NULL) 13120 ctxt->userData = user_data; 13121 } 13122 xmlDetectSAX2(ctxt); 13123 newDoc = xmlNewDoc(BAD_CAST "1.0"); 13124 if (newDoc == NULL) { 13125 ctxt->node_seq.maximum = 0; 13126 ctxt->node_seq.length = 0; 13127 ctxt->node_seq.buffer = NULL; 13128 xmlFreeParserCtxt(ctxt); 13129 return(XML_ERR_INTERNAL_ERROR); 13130 } 13131 newDoc->properties = XML_DOC_INTERNAL; 13132 newDoc->intSubset = doc->intSubset; 13133 newDoc->extSubset = doc->extSubset; 13134 newDoc->dict = doc->dict; 13135 xmlDictReference(newDoc->dict); 13136 13137 if (doc->URL != NULL) { 13138 newDoc->URL = xmlStrdup(doc->URL); 13139 } 13140 newRoot = xmlNewDocNode(newDoc, NULL, BAD_CAST "pseudoroot", NULL); 13141 if (newRoot == NULL) { 13142 if (sax != NULL) 13143 ctxt->sax = oldsax; 13144 ctxt->node_seq.maximum = 0; 13145 ctxt->node_seq.length = 0; 13146 ctxt->node_seq.buffer = NULL; 13147 xmlFreeParserCtxt(ctxt); 13148 newDoc->intSubset = NULL; 13149 newDoc->extSubset = NULL; 13150 xmlFreeDoc(newDoc); 13151 return(XML_ERR_INTERNAL_ERROR); 13152 } 13153 xmlAddChild((xmlNodePtr) newDoc, newRoot); 13154 nodePush(ctxt, newDoc->children); 13155 ctxt->myDoc = doc; 13156 newRoot->doc = doc; 13157 13158 /* 13159 * Get the 4 first bytes and decode the charset 13160 * if enc != XML_CHAR_ENCODING_NONE 13161 * plug some encoding conversion routines. 13162 */ 13163 GROW; 13164 if ((ctxt->input->end - ctxt->input->cur) >= 4) { 13165 start[0] = RAW; 13166 start[1] = NXT(1); 13167 start[2] = NXT(2); 13168 start[3] = NXT(3); 13169 enc = xmlDetectCharEncoding(start, 4); 13170 if (enc != XML_CHAR_ENCODING_NONE) { 13171 xmlSwitchEncoding(ctxt, enc); 13172 } 13173 } 13174 13175 /* 13176 * Parse a possible text declaration first 13177 */ 13178 if ((CMP5(CUR_PTR, '<', '?', 'x', 'm', 'l')) && (IS_BLANK_CH(NXT(5)))) { 13179 xmlParseTextDecl(ctxt); 13180 } 13181 13182 ctxt->instate = XML_PARSER_CONTENT; 13183 ctxt->depth = depth; 13184 13185 xmlParseContent(ctxt); 13186 13187 if ((RAW == '<') && (NXT(1) == '/')) { 13188 xmlFatalErr(ctxt, XML_ERR_NOT_WELL_BALANCED, NULL); 13189 } else if (RAW != 0) { 13190 xmlFatalErr(ctxt, XML_ERR_EXTRA_CONTENT, NULL); 13191 } 13192 if (ctxt->node != newDoc->children) { 13193 xmlFatalErr(ctxt, XML_ERR_NOT_WELL_BALANCED, NULL); 13194 } 13195 13196 if (!ctxt->wellFormed) { 13197 if (ctxt->errNo == 0) 13198 ret = XML_ERR_INTERNAL_ERROR; 13199 else 13200 ret = (xmlParserErrors)ctxt->errNo; 13201 } else { 13202 if (list != NULL) { 13203 xmlNodePtr cur; 13204 13205 /* 13206 * Return the newly created nodeset after unlinking it from 13207 * they pseudo parent. 13208 */ 13209 cur = newDoc->children->children; 13210 *list = cur; 13211 while (cur != NULL) { 13212 cur->parent = NULL; 13213 cur = cur->next; 13214 } 13215 newDoc->children->children = NULL; 13216 } 13217 ret = XML_ERR_OK; 13218 } 13219 13220 /* 13221 * Record in the parent context the number of entities replacement 13222 * done when parsing that reference. 13223 */ 13224 if (oldctxt != NULL) 13225 oldctxt->nbentities += ctxt->nbentities; 13226 13227 /* 13228 * Also record the size of the entity parsed 13229 */ 13230 if (ctxt->input != NULL) { 13231 oldctxt->sizeentities += ctxt->input->consumed; 13232 oldctxt->sizeentities += (ctxt->input->cur - ctxt->input->base); 13233 } 13234 /* 13235 * And record the last error if any 13236 */ 13237 if (ctxt->lastError.code != XML_ERR_OK) 13238 xmlCopyError(&ctxt->lastError, &oldctxt->lastError); 13239 13240 if (sax != NULL) 13241 ctxt->sax = oldsax; 13242 oldctxt->node_seq.maximum = ctxt->node_seq.maximum; 13243 oldctxt->node_seq.length = ctxt->node_seq.length; 13244 oldctxt->node_seq.buffer = ctxt->node_seq.buffer; 13245 ctxt->node_seq.maximum = 0; 13246 ctxt->node_seq.length = 0; 13247 ctxt->node_seq.buffer = NULL; 13248 xmlFreeParserCtxt(ctxt); 13249 newDoc->intSubset = NULL; 13250 newDoc->extSubset = NULL; 13251 xmlFreeDoc(newDoc); 13252 13253 return(ret); 13254 } 13255 13256 #ifdef LIBXML_SAX1_ENABLED 13257 /** 13258 * xmlParseExternalEntity: 13259 * @doc: the document the chunk pertains to 13260 * @sax: the SAX handler bloc (possibly NULL) 13261 * @user_data: The user data returned on SAX callbacks (possibly NULL) 13262 * @depth: Used for loop detection, use 0 13263 * @URL: the URL for the entity to load 13264 * @ID: the System ID for the entity to load 13265 * @lst: the return value for the set of parsed nodes 13266 * 13267 * Parse an external general entity 13268 * An external general parsed entity is well-formed if it matches the 13269 * production labeled extParsedEnt. 13270 * 13271 * [78] extParsedEnt ::= TextDecl? content 13272 * 13273 * Returns 0 if the entity is well formed, -1 in case of args problem and 13274 * the parser error code otherwise 13275 */ 13276 13277 int 13278 xmlParseExternalEntity(xmlDocPtr doc, xmlSAXHandlerPtr sax, void *user_data, 13279 int depth, const xmlChar *URL, const xmlChar *ID, xmlNodePtr *lst) { 13280 return(xmlParseExternalEntityPrivate(doc, NULL, sax, user_data, depth, URL, 13281 ID, lst)); 13282 } 13283 13284 /** 13285 * xmlParseBalancedChunkMemory: 13286 * @doc: the document the chunk pertains to 13287 * @sax: the SAX handler bloc (possibly NULL) 13288 * @user_data: The user data returned on SAX callbacks (possibly NULL) 13289 * @depth: Used for loop detection, use 0 13290 * @string: the input string in UTF8 or ISO-Latin (zero terminated) 13291 * @lst: the return value for the set of parsed nodes 13292 * 13293 * Parse a well-balanced chunk of an XML document 13294 * called by the parser 13295 * The allowed sequence for the Well Balanced Chunk is the one defined by 13296 * the content production in the XML grammar: 13297 * 13298 * [43] content ::= (element | CharData | Reference | CDSect | PI | Comment)* 13299 * 13300 * Returns 0 if the chunk is well balanced, -1 in case of args problem and 13301 * the parser error code otherwise 13302 */ 13303 13304 int 13305 xmlParseBalancedChunkMemory(xmlDocPtr doc, xmlSAXHandlerPtr sax, 13306 void *user_data, int depth, const xmlChar *string, xmlNodePtr *lst) { 13307 return xmlParseBalancedChunkMemoryRecover( doc, sax, user_data, 13308 depth, string, lst, 0 ); 13309 } 13310 #endif /* LIBXML_SAX1_ENABLED */ 13311 13312 /** 13313 * xmlParseBalancedChunkMemoryInternal: 13314 * @oldctxt: the existing parsing context 13315 * @string: the input string in UTF8 or ISO-Latin (zero terminated) 13316 * @user_data: the user data field for the parser context 13317 * @lst: the return value for the set of parsed nodes 13318 * 13319 * 13320 * Parse a well-balanced chunk of an XML document 13321 * called by the parser 13322 * The allowed sequence for the Well Balanced Chunk is the one defined by 13323 * the content production in the XML grammar: 13324 * 13325 * [43] content ::= (element | CharData | Reference | CDSect | PI | Comment)* 13326 * 13327 * Returns XML_ERR_OK if the chunk is well balanced, and the parser 13328 * error code otherwise 13329 * 13330 * In case recover is set to 1, the nodelist will not be empty even if 13331 * the parsed chunk is not well balanced. 13332 */ 13333 static xmlParserErrors 13334 xmlParseBalancedChunkMemoryInternal(xmlParserCtxtPtr oldctxt, 13335 const xmlChar *string, void *user_data, xmlNodePtr *lst) { 13336 xmlParserCtxtPtr ctxt; 13337 xmlDocPtr newDoc = NULL; 13338 xmlNodePtr newRoot; 13339 xmlSAXHandlerPtr oldsax = NULL; 13340 xmlNodePtr content = NULL; 13341 xmlNodePtr last = NULL; 13342 int size; 13343 xmlParserErrors ret = XML_ERR_OK; 13344 #ifdef SAX2 13345 int i; 13346 #endif 13347 13348 if (((oldctxt->depth > 40) && ((oldctxt->options & XML_PARSE_HUGE) == 0)) || 13349 (oldctxt->depth > 1024)) { 13350 return(XML_ERR_ENTITY_LOOP); 13351 } 13352 13353 13354 if (lst != NULL) 13355 *lst = NULL; 13356 if (string == NULL) 13357 return(XML_ERR_INTERNAL_ERROR); 13358 13359 size = xmlStrlen(string); 13360 13361 ctxt = xmlCreateMemoryParserCtxt((char *) string, size); 13362 if (ctxt == NULL) return(XML_WAR_UNDECLARED_ENTITY); 13363 if (user_data != NULL) 13364 ctxt->userData = user_data; 13365 else 13366 ctxt->userData = ctxt; 13367 if (ctxt->dict != NULL) xmlDictFree(ctxt->dict); 13368 ctxt->dict = oldctxt->dict; 13369 ctxt->str_xml = xmlDictLookup(ctxt->dict, BAD_CAST "xml", 3); 13370 ctxt->str_xmlns = xmlDictLookup(ctxt->dict, BAD_CAST "xmlns", 5); 13371 ctxt->str_xml_ns = xmlDictLookup(ctxt->dict, XML_XML_NAMESPACE, 36); 13372 13373 #ifdef SAX2 13374 /* propagate namespaces down the entity */ 13375 for (i = 0;i < oldctxt->nsNr;i += 2) { 13376 nsPush(ctxt, oldctxt->nsTab[i], oldctxt->nsTab[i+1]); 13377 } 13378 #endif 13379 13380 oldsax = ctxt->sax; 13381 ctxt->sax = oldctxt->sax; 13382 xmlDetectSAX2(ctxt); 13383 ctxt->replaceEntities = oldctxt->replaceEntities; 13384 ctxt->options = oldctxt->options; 13385 13386 ctxt->_private = oldctxt->_private; 13387 if (oldctxt->myDoc == NULL) { 13388 newDoc = xmlNewDoc(BAD_CAST "1.0"); 13389 if (newDoc == NULL) { 13390 ctxt->sax = oldsax; 13391 ctxt->dict = NULL; 13392 xmlFreeParserCtxt(ctxt); 13393 return(XML_ERR_INTERNAL_ERROR); 13394 } 13395 newDoc->properties = XML_DOC_INTERNAL; 13396 newDoc->dict = ctxt->dict; 13397 xmlDictReference(newDoc->dict); 13398 ctxt->myDoc = newDoc; 13399 } else { 13400 ctxt->myDoc = oldctxt->myDoc; 13401 content = ctxt->myDoc->children; 13402 last = ctxt->myDoc->last; 13403 } 13404 newRoot = xmlNewDocNode(ctxt->myDoc, NULL, BAD_CAST "pseudoroot", NULL); 13405 if (newRoot == NULL) { 13406 ctxt->sax = oldsax; 13407 ctxt->dict = NULL; 13408 xmlFreeParserCtxt(ctxt); 13409 if (newDoc != NULL) { 13410 xmlFreeDoc(newDoc); 13411 } 13412 return(XML_ERR_INTERNAL_ERROR); 13413 } 13414 ctxt->myDoc->children = NULL; 13415 ctxt->myDoc->last = NULL; 13416 xmlAddChild((xmlNodePtr) ctxt->myDoc, newRoot); 13417 nodePush(ctxt, ctxt->myDoc->children); 13418 ctxt->instate = XML_PARSER_CONTENT; 13419 ctxt->depth = oldctxt->depth + 1; 13420 13421 ctxt->validate = 0; 13422 ctxt->loadsubset = oldctxt->loadsubset; 13423 if ((oldctxt->validate) || (oldctxt->replaceEntities != 0)) { 13424 /* 13425 * ID/IDREF registration will be done in xmlValidateElement below 13426 */ 13427 ctxt->loadsubset |= XML_SKIP_IDS; 13428 } 13429 ctxt->dictNames = oldctxt->dictNames; 13430 ctxt->attsDefault = oldctxt->attsDefault; 13431 ctxt->attsSpecial = oldctxt->attsSpecial; 13432 13433 xmlParseContent(ctxt); 13434 if ((RAW == '<') && (NXT(1) == '/')) { 13435 xmlFatalErr(ctxt, XML_ERR_NOT_WELL_BALANCED, NULL); 13436 } else if (RAW != 0) { 13437 xmlFatalErr(ctxt, XML_ERR_EXTRA_CONTENT, NULL); 13438 } 13439 if (ctxt->node != ctxt->myDoc->children) { 13440 xmlFatalErr(ctxt, XML_ERR_NOT_WELL_BALANCED, NULL); 13441 } 13442 13443 if (!ctxt->wellFormed) { 13444 if (ctxt->errNo == 0) 13445 ret = XML_ERR_INTERNAL_ERROR; 13446 else 13447 ret = (xmlParserErrors)ctxt->errNo; 13448 } else { 13449 ret = XML_ERR_OK; 13450 } 13451 13452 if ((lst != NULL) && (ret == XML_ERR_OK)) { 13453 xmlNodePtr cur; 13454 13455 /* 13456 * Return the newly created nodeset after unlinking it from 13457 * they pseudo parent. 13458 */ 13459 cur = ctxt->myDoc->children->children; 13460 *lst = cur; 13461 while (cur != NULL) { 13462 #ifdef LIBXML_VALID_ENABLED 13463 if ((oldctxt->validate) && (oldctxt->wellFormed) && 13464 (oldctxt->myDoc) && (oldctxt->myDoc->intSubset) && 13465 (cur->type == XML_ELEMENT_NODE)) { 13466 oldctxt->valid &= xmlValidateElement(&oldctxt->vctxt, 13467 oldctxt->myDoc, cur); 13468 } 13469 #endif /* LIBXML_VALID_ENABLED */ 13470 cur->parent = NULL; 13471 cur = cur->next; 13472 } 13473 ctxt->myDoc->children->children = NULL; 13474 } 13475 if (ctxt->myDoc != NULL) { 13476 xmlFreeNode(ctxt->myDoc->children); 13477 ctxt->myDoc->children = content; 13478 ctxt->myDoc->last = last; 13479 } 13480 13481 /* 13482 * Record in the parent context the number of entities replacement 13483 * done when parsing that reference. 13484 */ 13485 if (oldctxt != NULL) 13486 oldctxt->nbentities += ctxt->nbentities; 13487 13488 /* 13489 * Also record the last error if any 13490 */ 13491 if (ctxt->lastError.code != XML_ERR_OK) 13492 xmlCopyError(&ctxt->lastError, &oldctxt->lastError); 13493 13494 ctxt->sax = oldsax; 13495 ctxt->dict = NULL; 13496 ctxt->attsDefault = NULL; 13497 ctxt->attsSpecial = NULL; 13498 xmlFreeParserCtxt(ctxt); 13499 if (newDoc != NULL) { 13500 xmlFreeDoc(newDoc); 13501 } 13502 13503 return(ret); 13504 } 13505 13506 /** 13507 * xmlParseInNodeContext: 13508 * @node: the context node 13509 * @data: the input string 13510 * @datalen: the input string length in bytes 13511 * @options: a combination of xmlParserOption 13512 * @lst: the return value for the set of parsed nodes 13513 * 13514 * Parse a well-balanced chunk of an XML document 13515 * within the context (DTD, namespaces, etc ...) of the given node. 13516 * 13517 * The allowed sequence for the data is a Well Balanced Chunk defined by 13518 * the content production in the XML grammar: 13519 * 13520 * [43] content ::= (element | CharData | Reference | CDSect | PI | Comment)* 13521 * 13522 * Returns XML_ERR_OK if the chunk is well balanced, and the parser 13523 * error code otherwise 13524 */ 13525 xmlParserErrors 13526 xmlParseInNodeContext(xmlNodePtr node, const char *data, int datalen, 13527 int options, xmlNodePtr *lst) { 13528 #ifdef SAX2 13529 xmlParserCtxtPtr ctxt; 13530 xmlDocPtr doc = NULL; 13531 xmlNodePtr fake, cur; 13532 int nsnr = 0; 13533 13534 xmlParserErrors ret = XML_ERR_OK; 13535 13536 /* 13537 * check all input parameters, grab the document 13538 */ 13539 if ((lst == NULL) || (node == NULL) || (data == NULL) || (datalen < 0)) 13540 return(XML_ERR_INTERNAL_ERROR); 13541 switch (node->type) { 13542 case XML_ELEMENT_NODE: 13543 case XML_ATTRIBUTE_NODE: 13544 case XML_TEXT_NODE: 13545 case XML_CDATA_SECTION_NODE: 13546 case XML_ENTITY_REF_NODE: 13547 case XML_PI_NODE: 13548 case XML_COMMENT_NODE: 13549 case XML_DOCUMENT_NODE: 13550 case XML_HTML_DOCUMENT_NODE: 13551 break; 13552 default: 13553 return(XML_ERR_INTERNAL_ERROR); 13554 13555 } 13556 while ((node != NULL) && (node->type != XML_ELEMENT_NODE) && 13557 (node->type != XML_DOCUMENT_NODE) && 13558 (node->type != XML_HTML_DOCUMENT_NODE)) 13559 node = node->parent; 13560 if (node == NULL) 13561 return(XML_ERR_INTERNAL_ERROR); 13562 if (node->type == XML_ELEMENT_NODE) 13563 doc = node->doc; 13564 else 13565 doc = (xmlDocPtr) node; 13566 if (doc == NULL) 13567 return(XML_ERR_INTERNAL_ERROR); 13568 13569 /* 13570 * allocate a context and set-up everything not related to the 13571 * node position in the tree 13572 */ 13573 if (doc->type == XML_DOCUMENT_NODE) 13574 ctxt = xmlCreateMemoryParserCtxt((char *) data, datalen); 13575 #ifdef LIBXML_HTML_ENABLED 13576 else if (doc->type == XML_HTML_DOCUMENT_NODE) { 13577 ctxt = htmlCreateMemoryParserCtxt((char *) data, datalen); 13578 /* 13579 * When parsing in context, it makes no sense to add implied 13580 * elements like html/body/etc... 13581 */ 13582 options |= HTML_PARSE_NOIMPLIED; 13583 } 13584 #endif 13585 else 13586 return(XML_ERR_INTERNAL_ERROR); 13587 13588 if (ctxt == NULL) 13589 return(XML_ERR_NO_MEMORY); 13590 13591 /* 13592 * Use input doc's dict if present, else assure XML_PARSE_NODICT is set. 13593 * We need a dictionary for xmlDetectSAX2, so if there's no doc dict 13594 * we must wait until the last moment to free the original one. 13595 */ 13596 if (doc->dict != NULL) { 13597 if (ctxt->dict != NULL) 13598 xmlDictFree(ctxt->dict); 13599 ctxt->dict = doc->dict; 13600 } else 13601 options |= XML_PARSE_NODICT; 13602 13603 if (doc->encoding != NULL) { 13604 xmlCharEncodingHandlerPtr hdlr; 13605 13606 if (ctxt->encoding != NULL) 13607 xmlFree((xmlChar *) ctxt->encoding); 13608 ctxt->encoding = xmlStrdup((const xmlChar *) doc->encoding); 13609 13610 hdlr = xmlFindCharEncodingHandler(doc->encoding); 13611 if (hdlr != NULL) { 13612 xmlSwitchToEncoding(ctxt, hdlr); 13613 } else { 13614 return(XML_ERR_UNSUPPORTED_ENCODING); 13615 } 13616 } 13617 13618 xmlCtxtUseOptionsInternal(ctxt, options, NULL); 13619 xmlDetectSAX2(ctxt); 13620 ctxt->myDoc = doc; 13621 13622 fake = xmlNewComment(NULL); 13623 if (fake == NULL) { 13624 xmlFreeParserCtxt(ctxt); 13625 return(XML_ERR_NO_MEMORY); 13626 } 13627 xmlAddChild(node, fake); 13628 13629 if (node->type == XML_ELEMENT_NODE) { 13630 nodePush(ctxt, node); 13631 /* 13632 * initialize the SAX2 namespaces stack 13633 */ 13634 cur = node; 13635 while ((cur != NULL) && (cur->type == XML_ELEMENT_NODE)) { 13636 xmlNsPtr ns = cur->nsDef; 13637 const xmlChar *iprefix, *ihref; 13638 13639 while (ns != NULL) { 13640 if (ctxt->dict) { 13641 iprefix = xmlDictLookup(ctxt->dict, ns->prefix, -1); 13642 ihref = xmlDictLookup(ctxt->dict, ns->href, -1); 13643 } else { 13644 iprefix = ns->prefix; 13645 ihref = ns->href; 13646 } 13647 13648 if (xmlGetNamespace(ctxt, iprefix) == NULL) { 13649 nsPush(ctxt, iprefix, ihref); 13650 nsnr++; 13651 } 13652 ns = ns->next; 13653 } 13654 cur = cur->parent; 13655 } 13656 ctxt->instate = XML_PARSER_CONTENT; 13657 } 13658 13659 if ((ctxt->validate) || (ctxt->replaceEntities != 0)) { 13660 /* 13661 * ID/IDREF registration will be done in xmlValidateElement below 13662 */ 13663 ctxt->loadsubset |= XML_SKIP_IDS; 13664 } 13665 13666 #ifdef LIBXML_HTML_ENABLED 13667 if (doc->type == XML_HTML_DOCUMENT_NODE) 13668 __htmlParseContent(ctxt); 13669 else 13670 #endif 13671 xmlParseContent(ctxt); 13672 13673 nsPop(ctxt, nsnr); 13674 if ((RAW == '<') && (NXT(1) == '/')) { 13675 xmlFatalErr(ctxt, XML_ERR_NOT_WELL_BALANCED, NULL); 13676 } else if (RAW != 0) { 13677 xmlFatalErr(ctxt, XML_ERR_EXTRA_CONTENT, NULL); 13678 } 13679 if ((ctxt->node != NULL) && (ctxt->node != node)) { 13680 xmlFatalErr(ctxt, XML_ERR_NOT_WELL_BALANCED, NULL); 13681 ctxt->wellFormed = 0; 13682 } 13683 13684 if (!ctxt->wellFormed) { 13685 if (ctxt->errNo == 0) 13686 ret = XML_ERR_INTERNAL_ERROR; 13687 else 13688 ret = (xmlParserErrors)ctxt->errNo; 13689 } else { 13690 ret = XML_ERR_OK; 13691 } 13692 13693 /* 13694 * Return the newly created nodeset after unlinking it from 13695 * the pseudo sibling. 13696 */ 13697 13698 cur = fake->next; 13699 fake->next = NULL; 13700 node->last = fake; 13701 13702 if (cur != NULL) { 13703 cur->prev = NULL; 13704 } 13705 13706 *lst = cur; 13707 13708 while (cur != NULL) { 13709 cur->parent = NULL; 13710 cur = cur->next; 13711 } 13712 13713 xmlUnlinkNode(fake); 13714 xmlFreeNode(fake); 13715 13716 13717 if (ret != XML_ERR_OK) { 13718 xmlFreeNodeList(*lst); 13719 *lst = NULL; 13720 } 13721 13722 if (doc->dict != NULL) 13723 ctxt->dict = NULL; 13724 xmlFreeParserCtxt(ctxt); 13725 13726 return(ret); 13727 #else /* !SAX2 */ 13728 return(XML_ERR_INTERNAL_ERROR); 13729 #endif 13730 } 13731 13732 #ifdef LIBXML_SAX1_ENABLED 13733 /** 13734 * xmlParseBalancedChunkMemoryRecover: 13735 * @doc: the document the chunk pertains to 13736 * @sax: the SAX handler bloc (possibly NULL) 13737 * @user_data: The user data returned on SAX callbacks (possibly NULL) 13738 * @depth: Used for loop detection, use 0 13739 * @string: the input string in UTF8 or ISO-Latin (zero terminated) 13740 * @lst: the return value for the set of parsed nodes 13741 * @recover: return nodes even if the data is broken (use 0) 13742 * 13743 * 13744 * Parse a well-balanced chunk of an XML document 13745 * called by the parser 13746 * The allowed sequence for the Well Balanced Chunk is the one defined by 13747 * the content production in the XML grammar: 13748 * 13749 * [43] content ::= (element | CharData | Reference | CDSect | PI | Comment)* 13750 * 13751 * Returns 0 if the chunk is well balanced, -1 in case of args problem and 13752 * the parser error code otherwise 13753 * 13754 * In case recover is set to 1, the nodelist will not be empty even if 13755 * the parsed chunk is not well balanced, assuming the parsing succeeded to 13756 * some extent. 13757 */ 13758 int 13759 xmlParseBalancedChunkMemoryRecover(xmlDocPtr doc, xmlSAXHandlerPtr sax, 13760 void *user_data, int depth, const xmlChar *string, xmlNodePtr *lst, 13761 int recover) { 13762 xmlParserCtxtPtr ctxt; 13763 xmlDocPtr newDoc; 13764 xmlSAXHandlerPtr oldsax = NULL; 13765 xmlNodePtr content, newRoot; 13766 int size; 13767 int ret = 0; 13768 13769 if (depth > 40) { 13770 return(XML_ERR_ENTITY_LOOP); 13771 } 13772 13773 13774 if (lst != NULL) 13775 *lst = NULL; 13776 if (string == NULL) 13777 return(-1); 13778 13779 size = xmlStrlen(string); 13780 13781 ctxt = xmlCreateMemoryParserCtxt((char *) string, size); 13782 if (ctxt == NULL) return(-1); 13783 ctxt->userData = ctxt; 13784 if (sax != NULL) { 13785 oldsax = ctxt->sax; 13786 ctxt->sax = sax; 13787 if (user_data != NULL) 13788 ctxt->userData = user_data; 13789 } 13790 newDoc = xmlNewDoc(BAD_CAST "1.0"); 13791 if (newDoc == NULL) { 13792 xmlFreeParserCtxt(ctxt); 13793 return(-1); 13794 } 13795 newDoc->properties = XML_DOC_INTERNAL; 13796 if ((doc != NULL) && (doc->dict != NULL)) { 13797 xmlDictFree(ctxt->dict); 13798 ctxt->dict = doc->dict; 13799 xmlDictReference(ctxt->dict); 13800 ctxt->str_xml = xmlDictLookup(ctxt->dict, BAD_CAST "xml", 3); 13801 ctxt->str_xmlns = xmlDictLookup(ctxt->dict, BAD_CAST "xmlns", 5); 13802 ctxt->str_xml_ns = xmlDictLookup(ctxt->dict, XML_XML_NAMESPACE, 36); 13803 ctxt->dictNames = 1; 13804 } else { 13805 xmlCtxtUseOptionsInternal(ctxt, XML_PARSE_NODICT, NULL); 13806 } 13807 if (doc != NULL) { 13808 newDoc->intSubset = doc->intSubset; 13809 newDoc->extSubset = doc->extSubset; 13810 } 13811 newRoot = xmlNewDocNode(newDoc, NULL, BAD_CAST "pseudoroot", NULL); 13812 if (newRoot == NULL) { 13813 if (sax != NULL) 13814 ctxt->sax = oldsax; 13815 xmlFreeParserCtxt(ctxt); 13816 newDoc->intSubset = NULL; 13817 newDoc->extSubset = NULL; 13818 xmlFreeDoc(newDoc); 13819 return(-1); 13820 } 13821 xmlAddChild((xmlNodePtr) newDoc, newRoot); 13822 nodePush(ctxt, newRoot); 13823 if (doc == NULL) { 13824 ctxt->myDoc = newDoc; 13825 } else { 13826 ctxt->myDoc = newDoc; 13827 newDoc->children->doc = doc; 13828 /* Ensure that doc has XML spec namespace */ 13829 xmlSearchNsByHref(doc, (xmlNodePtr)doc, XML_XML_NAMESPACE); 13830 newDoc->oldNs = doc->oldNs; 13831 } 13832 ctxt->instate = XML_PARSER_CONTENT; 13833 ctxt->depth = depth; 13834 13835 /* 13836 * Doing validity checking on chunk doesn't make sense 13837 */ 13838 ctxt->validate = 0; 13839 ctxt->loadsubset = 0; 13840 xmlDetectSAX2(ctxt); 13841 13842 if ( doc != NULL ){ 13843 content = doc->children; 13844 doc->children = NULL; 13845 xmlParseContent(ctxt); 13846 doc->children = content; 13847 } 13848 else { 13849 xmlParseContent(ctxt); 13850 } 13851 if ((RAW == '<') && (NXT(1) == '/')) { 13852 xmlFatalErr(ctxt, XML_ERR_NOT_WELL_BALANCED, NULL); 13853 } else if (RAW != 0) { 13854 xmlFatalErr(ctxt, XML_ERR_EXTRA_CONTENT, NULL); 13855 } 13856 if (ctxt->node != newDoc->children) { 13857 xmlFatalErr(ctxt, XML_ERR_NOT_WELL_BALANCED, NULL); 13858 } 13859 13860 if (!ctxt->wellFormed) { 13861 if (ctxt->errNo == 0) 13862 ret = 1; 13863 else 13864 ret = ctxt->errNo; 13865 } else { 13866 ret = 0; 13867 } 13868 13869 if ((lst != NULL) && ((ret == 0) || (recover == 1))) { 13870 xmlNodePtr cur; 13871 13872 /* 13873 * Return the newly created nodeset after unlinking it from 13874 * they pseudo parent. 13875 */ 13876 cur = newDoc->children->children; 13877 *lst = cur; 13878 while (cur != NULL) { 13879 xmlSetTreeDoc(cur, doc); 13880 cur->parent = NULL; 13881 cur = cur->next; 13882 } 13883 newDoc->children->children = NULL; 13884 } 13885 13886 if (sax != NULL) 13887 ctxt->sax = oldsax; 13888 xmlFreeParserCtxt(ctxt); 13889 newDoc->intSubset = NULL; 13890 newDoc->extSubset = NULL; 13891 newDoc->oldNs = NULL; 13892 xmlFreeDoc(newDoc); 13893 13894 return(ret); 13895 } 13896 13897 /** 13898 * xmlSAXParseEntity: 13899 * @sax: the SAX handler block 13900 * @filename: the filename 13901 * 13902 * parse an XML external entity out of context and build a tree. 13903 * It use the given SAX function block to handle the parsing callback. 13904 * If sax is NULL, fallback to the default DOM tree building routines. 13905 * 13906 * [78] extParsedEnt ::= TextDecl? content 13907 * 13908 * This correspond to a "Well Balanced" chunk 13909 * 13910 * Returns the resulting document tree 13911 */ 13912 13913 xmlDocPtr 13914 xmlSAXParseEntity(xmlSAXHandlerPtr sax, const char *filename) { 13915 xmlDocPtr ret; 13916 xmlParserCtxtPtr ctxt; 13917 13918 ctxt = xmlCreateFileParserCtxt(filename); 13919 if (ctxt == NULL) { 13920 return(NULL); 13921 } 13922 if (sax != NULL) { 13923 if (ctxt->sax != NULL) 13924 xmlFree(ctxt->sax); 13925 ctxt->sax = sax; 13926 ctxt->userData = NULL; 13927 } 13928 13929 xmlParseExtParsedEnt(ctxt); 13930 13931 if (ctxt->wellFormed) 13932 ret = ctxt->myDoc; 13933 else { 13934 ret = NULL; 13935 xmlFreeDoc(ctxt->myDoc); 13936 ctxt->myDoc = NULL; 13937 } 13938 if (sax != NULL) 13939 ctxt->sax = NULL; 13940 xmlFreeParserCtxt(ctxt); 13941 13942 return(ret); 13943 } 13944 13945 /** 13946 * xmlParseEntity: 13947 * @filename: the filename 13948 * 13949 * parse an XML external entity out of context and build a tree. 13950 * 13951 * [78] extParsedEnt ::= TextDecl? content 13952 * 13953 * This correspond to a "Well Balanced" chunk 13954 * 13955 * Returns the resulting document tree 13956 */ 13957 13958 xmlDocPtr 13959 xmlParseEntity(const char *filename) { 13960 return(xmlSAXParseEntity(NULL, filename)); 13961 } 13962 #endif /* LIBXML_SAX1_ENABLED */ 13963 13964 /** 13965 * xmlCreateEntityParserCtxtInternal: 13966 * @URL: the entity URL 13967 * @ID: the entity PUBLIC ID 13968 * @base: a possible base for the target URI 13969 * @pctx: parser context used to set options on new context 13970 * 13971 * Create a parser context for an external entity 13972 * Automatic support for ZLIB/Compress compressed document is provided 13973 * by default if found at compile-time. 13974 * 13975 * Returns the new parser context or NULL 13976 */ 13977 static xmlParserCtxtPtr 13978 xmlCreateEntityParserCtxtInternal(const xmlChar *URL, const xmlChar *ID, 13979 const xmlChar *base, xmlParserCtxtPtr pctx) { 13980 xmlParserCtxtPtr ctxt; 13981 xmlParserInputPtr inputStream; 13982 char *directory = NULL; 13983 xmlChar *uri; 13984 13985 ctxt = xmlNewParserCtxt(); 13986 if (ctxt == NULL) { 13987 return(NULL); 13988 } 13989 13990 if (pctx != NULL) { 13991 ctxt->options = pctx->options; 13992 ctxt->_private = pctx->_private; 13993 } 13994 13995 uri = xmlBuildURI(URL, base); 13996 13997 if (uri == NULL) { 13998 inputStream = xmlLoadExternalEntity((char *)URL, (char *)ID, ctxt); 13999 if (inputStream == NULL) { 14000 xmlFreeParserCtxt(ctxt); 14001 return(NULL); 14002 } 14003 14004 inputPush(ctxt, inputStream); 14005 14006 if ((ctxt->directory == NULL) && (directory == NULL)) 14007 directory = xmlParserGetDirectory((char *)URL); 14008 if ((ctxt->directory == NULL) && (directory != NULL)) 14009 ctxt->directory = directory; 14010 } else { 14011 inputStream = xmlLoadExternalEntity((char *)uri, (char *)ID, ctxt); 14012 if (inputStream == NULL) { 14013 xmlFree(uri); 14014 xmlFreeParserCtxt(ctxt); 14015 return(NULL); 14016 } 14017 14018 inputPush(ctxt, inputStream); 14019 14020 if ((ctxt->directory == NULL) && (directory == NULL)) 14021 directory = xmlParserGetDirectory((char *)uri); 14022 if ((ctxt->directory == NULL) && (directory != NULL)) 14023 ctxt->directory = directory; 14024 xmlFree(uri); 14025 } 14026 return(ctxt); 14027 } 14028 14029 /** 14030 * xmlCreateEntityParserCtxt: 14031 * @URL: the entity URL 14032 * @ID: the entity PUBLIC ID 14033 * @base: a possible base for the target URI 14034 * 14035 * Create a parser context for an external entity 14036 * Automatic support for ZLIB/Compress compressed document is provided 14037 * by default if found at compile-time. 14038 * 14039 * Returns the new parser context or NULL 14040 */ 14041 xmlParserCtxtPtr 14042 xmlCreateEntityParserCtxt(const xmlChar *URL, const xmlChar *ID, 14043 const xmlChar *base) { 14044 return xmlCreateEntityParserCtxtInternal(URL, ID, base, NULL); 14045 14046 } 14047 14048 /************************************************************************ 14049 * * 14050 * Front ends when parsing from a file * 14051 * * 14052 ************************************************************************/ 14053 14054 /** 14055 * xmlCreateURLParserCtxt: 14056 * @filename: the filename or URL 14057 * @options: a combination of xmlParserOption 14058 * 14059 * Create a parser context for a file or URL content. 14060 * Automatic support for ZLIB/Compress compressed document is provided 14061 * by default if found at compile-time and for file accesses 14062 * 14063 * Returns the new parser context or NULL 14064 */ 14065 xmlParserCtxtPtr 14066 xmlCreateURLParserCtxt(const char *filename, int options) 14067 { 14068 xmlParserCtxtPtr ctxt; 14069 xmlParserInputPtr inputStream; 14070 char *directory = NULL; 14071 14072 ctxt = xmlNewParserCtxt(); 14073 if (ctxt == NULL) { 14074 xmlErrMemory(NULL, "cannot allocate parser context"); 14075 return(NULL); 14076 } 14077 14078 if (options) 14079 xmlCtxtUseOptionsInternal(ctxt, options, NULL); 14080 ctxt->linenumbers = 1; 14081 14082 inputStream = xmlLoadExternalEntity(filename, NULL, ctxt); 14083 if (inputStream == NULL) { 14084 xmlFreeParserCtxt(ctxt); 14085 return(NULL); 14086 } 14087 14088 inputPush(ctxt, inputStream); 14089 if ((ctxt->directory == NULL) && (directory == NULL)) 14090 directory = xmlParserGetDirectory(filename); 14091 if ((ctxt->directory == NULL) && (directory != NULL)) 14092 ctxt->directory = directory; 14093 14094 return(ctxt); 14095 } 14096 14097 /** 14098 * xmlCreateFileParserCtxt: 14099 * @filename: the filename 14100 * 14101 * Create a parser context for a file content. 14102 * Automatic support for ZLIB/Compress compressed document is provided 14103 * by default if found at compile-time. 14104 * 14105 * Returns the new parser context or NULL 14106 */ 14107 xmlParserCtxtPtr 14108 xmlCreateFileParserCtxt(const char *filename) 14109 { 14110 return(xmlCreateURLParserCtxt(filename, 0)); 14111 } 14112 14113 #ifdef LIBXML_SAX1_ENABLED 14114 /** 14115 * xmlSAXParseFileWithData: 14116 * @sax: the SAX handler block 14117 * @filename: the filename 14118 * @recovery: work in recovery mode, i.e. tries to read no Well Formed 14119 * documents 14120 * @data: the userdata 14121 * 14122 * parse an XML file and build a tree. Automatic support for ZLIB/Compress 14123 * compressed document is provided by default if found at compile-time. 14124 * It use the given SAX function block to handle the parsing callback. 14125 * If sax is NULL, fallback to the default DOM tree building routines. 14126 * 14127 * User data (void *) is stored within the parser context in the 14128 * context's _private member, so it is available nearly everywhere in libxml 14129 * 14130 * Returns the resulting document tree 14131 */ 14132 14133 xmlDocPtr 14134 xmlSAXParseFileWithData(xmlSAXHandlerPtr sax, const char *filename, 14135 int recovery, void *data) { 14136 xmlDocPtr ret; 14137 xmlParserCtxtPtr ctxt; 14138 14139 xmlInitParser(); 14140 14141 ctxt = xmlCreateFileParserCtxt(filename); 14142 if (ctxt == NULL) { 14143 return(NULL); 14144 } 14145 if (sax != NULL) { 14146 if (ctxt->sax != NULL) 14147 xmlFree(ctxt->sax); 14148 ctxt->sax = sax; 14149 } 14150 xmlDetectSAX2(ctxt); 14151 if (data!=NULL) { 14152 ctxt->_private = data; 14153 } 14154 14155 if (ctxt->directory == NULL) 14156 ctxt->directory = xmlParserGetDirectory(filename); 14157 14158 ctxt->recovery = recovery; 14159 14160 xmlParseDocument(ctxt); 14161 14162 if ((ctxt->wellFormed) || recovery) { 14163 ret = ctxt->myDoc; 14164 if (ret != NULL) { 14165 if (ctxt->input->buf->compressed > 0) 14166 ret->compression = 9; 14167 else 14168 ret->compression = ctxt->input->buf->compressed; 14169 } 14170 } 14171 else { 14172 ret = NULL; 14173 xmlFreeDoc(ctxt->myDoc); 14174 ctxt->myDoc = NULL; 14175 } 14176 if (sax != NULL) 14177 ctxt->sax = NULL; 14178 xmlFreeParserCtxt(ctxt); 14179 14180 return(ret); 14181 } 14182 14183 /** 14184 * xmlSAXParseFile: 14185 * @sax: the SAX handler block 14186 * @filename: the filename 14187 * @recovery: work in recovery mode, i.e. tries to read no Well Formed 14188 * documents 14189 * 14190 * parse an XML file and build a tree. Automatic support for ZLIB/Compress 14191 * compressed document is provided by default if found at compile-time. 14192 * It use the given SAX function block to handle the parsing callback. 14193 * If sax is NULL, fallback to the default DOM tree building routines. 14194 * 14195 * Returns the resulting document tree 14196 */ 14197 14198 xmlDocPtr 14199 xmlSAXParseFile(xmlSAXHandlerPtr sax, const char *filename, 14200 int recovery) { 14201 return(xmlSAXParseFileWithData(sax,filename,recovery,NULL)); 14202 } 14203 14204 /** 14205 * xmlRecoverDoc: 14206 * @cur: a pointer to an array of xmlChar 14207 * 14208 * parse an XML in-memory document and build a tree. 14209 * In the case the document is not Well Formed, a attempt to build a 14210 * tree is tried anyway 14211 * 14212 * Returns the resulting document tree or NULL in case of failure 14213 */ 14214 14215 xmlDocPtr 14216 xmlRecoverDoc(const xmlChar *cur) { 14217 return(xmlSAXParseDoc(NULL, cur, 1)); 14218 } 14219 14220 /** 14221 * xmlParseFile: 14222 * @filename: the filename 14223 * 14224 * parse an XML file and build a tree. Automatic support for ZLIB/Compress 14225 * compressed document is provided by default if found at compile-time. 14226 * 14227 * Returns the resulting document tree if the file was wellformed, 14228 * NULL otherwise. 14229 */ 14230 14231 xmlDocPtr 14232 xmlParseFile(const char *filename) { 14233 return(xmlSAXParseFile(NULL, filename, 0)); 14234 } 14235 14236 /** 14237 * xmlRecoverFile: 14238 * @filename: the filename 14239 * 14240 * parse an XML file and build a tree. Automatic support for ZLIB/Compress 14241 * compressed document is provided by default if found at compile-time. 14242 * In the case the document is not Well Formed, it attempts to build 14243 * a tree anyway 14244 * 14245 * Returns the resulting document tree or NULL in case of failure 14246 */ 14247 14248 xmlDocPtr 14249 xmlRecoverFile(const char *filename) { 14250 return(xmlSAXParseFile(NULL, filename, 1)); 14251 } 14252 14253 14254 /** 14255 * xmlSetupParserForBuffer: 14256 * @ctxt: an XML parser context 14257 * @buffer: a xmlChar * buffer 14258 * @filename: a file name 14259 * 14260 * Setup the parser context to parse a new buffer; Clears any prior 14261 * contents from the parser context. The buffer parameter must not be 14262 * NULL, but the filename parameter can be 14263 */ 14264 void 14265 xmlSetupParserForBuffer(xmlParserCtxtPtr ctxt, const xmlChar* buffer, 14266 const char* filename) 14267 { 14268 xmlParserInputPtr input; 14269 14270 if ((ctxt == NULL) || (buffer == NULL)) 14271 return; 14272 14273 input = xmlNewInputStream(ctxt); 14274 if (input == NULL) { 14275 xmlErrMemory(NULL, "parsing new buffer: out of memory\n"); 14276 xmlClearParserCtxt(ctxt); 14277 return; 14278 } 14279 14280 xmlClearParserCtxt(ctxt); 14281 if (filename != NULL) 14282 input->filename = (char *) xmlCanonicPath((const xmlChar *)filename); 14283 input->base = buffer; 14284 input->cur = buffer; 14285 input->end = &buffer[xmlStrlen(buffer)]; 14286 inputPush(ctxt, input); 14287 } 14288 14289 /** 14290 * xmlSAXUserParseFile: 14291 * @sax: a SAX handler 14292 * @user_data: The user data returned on SAX callbacks 14293 * @filename: a file name 14294 * 14295 * parse an XML file and call the given SAX handler routines. 14296 * Automatic support for ZLIB/Compress compressed document is provided 14297 * 14298 * Returns 0 in case of success or a error number otherwise 14299 */ 14300 int 14301 xmlSAXUserParseFile(xmlSAXHandlerPtr sax, void *user_data, 14302 const char *filename) { 14303 int ret = 0; 14304 xmlParserCtxtPtr ctxt; 14305 14306 ctxt = xmlCreateFileParserCtxt(filename); 14307 if (ctxt == NULL) return -1; 14308 if (ctxt->sax != (xmlSAXHandlerPtr) &xmlDefaultSAXHandler) 14309 xmlFree(ctxt->sax); 14310 ctxt->sax = sax; 14311 xmlDetectSAX2(ctxt); 14312 14313 if (user_data != NULL) 14314 ctxt->userData = user_data; 14315 14316 xmlParseDocument(ctxt); 14317 14318 if (ctxt->wellFormed) 14319 ret = 0; 14320 else { 14321 if (ctxt->errNo != 0) 14322 ret = ctxt->errNo; 14323 else 14324 ret = -1; 14325 } 14326 if (sax != NULL) 14327 ctxt->sax = NULL; 14328 if (ctxt->myDoc != NULL) { 14329 xmlFreeDoc(ctxt->myDoc); 14330 ctxt->myDoc = NULL; 14331 } 14332 xmlFreeParserCtxt(ctxt); 14333 14334 return ret; 14335 } 14336 #endif /* LIBXML_SAX1_ENABLED */ 14337 14338 /************************************************************************ 14339 * * 14340 * Front ends when parsing from memory * 14341 * * 14342 ************************************************************************/ 14343 14344 /** 14345 * xmlCreateMemoryParserCtxt: 14346 * @buffer: a pointer to a char array 14347 * @size: the size of the array 14348 * 14349 * Create a parser context for an XML in-memory document. 14350 * 14351 * Returns the new parser context or NULL 14352 */ 14353 xmlParserCtxtPtr 14354 xmlCreateMemoryParserCtxt(const char *buffer, int size) { 14355 xmlParserCtxtPtr ctxt; 14356 xmlParserInputPtr input; 14357 xmlParserInputBufferPtr buf; 14358 14359 if (buffer == NULL) 14360 return(NULL); 14361 if (size <= 0) 14362 return(NULL); 14363 14364 ctxt = xmlNewParserCtxt(); 14365 if (ctxt == NULL) 14366 return(NULL); 14367 14368 /* TODO: xmlParserInputBufferCreateStatic, requires some serious changes */ 14369 buf = xmlParserInputBufferCreateMem(buffer, size, XML_CHAR_ENCODING_NONE); 14370 if (buf == NULL) { 14371 xmlFreeParserCtxt(ctxt); 14372 return(NULL); 14373 } 14374 14375 input = xmlNewInputStream(ctxt); 14376 if (input == NULL) { 14377 xmlFreeParserInputBuffer(buf); 14378 xmlFreeParserCtxt(ctxt); 14379 return(NULL); 14380 } 14381 14382 input->filename = NULL; 14383 input->buf = buf; 14384 xmlBufResetInput(input->buf->buffer, input); 14385 14386 inputPush(ctxt, input); 14387 return(ctxt); 14388 } 14389 14390 #ifdef LIBXML_SAX1_ENABLED 14391 /** 14392 * xmlSAXParseMemoryWithData: 14393 * @sax: the SAX handler block 14394 * @buffer: an pointer to a char array 14395 * @size: the size of the array 14396 * @recovery: work in recovery mode, i.e. tries to read no Well Formed 14397 * documents 14398 * @data: the userdata 14399 * 14400 * parse an XML in-memory block and use the given SAX function block 14401 * to handle the parsing callback. If sax is NULL, fallback to the default 14402 * DOM tree building routines. 14403 * 14404 * User data (void *) is stored within the parser context in the 14405 * context's _private member, so it is available nearly everywhere in libxml 14406 * 14407 * Returns the resulting document tree 14408 */ 14409 14410 xmlDocPtr 14411 xmlSAXParseMemoryWithData(xmlSAXHandlerPtr sax, const char *buffer, 14412 int size, int recovery, void *data) { 14413 xmlDocPtr ret; 14414 xmlParserCtxtPtr ctxt; 14415 14416 xmlInitParser(); 14417 14418 ctxt = xmlCreateMemoryParserCtxt(buffer, size); 14419 if (ctxt == NULL) return(NULL); 14420 if (sax != NULL) { 14421 if (ctxt->sax != NULL) 14422 xmlFree(ctxt->sax); 14423 ctxt->sax = sax; 14424 } 14425 xmlDetectSAX2(ctxt); 14426 if (data!=NULL) { 14427 ctxt->_private=data; 14428 } 14429 14430 ctxt->recovery = recovery; 14431 14432 xmlParseDocument(ctxt); 14433 14434 if ((ctxt->wellFormed) || recovery) ret = ctxt->myDoc; 14435 else { 14436 ret = NULL; 14437 xmlFreeDoc(ctxt->myDoc); 14438 ctxt->myDoc = NULL; 14439 } 14440 if (sax != NULL) 14441 ctxt->sax = NULL; 14442 xmlFreeParserCtxt(ctxt); 14443 14444 return(ret); 14445 } 14446 14447 /** 14448 * xmlSAXParseMemory: 14449 * @sax: the SAX handler block 14450 * @buffer: an pointer to a char array 14451 * @size: the size of the array 14452 * @recovery: work in recovery mode, i.e. tries to read not Well Formed 14453 * documents 14454 * 14455 * parse an XML in-memory block and use the given SAX function block 14456 * to handle the parsing callback. If sax is NULL, fallback to the default 14457 * DOM tree building routines. 14458 * 14459 * Returns the resulting document tree 14460 */ 14461 xmlDocPtr 14462 xmlSAXParseMemory(xmlSAXHandlerPtr sax, const char *buffer, 14463 int size, int recovery) { 14464 return xmlSAXParseMemoryWithData(sax, buffer, size, recovery, NULL); 14465 } 14466 14467 /** 14468 * xmlParseMemory: 14469 * @buffer: an pointer to a char array 14470 * @size: the size of the array 14471 * 14472 * parse an XML in-memory block and build a tree. 14473 * 14474 * Returns the resulting document tree 14475 */ 14476 14477 xmlDocPtr xmlParseMemory(const char *buffer, int size) { 14478 return(xmlSAXParseMemory(NULL, buffer, size, 0)); 14479 } 14480 14481 /** 14482 * xmlRecoverMemory: 14483 * @buffer: an pointer to a char array 14484 * @size: the size of the array 14485 * 14486 * parse an XML in-memory block and build a tree. 14487 * In the case the document is not Well Formed, an attempt to 14488 * build a tree is tried anyway 14489 * 14490 * Returns the resulting document tree or NULL in case of error 14491 */ 14492 14493 xmlDocPtr xmlRecoverMemory(const char *buffer, int size) { 14494 return(xmlSAXParseMemory(NULL, buffer, size, 1)); 14495 } 14496 14497 /** 14498 * xmlSAXUserParseMemory: 14499 * @sax: a SAX handler 14500 * @user_data: The user data returned on SAX callbacks 14501 * @buffer: an in-memory XML document input 14502 * @size: the length of the XML document in bytes 14503 * 14504 * A better SAX parsing routine. 14505 * parse an XML in-memory buffer and call the given SAX handler routines. 14506 * 14507 * Returns 0 in case of success or a error number otherwise 14508 */ 14509 int xmlSAXUserParseMemory(xmlSAXHandlerPtr sax, void *user_data, 14510 const char *buffer, int size) { 14511 int ret = 0; 14512 xmlParserCtxtPtr ctxt; 14513 14514 xmlInitParser(); 14515 14516 ctxt = xmlCreateMemoryParserCtxt(buffer, size); 14517 if (ctxt == NULL) return -1; 14518 if (ctxt->sax != (xmlSAXHandlerPtr) &xmlDefaultSAXHandler) 14519 xmlFree(ctxt->sax); 14520 ctxt->sax = sax; 14521 xmlDetectSAX2(ctxt); 14522 14523 if (user_data != NULL) 14524 ctxt->userData = user_data; 14525 14526 xmlParseDocument(ctxt); 14527 14528 if (ctxt->wellFormed) 14529 ret = 0; 14530 else { 14531 if (ctxt->errNo != 0) 14532 ret = ctxt->errNo; 14533 else 14534 ret = -1; 14535 } 14536 if (sax != NULL) 14537 ctxt->sax = NULL; 14538 if (ctxt->myDoc != NULL) { 14539 xmlFreeDoc(ctxt->myDoc); 14540 ctxt->myDoc = NULL; 14541 } 14542 xmlFreeParserCtxt(ctxt); 14543 14544 return ret; 14545 } 14546 #endif /* LIBXML_SAX1_ENABLED */ 14547 14548 /** 14549 * xmlCreateDocParserCtxt: 14550 * @cur: a pointer to an array of xmlChar 14551 * 14552 * Creates a parser context for an XML in-memory document. 14553 * 14554 * Returns the new parser context or NULL 14555 */ 14556 xmlParserCtxtPtr 14557 xmlCreateDocParserCtxt(const xmlChar *cur) { 14558 int len; 14559 14560 if (cur == NULL) 14561 return(NULL); 14562 len = xmlStrlen(cur); 14563 return(xmlCreateMemoryParserCtxt((const char *)cur, len)); 14564 } 14565 14566 #ifdef LIBXML_SAX1_ENABLED 14567 /** 14568 * xmlSAXParseDoc: 14569 * @sax: the SAX handler block 14570 * @cur: a pointer to an array of xmlChar 14571 * @recovery: work in recovery mode, i.e. tries to read no Well Formed 14572 * documents 14573 * 14574 * parse an XML in-memory document and build a tree. 14575 * It use the given SAX function block to handle the parsing callback. 14576 * If sax is NULL, fallback to the default DOM tree building routines. 14577 * 14578 * Returns the resulting document tree 14579 */ 14580 14581 xmlDocPtr 14582 xmlSAXParseDoc(xmlSAXHandlerPtr sax, const xmlChar *cur, int recovery) { 14583 xmlDocPtr ret; 14584 xmlParserCtxtPtr ctxt; 14585 xmlSAXHandlerPtr oldsax = NULL; 14586 14587 if (cur == NULL) return(NULL); 14588 14589 14590 ctxt = xmlCreateDocParserCtxt(cur); 14591 if (ctxt == NULL) return(NULL); 14592 if (sax != NULL) { 14593 oldsax = ctxt->sax; 14594 ctxt->sax = sax; 14595 ctxt->userData = NULL; 14596 } 14597 xmlDetectSAX2(ctxt); 14598 14599 xmlParseDocument(ctxt); 14600 if ((ctxt->wellFormed) || recovery) ret = ctxt->myDoc; 14601 else { 14602 ret = NULL; 14603 xmlFreeDoc(ctxt->myDoc); 14604 ctxt->myDoc = NULL; 14605 } 14606 if (sax != NULL) 14607 ctxt->sax = oldsax; 14608 xmlFreeParserCtxt(ctxt); 14609 14610 return(ret); 14611 } 14612 14613 /** 14614 * xmlParseDoc: 14615 * @cur: a pointer to an array of xmlChar 14616 * 14617 * parse an XML in-memory document and build a tree. 14618 * 14619 * Returns the resulting document tree 14620 */ 14621 14622 xmlDocPtr 14623 xmlParseDoc(const xmlChar *cur) { 14624 return(xmlSAXParseDoc(NULL, cur, 0)); 14625 } 14626 #endif /* LIBXML_SAX1_ENABLED */ 14627 14628 #ifdef LIBXML_LEGACY_ENABLED 14629 /************************************************************************ 14630 * * 14631 * Specific function to keep track of entities references * 14632 * and used by the XSLT debugger * 14633 * * 14634 ************************************************************************/ 14635 14636 static xmlEntityReferenceFunc xmlEntityRefFunc = NULL; 14637 14638 /** 14639 * xmlAddEntityReference: 14640 * @ent : A valid entity 14641 * @firstNode : A valid first node for children of entity 14642 * @lastNode : A valid last node of children entity 14643 * 14644 * Notify of a reference to an entity of type XML_EXTERNAL_GENERAL_PARSED_ENTITY 14645 */ 14646 static void 14647 xmlAddEntityReference(xmlEntityPtr ent, xmlNodePtr firstNode, 14648 xmlNodePtr lastNode) 14649 { 14650 if (xmlEntityRefFunc != NULL) { 14651 (*xmlEntityRefFunc) (ent, firstNode, lastNode); 14652 } 14653 } 14654 14655 14656 /** 14657 * xmlSetEntityReferenceFunc: 14658 * @func: A valid function 14659 * 14660 * Set the function to call call back when a xml reference has been made 14661 */ 14662 void 14663 xmlSetEntityReferenceFunc(xmlEntityReferenceFunc func) 14664 { 14665 xmlEntityRefFunc = func; 14666 } 14667 #endif /* LIBXML_LEGACY_ENABLED */ 14668 14669 /************************************************************************ 14670 * * 14671 * Miscellaneous * 14672 * * 14673 ************************************************************************/ 14674 14675 #ifdef LIBXML_XPATH_ENABLED 14676 #include <libxml/xpath.h> 14677 #endif 14678 14679 extern void XMLCDECL xmlGenericErrorDefaultFunc(void *ctx, const char *msg, ...); 14680 static int xmlParserInitialized = 0; 14681 14682 /** 14683 * xmlInitParser: 14684 * 14685 * Initialization function for the XML parser. 14686 * This is not reentrant. Call once before processing in case of 14687 * use in multithreaded programs. 14688 */ 14689 14690 void 14691 xmlInitParser(void) { 14692 if (xmlParserInitialized != 0) 14693 return; 14694 14695 #ifdef LIBXML_THREAD_ENABLED 14696 __xmlGlobalInitMutexLock(); 14697 if (xmlParserInitialized == 0) { 14698 #endif 14699 xmlInitThreads(); 14700 xmlInitGlobals(); 14701 if ((xmlGenericError == xmlGenericErrorDefaultFunc) || 14702 (xmlGenericError == NULL)) 14703 initGenericErrorDefaultFunc(NULL); 14704 xmlInitMemory(); 14705 xmlInitializeDict(); 14706 xmlInitCharEncodingHandlers(); 14707 xmlDefaultSAXHandlerInit(); 14708 xmlRegisterDefaultInputCallbacks(); 14709 #ifdef LIBXML_OUTPUT_ENABLED 14710 xmlRegisterDefaultOutputCallbacks(); 14711 #endif /* LIBXML_OUTPUT_ENABLED */ 14712 #ifdef LIBXML_HTML_ENABLED 14713 htmlInitAutoClose(); 14714 htmlDefaultSAXHandlerInit(); 14715 #endif 14716 #ifdef LIBXML_XPATH_ENABLED 14717 xmlXPathInit(); 14718 #endif 14719 xmlParserInitialized = 1; 14720 #ifdef LIBXML_THREAD_ENABLED 14721 } 14722 __xmlGlobalInitMutexUnlock(); 14723 #endif 14724 } 14725 14726 /** 14727 * xmlCleanupParser: 14728 * 14729 * This function name is somewhat misleading. It does not clean up 14730 * parser state, it cleans up memory allocated by the library itself. 14731 * It is a cleanup function for the XML library. It tries to reclaim all 14732 * related global memory allocated for the library processing. 14733 * It doesn't deallocate any document related memory. One should 14734 * call xmlCleanupParser() only when the process has finished using 14735 * the library and all XML/HTML documents built with it. 14736 * See also xmlInitParser() which has the opposite function of preparing 14737 * the library for operations. 14738 * 14739 * WARNING: if your application is multithreaded or has plugin support 14740 * calling this may crash the application if another thread or 14741 * a plugin is still using libxml2. It's sometimes very hard to 14742 * guess if libxml2 is in use in the application, some libraries 14743 * or plugins may use it without notice. In case of doubt abstain 14744 * from calling this function or do it just before calling exit() 14745 * to avoid leak reports from valgrind ! 14746 */ 14747 14748 void 14749 xmlCleanupParser(void) { 14750 if (!xmlParserInitialized) 14751 return; 14752 14753 xmlCleanupCharEncodingHandlers(); 14754 #ifdef LIBXML_CATALOG_ENABLED 14755 xmlCatalogCleanup(); 14756 #endif 14757 xmlDictCleanup(); 14758 xmlCleanupInputCallbacks(); 14759 #ifdef LIBXML_OUTPUT_ENABLED 14760 xmlCleanupOutputCallbacks(); 14761 #endif 14762 #ifdef LIBXML_SCHEMAS_ENABLED 14763 xmlSchemaCleanupTypes(); 14764 xmlRelaxNGCleanupTypes(); 14765 #endif 14766 xmlCleanupGlobals(); 14767 xmlResetLastError(); 14768 xmlCleanupThreads(); /* must be last if called not from the main thread */ 14769 xmlCleanupMemory(); 14770 xmlParserInitialized = 0; 14771 } 14772 14773 /************************************************************************ 14774 * * 14775 * New set (2.6.0) of simpler and more flexible APIs * 14776 * * 14777 ************************************************************************/ 14778 14779 /** 14780 * DICT_FREE: 14781 * @str: a string 14782 * 14783 * Free a string if it is not owned by the "dict" dictionnary in the 14784 * current scope 14785 */ 14786 #define DICT_FREE(str) \ 14787 if ((str) && ((!dict) || \ 14788 (xmlDictOwns(dict, (const xmlChar *)(str)) == 0))) \ 14789 xmlFree((char *)(str)); 14790 14791 /** 14792 * xmlCtxtReset: 14793 * @ctxt: an XML parser context 14794 * 14795 * Reset a parser context 14796 */ 14797 void 14798 xmlCtxtReset(xmlParserCtxtPtr ctxt) 14799 { 14800 xmlParserInputPtr input; 14801 xmlDictPtr dict; 14802 14803 if (ctxt == NULL) 14804 return; 14805 14806 dict = ctxt->dict; 14807 14808 while ((input = inputPop(ctxt)) != NULL) { /* Non consuming */ 14809 xmlFreeInputStream(input); 14810 } 14811 ctxt->inputNr = 0; 14812 ctxt->input = NULL; 14813 14814 ctxt->spaceNr = 0; 14815 if (ctxt->spaceTab != NULL) { 14816 ctxt->spaceTab[0] = -1; 14817 ctxt->space = &ctxt->spaceTab[0]; 14818 } else { 14819 ctxt->space = NULL; 14820 } 14821 14822 14823 ctxt->nodeNr = 0; 14824 ctxt->node = NULL; 14825 14826 ctxt->nameNr = 0; 14827 ctxt->name = NULL; 14828 14829 DICT_FREE(ctxt->version); 14830 ctxt->version = NULL; 14831 DICT_FREE(ctxt->encoding); 14832 ctxt->encoding = NULL; 14833 DICT_FREE(ctxt->directory); 14834 ctxt->directory = NULL; 14835 DICT_FREE(ctxt->extSubURI); 14836 ctxt->extSubURI = NULL; 14837 DICT_FREE(ctxt->extSubSystem); 14838 ctxt->extSubSystem = NULL; 14839 if (ctxt->myDoc != NULL) 14840 xmlFreeDoc(ctxt->myDoc); 14841 ctxt->myDoc = NULL; 14842 14843 ctxt->standalone = -1; 14844 ctxt->hasExternalSubset = 0; 14845 ctxt->hasPErefs = 0; 14846 ctxt->html = 0; 14847 ctxt->external = 0; 14848 ctxt->instate = XML_PARSER_START; 14849 ctxt->token = 0; 14850 14851 ctxt->wellFormed = 1; 14852 ctxt->nsWellFormed = 1; 14853 ctxt->disableSAX = 0; 14854 ctxt->valid = 1; 14855 #if 0 14856 ctxt->vctxt.userData = ctxt; 14857 ctxt->vctxt.error = xmlParserValidityError; 14858 ctxt->vctxt.warning = xmlParserValidityWarning; 14859 #endif 14860 ctxt->record_info = 0; 14861 ctxt->nbChars = 0; 14862 ctxt->checkIndex = 0; 14863 ctxt->inSubset = 0; 14864 ctxt->errNo = XML_ERR_OK; 14865 ctxt->depth = 0; 14866 ctxt->charset = XML_CHAR_ENCODING_UTF8; 14867 ctxt->catalogs = NULL; 14868 ctxt->nbentities = 0; 14869 ctxt->sizeentities = 0; 14870 ctxt->sizeentcopy = 0; 14871 xmlInitNodeInfoSeq(&ctxt->node_seq); 14872 14873 if (ctxt->attsDefault != NULL) { 14874 xmlHashFree(ctxt->attsDefault, (xmlHashDeallocator) xmlFree); 14875 ctxt->attsDefault = NULL; 14876 } 14877 if (ctxt->attsSpecial != NULL) { 14878 xmlHashFree(ctxt->attsSpecial, NULL); 14879 ctxt->attsSpecial = NULL; 14880 } 14881 14882 #ifdef LIBXML_CATALOG_ENABLED 14883 if (ctxt->catalogs != NULL) 14884 xmlCatalogFreeLocal(ctxt->catalogs); 14885 #endif 14886 if (ctxt->lastError.code != XML_ERR_OK) 14887 xmlResetError(&ctxt->lastError); 14888 } 14889 14890 /** 14891 * xmlCtxtResetPush: 14892 * @ctxt: an XML parser context 14893 * @chunk: a pointer to an array of chars 14894 * @size: number of chars in the array 14895 * @filename: an optional file name or URI 14896 * @encoding: the document encoding, or NULL 14897 * 14898 * Reset a push parser context 14899 * 14900 * Returns 0 in case of success and 1 in case of error 14901 */ 14902 int 14903 xmlCtxtResetPush(xmlParserCtxtPtr ctxt, const char *chunk, 14904 int size, const char *filename, const char *encoding) 14905 { 14906 xmlParserInputPtr inputStream; 14907 xmlParserInputBufferPtr buf; 14908 xmlCharEncoding enc = XML_CHAR_ENCODING_NONE; 14909 14910 if (ctxt == NULL) 14911 return(1); 14912 14913 if ((encoding == NULL) && (chunk != NULL) && (size >= 4)) 14914 enc = xmlDetectCharEncoding((const xmlChar *) chunk, size); 14915 14916 buf = xmlAllocParserInputBuffer(enc); 14917 if (buf == NULL) 14918 return(1); 14919 14920 if (ctxt == NULL) { 14921 xmlFreeParserInputBuffer(buf); 14922 return(1); 14923 } 14924 14925 xmlCtxtReset(ctxt); 14926 14927 if (ctxt->pushTab == NULL) { 14928 ctxt->pushTab = (void **) xmlMalloc(ctxt->nameMax * 3 * 14929 sizeof(xmlChar *)); 14930 if (ctxt->pushTab == NULL) { 14931 xmlErrMemory(ctxt, NULL); 14932 xmlFreeParserInputBuffer(buf); 14933 return(1); 14934 } 14935 } 14936 14937 if (filename == NULL) { 14938 ctxt->directory = NULL; 14939 } else { 14940 ctxt->directory = xmlParserGetDirectory(filename); 14941 } 14942 14943 inputStream = xmlNewInputStream(ctxt); 14944 if (inputStream == NULL) { 14945 xmlFreeParserInputBuffer(buf); 14946 return(1); 14947 } 14948 14949 if (filename == NULL) 14950 inputStream->filename = NULL; 14951 else 14952 inputStream->filename = (char *) 14953 xmlCanonicPath((const xmlChar *) filename); 14954 inputStream->buf = buf; 14955 xmlBufResetInput(buf->buffer, inputStream); 14956 14957 inputPush(ctxt, inputStream); 14958 14959 if ((size > 0) && (chunk != NULL) && (ctxt->input != NULL) && 14960 (ctxt->input->buf != NULL)) { 14961 size_t base = xmlBufGetInputBase(ctxt->input->buf->buffer, ctxt->input); 14962 size_t cur = ctxt->input->cur - ctxt->input->base; 14963 14964 xmlParserInputBufferPush(ctxt->input->buf, size, chunk); 14965 14966 xmlBufSetInputBaseCur(ctxt->input->buf->buffer, ctxt->input, base, cur); 14967 #ifdef DEBUG_PUSH 14968 xmlGenericError(xmlGenericErrorContext, "PP: pushed %d\n", size); 14969 #endif 14970 } 14971 14972 if (encoding != NULL) { 14973 xmlCharEncodingHandlerPtr hdlr; 14974 14975 if (ctxt->encoding != NULL) 14976 xmlFree((xmlChar *) ctxt->encoding); 14977 ctxt->encoding = xmlStrdup((const xmlChar *) encoding); 14978 14979 hdlr = xmlFindCharEncodingHandler(encoding); 14980 if (hdlr != NULL) { 14981 xmlSwitchToEncoding(ctxt, hdlr); 14982 } else { 14983 xmlFatalErrMsgStr(ctxt, XML_ERR_UNSUPPORTED_ENCODING, 14984 "Unsupported encoding %s\n", BAD_CAST encoding); 14985 } 14986 } else if (enc != XML_CHAR_ENCODING_NONE) { 14987 xmlSwitchEncoding(ctxt, enc); 14988 } 14989 14990 return(0); 14991 } 14992 14993 14994 /** 14995 * xmlCtxtUseOptionsInternal: 14996 * @ctxt: an XML parser context 14997 * @options: a combination of xmlParserOption 14998 * @encoding: the user provided encoding to use 14999 * 15000 * Applies the options to the parser context 15001 * 15002 * Returns 0 in case of success, the set of unknown or unimplemented options 15003 * in case of error. 15004 */ 15005 static int 15006 xmlCtxtUseOptionsInternal(xmlParserCtxtPtr ctxt, int options, const char *encoding) 15007 { 15008 if (ctxt == NULL) 15009 return(-1); 15010 if (encoding != NULL) { 15011 if (ctxt->encoding != NULL) 15012 xmlFree((xmlChar *) ctxt->encoding); 15013 ctxt->encoding = xmlStrdup((const xmlChar *) encoding); 15014 } 15015 if (options & XML_PARSE_RECOVER) { 15016 ctxt->recovery = 1; 15017 options -= XML_PARSE_RECOVER; 15018 ctxt->options |= XML_PARSE_RECOVER; 15019 } else 15020 ctxt->recovery = 0; 15021 if (options & XML_PARSE_DTDLOAD) { 15022 ctxt->loadsubset = XML_DETECT_IDS; 15023 options -= XML_PARSE_DTDLOAD; 15024 ctxt->options |= XML_PARSE_DTDLOAD; 15025 } else 15026 ctxt->loadsubset = 0; 15027 if (options & XML_PARSE_DTDATTR) { 15028 ctxt->loadsubset |= XML_COMPLETE_ATTRS; 15029 options -= XML_PARSE_DTDATTR; 15030 ctxt->options |= XML_PARSE_DTDATTR; 15031 } 15032 if (options & XML_PARSE_NOENT) { 15033 ctxt->replaceEntities = 1; 15034 /* ctxt->loadsubset |= XML_DETECT_IDS; */ 15035 options -= XML_PARSE_NOENT; 15036 ctxt->options |= XML_PARSE_NOENT; 15037 } else 15038 ctxt->replaceEntities = 0; 15039 if (options & XML_PARSE_PEDANTIC) { 15040 ctxt->pedantic = 1; 15041 options -= XML_PARSE_PEDANTIC; 15042 ctxt->options |= XML_PARSE_PEDANTIC; 15043 } else 15044 ctxt->pedantic = 0; 15045 if (options & XML_PARSE_NOBLANKS) { 15046 ctxt->keepBlanks = 0; 15047 ctxt->sax->ignorableWhitespace = xmlSAX2IgnorableWhitespace; 15048 options -= XML_PARSE_NOBLANKS; 15049 ctxt->options |= XML_PARSE_NOBLANKS; 15050 } else 15051 ctxt->keepBlanks = 1; 15052 if (options & XML_PARSE_DTDVALID) { 15053 ctxt->validate = 1; 15054 if (options & XML_PARSE_NOWARNING) 15055 ctxt->vctxt.warning = NULL; 15056 if (options & XML_PARSE_NOERROR) 15057 ctxt->vctxt.error = NULL; 15058 options -= XML_PARSE_DTDVALID; 15059 ctxt->options |= XML_PARSE_DTDVALID; 15060 } else 15061 ctxt->validate = 0; 15062 if (options & XML_PARSE_NOWARNING) { 15063 ctxt->sax->warning = NULL; 15064 options -= XML_PARSE_NOWARNING; 15065 } 15066 if (options & XML_PARSE_NOERROR) { 15067 ctxt->sax->error = NULL; 15068 ctxt->sax->fatalError = NULL; 15069 options -= XML_PARSE_NOERROR; 15070 } 15071 #ifdef LIBXML_SAX1_ENABLED 15072 if (options & XML_PARSE_SAX1) { 15073 ctxt->sax->startElement = xmlSAX2StartElement; 15074 ctxt->sax->endElement = xmlSAX2EndElement; 15075 ctxt->sax->startElementNs = NULL; 15076 ctxt->sax->endElementNs = NULL; 15077 ctxt->sax->initialized = 1; 15078 options -= XML_PARSE_SAX1; 15079 ctxt->options |= XML_PARSE_SAX1; 15080 } 15081 #endif /* LIBXML_SAX1_ENABLED */ 15082 if (options & XML_PARSE_NODICT) { 15083 ctxt->dictNames = 0; 15084 options -= XML_PARSE_NODICT; 15085 ctxt->options |= XML_PARSE_NODICT; 15086 } else { 15087 ctxt->dictNames = 1; 15088 } 15089 if (options & XML_PARSE_NOCDATA) { 15090 ctxt->sax->cdataBlock = NULL; 15091 options -= XML_PARSE_NOCDATA; 15092 ctxt->options |= XML_PARSE_NOCDATA; 15093 } 15094 if (options & XML_PARSE_NSCLEAN) { 15095 ctxt->options |= XML_PARSE_NSCLEAN; 15096 options -= XML_PARSE_NSCLEAN; 15097 } 15098 if (options & XML_PARSE_NONET) { 15099 ctxt->options |= XML_PARSE_NONET; 15100 options -= XML_PARSE_NONET; 15101 } 15102 if (options & XML_PARSE_COMPACT) { 15103 ctxt->options |= XML_PARSE_COMPACT; 15104 options -= XML_PARSE_COMPACT; 15105 } 15106 if (options & XML_PARSE_OLD10) { 15107 ctxt->options |= XML_PARSE_OLD10; 15108 options -= XML_PARSE_OLD10; 15109 } 15110 if (options & XML_PARSE_NOBASEFIX) { 15111 ctxt->options |= XML_PARSE_NOBASEFIX; 15112 options -= XML_PARSE_NOBASEFIX; 15113 } 15114 if (options & XML_PARSE_HUGE) { 15115 ctxt->options |= XML_PARSE_HUGE; 15116 options -= XML_PARSE_HUGE; 15117 if (ctxt->dict != NULL) 15118 xmlDictSetLimit(ctxt->dict, 0); 15119 } 15120 if (options & XML_PARSE_OLDSAX) { 15121 ctxt->options |= XML_PARSE_OLDSAX; 15122 options -= XML_PARSE_OLDSAX; 15123 } 15124 if (options & XML_PARSE_IGNORE_ENC) { 15125 ctxt->options |= XML_PARSE_IGNORE_ENC; 15126 options -= XML_PARSE_IGNORE_ENC; 15127 } 15128 if (options & XML_PARSE_BIG_LINES) { 15129 ctxt->options |= XML_PARSE_BIG_LINES; 15130 options -= XML_PARSE_BIG_LINES; 15131 } 15132 ctxt->linenumbers = 1; 15133 return (options); 15134 } 15135 15136 /** 15137 * xmlCtxtUseOptions: 15138 * @ctxt: an XML parser context 15139 * @options: a combination of xmlParserOption 15140 * 15141 * Applies the options to the parser context 15142 * 15143 * Returns 0 in case of success, the set of unknown or unimplemented options 15144 * in case of error. 15145 */ 15146 int 15147 xmlCtxtUseOptions(xmlParserCtxtPtr ctxt, int options) 15148 { 15149 return(xmlCtxtUseOptionsInternal(ctxt, options, NULL)); 15150 } 15151 15152 /** 15153 * xmlDoRead: 15154 * @ctxt: an XML parser context 15155 * @URL: the base URL to use for the document 15156 * @encoding: the document encoding, or NULL 15157 * @options: a combination of xmlParserOption 15158 * @reuse: keep the context for reuse 15159 * 15160 * Common front-end for the xmlRead functions 15161 * 15162 * Returns the resulting document tree or NULL 15163 */ 15164 static xmlDocPtr 15165 xmlDoRead(xmlParserCtxtPtr ctxt, const char *URL, const char *encoding, 15166 int options, int reuse) 15167 { 15168 xmlDocPtr ret; 15169 15170 xmlCtxtUseOptionsInternal(ctxt, options, encoding); 15171 if (encoding != NULL) { 15172 xmlCharEncodingHandlerPtr hdlr; 15173 15174 hdlr = xmlFindCharEncodingHandler(encoding); 15175 if (hdlr != NULL) 15176 xmlSwitchToEncoding(ctxt, hdlr); 15177 } 15178 if ((URL != NULL) && (ctxt->input != NULL) && 15179 (ctxt->input->filename == NULL)) 15180 ctxt->input->filename = (char *) xmlStrdup((const xmlChar *) URL); 15181 xmlParseDocument(ctxt); 15182 if ((ctxt->wellFormed) || ctxt->recovery) 15183 ret = ctxt->myDoc; 15184 else { 15185 ret = NULL; 15186 if (ctxt->myDoc != NULL) { 15187 xmlFreeDoc(ctxt->myDoc); 15188 } 15189 } 15190 ctxt->myDoc = NULL; 15191 if (!reuse) { 15192 xmlFreeParserCtxt(ctxt); 15193 } 15194 15195 return (ret); 15196 } 15197 15198 /** 15199 * xmlReadDoc: 15200 * @cur: a pointer to a zero terminated string 15201 * @URL: the base URL to use for the document 15202 * @encoding: the document encoding, or NULL 15203 * @options: a combination of xmlParserOption 15204 * 15205 * parse an XML in-memory document and build a tree. 15206 * 15207 * Returns the resulting document tree 15208 */ 15209 xmlDocPtr 15210 xmlReadDoc(const xmlChar * cur, const char *URL, const char *encoding, int options) 15211 { 15212 xmlParserCtxtPtr ctxt; 15213 15214 if (cur == NULL) 15215 return (NULL); 15216 15217 ctxt = xmlCreateDocParserCtxt(cur); 15218 if (ctxt == NULL) 15219 return (NULL); 15220 return (xmlDoRead(ctxt, URL, encoding, options, 0)); 15221 } 15222 15223 /** 15224 * xmlReadFile: 15225 * @filename: a file or URL 15226 * @encoding: the document encoding, or NULL 15227 * @options: a combination of xmlParserOption 15228 * 15229 * parse an XML file from the filesystem or the network. 15230 * 15231 * Returns the resulting document tree 15232 */ 15233 xmlDocPtr 15234 xmlReadFile(const char *filename, const char *encoding, int options) 15235 { 15236 xmlParserCtxtPtr ctxt; 15237 15238 ctxt = xmlCreateURLParserCtxt(filename, options); 15239 if (ctxt == NULL) 15240 return (NULL); 15241 return (xmlDoRead(ctxt, NULL, encoding, options, 0)); 15242 } 15243 15244 /** 15245 * xmlReadMemory: 15246 * @buffer: a pointer to a char array 15247 * @size: the size of the array 15248 * @URL: the base URL to use for the document 15249 * @encoding: the document encoding, or NULL 15250 * @options: a combination of xmlParserOption 15251 * 15252 * parse an XML in-memory document and build a tree. 15253 * 15254 * Returns the resulting document tree 15255 */ 15256 xmlDocPtr 15257 xmlReadMemory(const char *buffer, int size, const char *URL, const char *encoding, int options) 15258 { 15259 xmlParserCtxtPtr ctxt; 15260 15261 ctxt = xmlCreateMemoryParserCtxt(buffer, size); 15262 if (ctxt == NULL) 15263 return (NULL); 15264 return (xmlDoRead(ctxt, URL, encoding, options, 0)); 15265 } 15266 15267 /** 15268 * xmlReadFd: 15269 * @fd: an open file descriptor 15270 * @URL: the base URL to use for the document 15271 * @encoding: the document encoding, or NULL 15272 * @options: a combination of xmlParserOption 15273 * 15274 * parse an XML from a file descriptor and build a tree. 15275 * NOTE that the file descriptor will not be closed when the 15276 * reader is closed or reset. 15277 * 15278 * Returns the resulting document tree 15279 */ 15280 xmlDocPtr 15281 xmlReadFd(int fd, const char *URL, const char *encoding, int options) 15282 { 15283 xmlParserCtxtPtr ctxt; 15284 xmlParserInputBufferPtr input; 15285 xmlParserInputPtr stream; 15286 15287 if (fd < 0) 15288 return (NULL); 15289 15290 input = xmlParserInputBufferCreateFd(fd, XML_CHAR_ENCODING_NONE); 15291 if (input == NULL) 15292 return (NULL); 15293 input->closecallback = NULL; 15294 ctxt = xmlNewParserCtxt(); 15295 if (ctxt == NULL) { 15296 xmlFreeParserInputBuffer(input); 15297 return (NULL); 15298 } 15299 stream = xmlNewIOInputStream(ctxt, input, XML_CHAR_ENCODING_NONE); 15300 if (stream == NULL) { 15301 xmlFreeParserInputBuffer(input); 15302 xmlFreeParserCtxt(ctxt); 15303 return (NULL); 15304 } 15305 inputPush(ctxt, stream); 15306 return (xmlDoRead(ctxt, URL, encoding, options, 0)); 15307 } 15308 15309 /** 15310 * xmlReadIO: 15311 * @ioread: an I/O read function 15312 * @ioclose: an I/O close function 15313 * @ioctx: an I/O handler 15314 * @URL: the base URL to use for the document 15315 * @encoding: the document encoding, or NULL 15316 * @options: a combination of xmlParserOption 15317 * 15318 * parse an XML document from I/O functions and source and build a tree. 15319 * 15320 * Returns the resulting document tree 15321 */ 15322 xmlDocPtr 15323 xmlReadIO(xmlInputReadCallback ioread, xmlInputCloseCallback ioclose, 15324 void *ioctx, const char *URL, const char *encoding, int options) 15325 { 15326 xmlParserCtxtPtr ctxt; 15327 xmlParserInputBufferPtr input; 15328 xmlParserInputPtr stream; 15329 15330 if (ioread == NULL) 15331 return (NULL); 15332 15333 input = xmlParserInputBufferCreateIO(ioread, ioclose, ioctx, 15334 XML_CHAR_ENCODING_NONE); 15335 if (input == NULL) { 15336 if (ioclose != NULL) 15337 ioclose(ioctx); 15338 return (NULL); 15339 } 15340 ctxt = xmlNewParserCtxt(); 15341 if (ctxt == NULL) { 15342 xmlFreeParserInputBuffer(input); 15343 return (NULL); 15344 } 15345 stream = xmlNewIOInputStream(ctxt, input, XML_CHAR_ENCODING_NONE); 15346 if (stream == NULL) { 15347 xmlFreeParserInputBuffer(input); 15348 xmlFreeParserCtxt(ctxt); 15349 return (NULL); 15350 } 15351 inputPush(ctxt, stream); 15352 return (xmlDoRead(ctxt, URL, encoding, options, 0)); 15353 } 15354 15355 /** 15356 * xmlCtxtReadDoc: 15357 * @ctxt: an XML parser context 15358 * @cur: a pointer to a zero terminated string 15359 * @URL: the base URL to use for the document 15360 * @encoding: the document encoding, or NULL 15361 * @options: a combination of xmlParserOption 15362 * 15363 * parse an XML in-memory document and build a tree. 15364 * This reuses the existing @ctxt parser context 15365 * 15366 * Returns the resulting document tree 15367 */ 15368 xmlDocPtr 15369 xmlCtxtReadDoc(xmlParserCtxtPtr ctxt, const xmlChar * cur, 15370 const char *URL, const char *encoding, int options) 15371 { 15372 xmlParserInputPtr stream; 15373 15374 if (cur == NULL) 15375 return (NULL); 15376 if (ctxt == NULL) 15377 return (NULL); 15378 15379 xmlCtxtReset(ctxt); 15380 15381 stream = xmlNewStringInputStream(ctxt, cur); 15382 if (stream == NULL) { 15383 return (NULL); 15384 } 15385 inputPush(ctxt, stream); 15386 return (xmlDoRead(ctxt, URL, encoding, options, 1)); 15387 } 15388 15389 /** 15390 * xmlCtxtReadFile: 15391 * @ctxt: an XML parser context 15392 * @filename: a file or URL 15393 * @encoding: the document encoding, or NULL 15394 * @options: a combination of xmlParserOption 15395 * 15396 * parse an XML file from the filesystem or the network. 15397 * This reuses the existing @ctxt parser context 15398 * 15399 * Returns the resulting document tree 15400 */ 15401 xmlDocPtr 15402 xmlCtxtReadFile(xmlParserCtxtPtr ctxt, const char *filename, 15403 const char *encoding, int options) 15404 { 15405 xmlParserInputPtr stream; 15406 15407 if (filename == NULL) 15408 return (NULL); 15409 if (ctxt == NULL) 15410 return (NULL); 15411 15412 xmlCtxtReset(ctxt); 15413 15414 stream = xmlLoadExternalEntity(filename, NULL, ctxt); 15415 if (stream == NULL) { 15416 return (NULL); 15417 } 15418 inputPush(ctxt, stream); 15419 return (xmlDoRead(ctxt, NULL, encoding, options, 1)); 15420 } 15421 15422 /** 15423 * xmlCtxtReadMemory: 15424 * @ctxt: an XML parser context 15425 * @buffer: a pointer to a char array 15426 * @size: the size of the array 15427 * @URL: the base URL to use for the document 15428 * @encoding: the document encoding, or NULL 15429 * @options: a combination of xmlParserOption 15430 * 15431 * parse an XML in-memory document and build a tree. 15432 * This reuses the existing @ctxt parser context 15433 * 15434 * Returns the resulting document tree 15435 */ 15436 xmlDocPtr 15437 xmlCtxtReadMemory(xmlParserCtxtPtr ctxt, const char *buffer, int size, 15438 const char *URL, const char *encoding, int options) 15439 { 15440 xmlParserInputBufferPtr input; 15441 xmlParserInputPtr stream; 15442 15443 if (ctxt == NULL) 15444 return (NULL); 15445 if (buffer == NULL) 15446 return (NULL); 15447 15448 xmlCtxtReset(ctxt); 15449 15450 input = xmlParserInputBufferCreateMem(buffer, size, XML_CHAR_ENCODING_NONE); 15451 if (input == NULL) { 15452 return(NULL); 15453 } 15454 15455 stream = xmlNewIOInputStream(ctxt, input, XML_CHAR_ENCODING_NONE); 15456 if (stream == NULL) { 15457 xmlFreeParserInputBuffer(input); 15458 return(NULL); 15459 } 15460 15461 inputPush(ctxt, stream); 15462 return (xmlDoRead(ctxt, URL, encoding, options, 1)); 15463 } 15464 15465 /** 15466 * xmlCtxtReadFd: 15467 * @ctxt: an XML parser context 15468 * @fd: an open file descriptor 15469 * @URL: the base URL to use for the document 15470 * @encoding: the document encoding, or NULL 15471 * @options: a combination of xmlParserOption 15472 * 15473 * parse an XML from a file descriptor and build a tree. 15474 * This reuses the existing @ctxt parser context 15475 * NOTE that the file descriptor will not be closed when the 15476 * reader is closed or reset. 15477 * 15478 * Returns the resulting document tree 15479 */ 15480 xmlDocPtr 15481 xmlCtxtReadFd(xmlParserCtxtPtr ctxt, int fd, 15482 const char *URL, const char *encoding, int options) 15483 { 15484 xmlParserInputBufferPtr input; 15485 xmlParserInputPtr stream; 15486 15487 if (fd < 0) 15488 return (NULL); 15489 if (ctxt == NULL) 15490 return (NULL); 15491 15492 xmlCtxtReset(ctxt); 15493 15494 15495 input = xmlParserInputBufferCreateFd(fd, XML_CHAR_ENCODING_NONE); 15496 if (input == NULL) 15497 return (NULL); 15498 input->closecallback = NULL; 15499 stream = xmlNewIOInputStream(ctxt, input, XML_CHAR_ENCODING_NONE); 15500 if (stream == NULL) { 15501 xmlFreeParserInputBuffer(input); 15502 return (NULL); 15503 } 15504 inputPush(ctxt, stream); 15505 return (xmlDoRead(ctxt, URL, encoding, options, 1)); 15506 } 15507 15508 /** 15509 * xmlCtxtReadIO: 15510 * @ctxt: an XML parser context 15511 * @ioread: an I/O read function 15512 * @ioclose: an I/O close function 15513 * @ioctx: an I/O handler 15514 * @URL: the base URL to use for the document 15515 * @encoding: the document encoding, or NULL 15516 * @options: a combination of xmlParserOption 15517 * 15518 * parse an XML document from I/O functions and source and build a tree. 15519 * This reuses the existing @ctxt parser context 15520 * 15521 * Returns the resulting document tree 15522 */ 15523 xmlDocPtr 15524 xmlCtxtReadIO(xmlParserCtxtPtr ctxt, xmlInputReadCallback ioread, 15525 xmlInputCloseCallback ioclose, void *ioctx, 15526 const char *URL, 15527 const char *encoding, int options) 15528 { 15529 xmlParserInputBufferPtr input; 15530 xmlParserInputPtr stream; 15531 15532 if (ioread == NULL) 15533 return (NULL); 15534 if (ctxt == NULL) 15535 return (NULL); 15536 15537 xmlCtxtReset(ctxt); 15538 15539 input = xmlParserInputBufferCreateIO(ioread, ioclose, ioctx, 15540 XML_CHAR_ENCODING_NONE); 15541 if (input == NULL) { 15542 if (ioclose != NULL) 15543 ioclose(ioctx); 15544 return (NULL); 15545 } 15546 stream = xmlNewIOInputStream(ctxt, input, XML_CHAR_ENCODING_NONE); 15547 if (stream == NULL) { 15548 xmlFreeParserInputBuffer(input); 15549 return (NULL); 15550 } 15551 inputPush(ctxt, stream); 15552 return (xmlDoRead(ctxt, URL, encoding, options, 1)); 15553 } 15554 15555 #define bottom_parser 15556 #include "elfgcchack.h" 15557
