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 <string.h> 44 #include <stdarg.h> 45 #include <libxml/xmlmemory.h> 46 #include <libxml/threads.h> 47 #include <libxml/globals.h> 48 #include <libxml/tree.h> 49 #include <libxml/parser.h> 50 #include <libxml/parserInternals.h> 51 #include <libxml/valid.h> 52 #include <libxml/entities.h> 53 #include <libxml/xmlerror.h> 54 #include <libxml/encoding.h> 55 #include <libxml/xmlIO.h> 56 #include <libxml/uri.h> 57 #ifdef LIBXML_CATALOG_ENABLED 58 #include <libxml/catalog.h> 59 #endif 60 #ifdef LIBXML_SCHEMAS_ENABLED 61 #include <libxml/xmlschemastypes.h> 62 #include <libxml/relaxng.h> 63 #endif 64 #ifdef HAVE_CTYPE_H 65 #include <ctype.h> 66 #endif 67 #ifdef HAVE_STDLIB_H 68 #include <stdlib.h> 69 #endif 70 #ifdef HAVE_SYS_STAT_H 71 #include <sys/stat.h> 72 #endif 73 #ifdef HAVE_FCNTL_H 74 #include <fcntl.h> 75 #endif 76 #ifdef HAVE_UNISTD_H 77 #include <unistd.h> 78 #endif 79 #ifdef HAVE_ZLIB_H 80 #include <zlib.h> 81 #endif 82 83 static void 84 xmlFatalErr(xmlParserCtxtPtr ctxt, xmlParserErrors error, const char *info); 85 86 static xmlParserCtxtPtr 87 xmlCreateEntityParserCtxtInternal(const xmlChar *URL, const xmlChar *ID, 88 const xmlChar *base, xmlParserCtxtPtr pctx); 89 90 /************************************************************************ 91 * * 92 * Arbitrary limits set in the parser. See XML_PARSE_HUGE * 93 * * 94 ************************************************************************/ 95 96 #define XML_PARSER_BIG_ENTITY 1000 97 #define XML_PARSER_LOT_ENTITY 5000 98 99 /* 100 * XML_PARSER_NON_LINEAR is the threshold where the ratio of parsed entity 101 * replacement over the size in byte of the input indicates that you have 102 * and eponential behaviour. A value of 10 correspond to at least 3 entity 103 * replacement per byte of input. 104 */ 105 #define XML_PARSER_NON_LINEAR 10 106 107 /* 108 * xmlParserEntityCheck 109 * 110 * Function to check non-linear entity expansion behaviour 111 * This is here to detect and stop exponential linear entity expansion 112 * This is not a limitation of the parser but a safety 113 * boundary feature. It can be disabled with the XML_PARSE_HUGE 114 * parser option. 115 */ 116 static int 117 xmlParserEntityCheck(xmlParserCtxtPtr ctxt, unsigned long size, 118 xmlEntityPtr ent) 119 { 120 unsigned long consumed = 0; 121 122 if ((ctxt == NULL) || (ctxt->options & XML_PARSE_HUGE)) 123 return (0); 124 if (ctxt->lastError.code == XML_ERR_ENTITY_LOOP) 125 return (1); 126 if (size != 0) { 127 /* 128 * Do the check based on the replacement size of the entity 129 */ 130 if (size < XML_PARSER_BIG_ENTITY) 131 return(0); 132 133 /* 134 * A limit on the amount of text data reasonably used 135 */ 136 if (ctxt->input != NULL) { 137 consumed = ctxt->input->consumed + 138 (ctxt->input->cur - ctxt->input->base); 139 } 140 consumed += ctxt->sizeentities; 141 142 if ((size < XML_PARSER_NON_LINEAR * consumed) && 143 (ctxt->nbentities * 3 < XML_PARSER_NON_LINEAR * consumed)) 144 return (0); 145 } else if (ent != NULL) { 146 /* 147 * use the number of parsed entities in the replacement 148 */ 149 size = ent->checked; 150 151 /* 152 * The amount of data parsed counting entities size only once 153 */ 154 if (ctxt->input != NULL) { 155 consumed = ctxt->input->consumed + 156 (ctxt->input->cur - ctxt->input->base); 157 } 158 consumed += ctxt->sizeentities; 159 160 /* 161 * Check the density of entities for the amount of data 162 * knowing an entity reference will take at least 3 bytes 163 */ 164 if (size * 3 < consumed * XML_PARSER_NON_LINEAR) 165 return (0); 166 } else { 167 /* 168 * strange we got no data for checking just return 169 */ 170 return (0); 171 } 172 173 xmlFatalErr(ctxt, XML_ERR_ENTITY_LOOP, NULL); 174 return (1); 175 } 176 177 /** 178 * xmlParserMaxDepth: 179 * 180 * arbitrary depth limit for the XML documents that we allow to 181 * process. This is not a limitation of the parser but a safety 182 * boundary feature. It can be disabled with the XML_PARSE_HUGE 183 * parser option. 184 */ 185 unsigned int xmlParserMaxDepth = 256; 186 187 188 189 #define SAX2 1 190 #define XML_PARSER_BIG_BUFFER_SIZE 300 191 #define XML_PARSER_BUFFER_SIZE 100 192 #define SAX_COMPAT_MODE BAD_CAST "SAX compatibility mode document" 193 194 /* 195 * List of XML prefixed PI allowed by W3C specs 196 */ 197 198 static const char *xmlW3CPIs[] = { 199 "xml-stylesheet", 200 NULL 201 }; 202 203 204 /* DEPR void xmlParserHandleReference(xmlParserCtxtPtr ctxt); */ 205 static xmlEntityPtr xmlParseStringPEReference(xmlParserCtxtPtr ctxt, 206 const xmlChar **str); 207 208 static xmlParserErrors 209 xmlParseExternalEntityPrivate(xmlDocPtr doc, xmlParserCtxtPtr oldctxt, 210 xmlSAXHandlerPtr sax, 211 void *user_data, int depth, const xmlChar *URL, 212 const xmlChar *ID, xmlNodePtr *list); 213 214 static int 215 xmlCtxtUseOptionsInternal(xmlParserCtxtPtr ctxt, int options, 216 const char *encoding); 217 #ifdef LIBXML_LEGACY_ENABLED 218 static void 219 xmlAddEntityReference(xmlEntityPtr ent, xmlNodePtr firstNode, 220 xmlNodePtr lastNode); 221 #endif /* LIBXML_LEGACY_ENABLED */ 222 223 static xmlParserErrors 224 xmlParseBalancedChunkMemoryInternal(xmlParserCtxtPtr oldctxt, 225 const xmlChar *string, void *user_data, xmlNodePtr *lst); 226 227 static int 228 xmlLoadEntityContent(xmlParserCtxtPtr ctxt, xmlEntityPtr entity); 229 230 /************************************************************************ 231 * * 232 * Some factorized error routines * 233 * * 234 ************************************************************************/ 235 236 /** 237 * xmlErrAttributeDup: 238 * @ctxt: an XML parser context 239 * @prefix: the attribute prefix 240 * @localname: the attribute localname 241 * 242 * Handle a redefinition of attribute error 243 */ 244 static void 245 xmlErrAttributeDup(xmlParserCtxtPtr ctxt, const xmlChar * prefix, 246 const xmlChar * localname) 247 { 248 if ((ctxt != NULL) && (ctxt->disableSAX != 0) && 249 (ctxt->instate == XML_PARSER_EOF)) 250 return; 251 if (ctxt != NULL) 252 ctxt->errNo = XML_ERR_ATTRIBUTE_REDEFINED; 253 254 if (prefix == NULL) 255 __xmlRaiseError(NULL, NULL, NULL, ctxt, NULL, XML_FROM_PARSER, 256 XML_ERR_ATTRIBUTE_REDEFINED, XML_ERR_FATAL, NULL, 0, 257 (const char *) localname, NULL, NULL, 0, 0, 258 "Attribute %s redefined\n", localname); 259 else 260 __xmlRaiseError(NULL, NULL, NULL, ctxt, NULL, XML_FROM_PARSER, 261 XML_ERR_ATTRIBUTE_REDEFINED, XML_ERR_FATAL, NULL, 0, 262 (const char *) prefix, (const char *) localname, 263 NULL, 0, 0, "Attribute %s:%s redefined\n", prefix, 264 localname); 265 if (ctxt != NULL) { 266 ctxt->wellFormed = 0; 267 if (ctxt->recovery == 0) 268 ctxt->disableSAX = 1; 269 } 270 } 271 272 /** 273 * xmlFatalErr: 274 * @ctxt: an XML parser context 275 * @error: the error number 276 * @extra: extra information string 277 * 278 * Handle a fatal parser error, i.e. violating Well-Formedness constraints 279 */ 280 static void 281 xmlFatalErr(xmlParserCtxtPtr ctxt, xmlParserErrors error, const char *info) 282 { 283 const char *errmsg; 284 285 if ((ctxt != NULL) && (ctxt->disableSAX != 0) && 286 (ctxt->instate == XML_PARSER_EOF)) 287 return; 288 switch (error) { 289 case XML_ERR_INVALID_HEX_CHARREF: 290 errmsg = "CharRef: invalid hexadecimal value\n"; 291 break; 292 case XML_ERR_INVALID_DEC_CHARREF: 293 errmsg = "CharRef: invalid decimal value\n"; 294 break; 295 case XML_ERR_INVALID_CHARREF: 296 errmsg = "CharRef: invalid value\n"; 297 break; 298 case XML_ERR_INTERNAL_ERROR: 299 errmsg = "internal error"; 300 break; 301 case XML_ERR_PEREF_AT_EOF: 302 errmsg = "PEReference at end of document\n"; 303 break; 304 case XML_ERR_PEREF_IN_PROLOG: 305 errmsg = "PEReference in prolog\n"; 306 break; 307 case XML_ERR_PEREF_IN_EPILOG: 308 errmsg = "PEReference in epilog\n"; 309 break; 310 case XML_ERR_PEREF_NO_NAME: 311 errmsg = "PEReference: no name\n"; 312 break; 313 case XML_ERR_PEREF_SEMICOL_MISSING: 314 errmsg = "PEReference: expecting ';'\n"; 315 break; 316 case XML_ERR_ENTITY_LOOP: 317 errmsg = "Detected an entity reference loop\n"; 318 break; 319 case XML_ERR_ENTITY_NOT_STARTED: 320 errmsg = "EntityValue: \" or ' expected\n"; 321 break; 322 case XML_ERR_ENTITY_PE_INTERNAL: 323 errmsg = "PEReferences forbidden in internal subset\n"; 324 break; 325 case XML_ERR_ENTITY_NOT_FINISHED: 326 errmsg = "EntityValue: \" or ' expected\n"; 327 break; 328 case XML_ERR_ATTRIBUTE_NOT_STARTED: 329 errmsg = "AttValue: \" or ' expected\n"; 330 break; 331 case XML_ERR_LT_IN_ATTRIBUTE: 332 errmsg = "Unescaped '<' not allowed in attributes values\n"; 333 break; 334 case XML_ERR_LITERAL_NOT_STARTED: 335 errmsg = "SystemLiteral \" or ' expected\n"; 336 break; 337 case XML_ERR_LITERAL_NOT_FINISHED: 338 errmsg = "Unfinished System or Public ID \" or ' expected\n"; 339 break; 340 case XML_ERR_MISPLACED_CDATA_END: 341 errmsg = "Sequence ']]>' not allowed in content\n"; 342 break; 343 case XML_ERR_URI_REQUIRED: 344 errmsg = "SYSTEM or PUBLIC, the URI is missing\n"; 345 break; 346 case XML_ERR_PUBID_REQUIRED: 347 errmsg = "PUBLIC, the Public Identifier is missing\n"; 348 break; 349 case XML_ERR_HYPHEN_IN_COMMENT: 350 errmsg = "Comment must not contain '--' (double-hyphen)\n"; 351 break; 352 case XML_ERR_PI_NOT_STARTED: 353 errmsg = "xmlParsePI : no target name\n"; 354 break; 355 case XML_ERR_RESERVED_XML_NAME: 356 errmsg = "Invalid PI name\n"; 357 break; 358 case XML_ERR_NOTATION_NOT_STARTED: 359 errmsg = "NOTATION: Name expected here\n"; 360 break; 361 case XML_ERR_NOTATION_NOT_FINISHED: 362 errmsg = "'>' required to close NOTATION declaration\n"; 363 break; 364 case XML_ERR_VALUE_REQUIRED: 365 errmsg = "Entity value required\n"; 366 break; 367 case XML_ERR_URI_FRAGMENT: 368 errmsg = "Fragment not allowed"; 369 break; 370 case XML_ERR_ATTLIST_NOT_STARTED: 371 errmsg = "'(' required to start ATTLIST enumeration\n"; 372 break; 373 case XML_ERR_NMTOKEN_REQUIRED: 374 errmsg = "NmToken expected in ATTLIST enumeration\n"; 375 break; 376 case XML_ERR_ATTLIST_NOT_FINISHED: 377 errmsg = "')' required to finish ATTLIST enumeration\n"; 378 break; 379 case XML_ERR_MIXED_NOT_STARTED: 380 errmsg = "MixedContentDecl : '|' or ')*' expected\n"; 381 break; 382 case XML_ERR_PCDATA_REQUIRED: 383 errmsg = "MixedContentDecl : '#PCDATA' expected\n"; 384 break; 385 case XML_ERR_ELEMCONTENT_NOT_STARTED: 386 errmsg = "ContentDecl : Name or '(' expected\n"; 387 break; 388 case XML_ERR_ELEMCONTENT_NOT_FINISHED: 389 errmsg = "ContentDecl : ',' '|' or ')' expected\n"; 390 break; 391 case XML_ERR_PEREF_IN_INT_SUBSET: 392 errmsg = 393 "PEReference: forbidden within markup decl in internal subset\n"; 394 break; 395 case XML_ERR_GT_REQUIRED: 396 errmsg = "expected '>'\n"; 397 break; 398 case XML_ERR_CONDSEC_INVALID: 399 errmsg = "XML conditional section '[' expected\n"; 400 break; 401 case XML_ERR_EXT_SUBSET_NOT_FINISHED: 402 errmsg = "Content error in the external subset\n"; 403 break; 404 case XML_ERR_CONDSEC_INVALID_KEYWORD: 405 errmsg = 406 "conditional section INCLUDE or IGNORE keyword expected\n"; 407 break; 408 case XML_ERR_CONDSEC_NOT_FINISHED: 409 errmsg = "XML conditional section not closed\n"; 410 break; 411 case XML_ERR_XMLDECL_NOT_STARTED: 412 errmsg = "Text declaration '<?xml' required\n"; 413 break; 414 case XML_ERR_XMLDECL_NOT_FINISHED: 415 errmsg = "parsing XML declaration: '?>' expected\n"; 416 break; 417 case XML_ERR_EXT_ENTITY_STANDALONE: 418 errmsg = "external parsed entities cannot be standalone\n"; 419 break; 420 case XML_ERR_ENTITYREF_SEMICOL_MISSING: 421 errmsg = "EntityRef: expecting ';'\n"; 422 break; 423 case XML_ERR_DOCTYPE_NOT_FINISHED: 424 errmsg = "DOCTYPE improperly terminated\n"; 425 break; 426 case XML_ERR_LTSLASH_REQUIRED: 427 errmsg = "EndTag: '</' not found\n"; 428 break; 429 case XML_ERR_EQUAL_REQUIRED: 430 errmsg = "expected '='\n"; 431 break; 432 case XML_ERR_STRING_NOT_CLOSED: 433 errmsg = "String not closed expecting \" or '\n"; 434 break; 435 case XML_ERR_STRING_NOT_STARTED: 436 errmsg = "String not started expecting ' or \"\n"; 437 break; 438 case XML_ERR_ENCODING_NAME: 439 errmsg = "Invalid XML encoding name\n"; 440 break; 441 case XML_ERR_STANDALONE_VALUE: 442 errmsg = "standalone accepts only 'yes' or 'no'\n"; 443 break; 444 case XML_ERR_DOCUMENT_EMPTY: 445 errmsg = "Document is empty\n"; 446 break; 447 case XML_ERR_DOCUMENT_END: 448 errmsg = "Extra content at the end of the document\n"; 449 break; 450 case XML_ERR_NOT_WELL_BALANCED: 451 errmsg = "chunk is not well balanced\n"; 452 break; 453 case XML_ERR_EXTRA_CONTENT: 454 errmsg = "extra content at the end of well balanced chunk\n"; 455 break; 456 case XML_ERR_VERSION_MISSING: 457 errmsg = "Malformed declaration expecting version\n"; 458 break; 459 #if 0 460 case: 461 errmsg = "\n"; 462 break; 463 #endif 464 default: 465 errmsg = "Unregistered error message\n"; 466 } 467 if (ctxt != NULL) 468 ctxt->errNo = error; 469 __xmlRaiseError(NULL, NULL, NULL, ctxt, NULL, XML_FROM_PARSER, error, 470 XML_ERR_FATAL, NULL, 0, info, NULL, NULL, 0, 0, errmsg, 471 info); 472 if (ctxt != NULL) { 473 ctxt->wellFormed = 0; 474 if (ctxt->recovery == 0) 475 ctxt->disableSAX = 1; 476 } 477 } 478 479 /** 480 * xmlFatalErrMsg: 481 * @ctxt: an XML parser context 482 * @error: the error number 483 * @msg: the error message 484 * 485 * Handle a fatal parser error, i.e. violating Well-Formedness constraints 486 */ 487 static void 488 xmlFatalErrMsg(xmlParserCtxtPtr ctxt, xmlParserErrors error, 489 const char *msg) 490 { 491 if ((ctxt != NULL) && (ctxt->disableSAX != 0) && 492 (ctxt->instate == XML_PARSER_EOF)) 493 return; 494 if (ctxt != NULL) 495 ctxt->errNo = error; 496 __xmlRaiseError(NULL, NULL, NULL, ctxt, NULL, XML_FROM_PARSER, error, 497 XML_ERR_FATAL, NULL, 0, NULL, NULL, NULL, 0, 0, "%s", msg); 498 if (ctxt != NULL) { 499 ctxt->wellFormed = 0; 500 if (ctxt->recovery == 0) 501 ctxt->disableSAX = 1; 502 } 503 } 504 505 /** 506 * xmlWarningMsg: 507 * @ctxt: an XML parser context 508 * @error: the error number 509 * @msg: the error message 510 * @str1: extra data 511 * @str2: extra data 512 * 513 * Handle a warning. 514 */ 515 static void 516 xmlWarningMsg(xmlParserCtxtPtr ctxt, xmlParserErrors error, 517 const char *msg, const xmlChar *str1, const xmlChar *str2) 518 { 519 xmlStructuredErrorFunc schannel = NULL; 520 521 if ((ctxt != NULL) && (ctxt->disableSAX != 0) && 522 (ctxt->instate == XML_PARSER_EOF)) 523 return; 524 if ((ctxt != NULL) && (ctxt->sax != NULL) && 525 (ctxt->sax->initialized == XML_SAX2_MAGIC)) 526 schannel = ctxt->sax->serror; 527 if (ctxt != NULL) { 528 __xmlRaiseError(schannel, 529 (ctxt->sax) ? ctxt->sax->warning : NULL, 530 ctxt->userData, 531 ctxt, NULL, XML_FROM_PARSER, error, 532 XML_ERR_WARNING, NULL, 0, 533 (const char *) str1, (const char *) str2, NULL, 0, 0, 534 msg, (const char *) str1, (const char *) str2); 535 } else { 536 __xmlRaiseError(schannel, NULL, NULL, 537 ctxt, NULL, XML_FROM_PARSER, error, 538 XML_ERR_WARNING, NULL, 0, 539 (const char *) str1, (const char *) str2, NULL, 0, 0, 540 msg, (const char *) str1, (const char *) str2); 541 } 542 } 543 544 /** 545 * xmlValidityError: 546 * @ctxt: an XML parser context 547 * @error: the error number 548 * @msg: the error message 549 * @str1: extra data 550 * 551 * Handle a validity error. 552 */ 553 static void 554 xmlValidityError(xmlParserCtxtPtr ctxt, xmlParserErrors error, 555 const char *msg, const xmlChar *str1, const xmlChar *str2) 556 { 557 xmlStructuredErrorFunc schannel = NULL; 558 559 if ((ctxt != NULL) && (ctxt->disableSAX != 0) && 560 (ctxt->instate == XML_PARSER_EOF)) 561 return; 562 if (ctxt != NULL) { 563 ctxt->errNo = error; 564 if ((ctxt->sax != NULL) && (ctxt->sax->initialized == XML_SAX2_MAGIC)) 565 schannel = ctxt->sax->serror; 566 } 567 if (ctxt != NULL) { 568 __xmlRaiseError(schannel, 569 ctxt->vctxt.error, ctxt->vctxt.userData, 570 ctxt, NULL, XML_FROM_DTD, error, 571 XML_ERR_ERROR, NULL, 0, (const char *) str1, 572 (const char *) str2, NULL, 0, 0, 573 msg, (const char *) str1, (const char *) str2); 574 ctxt->valid = 0; 575 } else { 576 __xmlRaiseError(schannel, NULL, NULL, 577 ctxt, NULL, XML_FROM_DTD, error, 578 XML_ERR_ERROR, NULL, 0, (const char *) str1, 579 (const char *) str2, NULL, 0, 0, 580 msg, (const char *) str1, (const char *) str2); 581 } 582 } 583 584 /** 585 * xmlFatalErrMsgInt: 586 * @ctxt: an XML parser context 587 * @error: the error number 588 * @msg: the error message 589 * @val: an integer value 590 * 591 * Handle a fatal parser error, i.e. violating Well-Formedness constraints 592 */ 593 static void 594 xmlFatalErrMsgInt(xmlParserCtxtPtr ctxt, xmlParserErrors error, 595 const char *msg, int val) 596 { 597 if ((ctxt != NULL) && (ctxt->disableSAX != 0) && 598 (ctxt->instate == XML_PARSER_EOF)) 599 return; 600 if (ctxt != NULL) 601 ctxt->errNo = error; 602 __xmlRaiseError(NULL, NULL, NULL, 603 ctxt, NULL, XML_FROM_PARSER, error, XML_ERR_FATAL, 604 NULL, 0, NULL, NULL, NULL, val, 0, msg, val); 605 if (ctxt != NULL) { 606 ctxt->wellFormed = 0; 607 if (ctxt->recovery == 0) 608 ctxt->disableSAX = 1; 609 } 610 } 611 612 /** 613 * xmlFatalErrMsgStrIntStr: 614 * @ctxt: an XML parser context 615 * @error: the error number 616 * @msg: the error message 617 * @str1: an string info 618 * @val: an integer value 619 * @str2: an string info 620 * 621 * Handle a fatal parser error, i.e. violating Well-Formedness constraints 622 */ 623 static void 624 xmlFatalErrMsgStrIntStr(xmlParserCtxtPtr ctxt, xmlParserErrors error, 625 const char *msg, const xmlChar *str1, int val, 626 const xmlChar *str2) 627 { 628 if ((ctxt != NULL) && (ctxt->disableSAX != 0) && 629 (ctxt->instate == XML_PARSER_EOF)) 630 return; 631 if (ctxt != NULL) 632 ctxt->errNo = error; 633 __xmlRaiseError(NULL, NULL, NULL, 634 ctxt, NULL, XML_FROM_PARSER, error, XML_ERR_FATAL, 635 NULL, 0, (const char *) str1, (const char *) str2, 636 NULL, val, 0, msg, str1, val, str2); 637 if (ctxt != NULL) { 638 ctxt->wellFormed = 0; 639 if (ctxt->recovery == 0) 640 ctxt->disableSAX = 1; 641 } 642 } 643 644 /** 645 * xmlFatalErrMsgStr: 646 * @ctxt: an XML parser context 647 * @error: the error number 648 * @msg: the error message 649 * @val: a string value 650 * 651 * Handle a fatal parser error, i.e. violating Well-Formedness constraints 652 */ 653 static void 654 xmlFatalErrMsgStr(xmlParserCtxtPtr ctxt, xmlParserErrors error, 655 const char *msg, const xmlChar * val) 656 { 657 if ((ctxt != NULL) && (ctxt->disableSAX != 0) && 658 (ctxt->instate == XML_PARSER_EOF)) 659 return; 660 if (ctxt != NULL) 661 ctxt->errNo = error; 662 __xmlRaiseError(NULL, NULL, NULL, ctxt, NULL, 663 XML_FROM_PARSER, error, XML_ERR_FATAL, 664 NULL, 0, (const char *) val, NULL, NULL, 0, 0, msg, 665 val); 666 if (ctxt != NULL) { 667 ctxt->wellFormed = 0; 668 if (ctxt->recovery == 0) 669 ctxt->disableSAX = 1; 670 } 671 } 672 673 /** 674 * xmlErrMsgStr: 675 * @ctxt: an XML parser context 676 * @error: the error number 677 * @msg: the error message 678 * @val: a string value 679 * 680 * Handle a non fatal parser error 681 */ 682 static void 683 xmlErrMsgStr(xmlParserCtxtPtr ctxt, xmlParserErrors error, 684 const char *msg, const xmlChar * val) 685 { 686 if ((ctxt != NULL) && (ctxt->disableSAX != 0) && 687 (ctxt->instate == XML_PARSER_EOF)) 688 return; 689 if (ctxt != NULL) 690 ctxt->errNo = error; 691 __xmlRaiseError(NULL, NULL, NULL, ctxt, NULL, 692 XML_FROM_PARSER, error, XML_ERR_ERROR, 693 NULL, 0, (const char *) val, NULL, NULL, 0, 0, msg, 694 val); 695 } 696 697 /** 698 * xmlNsErr: 699 * @ctxt: an XML parser context 700 * @error: the error number 701 * @msg: the message 702 * @info1: extra information string 703 * @info2: extra information string 704 * 705 * Handle a fatal parser error, i.e. violating Well-Formedness constraints 706 */ 707 static void 708 xmlNsErr(xmlParserCtxtPtr ctxt, xmlParserErrors error, 709 const char *msg, 710 const xmlChar * info1, const xmlChar * info2, 711 const xmlChar * info3) 712 { 713 if ((ctxt != NULL) && (ctxt->disableSAX != 0) && 714 (ctxt->instate == XML_PARSER_EOF)) 715 return; 716 if (ctxt != NULL) 717 ctxt->errNo = error; 718 __xmlRaiseError(NULL, NULL, NULL, ctxt, NULL, XML_FROM_NAMESPACE, error, 719 XML_ERR_ERROR, NULL, 0, (const char *) info1, 720 (const char *) info2, (const char *) info3, 0, 0, msg, 721 info1, info2, info3); 722 if (ctxt != NULL) 723 ctxt->nsWellFormed = 0; 724 } 725 726 /** 727 * xmlNsWarn 728 * @ctxt: an XML parser context 729 * @error: the error number 730 * @msg: the message 731 * @info1: extra information string 732 * @info2: extra information string 733 * 734 * Handle a fatal parser error, i.e. violating Well-Formedness constraints 735 */ 736 static void 737 xmlNsWarn(xmlParserCtxtPtr ctxt, xmlParserErrors error, 738 const char *msg, 739 const xmlChar * info1, const xmlChar * info2, 740 const xmlChar * info3) 741 { 742 if ((ctxt != NULL) && (ctxt->disableSAX != 0) && 743 (ctxt->instate == XML_PARSER_EOF)) 744 return; 745 __xmlRaiseError(NULL, NULL, NULL, ctxt, NULL, XML_FROM_NAMESPACE, error, 746 XML_ERR_WARNING, NULL, 0, (const char *) info1, 747 (const char *) info2, (const char *) info3, 0, 0, msg, 748 info1, info2, info3); 749 } 750 751 /************************************************************************ 752 * * 753 * Library wide options * 754 * * 755 ************************************************************************/ 756 757 /** 758 * xmlHasFeature: 759 * @feature: the feature to be examined 760 * 761 * Examines if the library has been compiled with a given feature. 762 * 763 * Returns a non-zero value if the feature exist, otherwise zero. 764 * Returns zero (0) if the feature does not exist or an unknown 765 * unknown feature is requested, non-zero otherwise. 766 */ 767 int 768 xmlHasFeature(xmlFeature feature) 769 { 770 switch (feature) { 771 case XML_WITH_THREAD: 772 #ifdef LIBXML_THREAD_ENABLED 773 return(1); 774 #else 775 return(0); 776 #endif 777 case XML_WITH_TREE: 778 #ifdef LIBXML_TREE_ENABLED 779 return(1); 780 #else 781 return(0); 782 #endif 783 case XML_WITH_OUTPUT: 784 #ifdef LIBXML_OUTPUT_ENABLED 785 return(1); 786 #else 787 return(0); 788 #endif 789 case XML_WITH_PUSH: 790 #ifdef LIBXML_PUSH_ENABLED 791 return(1); 792 #else 793 return(0); 794 #endif 795 case XML_WITH_READER: 796 #ifdef LIBXML_READER_ENABLED 797 return(1); 798 #else 799 return(0); 800 #endif 801 case XML_WITH_PATTERN: 802 #ifdef LIBXML_PATTERN_ENABLED 803 return(1); 804 #else 805 return(0); 806 #endif 807 case XML_WITH_WRITER: 808 #ifdef LIBXML_WRITER_ENABLED 809 return(1); 810 #else 811 return(0); 812 #endif 813 case XML_WITH_SAX1: 814 #ifdef LIBXML_SAX1_ENABLED 815 return(1); 816 #else 817 return(0); 818 #endif 819 case XML_WITH_FTP: 820 #ifdef LIBXML_FTP_ENABLED 821 return(1); 822 #else 823 return(0); 824 #endif 825 case XML_WITH_HTTP: 826 #ifdef LIBXML_HTTP_ENABLED 827 return(1); 828 #else 829 return(0); 830 #endif 831 case XML_WITH_VALID: 832 #ifdef LIBXML_VALID_ENABLED 833 return(1); 834 #else 835 return(0); 836 #endif 837 case XML_WITH_HTML: 838 #ifdef LIBXML_HTML_ENABLED 839 return(1); 840 #else 841 return(0); 842 #endif 843 case XML_WITH_LEGACY: 844 #ifdef LIBXML_LEGACY_ENABLED 845 return(1); 846 #else 847 return(0); 848 #endif 849 case XML_WITH_C14N: 850 #ifdef LIBXML_C14N_ENABLED 851 return(1); 852 #else 853 return(0); 854 #endif 855 case XML_WITH_CATALOG: 856 #ifdef LIBXML_CATALOG_ENABLED 857 return(1); 858 #else 859 return(0); 860 #endif 861 case XML_WITH_XPATH: 862 #ifdef LIBXML_XPATH_ENABLED 863 return(1); 864 #else 865 return(0); 866 #endif 867 case XML_WITH_XPTR: 868 #ifdef LIBXML_XPTR_ENABLED 869 return(1); 870 #else 871 return(0); 872 #endif 873 case XML_WITH_XINCLUDE: 874 #ifdef LIBXML_XINCLUDE_ENABLED 875 return(1); 876 #else 877 return(0); 878 #endif 879 case XML_WITH_ICONV: 880 #ifdef LIBXML_ICONV_ENABLED 881 return(1); 882 #else 883 return(0); 884 #endif 885 case XML_WITH_ISO8859X: 886 #ifdef LIBXML_ISO8859X_ENABLED 887 return(1); 888 #else 889 return(0); 890 #endif 891 case XML_WITH_UNICODE: 892 #ifdef LIBXML_UNICODE_ENABLED 893 return(1); 894 #else 895 return(0); 896 #endif 897 case XML_WITH_REGEXP: 898 #ifdef LIBXML_REGEXP_ENABLED 899 return(1); 900 #else 901 return(0); 902 #endif 903 case XML_WITH_AUTOMATA: 904 #ifdef LIBXML_AUTOMATA_ENABLED 905 return(1); 906 #else 907 return(0); 908 #endif 909 case XML_WITH_EXPR: 910 #ifdef LIBXML_EXPR_ENABLED 911 return(1); 912 #else 913 return(0); 914 #endif 915 case XML_WITH_SCHEMAS: 916 #ifdef LIBXML_SCHEMAS_ENABLED 917 return(1); 918 #else 919 return(0); 920 #endif 921 case XML_WITH_SCHEMATRON: 922 #ifdef LIBXML_SCHEMATRON_ENABLED 923 return(1); 924 #else 925 return(0); 926 #endif 927 case XML_WITH_MODULES: 928 #ifdef LIBXML_MODULES_ENABLED 929 return(1); 930 #else 931 return(0); 932 #endif 933 case XML_WITH_DEBUG: 934 #ifdef LIBXML_DEBUG_ENABLED 935 return(1); 936 #else 937 return(0); 938 #endif 939 case XML_WITH_DEBUG_MEM: 940 #ifdef DEBUG_MEMORY_LOCATION 941 return(1); 942 #else 943 return(0); 944 #endif 945 case XML_WITH_DEBUG_RUN: 946 #ifdef LIBXML_DEBUG_RUNTIME 947 return(1); 948 #else 949 return(0); 950 #endif 951 case XML_WITH_ZLIB: 952 #ifdef LIBXML_ZLIB_ENABLED 953 return(1); 954 #else 955 return(0); 956 #endif 957 case XML_WITH_ICU: 958 #ifdef LIBXML_ICU_ENABLED 959 return(1); 960 #else 961 return(0); 962 #endif 963 default: 964 break; 965 } 966 return(0); 967 } 968 969 /************************************************************************ 970 * * 971 * SAX2 defaulted attributes handling * 972 * * 973 ************************************************************************/ 974 975 /** 976 * xmlDetectSAX2: 977 * @ctxt: an XML parser context 978 * 979 * Do the SAX2 detection and specific intialization 980 */ 981 static void 982 xmlDetectSAX2(xmlParserCtxtPtr ctxt) { 983 if (ctxt == NULL) return; 984 #ifdef LIBXML_SAX1_ENABLED 985 if ((ctxt->sax) && (ctxt->sax->initialized == XML_SAX2_MAGIC) && 986 ((ctxt->sax->startElementNs != NULL) || 987 (ctxt->sax->endElementNs != NULL))) ctxt->sax2 = 1; 988 #else 989 ctxt->sax2 = 1; 990 #endif /* LIBXML_SAX1_ENABLED */ 991 992 ctxt->str_xml = xmlDictLookup(ctxt->dict, BAD_CAST "xml", 3); 993 ctxt->str_xmlns = xmlDictLookup(ctxt->dict, BAD_CAST "xmlns", 5); 994 ctxt->str_xml_ns = xmlDictLookup(ctxt->dict, XML_XML_NAMESPACE, 36); 995 if ((ctxt->str_xml==NULL) || (ctxt->str_xmlns==NULL) || 996 (ctxt->str_xml_ns == NULL)) { 997 xmlErrMemory(ctxt, NULL); 998 } 999 } 1000 1001 typedef struct _xmlDefAttrs xmlDefAttrs; 1002 typedef xmlDefAttrs *xmlDefAttrsPtr; 1003 struct _xmlDefAttrs { 1004 int nbAttrs; /* number of defaulted attributes on that element */ 1005 int maxAttrs; /* the size of the array */ 1006 const xmlChar *values[5]; /* array of localname/prefix/values/external */ 1007 }; 1008 1009 /** 1010 * xmlAttrNormalizeSpace: 1011 * @src: the source string 1012 * @dst: the target string 1013 * 1014 * Normalize the space in non CDATA attribute values: 1015 * If the attribute type is not CDATA, then the XML processor MUST further 1016 * process the normalized attribute value by discarding any leading and 1017 * trailing space (#x20) characters, and by replacing sequences of space 1018 * (#x20) characters by a single space (#x20) character. 1019 * Note that the size of dst need to be at least src, and if one doesn't need 1020 * to preserve dst (and it doesn't come from a dictionary or read-only) then 1021 * passing src as dst is just fine. 1022 * 1023 * Returns a pointer to the normalized value (dst) or NULL if no conversion 1024 * is needed. 1025 */ 1026 static xmlChar * 1027 xmlAttrNormalizeSpace(const xmlChar *src, xmlChar *dst) 1028 { 1029 if ((src == NULL) || (dst == NULL)) 1030 return(NULL); 1031 1032 while (*src == 0x20) src++; 1033 while (*src != 0) { 1034 if (*src == 0x20) { 1035 while (*src == 0x20) src++; 1036 if (*src != 0) 1037 *dst++ = 0x20; 1038 } else { 1039 *dst++ = *src++; 1040 } 1041 } 1042 *dst = 0; 1043 if (dst == src) 1044 return(NULL); 1045 return(dst); 1046 } 1047 1048 /** 1049 * xmlAttrNormalizeSpace2: 1050 * @src: the source string 1051 * 1052 * Normalize the space in non CDATA attribute values, a slightly more complex 1053 * front end to avoid allocation problems when running on attribute values 1054 * coming from the input. 1055 * 1056 * Returns a pointer to the normalized value (dst) or NULL if no conversion 1057 * is needed. 1058 */ 1059 static const xmlChar * 1060 xmlAttrNormalizeSpace2(xmlParserCtxtPtr ctxt, xmlChar *src, int *len) 1061 { 1062 int i; 1063 int remove_head = 0; 1064 int need_realloc = 0; 1065 const xmlChar *cur; 1066 1067 if ((ctxt == NULL) || (src == NULL) || (len == NULL)) 1068 return(NULL); 1069 i = *len; 1070 if (i <= 0) 1071 return(NULL); 1072 1073 cur = src; 1074 while (*cur == 0x20) { 1075 cur++; 1076 remove_head++; 1077 } 1078 while (*cur != 0) { 1079 if (*cur == 0x20) { 1080 cur++; 1081 if ((*cur == 0x20) || (*cur == 0)) { 1082 need_realloc = 1; 1083 break; 1084 } 1085 } else 1086 cur++; 1087 } 1088 if (need_realloc) { 1089 xmlChar *ret; 1090 1091 ret = xmlStrndup(src + remove_head, i - remove_head + 1); 1092 if (ret == NULL) { 1093 xmlErrMemory(ctxt, NULL); 1094 return(NULL); 1095 } 1096 xmlAttrNormalizeSpace(ret, ret); 1097 *len = (int) strlen((const char *)ret); 1098 return(ret); 1099 } else if (remove_head) { 1100 *len -= remove_head; 1101 memmove(src, src + remove_head, 1 + *len); 1102 return(src); 1103 } 1104 return(NULL); 1105 } 1106 1107 /** 1108 * xmlAddDefAttrs: 1109 * @ctxt: an XML parser context 1110 * @fullname: the element fullname 1111 * @fullattr: the attribute fullname 1112 * @value: the attribute value 1113 * 1114 * Add a defaulted attribute for an element 1115 */ 1116 static void 1117 xmlAddDefAttrs(xmlParserCtxtPtr ctxt, 1118 const xmlChar *fullname, 1119 const xmlChar *fullattr, 1120 const xmlChar *value) { 1121 xmlDefAttrsPtr defaults; 1122 int len; 1123 const xmlChar *name; 1124 const xmlChar *prefix; 1125 1126 /* 1127 * Allows to detect attribute redefinitions 1128 */ 1129 if (ctxt->attsSpecial != NULL) { 1130 if (xmlHashLookup2(ctxt->attsSpecial, fullname, fullattr) != NULL) 1131 return; 1132 } 1133 1134 if (ctxt->attsDefault == NULL) { 1135 ctxt->attsDefault = xmlHashCreateDict(10, ctxt->dict); 1136 if (ctxt->attsDefault == NULL) 1137 goto mem_error; 1138 } 1139 1140 /* 1141 * split the element name into prefix:localname , the string found 1142 * are within the DTD and then not associated to namespace names. 1143 */ 1144 name = xmlSplitQName3(fullname, &len); 1145 if (name == NULL) { 1146 name = xmlDictLookup(ctxt->dict, fullname, -1); 1147 prefix = NULL; 1148 } else { 1149 name = xmlDictLookup(ctxt->dict, name, -1); 1150 prefix = xmlDictLookup(ctxt->dict, fullname, len); 1151 } 1152 1153 /* 1154 * make sure there is some storage 1155 */ 1156 defaults = xmlHashLookup2(ctxt->attsDefault, name, prefix); 1157 if (defaults == NULL) { 1158 defaults = (xmlDefAttrsPtr) xmlMalloc(sizeof(xmlDefAttrs) + 1159 (4 * 5) * sizeof(const xmlChar *)); 1160 if (defaults == NULL) 1161 goto mem_error; 1162 defaults->nbAttrs = 0; 1163 defaults->maxAttrs = 4; 1164 if (xmlHashUpdateEntry2(ctxt->attsDefault, name, prefix, 1165 defaults, NULL) < 0) { 1166 xmlFree(defaults); 1167 goto mem_error; 1168 } 1169 } else if (defaults->nbAttrs >= defaults->maxAttrs) { 1170 xmlDefAttrsPtr temp; 1171 1172 temp = (xmlDefAttrsPtr) xmlRealloc(defaults, sizeof(xmlDefAttrs) + 1173 (2 * defaults->maxAttrs * 5) * sizeof(const xmlChar *)); 1174 if (temp == NULL) 1175 goto mem_error; 1176 defaults = temp; 1177 defaults->maxAttrs *= 2; 1178 if (xmlHashUpdateEntry2(ctxt->attsDefault, name, prefix, 1179 defaults, NULL) < 0) { 1180 xmlFree(defaults); 1181 goto mem_error; 1182 } 1183 } 1184 1185 /* 1186 * Split the element name into prefix:localname , the string found 1187 * are within the DTD and hen not associated to namespace names. 1188 */ 1189 name = xmlSplitQName3(fullattr, &len); 1190 if (name == NULL) { 1191 name = xmlDictLookup(ctxt->dict, fullattr, -1); 1192 prefix = NULL; 1193 } else { 1194 name = xmlDictLookup(ctxt->dict, name, -1); 1195 prefix = xmlDictLookup(ctxt->dict, fullattr, len); 1196 } 1197 1198 defaults->values[5 * defaults->nbAttrs] = name; 1199 defaults->values[5 * defaults->nbAttrs + 1] = prefix; 1200 /* intern the string and precompute the end */ 1201 len = xmlStrlen(value); 1202 value = xmlDictLookup(ctxt->dict, value, len); 1203 defaults->values[5 * defaults->nbAttrs + 2] = value; 1204 defaults->values[5 * defaults->nbAttrs + 3] = value + len; 1205 if (ctxt->external) 1206 defaults->values[5 * defaults->nbAttrs + 4] = BAD_CAST "external"; 1207 else 1208 defaults->values[5 * defaults->nbAttrs + 4] = NULL; 1209 defaults->nbAttrs++; 1210 1211 return; 1212 1213 mem_error: 1214 xmlErrMemory(ctxt, NULL); 1215 return; 1216 } 1217 1218 /** 1219 * xmlAddSpecialAttr: 1220 * @ctxt: an XML parser context 1221 * @fullname: the element fullname 1222 * @fullattr: the attribute fullname 1223 * @type: the attribute type 1224 * 1225 * Register this attribute type 1226 */ 1227 static void 1228 xmlAddSpecialAttr(xmlParserCtxtPtr ctxt, 1229 const xmlChar *fullname, 1230 const xmlChar *fullattr, 1231 int type) 1232 { 1233 if (ctxt->attsSpecial == NULL) { 1234 ctxt->attsSpecial = xmlHashCreateDict(10, ctxt->dict); 1235 if (ctxt->attsSpecial == NULL) 1236 goto mem_error; 1237 } 1238 1239 if (xmlHashLookup2(ctxt->attsSpecial, fullname, fullattr) != NULL) 1240 return; 1241 1242 xmlHashAddEntry2(ctxt->attsSpecial, fullname, fullattr, 1243 (void *) (long) type); 1244 return; 1245 1246 mem_error: 1247 xmlErrMemory(ctxt, NULL); 1248 return; 1249 } 1250 1251 /** 1252 * xmlCleanSpecialAttrCallback: 1253 * 1254 * Removes CDATA attributes from the special attribute table 1255 */ 1256 static void 1257 xmlCleanSpecialAttrCallback(void *payload, void *data, 1258 const xmlChar *fullname, const xmlChar *fullattr, 1259 const xmlChar *unused ATTRIBUTE_UNUSED) { 1260 xmlParserCtxtPtr ctxt = (xmlParserCtxtPtr) data; 1261 1262 if (((long) payload) == XML_ATTRIBUTE_CDATA) { 1263 xmlHashRemoveEntry2(ctxt->attsSpecial, fullname, fullattr, NULL); 1264 } 1265 } 1266 1267 /** 1268 * xmlCleanSpecialAttr: 1269 * @ctxt: an XML parser context 1270 * 1271 * Trim the list of attributes defined to remove all those of type 1272 * CDATA as they are not special. This call should be done when finishing 1273 * to parse the DTD and before starting to parse the document root. 1274 */ 1275 static void 1276 xmlCleanSpecialAttr(xmlParserCtxtPtr ctxt) 1277 { 1278 if (ctxt->attsSpecial == NULL) 1279 return; 1280 1281 xmlHashScanFull(ctxt->attsSpecial, xmlCleanSpecialAttrCallback, ctxt); 1282 1283 if (xmlHashSize(ctxt->attsSpecial) == 0) { 1284 xmlHashFree(ctxt->attsSpecial, NULL); 1285 ctxt->attsSpecial = NULL; 1286 } 1287 return; 1288 } 1289 1290 /** 1291 * xmlCheckLanguageID: 1292 * @lang: pointer to the string value 1293 * 1294 * Checks that the value conforms to the LanguageID production: 1295 * 1296 * NOTE: this is somewhat deprecated, those productions were removed from 1297 * the XML Second edition. 1298 * 1299 * [33] LanguageID ::= Langcode ('-' Subcode)* 1300 * [34] Langcode ::= ISO639Code | IanaCode | UserCode 1301 * [35] ISO639Code ::= ([a-z] | [A-Z]) ([a-z] | [A-Z]) 1302 * [36] IanaCode ::= ('i' | 'I') '-' ([a-z] | [A-Z])+ 1303 * [37] UserCode ::= ('x' | 'X') '-' ([a-z] | [A-Z])+ 1304 * [38] Subcode ::= ([a-z] | [A-Z])+ 1305 * 1306 * Returns 1 if correct 0 otherwise 1307 **/ 1308 int 1309 xmlCheckLanguageID(const xmlChar * lang) 1310 { 1311 const xmlChar *cur = lang; 1312 1313 if (cur == NULL) 1314 return (0); 1315 if (((cur[0] == 'i') && (cur[1] == '-')) || 1316 ((cur[0] == 'I') && (cur[1] == '-'))) { 1317 /* 1318 * IANA code 1319 */ 1320 cur += 2; 1321 while (((cur[0] >= 'A') && (cur[0] <= 'Z')) || /* non input consuming */ 1322 ((cur[0] >= 'a') && (cur[0] <= 'z'))) 1323 cur++; 1324 } else if (((cur[0] == 'x') && (cur[1] == '-')) || 1325 ((cur[0] == 'X') && (cur[1] == '-'))) { 1326 /* 1327 * User code 1328 */ 1329 cur += 2; 1330 while (((cur[0] >= 'A') && (cur[0] <= 'Z')) || /* non input consuming */ 1331 ((cur[0] >= 'a') && (cur[0] <= 'z'))) 1332 cur++; 1333 } else if (((cur[0] >= 'A') && (cur[0] <= 'Z')) || 1334 ((cur[0] >= 'a') && (cur[0] <= 'z'))) { 1335 /* 1336 * ISO639 1337 */ 1338 cur++; 1339 if (((cur[0] >= 'A') && (cur[0] <= 'Z')) || 1340 ((cur[0] >= 'a') && (cur[0] <= 'z'))) 1341 cur++; 1342 else 1343 return (0); 1344 } else 1345 return (0); 1346 while (cur[0] != 0) { /* non input consuming */ 1347 if (cur[0] != '-') 1348 return (0); 1349 cur++; 1350 if (((cur[0] >= 'A') && (cur[0] <= 'Z')) || 1351 ((cur[0] >= 'a') && (cur[0] <= 'z'))) 1352 cur++; 1353 else 1354 return (0); 1355 while (((cur[0] >= 'A') && (cur[0] <= 'Z')) || /* non input consuming */ 1356 ((cur[0] >= 'a') && (cur[0] <= 'z'))) 1357 cur++; 1358 } 1359 return (1); 1360 } 1361 1362 /************************************************************************ 1363 * * 1364 * Parser stacks related functions and macros * 1365 * * 1366 ************************************************************************/ 1367 1368 static xmlEntityPtr xmlParseStringEntityRef(xmlParserCtxtPtr ctxt, 1369 const xmlChar ** str); 1370 1371 #ifdef SAX2 1372 /** 1373 * nsPush: 1374 * @ctxt: an XML parser context 1375 * @prefix: the namespace prefix or NULL 1376 * @URL: the namespace name 1377 * 1378 * Pushes a new parser namespace on top of the ns stack 1379 * 1380 * Returns -1 in case of error, -2 if the namespace should be discarded 1381 * and the index in the stack otherwise. 1382 */ 1383 static int 1384 nsPush(xmlParserCtxtPtr ctxt, const xmlChar *prefix, const xmlChar *URL) 1385 { 1386 if (ctxt->options & XML_PARSE_NSCLEAN) { 1387 int i; 1388 for (i = 0;i < ctxt->nsNr;i += 2) { 1389 if (ctxt->nsTab[i] == prefix) { 1390 /* in scope */ 1391 if (ctxt->nsTab[i + 1] == URL) 1392 return(-2); 1393 /* out of scope keep it */ 1394 break; 1395 } 1396 } 1397 } 1398 if ((ctxt->nsMax == 0) || (ctxt->nsTab == NULL)) { 1399 ctxt->nsMax = 10; 1400 ctxt->nsNr = 0; 1401 ctxt->nsTab = (const xmlChar **) 1402 xmlMalloc(ctxt->nsMax * sizeof(xmlChar *)); 1403 if (ctxt->nsTab == NULL) { 1404 xmlErrMemory(ctxt, NULL); 1405 ctxt->nsMax = 0; 1406 return (-1); 1407 } 1408 } else if (ctxt->nsNr >= ctxt->nsMax) { 1409 const xmlChar ** tmp; 1410 ctxt->nsMax *= 2; 1411 tmp = (const xmlChar **) xmlRealloc((char *) ctxt->nsTab, 1412 ctxt->nsMax * sizeof(ctxt->nsTab[0])); 1413 if (tmp == NULL) { 1414 xmlErrMemory(ctxt, NULL); 1415 ctxt->nsMax /= 2; 1416 return (-1); 1417 } 1418 ctxt->nsTab = tmp; 1419 } 1420 ctxt->nsTab[ctxt->nsNr++] = prefix; 1421 ctxt->nsTab[ctxt->nsNr++] = URL; 1422 return (ctxt->nsNr); 1423 } 1424 /** 1425 * nsPop: 1426 * @ctxt: an XML parser context 1427 * @nr: the number to pop 1428 * 1429 * Pops the top @nr parser prefix/namespace from the ns stack 1430 * 1431 * Returns the number of namespaces removed 1432 */ 1433 static int 1434 nsPop(xmlParserCtxtPtr ctxt, int nr) 1435 { 1436 int i; 1437 1438 if (ctxt->nsTab == NULL) return(0); 1439 if (ctxt->nsNr < nr) { 1440 xmlGenericError(xmlGenericErrorContext, "Pbm popping %d NS\n", nr); 1441 nr = ctxt->nsNr; 1442 } 1443 if (ctxt->nsNr <= 0) 1444 return (0); 1445 1446 for (i = 0;i < nr;i++) { 1447 ctxt->nsNr--; 1448 ctxt->nsTab[ctxt->nsNr] = NULL; 1449 } 1450 return(nr); 1451 } 1452 #endif 1453 1454 static int 1455 xmlCtxtGrowAttrs(xmlParserCtxtPtr ctxt, int nr) { 1456 const xmlChar **atts; 1457 int *attallocs; 1458 int maxatts; 1459 1460 if (ctxt->atts == NULL) { 1461 maxatts = 55; /* allow for 10 attrs by default */ 1462 atts = (const xmlChar **) 1463 xmlMalloc(maxatts * sizeof(xmlChar *)); 1464 if (atts == NULL) goto mem_error; 1465 ctxt->atts = atts; 1466 attallocs = (int *) xmlMalloc((maxatts / 5) * sizeof(int)); 1467 if (attallocs == NULL) goto mem_error; 1468 ctxt->attallocs = attallocs; 1469 ctxt->maxatts = maxatts; 1470 } else if (nr + 5 > ctxt->maxatts) { 1471 maxatts = (nr + 5) * 2; 1472 atts = (const xmlChar **) xmlRealloc((void *) ctxt->atts, 1473 maxatts * sizeof(const xmlChar *)); 1474 if (atts == NULL) goto mem_error; 1475 ctxt->atts = atts; 1476 attallocs = (int *) xmlRealloc((void *) ctxt->attallocs, 1477 (maxatts / 5) * sizeof(int)); 1478 if (attallocs == NULL) goto mem_error; 1479 ctxt->attallocs = attallocs; 1480 ctxt->maxatts = maxatts; 1481 } 1482 return(ctxt->maxatts); 1483 mem_error: 1484 xmlErrMemory(ctxt, NULL); 1485 return(-1); 1486 } 1487 1488 /** 1489 * inputPush: 1490 * @ctxt: an XML parser context 1491 * @value: the parser input 1492 * 1493 * Pushes a new parser input on top of the input stack 1494 * 1495 * Returns -1 in case of error, the index in the stack otherwise 1496 */ 1497 int 1498 inputPush(xmlParserCtxtPtr ctxt, xmlParserInputPtr value) 1499 { 1500 if ((ctxt == NULL) || (value == NULL)) 1501 return(-1); 1502 if (ctxt->inputNr >= ctxt->inputMax) { 1503 ctxt->inputMax *= 2; 1504 ctxt->inputTab = 1505 (xmlParserInputPtr *) xmlRealloc(ctxt->inputTab, 1506 ctxt->inputMax * 1507 sizeof(ctxt->inputTab[0])); 1508 if (ctxt->inputTab == NULL) { 1509 xmlErrMemory(ctxt, NULL); 1510 xmlFreeInputStream(value); 1511 ctxt->inputMax /= 2; 1512 value = NULL; 1513 return (-1); 1514 } 1515 } 1516 ctxt->inputTab[ctxt->inputNr] = value; 1517 ctxt->input = value; 1518 return (ctxt->inputNr++); 1519 } 1520 /** 1521 * inputPop: 1522 * @ctxt: an XML parser context 1523 * 1524 * Pops the top parser input from the input stack 1525 * 1526 * Returns the input just removed 1527 */ 1528 xmlParserInputPtr 1529 inputPop(xmlParserCtxtPtr ctxt) 1530 { 1531 xmlParserInputPtr ret; 1532 1533 if (ctxt == NULL) 1534 return(NULL); 1535 if (ctxt->inputNr <= 0) 1536 return (NULL); 1537 ctxt->inputNr--; 1538 if (ctxt->inputNr > 0) 1539 ctxt->input = ctxt->inputTab[ctxt->inputNr - 1]; 1540 else 1541 ctxt->input = NULL; 1542 ret = ctxt->inputTab[ctxt->inputNr]; 1543 ctxt->inputTab[ctxt->inputNr] = NULL; 1544 return (ret); 1545 } 1546 /** 1547 * nodePush: 1548 * @ctxt: an XML parser context 1549 * @value: the element node 1550 * 1551 * Pushes a new element node on top of the node stack 1552 * 1553 * Returns -1 in case of error, the index in the stack otherwise 1554 */ 1555 int 1556 nodePush(xmlParserCtxtPtr ctxt, xmlNodePtr value) 1557 { 1558 if (ctxt == NULL) return(0); 1559 if (ctxt->nodeNr >= ctxt->nodeMax) { 1560 xmlNodePtr *tmp; 1561 1562 tmp = (xmlNodePtr *) xmlRealloc(ctxt->nodeTab, 1563 ctxt->nodeMax * 2 * 1564 sizeof(ctxt->nodeTab[0])); 1565 if (tmp == NULL) { 1566 xmlErrMemory(ctxt, NULL); 1567 return (-1); 1568 } 1569 ctxt->nodeTab = tmp; 1570 ctxt->nodeMax *= 2; 1571 } 1572 if ((((unsigned int) ctxt->nodeNr) > xmlParserMaxDepth) && 1573 ((ctxt->options & XML_PARSE_HUGE) == 0)) { 1574 xmlFatalErrMsgInt(ctxt, XML_ERR_INTERNAL_ERROR, 1575 "Excessive depth in document: %d use XML_PARSE_HUGE option\n", 1576 xmlParserMaxDepth); 1577 ctxt->instate = XML_PARSER_EOF; 1578 return(-1); 1579 } 1580 ctxt->nodeTab[ctxt->nodeNr] = value; 1581 ctxt->node = value; 1582 return (ctxt->nodeNr++); 1583 } 1584 1585 /** 1586 * nodePop: 1587 * @ctxt: an XML parser context 1588 * 1589 * Pops the top element node from the node stack 1590 * 1591 * Returns the node just removed 1592 */ 1593 xmlNodePtr 1594 nodePop(xmlParserCtxtPtr ctxt) 1595 { 1596 xmlNodePtr ret; 1597 1598 if (ctxt == NULL) return(NULL); 1599 if (ctxt->nodeNr <= 0) 1600 return (NULL); 1601 ctxt->nodeNr--; 1602 if (ctxt->nodeNr > 0) 1603 ctxt->node = ctxt->nodeTab[ctxt->nodeNr - 1]; 1604 else 1605 ctxt->node = NULL; 1606 ret = ctxt->nodeTab[ctxt->nodeNr]; 1607 ctxt->nodeTab[ctxt->nodeNr] = NULL; 1608 return (ret); 1609 } 1610 1611 #ifdef LIBXML_PUSH_ENABLED 1612 /** 1613 * nameNsPush: 1614 * @ctxt: an XML parser context 1615 * @value: the element name 1616 * @prefix: the element prefix 1617 * @URI: the element namespace name 1618 * 1619 * Pushes a new element name/prefix/URL on top of the name stack 1620 * 1621 * Returns -1 in case of error, the index in the stack otherwise 1622 */ 1623 static int 1624 nameNsPush(xmlParserCtxtPtr ctxt, const xmlChar * value, 1625 const xmlChar *prefix, const xmlChar *URI, int nsNr) 1626 { 1627 if (ctxt->nameNr >= ctxt->nameMax) { 1628 const xmlChar * *tmp; 1629 void **tmp2; 1630 ctxt->nameMax *= 2; 1631 tmp = (const xmlChar * *) xmlRealloc((xmlChar * *)ctxt->nameTab, 1632 ctxt->nameMax * 1633 sizeof(ctxt->nameTab[0])); 1634 if (tmp == NULL) { 1635 ctxt->nameMax /= 2; 1636 goto mem_error; 1637 } 1638 ctxt->nameTab = tmp; 1639 tmp2 = (void **) xmlRealloc((void * *)ctxt->pushTab, 1640 ctxt->nameMax * 3 * 1641 sizeof(ctxt->pushTab[0])); 1642 if (tmp2 == NULL) { 1643 ctxt->nameMax /= 2; 1644 goto mem_error; 1645 } 1646 ctxt->pushTab = tmp2; 1647 } 1648 ctxt->nameTab[ctxt->nameNr] = value; 1649 ctxt->name = value; 1650 ctxt->pushTab[ctxt->nameNr * 3] = (void *) prefix; 1651 ctxt->pushTab[ctxt->nameNr * 3 + 1] = (void *) URI; 1652 ctxt->pushTab[ctxt->nameNr * 3 + 2] = (void *) (long) nsNr; 1653 return (ctxt->nameNr++); 1654 mem_error: 1655 xmlErrMemory(ctxt, NULL); 1656 return (-1); 1657 } 1658 /** 1659 * nameNsPop: 1660 * @ctxt: an XML parser context 1661 * 1662 * Pops the top element/prefix/URI name from the name stack 1663 * 1664 * Returns the name just removed 1665 */ 1666 static const xmlChar * 1667 nameNsPop(xmlParserCtxtPtr ctxt) 1668 { 1669 const xmlChar *ret; 1670 1671 if (ctxt->nameNr <= 0) 1672 return (NULL); 1673 ctxt->nameNr--; 1674 if (ctxt->nameNr > 0) 1675 ctxt->name = ctxt->nameTab[ctxt->nameNr - 1]; 1676 else 1677 ctxt->name = NULL; 1678 ret = ctxt->nameTab[ctxt->nameNr]; 1679 ctxt->nameTab[ctxt->nameNr] = NULL; 1680 return (ret); 1681 } 1682 #endif /* LIBXML_PUSH_ENABLED */ 1683 1684 /** 1685 * namePush: 1686 * @ctxt: an XML parser context 1687 * @value: the element name 1688 * 1689 * Pushes a new element name on top of the name stack 1690 * 1691 * Returns -1 in case of error, the index in the stack otherwise 1692 */ 1693 int 1694 namePush(xmlParserCtxtPtr ctxt, const xmlChar * value) 1695 { 1696 if (ctxt == NULL) return (-1); 1697 1698 if (ctxt->nameNr >= ctxt->nameMax) { 1699 const xmlChar * *tmp; 1700 ctxt->nameMax *= 2; 1701 tmp = (const xmlChar * *) xmlRealloc((xmlChar * *)ctxt->nameTab, 1702 ctxt->nameMax * 1703 sizeof(ctxt->nameTab[0])); 1704 if (tmp == NULL) { 1705 ctxt->nameMax /= 2; 1706 goto mem_error; 1707 } 1708 ctxt->nameTab = tmp; 1709 } 1710 ctxt->nameTab[ctxt->nameNr] = value; 1711 ctxt->name = value; 1712 return (ctxt->nameNr++); 1713 mem_error: 1714 xmlErrMemory(ctxt, NULL); 1715 return (-1); 1716 } 1717 /** 1718 * namePop: 1719 * @ctxt: an XML parser context 1720 * 1721 * Pops the top element name from the name stack 1722 * 1723 * Returns the name just removed 1724 */ 1725 const xmlChar * 1726 namePop(xmlParserCtxtPtr ctxt) 1727 { 1728 const xmlChar *ret; 1729 1730 if ((ctxt == NULL) || (ctxt->nameNr <= 0)) 1731 return (NULL); 1732 ctxt->nameNr--; 1733 if (ctxt->nameNr > 0) 1734 ctxt->name = ctxt->nameTab[ctxt->nameNr - 1]; 1735 else 1736 ctxt->name = NULL; 1737 ret = ctxt->nameTab[ctxt->nameNr]; 1738 ctxt->nameTab[ctxt->nameNr] = NULL; 1739 return (ret); 1740 } 1741 1742 static int spacePush(xmlParserCtxtPtr ctxt, int val) { 1743 if (ctxt->spaceNr >= ctxt->spaceMax) { 1744 int *tmp; 1745 1746 ctxt->spaceMax *= 2; 1747 tmp = (int *) xmlRealloc(ctxt->spaceTab, 1748 ctxt->spaceMax * sizeof(ctxt->spaceTab[0])); 1749 if (tmp == NULL) { 1750 xmlErrMemory(ctxt, NULL); 1751 ctxt->spaceMax /=2; 1752 return(-1); 1753 } 1754 ctxt->spaceTab = tmp; 1755 } 1756 ctxt->spaceTab[ctxt->spaceNr] = val; 1757 ctxt->space = &ctxt->spaceTab[ctxt->spaceNr]; 1758 return(ctxt->spaceNr++); 1759 } 1760 1761 static int spacePop(xmlParserCtxtPtr ctxt) { 1762 int ret; 1763 if (ctxt->spaceNr <= 0) return(0); 1764 ctxt->spaceNr--; 1765 if (ctxt->spaceNr > 0) 1766 ctxt->space = &ctxt->spaceTab[ctxt->spaceNr - 1]; 1767 else 1768 ctxt->space = &ctxt->spaceTab[0]; 1769 ret = ctxt->spaceTab[ctxt->spaceNr]; 1770 ctxt->spaceTab[ctxt->spaceNr] = -1; 1771 return(ret); 1772 } 1773 1774 /* 1775 * Macros for accessing the content. Those should be used only by the parser, 1776 * and not exported. 1777 * 1778 * Dirty macros, i.e. one often need to make assumption on the context to 1779 * use them 1780 * 1781 * CUR_PTR return the current pointer to the xmlChar to be parsed. 1782 * To be used with extreme caution since operations consuming 1783 * characters may move the input buffer to a different location ! 1784 * CUR returns the current xmlChar value, i.e. a 8 bit value if compiled 1785 * This should be used internally by the parser 1786 * only to compare to ASCII values otherwise it would break when 1787 * running with UTF-8 encoding. 1788 * RAW same as CUR but in the input buffer, bypass any token 1789 * extraction that may have been done 1790 * NXT(n) returns the n'th next xmlChar. Same as CUR is should be used only 1791 * to compare on ASCII based substring. 1792 * SKIP(n) Skip n xmlChar, and must also be used only to skip ASCII defined 1793 * strings without newlines within the parser. 1794 * NEXT1(l) Skip 1 xmlChar, and must also be used only to skip 1 non-newline ASCII 1795 * defined char within the parser. 1796 * Clean macros, not dependent of an ASCII context, expect UTF-8 encoding 1797 * 1798 * NEXT Skip to the next character, this does the proper decoding 1799 * in UTF-8 mode. It also pop-up unfinished entities on the fly. 1800 * NEXTL(l) Skip the current unicode character of l xmlChars long. 1801 * CUR_CHAR(l) returns the current unicode character (int), set l 1802 * to the number of xmlChars used for the encoding [0-5]. 1803 * CUR_SCHAR same but operate on a string instead of the context 1804 * COPY_BUF copy the current unicode char to the target buffer, increment 1805 * the index 1806 * GROW, SHRINK handling of input buffers 1807 */ 1808 1809 #define RAW (*ctxt->input->cur) 1810 #define CUR (*ctxt->input->cur) 1811 #define NXT(val) ctxt->input->cur[(val)] 1812 #define CUR_PTR ctxt->input->cur 1813 1814 #define CMP4( s, c1, c2, c3, c4 ) \ 1815 ( ((unsigned char *) s)[ 0 ] == c1 && ((unsigned char *) s)[ 1 ] == c2 && \ 1816 ((unsigned char *) s)[ 2 ] == c3 && ((unsigned char *) s)[ 3 ] == c4 ) 1817 #define CMP5( s, c1, c2, c3, c4, c5 ) \ 1818 ( CMP4( s, c1, c2, c3, c4 ) && ((unsigned char *) s)[ 4 ] == c5 ) 1819 #define CMP6( s, c1, c2, c3, c4, c5, c6 ) \ 1820 ( CMP5( s, c1, c2, c3, c4, c5 ) && ((unsigned char *) s)[ 5 ] == c6 ) 1821 #define CMP7( s, c1, c2, c3, c4, c5, c6, c7 ) \ 1822 ( CMP6( s, c1, c2, c3, c4, c5, c6 ) && ((unsigned char *) s)[ 6 ] == c7 ) 1823 #define CMP8( s, c1, c2, c3, c4, c5, c6, c7, c8 ) \ 1824 ( CMP7( s, c1, c2, c3, c4, c5, c6, c7 ) && ((unsigned char *) s)[ 7 ] == c8 ) 1825 #define CMP9( s, c1, c2, c3, c4, c5, c6, c7, c8, c9 ) \ 1826 ( CMP8( s, c1, c2, c3, c4, c5, c6, c7, c8 ) && \ 1827 ((unsigned char *) s)[ 8 ] == c9 ) 1828 #define CMP10( s, c1, c2, c3, c4, c5, c6, c7, c8, c9, c10 ) \ 1829 ( CMP9( s, c1, c2, c3, c4, c5, c6, c7, c8, c9 ) && \ 1830 ((unsigned char *) s)[ 9 ] == c10 ) 1831 1832 #define SKIP(val) do { \ 1833 ctxt->nbChars += (val),ctxt->input->cur += (val),ctxt->input->col+=(val); \ 1834 if (*ctxt->input->cur == '%') xmlParserHandlePEReference(ctxt); \ 1835 if ((*ctxt->input->cur == 0) && \ 1836 (xmlParserInputGrow(ctxt->input, INPUT_CHUNK) <= 0)) \ 1837 xmlPopInput(ctxt); \ 1838 } while (0) 1839 1840 #define SKIPL(val) do { \ 1841 int skipl; \ 1842 for(skipl=0; skipl<val; skipl++) { \ 1843 if (*(ctxt->input->cur) == '\n') { \ 1844 ctxt->input->line++; ctxt->input->col = 1; \ 1845 } else ctxt->input->col++; \ 1846 ctxt->nbChars++; \ 1847 ctxt->input->cur++; \ 1848 } \ 1849 if (*ctxt->input->cur == '%') xmlParserHandlePEReference(ctxt); \ 1850 if ((*ctxt->input->cur == 0) && \ 1851 (xmlParserInputGrow(ctxt->input, INPUT_CHUNK) <= 0)) \ 1852 xmlPopInput(ctxt); \ 1853 } while (0) 1854 1855 #define SHRINK if ((ctxt->progressive == 0) && \ 1856 (ctxt->input->cur - ctxt->input->base > 2 * INPUT_CHUNK) && \ 1857 (ctxt->input->end - ctxt->input->cur < 2 * INPUT_CHUNK)) \ 1858 xmlSHRINK (ctxt); 1859 1860 static void xmlSHRINK (xmlParserCtxtPtr ctxt) { 1861 xmlParserInputShrink(ctxt->input); 1862 if ((*ctxt->input->cur == 0) && 1863 (xmlParserInputGrow(ctxt->input, INPUT_CHUNK) <= 0)) 1864 xmlPopInput(ctxt); 1865 } 1866 1867 #define GROW if ((ctxt->progressive == 0) && \ 1868 (ctxt->input->end - ctxt->input->cur < INPUT_CHUNK)) \ 1869 xmlGROW (ctxt); 1870 1871 static void xmlGROW (xmlParserCtxtPtr ctxt) { 1872 xmlParserInputGrow(ctxt->input, INPUT_CHUNK); 1873 if ((ctxt->input->cur != NULL) && (*ctxt->input->cur == 0) && 1874 (xmlParserInputGrow(ctxt->input, INPUT_CHUNK) <= 0)) 1875 xmlPopInput(ctxt); 1876 } 1877 1878 #define SKIP_BLANKS xmlSkipBlankChars(ctxt) 1879 1880 #define NEXT xmlNextChar(ctxt) 1881 1882 #define NEXT1 { \ 1883 ctxt->input->col++; \ 1884 ctxt->input->cur++; \ 1885 ctxt->nbChars++; \ 1886 if (*ctxt->input->cur == 0) \ 1887 xmlParserInputGrow(ctxt->input, INPUT_CHUNK); \ 1888 } 1889 1890 #define NEXTL(l) do { \ 1891 if (*(ctxt->input->cur) == '\n') { \ 1892 ctxt->input->line++; ctxt->input->col = 1; \ 1893 } else ctxt->input->col++; \ 1894 ctxt->input->cur += l; \ 1895 if (*ctxt->input->cur == '%') xmlParserHandlePEReference(ctxt); \ 1896 } while (0) 1897 1898 #define CUR_CHAR(l) xmlCurrentChar(ctxt, &l) 1899 #define CUR_SCHAR(s, l) xmlStringCurrentChar(ctxt, s, &l) 1900 1901 #define COPY_BUF(l,b,i,v) \ 1902 if (l == 1) b[i++] = (xmlChar) v; \ 1903 else i += xmlCopyCharMultiByte(&b[i],v) 1904 1905 /** 1906 * xmlSkipBlankChars: 1907 * @ctxt: the XML parser context 1908 * 1909 * skip all blanks character found at that point in the input streams. 1910 * It pops up finished entities in the process if allowable at that point. 1911 * 1912 * Returns the number of space chars skipped 1913 */ 1914 1915 int 1916 xmlSkipBlankChars(xmlParserCtxtPtr ctxt) { 1917 int res = 0; 1918 1919 /* 1920 * It's Okay to use CUR/NEXT here since all the blanks are on 1921 * the ASCII range. 1922 */ 1923 if ((ctxt->inputNr == 1) && (ctxt->instate != XML_PARSER_DTD)) { 1924 const xmlChar *cur; 1925 /* 1926 * if we are in the document content, go really fast 1927 */ 1928 cur = ctxt->input->cur; 1929 while (IS_BLANK_CH(*cur)) { 1930 if (*cur == '\n') { 1931 ctxt->input->line++; ctxt->input->col = 1; 1932 } 1933 cur++; 1934 res++; 1935 if (*cur == 0) { 1936 ctxt->input->cur = cur; 1937 xmlParserInputGrow(ctxt->input, INPUT_CHUNK); 1938 cur = ctxt->input->cur; 1939 } 1940 } 1941 ctxt->input->cur = cur; 1942 } else { 1943 int cur; 1944 do { 1945 cur = CUR; 1946 while (IS_BLANK_CH(cur)) { /* CHECKED tstblanks.xml */ 1947 NEXT; 1948 cur = CUR; 1949 res++; 1950 } 1951 while ((cur == 0) && (ctxt->inputNr > 1) && 1952 (ctxt->instate != XML_PARSER_COMMENT)) { 1953 xmlPopInput(ctxt); 1954 cur = CUR; 1955 } 1956 /* 1957 * Need to handle support of entities branching here 1958 */ 1959 if (*ctxt->input->cur == '%') xmlParserHandlePEReference(ctxt); 1960 } while (IS_BLANK(cur)); /* CHECKED tstblanks.xml */ 1961 } 1962 return(res); 1963 } 1964 1965 /************************************************************************ 1966 * * 1967 * Commodity functions to handle entities * 1968 * * 1969 ************************************************************************/ 1970 1971 /** 1972 * xmlPopInput: 1973 * @ctxt: an XML parser context 1974 * 1975 * xmlPopInput: the current input pointed by ctxt->input came to an end 1976 * pop it and return the next char. 1977 * 1978 * Returns the current xmlChar in the parser context 1979 */ 1980 xmlChar 1981 xmlPopInput(xmlParserCtxtPtr ctxt) { 1982 if ((ctxt == NULL) || (ctxt->inputNr <= 1)) return(0); 1983 if (xmlParserDebugEntities) 1984 xmlGenericError(xmlGenericErrorContext, 1985 "Popping input %d\n", ctxt->inputNr); 1986 xmlFreeInputStream(inputPop(ctxt)); 1987 if ((*ctxt->input->cur == 0) && 1988 (xmlParserInputGrow(ctxt->input, INPUT_CHUNK) <= 0)) 1989 return(xmlPopInput(ctxt)); 1990 return(CUR); 1991 } 1992 1993 /** 1994 * xmlPushInput: 1995 * @ctxt: an XML parser context 1996 * @input: an XML parser input fragment (entity, XML fragment ...). 1997 * 1998 * xmlPushInput: switch to a new input stream which is stacked on top 1999 * of the previous one(s). 2000 * Returns -1 in case of error or the index in the input stack 2001 */ 2002 int 2003 xmlPushInput(xmlParserCtxtPtr ctxt, xmlParserInputPtr input) { 2004 int ret; 2005 if (input == NULL) return(-1); 2006 2007 if (xmlParserDebugEntities) { 2008 if ((ctxt->input != NULL) && (ctxt->input->filename)) 2009 xmlGenericError(xmlGenericErrorContext, 2010 "%s(%d): ", ctxt->input->filename, 2011 ctxt->input->line); 2012 xmlGenericError(xmlGenericErrorContext, 2013 "Pushing input %d : %.30s\n", ctxt->inputNr+1, input->cur); 2014 } 2015 ret = inputPush(ctxt, input); 2016 if (ctxt->instate == XML_PARSER_EOF) 2017 return(-1); 2018 GROW; 2019 return(ret); 2020 } 2021 2022 /** 2023 * xmlParseCharRef: 2024 * @ctxt: an XML parser context 2025 * 2026 * parse Reference declarations 2027 * 2028 * [66] CharRef ::= '&#' [0-9]+ ';' | 2029 * '&#x' [0-9a-fA-F]+ ';' 2030 * 2031 * [ WFC: Legal Character ] 2032 * Characters referred to using character references must match the 2033 * production for Char. 2034 * 2035 * Returns the value parsed (as an int), 0 in case of error 2036 */ 2037 int 2038 xmlParseCharRef(xmlParserCtxtPtr ctxt) { 2039 unsigned int val = 0; 2040 int count = 0; 2041 unsigned int outofrange = 0; 2042 2043 /* 2044 * Using RAW/CUR/NEXT is okay since we are working on ASCII range here 2045 */ 2046 if ((RAW == '&') && (NXT(1) == '#') && 2047 (NXT(2) == 'x')) { 2048 SKIP(3); 2049 GROW; 2050 while (RAW != ';') { /* loop blocked by count */ 2051 if (count++ > 20) { 2052 count = 0; 2053 GROW; 2054 if (ctxt->instate == XML_PARSER_EOF) 2055 return(0); 2056 } 2057 if ((RAW >= '0') && (RAW <= '9')) 2058 val = val * 16 + (CUR - '0'); 2059 else if ((RAW >= 'a') && (RAW <= 'f') && (count < 20)) 2060 val = val * 16 + (CUR - 'a') + 10; 2061 else if ((RAW >= 'A') && (RAW <= 'F') && (count < 20)) 2062 val = val * 16 + (CUR - 'A') + 10; 2063 else { 2064 xmlFatalErr(ctxt, XML_ERR_INVALID_HEX_CHARREF, NULL); 2065 val = 0; 2066 break; 2067 } 2068 if (val > 0x10FFFF) 2069 outofrange = val; 2070 2071 NEXT; 2072 count++; 2073 } 2074 if (RAW == ';') { 2075 /* on purpose to avoid reentrancy problems with NEXT and SKIP */ 2076 ctxt->input->col++; 2077 ctxt->nbChars ++; 2078 ctxt->input->cur++; 2079 } 2080 } else if ((RAW == '&') && (NXT(1) == '#')) { 2081 SKIP(2); 2082 GROW; 2083 while (RAW != ';') { /* loop blocked by count */ 2084 if (count++ > 20) { 2085 count = 0; 2086 GROW; 2087 if (ctxt->instate == XML_PARSER_EOF) 2088 return(0); 2089 } 2090 if ((RAW >= '0') && (RAW <= '9')) 2091 val = val * 10 + (CUR - '0'); 2092 else { 2093 xmlFatalErr(ctxt, XML_ERR_INVALID_DEC_CHARREF, NULL); 2094 val = 0; 2095 break; 2096 } 2097 if (val > 0x10FFFF) 2098 outofrange = val; 2099 2100 NEXT; 2101 count++; 2102 } 2103 if (RAW == ';') { 2104 /* on purpose to avoid reentrancy problems with NEXT and SKIP */ 2105 ctxt->input->col++; 2106 ctxt->nbChars ++; 2107 ctxt->input->cur++; 2108 } 2109 } else { 2110 xmlFatalErr(ctxt, XML_ERR_INVALID_CHARREF, NULL); 2111 } 2112 2113 /* 2114 * [ WFC: Legal Character ] 2115 * Characters referred to using character references must match the 2116 * production for Char. 2117 */ 2118 if ((IS_CHAR(val) && (outofrange == 0))) { 2119 return(val); 2120 } else { 2121 xmlFatalErrMsgInt(ctxt, XML_ERR_INVALID_CHAR, 2122 "xmlParseCharRef: invalid xmlChar value %d\n", 2123 val); 2124 } 2125 return(0); 2126 } 2127 2128 /** 2129 * xmlParseStringCharRef: 2130 * @ctxt: an XML parser context 2131 * @str: a pointer to an index in the string 2132 * 2133 * parse Reference declarations, variant parsing from a string rather 2134 * than an an input flow. 2135 * 2136 * [66] CharRef ::= '&#' [0-9]+ ';' | 2137 * '&#x' [0-9a-fA-F]+ ';' 2138 * 2139 * [ WFC: Legal Character ] 2140 * Characters referred to using character references must match the 2141 * production for Char. 2142 * 2143 * Returns the value parsed (as an int), 0 in case of error, str will be 2144 * updated to the current value of the index 2145 */ 2146 static int 2147 xmlParseStringCharRef(xmlParserCtxtPtr ctxt, const xmlChar **str) { 2148 const xmlChar *ptr; 2149 xmlChar cur; 2150 unsigned int val = 0; 2151 unsigned int outofrange = 0; 2152 2153 if ((str == NULL) || (*str == NULL)) return(0); 2154 ptr = *str; 2155 cur = *ptr; 2156 if ((cur == '&') && (ptr[1] == '#') && (ptr[2] == 'x')) { 2157 ptr += 3; 2158 cur = *ptr; 2159 while (cur != ';') { /* Non input consuming loop */ 2160 if ((cur >= '0') && (cur <= '9')) 2161 val = val * 16 + (cur - '0'); 2162 else if ((cur >= 'a') && (cur <= 'f')) 2163 val = val * 16 + (cur - 'a') + 10; 2164 else if ((cur >= 'A') && (cur <= 'F')) 2165 val = val * 16 + (cur - 'A') + 10; 2166 else { 2167 xmlFatalErr(ctxt, XML_ERR_INVALID_HEX_CHARREF, NULL); 2168 val = 0; 2169 break; 2170 } 2171 if (val > 0x10FFFF) 2172 outofrange = val; 2173 2174 ptr++; 2175 cur = *ptr; 2176 } 2177 if (cur == ';') 2178 ptr++; 2179 } else if ((cur == '&') && (ptr[1] == '#')){ 2180 ptr += 2; 2181 cur = *ptr; 2182 while (cur != ';') { /* Non input consuming loops */ 2183 if ((cur >= '0') && (cur <= '9')) 2184 val = val * 10 + (cur - '0'); 2185 else { 2186 xmlFatalErr(ctxt, XML_ERR_INVALID_DEC_CHARREF, NULL); 2187 val = 0; 2188 break; 2189 } 2190 if (val > 0x10FFFF) 2191 outofrange = val; 2192 2193 ptr++; 2194 cur = *ptr; 2195 } 2196 if (cur == ';') 2197 ptr++; 2198 } else { 2199 xmlFatalErr(ctxt, XML_ERR_INVALID_CHARREF, NULL); 2200 return(0); 2201 } 2202 *str = ptr; 2203 2204 /* 2205 * [ WFC: Legal Character ] 2206 * Characters referred to using character references must match the 2207 * production for Char. 2208 */ 2209 if ((IS_CHAR(val) && (outofrange == 0))) { 2210 return(val); 2211 } else { 2212 xmlFatalErrMsgInt(ctxt, XML_ERR_INVALID_CHAR, 2213 "xmlParseStringCharRef: invalid xmlChar value %d\n", 2214 val); 2215 } 2216 return(0); 2217 } 2218 2219 /** 2220 * xmlNewBlanksWrapperInputStream: 2221 * @ctxt: an XML parser context 2222 * @entity: an Entity pointer 2223 * 2224 * Create a new input stream for wrapping 2225 * blanks around a PEReference 2226 * 2227 * Returns the new input stream or NULL 2228 */ 2229 2230 static void deallocblankswrapper (xmlChar *str) {xmlFree(str);} 2231 2232 static xmlParserInputPtr 2233 xmlNewBlanksWrapperInputStream(xmlParserCtxtPtr ctxt, xmlEntityPtr entity) { 2234 xmlParserInputPtr input; 2235 xmlChar *buffer; 2236 size_t length; 2237 if (entity == NULL) { 2238 xmlFatalErr(ctxt, XML_ERR_INTERNAL_ERROR, 2239 "xmlNewBlanksWrapperInputStream entity\n"); 2240 return(NULL); 2241 } 2242 if (xmlParserDebugEntities) 2243 xmlGenericError(xmlGenericErrorContext, 2244 "new blanks wrapper for entity: %s\n", entity->name); 2245 input = xmlNewInputStream(ctxt); 2246 if (input == NULL) { 2247 return(NULL); 2248 } 2249 length = xmlStrlen(entity->name) + 5; 2250 buffer = xmlMallocAtomic(length); 2251 if (buffer == NULL) { 2252 xmlErrMemory(ctxt, NULL); 2253 xmlFree(input); 2254 return(NULL); 2255 } 2256 buffer [0] = ' '; 2257 buffer [1] = '%'; 2258 buffer [length-3] = ';'; 2259 buffer [length-2] = ' '; 2260 buffer [length-1] = 0; 2261 memcpy(buffer + 2, entity->name, length - 5); 2262 input->free = deallocblankswrapper; 2263 input->base = buffer; 2264 input->cur = buffer; 2265 input->length = length; 2266 input->end = &buffer[length]; 2267 return(input); 2268 } 2269 2270 /** 2271 * xmlParserHandlePEReference: 2272 * @ctxt: the parser context 2273 * 2274 * [69] PEReference ::= '%' Name ';' 2275 * 2276 * [ WFC: No Recursion ] 2277 * A parsed entity must not contain a recursive 2278 * reference to itself, either directly or indirectly. 2279 * 2280 * [ WFC: Entity Declared ] 2281 * In a document without any DTD, a document with only an internal DTD 2282 * subset which contains no parameter entity references, or a document 2283 * with "standalone='yes'", ... ... The declaration of a parameter 2284 * entity must precede any reference to it... 2285 * 2286 * [ VC: Entity Declared ] 2287 * In a document with an external subset or external parameter entities 2288 * with "standalone='no'", ... ... The declaration of a parameter entity 2289 * must precede any reference to it... 2290 * 2291 * [ WFC: In DTD ] 2292 * Parameter-entity references may only appear in the DTD. 2293 * NOTE: misleading but this is handled. 2294 * 2295 * A PEReference may have been detected in the current input stream 2296 * the handling is done accordingly to 2297 * http://www.w3.org/TR/REC-xml#entproc 2298 * i.e. 2299 * - Included in literal in entity values 2300 * - Included as Parameter Entity reference within DTDs 2301 */ 2302 void 2303 xmlParserHandlePEReference(xmlParserCtxtPtr ctxt) { 2304 const xmlChar *name; 2305 xmlEntityPtr entity = NULL; 2306 xmlParserInputPtr input; 2307 2308 if (RAW != '%') return; 2309 switch(ctxt->instate) { 2310 case XML_PARSER_CDATA_SECTION: 2311 return; 2312 case XML_PARSER_COMMENT: 2313 return; 2314 case XML_PARSER_START_TAG: 2315 return; 2316 case XML_PARSER_END_TAG: 2317 return; 2318 case XML_PARSER_EOF: 2319 xmlFatalErr(ctxt, XML_ERR_PEREF_AT_EOF, NULL); 2320 return; 2321 case XML_PARSER_PROLOG: 2322 case XML_PARSER_START: 2323 case XML_PARSER_MISC: 2324 xmlFatalErr(ctxt, XML_ERR_PEREF_IN_PROLOG, NULL); 2325 return; 2326 case XML_PARSER_ENTITY_DECL: 2327 case XML_PARSER_CONTENT: 2328 case XML_PARSER_ATTRIBUTE_VALUE: 2329 case XML_PARSER_PI: 2330 case XML_PARSER_SYSTEM_LITERAL: 2331 case XML_PARSER_PUBLIC_LITERAL: 2332 /* we just ignore it there */ 2333 return; 2334 case XML_PARSER_EPILOG: 2335 xmlFatalErr(ctxt, XML_ERR_PEREF_IN_EPILOG, NULL); 2336 return; 2337 case XML_PARSER_ENTITY_VALUE: 2338 /* 2339 * NOTE: in the case of entity values, we don't do the 2340 * substitution here since we need the literal 2341 * entity value to be able to save the internal 2342 * subset of the document. 2343 * This will be handled by xmlStringDecodeEntities 2344 */ 2345 return; 2346 case XML_PARSER_DTD: 2347 /* 2348 * [WFC: Well-Formedness Constraint: PEs in Internal Subset] 2349 * In the internal DTD subset, parameter-entity references 2350 * can occur only where markup declarations can occur, not 2351 * within markup declarations. 2352 * In that case this is handled in xmlParseMarkupDecl 2353 */ 2354 if ((ctxt->external == 0) && (ctxt->inputNr == 1)) 2355 return; 2356 if (IS_BLANK_CH(NXT(1)) || NXT(1) == 0) 2357 return; 2358 break; 2359 case XML_PARSER_IGNORE: 2360 return; 2361 } 2362 2363 NEXT; 2364 name = xmlParseName(ctxt); 2365 if (xmlParserDebugEntities) 2366 xmlGenericError(xmlGenericErrorContext, 2367 "PEReference: %s\n", name); 2368 if (name == NULL) { 2369 xmlFatalErr(ctxt, XML_ERR_PEREF_NO_NAME, NULL); 2370 } else { 2371 if (RAW == ';') { 2372 NEXT; 2373 if ((ctxt->sax != NULL) && (ctxt->sax->getParameterEntity != NULL)) 2374 entity = ctxt->sax->getParameterEntity(ctxt->userData, name); 2375 if (ctxt->instate == XML_PARSER_EOF) 2376 return; 2377 if (entity == NULL) { 2378 2379 /* 2380 * [ WFC: Entity Declared ] 2381 * In a document without any DTD, a document with only an 2382 * internal DTD subset which contains no parameter entity 2383 * references, or a document with "standalone='yes'", ... 2384 * ... The declaration of a parameter entity must precede 2385 * any reference to it... 2386 */ 2387 if ((ctxt->standalone == 1) || 2388 ((ctxt->hasExternalSubset == 0) && 2389 (ctxt->hasPErefs == 0))) { 2390 xmlFatalErrMsgStr(ctxt, XML_ERR_UNDECLARED_ENTITY, 2391 "PEReference: %%%s; not found\n", name); 2392 } else { 2393 /* 2394 * [ VC: Entity Declared ] 2395 * In a document with an external subset or external 2396 * parameter entities with "standalone='no'", ... 2397 * ... The declaration of a parameter entity must precede 2398 * any reference to it... 2399 */ 2400 if ((ctxt->validate) && (ctxt->vctxt.error != NULL)) { 2401 xmlValidityError(ctxt, XML_WAR_UNDECLARED_ENTITY, 2402 "PEReference: %%%s; not found\n", 2403 name, NULL); 2404 } else 2405 xmlWarningMsg(ctxt, XML_WAR_UNDECLARED_ENTITY, 2406 "PEReference: %%%s; not found\n", 2407 name, NULL); 2408 ctxt->valid = 0; 2409 } 2410 } else if (ctxt->input->free != deallocblankswrapper) { 2411 input = xmlNewBlanksWrapperInputStream(ctxt, entity); 2412 if (xmlPushInput(ctxt, input) < 0) 2413 return; 2414 } else { 2415 if ((entity->etype == XML_INTERNAL_PARAMETER_ENTITY) || 2416 (entity->etype == XML_EXTERNAL_PARAMETER_ENTITY)) { 2417 xmlChar start[4]; 2418 xmlCharEncoding enc; 2419 2420 /* 2421 * handle the extra spaces added before and after 2422 * c.f. http://www.w3.org/TR/REC-xml#as-PE 2423 * this is done independently. 2424 */ 2425 input = xmlNewEntityInputStream(ctxt, entity); 2426 if (xmlPushInput(ctxt, input) < 0) 2427 return; 2428 2429 /* 2430 * Get the 4 first bytes and decode the charset 2431 * if enc != XML_CHAR_ENCODING_NONE 2432 * plug some encoding conversion routines. 2433 * Note that, since we may have some non-UTF8 2434 * encoding (like UTF16, bug 135229), the 'length' 2435 * is not known, but we can calculate based upon 2436 * the amount of data in the buffer. 2437 */ 2438 GROW 2439 if (ctxt->instate == XML_PARSER_EOF) 2440 return; 2441 if ((ctxt->input->end - ctxt->input->cur)>=4) { 2442 start[0] = RAW; 2443 start[1] = NXT(1); 2444 start[2] = NXT(2); 2445 start[3] = NXT(3); 2446 enc = xmlDetectCharEncoding(start, 4); 2447 if (enc != XML_CHAR_ENCODING_NONE) { 2448 xmlSwitchEncoding(ctxt, enc); 2449 } 2450 } 2451 2452 if ((entity->etype == XML_EXTERNAL_PARAMETER_ENTITY) && 2453 (CMP5(CUR_PTR, '<', '?', 'x', 'm', 'l' )) && 2454 (IS_BLANK_CH(NXT(5)))) { 2455 xmlParseTextDecl(ctxt); 2456 } 2457 } else { 2458 xmlFatalErrMsgStr(ctxt, XML_ERR_ENTITY_IS_PARAMETER, 2459 "PEReference: %s is not a parameter entity\n", 2460 name); 2461 } 2462 } 2463 } else { 2464 xmlFatalErr(ctxt, XML_ERR_PEREF_SEMICOL_MISSING, NULL); 2465 } 2466 } 2467 } 2468 2469 /* 2470 * Macro used to grow the current buffer. 2471 */ 2472 #define growBuffer(buffer, n) { \ 2473 xmlChar *tmp; \ 2474 buffer##_size *= 2; \ 2475 buffer##_size += n; \ 2476 tmp = (xmlChar *) \ 2477 xmlRealloc(buffer, buffer##_size * sizeof(xmlChar)); \ 2478 if (tmp == NULL) goto mem_error; \ 2479 buffer = tmp; \ 2480 } 2481 2482 /** 2483 * xmlStringLenDecodeEntities: 2484 * @ctxt: the parser context 2485 * @str: the input string 2486 * @len: the string length 2487 * @what: combination of XML_SUBSTITUTE_REF and XML_SUBSTITUTE_PEREF 2488 * @end: an end marker xmlChar, 0 if none 2489 * @end2: an end marker xmlChar, 0 if none 2490 * @end3: an end marker xmlChar, 0 if none 2491 * 2492 * Takes a entity string content and process to do the adequate substitutions. 2493 * 2494 * [67] Reference ::= EntityRef | CharRef 2495 * 2496 * [69] PEReference ::= '%' Name ';' 2497 * 2498 * Returns A newly allocated string with the substitution done. The caller 2499 * must deallocate it ! 2500 */ 2501 xmlChar * 2502 xmlStringLenDecodeEntities(xmlParserCtxtPtr ctxt, const xmlChar *str, int len, 2503 int what, xmlChar end, xmlChar end2, xmlChar end3) { 2504 xmlChar *buffer = NULL; 2505 int buffer_size = 0; 2506 2507 xmlChar *current = NULL; 2508 xmlChar *rep = NULL; 2509 const xmlChar *last; 2510 xmlEntityPtr ent; 2511 int c,l; 2512 int nbchars = 0; 2513 2514 if ((ctxt == NULL) || (str == NULL) || (len < 0)) 2515 return(NULL); 2516 last = str + len; 2517 2518 if (((ctxt->depth > 40) && 2519 ((ctxt->options & XML_PARSE_HUGE) == 0)) || 2520 (ctxt->depth > 1024)) { 2521 xmlFatalErr(ctxt, XML_ERR_ENTITY_LOOP, NULL); 2522 return(NULL); 2523 } 2524 2525 /* 2526 * allocate a translation buffer. 2527 */ 2528 buffer_size = XML_PARSER_BIG_BUFFER_SIZE; 2529 buffer = (xmlChar *) xmlMallocAtomic(buffer_size * sizeof(xmlChar)); 2530 if (buffer == NULL) goto mem_error; 2531 2532 /* 2533 * OK loop until we reach one of the ending char or a size limit. 2534 * we are operating on already parsed values. 2535 */ 2536 if (str < last) 2537 c = CUR_SCHAR(str, l); 2538 else 2539 c = 0; 2540 while ((c != 0) && (c != end) && /* non input consuming loop */ 2541 (c != end2) && (c != end3)) { 2542 2543 if (c == 0) break; 2544 if ((c == '&') && (str[1] == '#')) { 2545 int val = xmlParseStringCharRef(ctxt, &str); 2546 if (val != 0) { 2547 COPY_BUF(0,buffer,nbchars,val); 2548 } 2549 if (nbchars > buffer_size - XML_PARSER_BUFFER_SIZE) { 2550 growBuffer(buffer, XML_PARSER_BUFFER_SIZE); 2551 } 2552 } else if ((c == '&') && (what & XML_SUBSTITUTE_REF)) { 2553 if (xmlParserDebugEntities) 2554 xmlGenericError(xmlGenericErrorContext, 2555 "String decoding Entity Reference: %.30s\n", 2556 str); 2557 ent = xmlParseStringEntityRef(ctxt, &str); 2558 if ((ctxt->lastError.code == XML_ERR_ENTITY_LOOP) || 2559 (ctxt->lastError.code == XML_ERR_INTERNAL_ERROR)) 2560 goto int_error; 2561 if (ent != NULL) 2562 ctxt->nbentities += ent->checked; 2563 if ((ent != NULL) && 2564 (ent->etype == XML_INTERNAL_PREDEFINED_ENTITY)) { 2565 if (ent->content != NULL) { 2566 COPY_BUF(0,buffer,nbchars,ent->content[0]); 2567 if (nbchars > buffer_size - XML_PARSER_BUFFER_SIZE) { 2568 growBuffer(buffer, XML_PARSER_BUFFER_SIZE); 2569 } 2570 } else { 2571 xmlFatalErrMsg(ctxt, XML_ERR_INTERNAL_ERROR, 2572 "predefined entity has no content\n"); 2573 } 2574 } else if ((ent != NULL) && (ent->content != NULL)) { 2575 ctxt->depth++; 2576 rep = xmlStringDecodeEntities(ctxt, ent->content, what, 2577 0, 0, 0); 2578 ctxt->depth--; 2579 2580 if (rep != NULL) { 2581 current = rep; 2582 while (*current != 0) { /* non input consuming loop */ 2583 buffer[nbchars++] = *current++; 2584 if (nbchars > 2585 buffer_size - XML_PARSER_BUFFER_SIZE) { 2586 if (xmlParserEntityCheck(ctxt, nbchars, ent)) 2587 goto int_error; 2588 growBuffer(buffer, XML_PARSER_BUFFER_SIZE); 2589 } 2590 } 2591 xmlFree(rep); 2592 rep = NULL; 2593 } 2594 } else if (ent != NULL) { 2595 int i = xmlStrlen(ent->name); 2596 const xmlChar *cur = ent->name; 2597 2598 buffer[nbchars++] = '&'; 2599 if (nbchars > buffer_size - i - XML_PARSER_BUFFER_SIZE) { 2600 growBuffer(buffer, i + XML_PARSER_BUFFER_SIZE); 2601 } 2602 for (;i > 0;i--) 2603 buffer[nbchars++] = *cur++; 2604 buffer[nbchars++] = ';'; 2605 } 2606 } else if (c == '%' && (what & XML_SUBSTITUTE_PEREF)) { 2607 if (xmlParserDebugEntities) 2608 xmlGenericError(xmlGenericErrorContext, 2609 "String decoding PE Reference: %.30s\n", str); 2610 ent = xmlParseStringPEReference(ctxt, &str); 2611 if (ctxt->lastError.code == XML_ERR_ENTITY_LOOP) 2612 goto int_error; 2613 if (ent != NULL) 2614 ctxt->nbentities += ent->checked; 2615 if (ent != NULL) { 2616 if (ent->content == NULL) { 2617 xmlLoadEntityContent(ctxt, ent); 2618 } 2619 ctxt->depth++; 2620 rep = xmlStringDecodeEntities(ctxt, ent->content, what, 2621 0, 0, 0); 2622 ctxt->depth--; 2623 if (rep != NULL) { 2624 current = rep; 2625 while (*current != 0) { /* non input consuming loop */ 2626 buffer[nbchars++] = *current++; 2627 if (nbchars > 2628 buffer_size - XML_PARSER_BUFFER_SIZE) { 2629 if (xmlParserEntityCheck(ctxt, nbchars, ent)) 2630 goto int_error; 2631 growBuffer(buffer, XML_PARSER_BUFFER_SIZE); 2632 } 2633 } 2634 xmlFree(rep); 2635 rep = NULL; 2636 } 2637 } 2638 } else { 2639 COPY_BUF(l,buffer,nbchars,c); 2640 str += l; 2641 if (nbchars > buffer_size - XML_PARSER_BUFFER_SIZE) { 2642 growBuffer(buffer, XML_PARSER_BUFFER_SIZE); 2643 } 2644 } 2645 if (str < last) 2646 c = CUR_SCHAR(str, l); 2647 else 2648 c = 0; 2649 } 2650 buffer[nbchars] = 0; 2651 return(buffer); 2652 2653 mem_error: 2654 xmlErrMemory(ctxt, NULL); 2655 int_error: 2656 if (rep != NULL) 2657 xmlFree(rep); 2658 if (buffer != NULL) 2659 xmlFree(buffer); 2660 return(NULL); 2661 } 2662 2663 /** 2664 * xmlStringDecodeEntities: 2665 * @ctxt: the parser context 2666 * @str: the input string 2667 * @what: combination of XML_SUBSTITUTE_REF and XML_SUBSTITUTE_PEREF 2668 * @end: an end marker xmlChar, 0 if none 2669 * @end2: an end marker xmlChar, 0 if none 2670 * @end3: an end marker xmlChar, 0 if none 2671 * 2672 * Takes a entity string content and process to do the adequate substitutions. 2673 * 2674 * [67] Reference ::= EntityRef | CharRef 2675 * 2676 * [69] PEReference ::= '%' Name ';' 2677 * 2678 * Returns A newly allocated string with the substitution done. The caller 2679 * must deallocate it ! 2680 */ 2681 xmlChar * 2682 xmlStringDecodeEntities(xmlParserCtxtPtr ctxt, const xmlChar *str, int what, 2683 xmlChar end, xmlChar end2, xmlChar end3) { 2684 if ((ctxt == NULL) || (str == NULL)) return(NULL); 2685 return(xmlStringLenDecodeEntities(ctxt, str, xmlStrlen(str), what, 2686 end, end2, end3)); 2687 } 2688 2689 /************************************************************************ 2690 * * 2691 * Commodity functions, cleanup needed ? * 2692 * * 2693 ************************************************************************/ 2694 2695 /** 2696 * areBlanks: 2697 * @ctxt: an XML parser context 2698 * @str: a xmlChar * 2699 * @len: the size of @str 2700 * @blank_chars: we know the chars are blanks 2701 * 2702 * Is this a sequence of blank chars that one can ignore ? 2703 * 2704 * Returns 1 if ignorable 0 otherwise. 2705 */ 2706 2707 static int areBlanks(xmlParserCtxtPtr ctxt, const xmlChar *str, int len, 2708 int blank_chars) { 2709 int i, ret; 2710 xmlNodePtr lastChild; 2711 2712 /* 2713 * Don't spend time trying to differentiate them, the same callback is 2714 * used ! 2715 */ 2716 if (ctxt->sax->ignorableWhitespace == ctxt->sax->characters) 2717 return(0); 2718 2719 /* 2720 * Check for xml:space value. 2721 */ 2722 if ((ctxt->space == NULL) || (*(ctxt->space) == 1) || 2723 (*(ctxt->space) == -2)) 2724 return(0); 2725 2726 /* 2727 * Check that the string is made of blanks 2728 */ 2729 if (blank_chars == 0) { 2730 for (i = 0;i < len;i++) 2731 if (!(IS_BLANK_CH(str[i]))) return(0); 2732 } 2733 2734 /* 2735 * Look if the element is mixed content in the DTD if available 2736 */ 2737 if (ctxt->node == NULL) return(0); 2738 if (ctxt->myDoc != NULL) { 2739 ret = xmlIsMixedElement(ctxt->myDoc, ctxt->node->name); 2740 if (ret == 0) return(1); 2741 if (ret == 1) return(0); 2742 } 2743 2744 /* 2745 * Otherwise, heuristic :-\ 2746 */ 2747 if ((RAW != '<') && (RAW != 0xD)) return(0); 2748 if ((ctxt->node->children == NULL) && 2749 (RAW == '<') && (NXT(1) == '/')) return(0); 2750 2751 lastChild = xmlGetLastChild(ctxt->node); 2752 if (lastChild == NULL) { 2753 if ((ctxt->node->type != XML_ELEMENT_NODE) && 2754 (ctxt->node->content != NULL)) return(0); 2755 } else if (xmlNodeIsText(lastChild)) 2756 return(0); 2757 else if ((ctxt->node->children != NULL) && 2758 (xmlNodeIsText(ctxt->node->children))) 2759 return(0); 2760 return(1); 2761 } 2762 2763 /************************************************************************ 2764 * * 2765 * Extra stuff for namespace support * 2766 * Relates to http://www.w3.org/TR/WD-xml-names * 2767 * * 2768 ************************************************************************/ 2769 2770 /** 2771 * xmlSplitQName: 2772 * @ctxt: an XML parser context 2773 * @name: an XML parser context 2774 * @prefix: a xmlChar ** 2775 * 2776 * parse an UTF8 encoded XML qualified name string 2777 * 2778 * [NS 5] QName ::= (Prefix ':')? LocalPart 2779 * 2780 * [NS 6] Prefix ::= NCName 2781 * 2782 * [NS 7] LocalPart ::= NCName 2783 * 2784 * Returns the local part, and prefix is updated 2785 * to get the Prefix if any. 2786 */ 2787 2788 xmlChar * 2789 xmlSplitQName(xmlParserCtxtPtr ctxt, const xmlChar *name, xmlChar **prefix) { 2790 xmlChar buf[XML_MAX_NAMELEN + 5]; 2791 xmlChar *buffer = NULL; 2792 int len = 0; 2793 int max = XML_MAX_NAMELEN; 2794 xmlChar *ret = NULL; 2795 const xmlChar *cur = name; 2796 int c; 2797 2798 if (prefix == NULL) return(NULL); 2799 *prefix = NULL; 2800 2801 if (cur == NULL) return(NULL); 2802 2803 #ifndef XML_XML_NAMESPACE 2804 /* xml: prefix is not really a namespace */ 2805 if ((cur[0] == 'x') && (cur[1] == 'm') && 2806 (cur[2] == 'l') && (cur[3] == ':')) 2807 return(xmlStrdup(name)); 2808 #endif 2809 2810 /* nasty but well=formed */ 2811 if (cur[0] == ':') 2812 return(xmlStrdup(name)); 2813 2814 c = *cur++; 2815 while ((c != 0) && (c != ':') && (len < max)) { /* tested bigname.xml */ 2816 buf[len++] = c; 2817 c = *cur++; 2818 } 2819 if (len >= max) { 2820 /* 2821 * Okay someone managed to make a huge name, so he's ready to pay 2822 * for the processing speed. 2823 */ 2824 max = len * 2; 2825 2826 buffer = (xmlChar *) xmlMallocAtomic(max * sizeof(xmlChar)); 2827 if (buffer == NULL) { 2828 xmlErrMemory(ctxt, NULL); 2829 return(NULL); 2830 } 2831 memcpy(buffer, buf, len); 2832 while ((c != 0) && (c != ':')) { /* tested bigname.xml */ 2833 if (len + 10 > max) { 2834 xmlChar *tmp; 2835 2836 max *= 2; 2837 tmp = (xmlChar *) xmlRealloc(buffer, 2838 max * sizeof(xmlChar)); 2839 if (tmp == NULL) { 2840 xmlFree(buffer); 2841 xmlErrMemory(ctxt, NULL); 2842 return(NULL); 2843 } 2844 buffer = tmp; 2845 } 2846 buffer[len++] = c; 2847 c = *cur++; 2848 } 2849 buffer[len] = 0; 2850 } 2851 2852 if ((c == ':') && (*cur == 0)) { 2853 if (buffer != NULL) 2854 xmlFree(buffer); 2855 *prefix = NULL; 2856 return(xmlStrdup(name)); 2857 } 2858 2859 if (buffer == NULL) 2860 ret = xmlStrndup(buf, len); 2861 else { 2862 ret = buffer; 2863 buffer = NULL; 2864 max = XML_MAX_NAMELEN; 2865 } 2866 2867 2868 if (c == ':') { 2869 c = *cur; 2870 *prefix = ret; 2871 if (c == 0) { 2872 return(xmlStrndup(BAD_CAST "", 0)); 2873 } 2874 len = 0; 2875 2876 /* 2877 * Check that the first character is proper to start 2878 * a new name 2879 */ 2880 if (!(((c >= 0x61) && (c <= 0x7A)) || 2881 ((c >= 0x41) && (c <= 0x5A)) || 2882 (c == '_') || (c == ':'))) { 2883 int l; 2884 int first = CUR_SCHAR(cur, l); 2885 2886 if (!IS_LETTER(first) && (first != '_')) { 2887 xmlFatalErrMsgStr(ctxt, XML_NS_ERR_QNAME, 2888 "Name %s is not XML Namespace compliant\n", 2889 name); 2890 } 2891 } 2892 cur++; 2893 2894 while ((c != 0) && (len < max)) { /* tested bigname2.xml */ 2895 buf[len++] = c; 2896 c = *cur++; 2897 } 2898 if (len >= max) { 2899 /* 2900 * Okay someone managed to make a huge name, so he's ready to pay 2901 * for the processing speed. 2902 */ 2903 max = len * 2; 2904 2905 buffer = (xmlChar *) xmlMallocAtomic(max * sizeof(xmlChar)); 2906 if (buffer == NULL) { 2907 xmlErrMemory(ctxt, NULL); 2908 return(NULL); 2909 } 2910 memcpy(buffer, buf, len); 2911 while (c != 0) { /* tested bigname2.xml */ 2912 if (len + 10 > max) { 2913 xmlChar *tmp; 2914 2915 max *= 2; 2916 tmp = (xmlChar *) xmlRealloc(buffer, 2917 max * sizeof(xmlChar)); 2918 if (tmp == NULL) { 2919 xmlErrMemory(ctxt, NULL); 2920 xmlFree(buffer); 2921 return(NULL); 2922 } 2923 buffer = tmp; 2924 } 2925 buffer[len++] = c; 2926 c = *cur++; 2927 } 2928 buffer[len] = 0; 2929 } 2930 2931 if (buffer == NULL) 2932 ret = xmlStrndup(buf, len); 2933 else { 2934 ret = buffer; 2935 } 2936 } 2937 2938 return(ret); 2939 } 2940 2941 /************************************************************************ 2942 * * 2943 * The parser itself * 2944 * Relates to http://www.w3.org/TR/REC-xml * 2945 * * 2946 ************************************************************************/ 2947 2948 /************************************************************************ 2949 * * 2950 * Routines to parse Name, NCName and NmToken * 2951 * * 2952 ************************************************************************/ 2953 #ifdef DEBUG 2954 static unsigned long nbParseName = 0; 2955 static unsigned long nbParseNmToken = 0; 2956 static unsigned long nbParseNCName = 0; 2957 static unsigned long nbParseNCNameComplex = 0; 2958 static unsigned long nbParseNameComplex = 0; 2959 static unsigned long nbParseStringName = 0; 2960 #endif 2961 2962 /* 2963 * The two following functions are related to the change of accepted 2964 * characters for Name and NmToken in the Revision 5 of XML-1.0 2965 * They correspond to the modified production [4] and the new production [4a] 2966 * changes in that revision. Also note that the macros used for the 2967 * productions Letter, Digit, CombiningChar and Extender are not needed 2968 * anymore. 2969 * We still keep compatibility to pre-revision5 parsing semantic if the 2970 * new XML_PARSE_OLD10 option is given to the parser. 2971 */ 2972 static int 2973 xmlIsNameStartChar(xmlParserCtxtPtr ctxt, int c) { 2974 if ((ctxt->options & XML_PARSE_OLD10) == 0) { 2975 /* 2976 * Use the new checks of production [4] [4a] amd [5] of the 2977 * Update 5 of XML-1.0 2978 */ 2979 if ((c != ' ') && (c != '>') && (c != '/') && /* accelerators */ 2980 (((c >= 'a') && (c <= 'z')) || 2981 ((c >= 'A') && (c <= 'Z')) || 2982 (c == '_') || (c == ':') || 2983 ((c >= 0xC0) && (c <= 0xD6)) || 2984 ((c >= 0xD8) && (c <= 0xF6)) || 2985 ((c >= 0xF8) && (c <= 0x2FF)) || 2986 ((c >= 0x370) && (c <= 0x37D)) || 2987 ((c >= 0x37F) && (c <= 0x1FFF)) || 2988 ((c >= 0x200C) && (c <= 0x200D)) || 2989 ((c >= 0x2070) && (c <= 0x218F)) || 2990 ((c >= 0x2C00) && (c <= 0x2FEF)) || 2991 ((c >= 0x3001) && (c <= 0xD7FF)) || 2992 ((c >= 0xF900) && (c <= 0xFDCF)) || 2993 ((c >= 0xFDF0) && (c <= 0xFFFD)) || 2994 ((c >= 0x10000) && (c <= 0xEFFFF)))) 2995 return(1); 2996 } else { 2997 if (IS_LETTER(c) || (c == '_') || (c == ':')) 2998 return(1); 2999 } 3000 return(0); 3001 } 3002 3003 static int 3004 xmlIsNameChar(xmlParserCtxtPtr ctxt, int c) { 3005 if ((ctxt->options & XML_PARSE_OLD10) == 0) { 3006 /* 3007 * Use the new checks of production [4] [4a] amd [5] of the 3008 * Update 5 of XML-1.0 3009 */ 3010 if ((c != ' ') && (c != '>') && (c != '/') && /* accelerators */ 3011 (((c >= 'a') && (c <= 'z')) || 3012 ((c >= 'A') && (c <= 'Z')) || 3013 ((c >= '0') && (c <= '9')) || /* !start */ 3014 (c == '_') || (c == ':') || 3015 (c == '-') || (c == '.') || (c == 0xB7) || /* !start */ 3016 ((c >= 0xC0) && (c <= 0xD6)) || 3017 ((c >= 0xD8) && (c <= 0xF6)) || 3018 ((c >= 0xF8) && (c <= 0x2FF)) || 3019 ((c >= 0x300) && (c <= 0x36F)) || /* !start */ 3020 ((c >= 0x370) && (c <= 0x37D)) || 3021 ((c >= 0x37F) && (c <= 0x1FFF)) || 3022 ((c >= 0x200C) && (c <= 0x200D)) || 3023 ((c >= 0x203F) && (c <= 0x2040)) || /* !start */ 3024 ((c >= 0x2070) && (c <= 0x218F)) || 3025 ((c >= 0x2C00) && (c <= 0x2FEF)) || 3026 ((c >= 0x3001) && (c <= 0xD7FF)) || 3027 ((c >= 0xF900) && (c <= 0xFDCF)) || 3028 ((c >= 0xFDF0) && (c <= 0xFFFD)) || 3029 ((c >= 0x10000) && (c <= 0xEFFFF)))) 3030 return(1); 3031 } else { 3032 if ((IS_LETTER(c)) || (IS_DIGIT(c)) || 3033 (c == '.') || (c == '-') || 3034 (c == '_') || (c == ':') || 3035 (IS_COMBINING(c)) || 3036 (IS_EXTENDER(c))) 3037 return(1); 3038 } 3039 return(0); 3040 } 3041 3042 static xmlChar * xmlParseAttValueInternal(xmlParserCtxtPtr ctxt, 3043 int *len, int *alloc, int normalize); 3044 3045 static const xmlChar * 3046 xmlParseNameComplex(xmlParserCtxtPtr ctxt) { 3047 int len = 0, l; 3048 int c; 3049 int count = 0; 3050 3051 #ifdef DEBUG 3052 nbParseNameComplex++; 3053 #endif 3054 3055 /* 3056 * Handler for more complex cases 3057 */ 3058 GROW; 3059 if (ctxt->instate == XML_PARSER_EOF) 3060 return(NULL); 3061 c = CUR_CHAR(l); 3062 if ((ctxt->options & XML_PARSE_OLD10) == 0) { 3063 /* 3064 * Use the new checks of production [4] [4a] amd [5] of the 3065 * Update 5 of XML-1.0 3066 */ 3067 if ((c == ' ') || (c == '>') || (c == '/') || /* accelerators */ 3068 (!(((c >= 'a') && (c <= 'z')) || 3069 ((c >= 'A') && (c <= 'Z')) || 3070 (c == '_') || (c == ':') || 3071 ((c >= 0xC0) && (c <= 0xD6)) || 3072 ((c >= 0xD8) && (c <= 0xF6)) || 3073 ((c >= 0xF8) && (c <= 0x2FF)) || 3074 ((c >= 0x370) && (c <= 0x37D)) || 3075 ((c >= 0x37F) && (c <= 0x1FFF)) || 3076 ((c >= 0x200C) && (c <= 0x200D)) || 3077 ((c >= 0x2070) && (c <= 0x218F)) || 3078 ((c >= 0x2C00) && (c <= 0x2FEF)) || 3079 ((c >= 0x3001) && (c <= 0xD7FF)) || 3080 ((c >= 0xF900) && (c <= 0xFDCF)) || 3081 ((c >= 0xFDF0) && (c <= 0xFFFD)) || 3082 ((c >= 0x10000) && (c <= 0xEFFFF))))) { 3083 return(NULL); 3084 } 3085 len += l; 3086 NEXTL(l); 3087 c = CUR_CHAR(l); 3088 while ((c != ' ') && (c != '>') && (c != '/') && /* accelerators */ 3089 (((c >= 'a') && (c <= 'z')) || 3090 ((c >= 'A') && (c <= 'Z')) || 3091 ((c >= '0') && (c <= '9')) || /* !start */ 3092 (c == '_') || (c == ':') || 3093 (c == '-') || (c == '.') || (c == 0xB7) || /* !start */ 3094 ((c >= 0xC0) && (c <= 0xD6)) || 3095 ((c >= 0xD8) && (c <= 0xF6)) || 3096 ((c >= 0xF8) && (c <= 0x2FF)) || 3097 ((c >= 0x300) && (c <= 0x36F)) || /* !start */ 3098 ((c >= 0x370) && (c <= 0x37D)) || 3099 ((c >= 0x37F) && (c <= 0x1FFF)) || 3100 ((c >= 0x200C) && (c <= 0x200D)) || 3101 ((c >= 0x203F) && (c <= 0x2040)) || /* !start */ 3102 ((c >= 0x2070) && (c <= 0x218F)) || 3103 ((c >= 0x2C00) && (c <= 0x2FEF)) || 3104 ((c >= 0x3001) && (c <= 0xD7FF)) || 3105 ((c >= 0xF900) && (c <= 0xFDCF)) || 3106 ((c >= 0xFDF0) && (c <= 0xFFFD)) || 3107 ((c >= 0x10000) && (c <= 0xEFFFF)) 3108 )) { 3109 if (count++ > 100) { 3110 count = 0; 3111 GROW; 3112 if (ctxt->instate == XML_PARSER_EOF) 3113 return(NULL); 3114 } 3115 len += l; 3116 NEXTL(l); 3117 c = CUR_CHAR(l); 3118 } 3119 } else { 3120 if ((c == ' ') || (c == '>') || (c == '/') || /* accelerators */ 3121 (!IS_LETTER(c) && (c != '_') && 3122 (c != ':'))) { 3123 return(NULL); 3124 } 3125 len += l; 3126 NEXTL(l); 3127 c = CUR_CHAR(l); 3128 3129 while ((c != ' ') && (c != '>') && (c != '/') && /* test bigname.xml */ 3130 ((IS_LETTER(c)) || (IS_DIGIT(c)) || 3131 (c == '.') || (c == '-') || 3132 (c == '_') || (c == ':') || 3133 (IS_COMBINING(c)) || 3134 (IS_EXTENDER(c)))) { 3135 if (count++ > 100) { 3136 count = 0; 3137 GROW; 3138 if (ctxt->instate == XML_PARSER_EOF) 3139 return(NULL); 3140 } 3141 len += l; 3142 NEXTL(l); 3143 c = CUR_CHAR(l); 3144 } 3145 } 3146 if ((*ctxt->input->cur == '\n') && (ctxt->input->cur[-1] == '\r')) 3147 return(xmlDictLookup(ctxt->dict, ctxt->input->cur - (len + 1), len)); 3148 return(xmlDictLookup(ctxt->dict, ctxt->input->cur - len, len)); 3149 } 3150 3151 /** 3152 * xmlParseName: 3153 * @ctxt: an XML parser context 3154 * 3155 * parse an XML name. 3156 * 3157 * [4] NameChar ::= Letter | Digit | '.' | '-' | '_' | ':' | 3158 * CombiningChar | Extender 3159 * 3160 * [5] Name ::= (Letter | '_' | ':') (NameChar)* 3161 * 3162 * [6] Names ::= Name (#x20 Name)* 3163 * 3164 * Returns the Name parsed or NULL 3165 */ 3166 3167 const xmlChar * 3168 xmlParseName(xmlParserCtxtPtr ctxt) { 3169 const xmlChar *in; 3170 const xmlChar *ret; 3171 int count = 0; 3172 3173 GROW; 3174 3175 #ifdef DEBUG 3176 nbParseName++; 3177 #endif 3178 3179 /* 3180 * Accelerator for simple ASCII names 3181 */ 3182 in = ctxt->input->cur; 3183 if (((*in >= 0x61) && (*in <= 0x7A)) || 3184 ((*in >= 0x41) && (*in <= 0x5A)) || 3185 (*in == '_') || (*in == ':')) { 3186 in++; 3187 while (((*in >= 0x61) && (*in <= 0x7A)) || 3188 ((*in >= 0x41) && (*in <= 0x5A)) || 3189 ((*in >= 0x30) && (*in <= 0x39)) || 3190 (*in == '_') || (*in == '-') || 3191 (*in == ':') || (*in == '.')) 3192 in++; 3193 if ((*in > 0) && (*in < 0x80)) { 3194 count = in - ctxt->input->cur; 3195 ret = xmlDictLookup(ctxt->dict, ctxt->input->cur, count); 3196 ctxt->input->cur = in; 3197 ctxt->nbChars += count; 3198 ctxt->input->col += count; 3199 if (ret == NULL) 3200 xmlErrMemory(ctxt, NULL); 3201 return(ret); 3202 } 3203 } 3204 /* accelerator for special cases */ 3205 return(xmlParseNameComplex(ctxt)); 3206 } 3207 3208 static const xmlChar * 3209 xmlParseNCNameComplex(xmlParserCtxtPtr ctxt) { 3210 int len = 0, l; 3211 int c; 3212 int count = 0; 3213 3214 #ifdef DEBUG 3215 nbParseNCNameComplex++; 3216 #endif 3217 3218 /* 3219 * Handler for more complex cases 3220 */ 3221 GROW; 3222 c = CUR_CHAR(l); 3223 if ((c == ' ') || (c == '>') || (c == '/') || /* accelerators */ 3224 (!xmlIsNameStartChar(ctxt, c) || (c == ':'))) { 3225 return(NULL); 3226 } 3227 3228 while ((c != ' ') && (c != '>') && (c != '/') && /* test bigname.xml */ 3229 (xmlIsNameChar(ctxt, c) && (c != ':'))) { 3230 if (count++ > 100) { 3231 count = 0; 3232 GROW; 3233 if (ctxt->instate == XML_PARSER_EOF) 3234 return(NULL); 3235 } 3236 len += l; 3237 NEXTL(l); 3238 c = CUR_CHAR(l); 3239 } 3240 return(xmlDictLookup(ctxt->dict, ctxt->input->cur - len, len)); 3241 } 3242 3243 /** 3244 * xmlParseNCName: 3245 * @ctxt: an XML parser context 3246 * @len: lenght of the string parsed 3247 * 3248 * parse an XML name. 3249 * 3250 * [4NS] NCNameChar ::= Letter | Digit | '.' | '-' | '_' | 3251 * CombiningChar | Extender 3252 * 3253 * [5NS] NCName ::= (Letter | '_') (NCNameChar)* 3254 * 3255 * Returns the Name parsed or NULL 3256 */ 3257 3258 static const xmlChar * 3259 xmlParseNCName(xmlParserCtxtPtr ctxt) { 3260 const xmlChar *in; 3261 const xmlChar *ret; 3262 int count = 0; 3263 3264 #ifdef DEBUG 3265 nbParseNCName++; 3266 #endif 3267 3268 /* 3269 * Accelerator for simple ASCII names 3270 */ 3271 in = ctxt->input->cur; 3272 if (((*in >= 0x61) && (*in <= 0x7A)) || 3273 ((*in >= 0x41) && (*in <= 0x5A)) || 3274 (*in == '_')) { 3275 in++; 3276 while (((*in >= 0x61) && (*in <= 0x7A)) || 3277 ((*in >= 0x41) && (*in <= 0x5A)) || 3278 ((*in >= 0x30) && (*in <= 0x39)) || 3279 (*in == '_') || (*in == '-') || 3280 (*in == '.')) 3281 in++; 3282 if ((*in > 0) && (*in < 0x80)) { 3283 count = in - ctxt->input->cur; 3284 ret = xmlDictLookup(ctxt->dict, ctxt->input->cur, count); 3285 ctxt->input->cur = in; 3286 ctxt->nbChars += count; 3287 ctxt->input->col += count; 3288 if (ret == NULL) { 3289 xmlErrMemory(ctxt, NULL); 3290 } 3291 return(ret); 3292 } 3293 } 3294 return(xmlParseNCNameComplex(ctxt)); 3295 } 3296 3297 /** 3298 * xmlParseNameAndCompare: 3299 * @ctxt: an XML parser context 3300 * 3301 * parse an XML name and compares for match 3302 * (specialized for endtag parsing) 3303 * 3304 * Returns NULL for an illegal name, (xmlChar*) 1 for success 3305 * and the name for mismatch 3306 */ 3307 3308 static const xmlChar * 3309 xmlParseNameAndCompare(xmlParserCtxtPtr ctxt, xmlChar const *other) { 3310 register const xmlChar *cmp = other; 3311 register const xmlChar *in; 3312 const xmlChar *ret; 3313 3314 GROW; 3315 if (ctxt->instate == XML_PARSER_EOF) 3316 return(NULL); 3317 3318 in = ctxt->input->cur; 3319 while (*in != 0 && *in == *cmp) { 3320 ++in; 3321 ++cmp; 3322 ctxt->input->col++; 3323 } 3324 if (*cmp == 0 && (*in == '>' || IS_BLANK_CH (*in))) { 3325 /* success */ 3326 ctxt->input->cur = in; 3327 return (const xmlChar*) 1; 3328 } 3329 /* failure (or end of input buffer), check with full function */ 3330 ret = xmlParseName (ctxt); 3331 /* strings coming from the dictionnary direct compare possible */ 3332 if (ret == other) { 3333 return (const xmlChar*) 1; 3334 } 3335 return ret; 3336 } 3337 3338 /** 3339 * xmlParseStringName: 3340 * @ctxt: an XML parser context 3341 * @str: a pointer to the string pointer (IN/OUT) 3342 * 3343 * parse an XML name. 3344 * 3345 * [4] NameChar ::= Letter | Digit | '.' | '-' | '_' | ':' | 3346 * CombiningChar | Extender 3347 * 3348 * [5] Name ::= (Letter | '_' | ':') (NameChar)* 3349 * 3350 * [6] Names ::= Name (#x20 Name)* 3351 * 3352 * Returns the Name parsed or NULL. The @str pointer 3353 * is updated to the current location in the string. 3354 */ 3355 3356 static xmlChar * 3357 xmlParseStringName(xmlParserCtxtPtr ctxt, const xmlChar** str) { 3358 xmlChar buf[XML_MAX_NAMELEN + 5]; 3359 const xmlChar *cur = *str; 3360 int len = 0, l; 3361 int c; 3362 3363 #ifdef DEBUG 3364 nbParseStringName++; 3365 #endif 3366 3367 c = CUR_SCHAR(cur, l); 3368 if (!xmlIsNameStartChar(ctxt, c)) { 3369 return(NULL); 3370 } 3371 3372 COPY_BUF(l,buf,len,c); 3373 cur += l; 3374 c = CUR_SCHAR(cur, l); 3375 while (xmlIsNameChar(ctxt, c)) { 3376 COPY_BUF(l,buf,len,c); 3377 cur += l; 3378 c = CUR_SCHAR(cur, l); 3379 if (len >= XML_MAX_NAMELEN) { /* test bigentname.xml */ 3380 /* 3381 * Okay someone managed to make a huge name, so he's ready to pay 3382 * for the processing speed. 3383 */ 3384 xmlChar *buffer; 3385 int max = len * 2; 3386 3387 buffer = (xmlChar *) xmlMallocAtomic(max * sizeof(xmlChar)); 3388 if (buffer == NULL) { 3389 xmlErrMemory(ctxt, NULL); 3390 return(NULL); 3391 } 3392 memcpy(buffer, buf, len); 3393 while (xmlIsNameChar(ctxt, c)) { 3394 if (len + 10 > max) { 3395 xmlChar *tmp; 3396 max *= 2; 3397 tmp = (xmlChar *) xmlRealloc(buffer, 3398 max * sizeof(xmlChar)); 3399 if (tmp == NULL) { 3400 xmlErrMemory(ctxt, NULL); 3401 xmlFree(buffer); 3402 return(NULL); 3403 } 3404 buffer = tmp; 3405 } 3406 COPY_BUF(l,buffer,len,c); 3407 cur += l; 3408 c = CUR_SCHAR(cur, l); 3409 } 3410 buffer[len] = 0; 3411 *str = cur; 3412 return(buffer); 3413 } 3414 } 3415 *str = cur; 3416 return(xmlStrndup(buf, len)); 3417 } 3418 3419 /** 3420 * xmlParseNmtoken: 3421 * @ctxt: an XML parser context 3422 * 3423 * parse an XML Nmtoken. 3424 * 3425 * [7] Nmtoken ::= (NameChar)+ 3426 * 3427 * [8] Nmtokens ::= Nmtoken (#x20 Nmtoken)* 3428 * 3429 * Returns the Nmtoken parsed or NULL 3430 */ 3431 3432 xmlChar * 3433 xmlParseNmtoken(xmlParserCtxtPtr ctxt) { 3434 xmlChar buf[XML_MAX_NAMELEN + 5]; 3435 int len = 0, l; 3436 int c; 3437 int count = 0; 3438 3439 #ifdef DEBUG 3440 nbParseNmToken++; 3441 #endif 3442 3443 GROW; 3444 if (ctxt->instate == XML_PARSER_EOF) 3445 return(NULL); 3446 c = CUR_CHAR(l); 3447 3448 while (xmlIsNameChar(ctxt, c)) { 3449 if (count++ > 100) { 3450 count = 0; 3451 GROW; 3452 } 3453 COPY_BUF(l,buf,len,c); 3454 NEXTL(l); 3455 c = CUR_CHAR(l); 3456 if (len >= XML_MAX_NAMELEN) { 3457 /* 3458 * Okay someone managed to make a huge token, so he's ready to pay 3459 * for the processing speed. 3460 */ 3461 xmlChar *buffer; 3462 int max = len * 2; 3463 3464 buffer = (xmlChar *) xmlMallocAtomic(max * sizeof(xmlChar)); 3465 if (buffer == NULL) { 3466 xmlErrMemory(ctxt, NULL); 3467 return(NULL); 3468 } 3469 memcpy(buffer, buf, len); 3470 while (xmlIsNameChar(ctxt, c)) { 3471 if (count++ > 100) { 3472 count = 0; 3473 GROW; 3474 if (ctxt->instate == XML_PARSER_EOF) { 3475 xmlFree(buffer); 3476 return(NULL); 3477 } 3478 } 3479 if (len + 10 > max) { 3480 xmlChar *tmp; 3481 3482 max *= 2; 3483 tmp = (xmlChar *) xmlRealloc(buffer, 3484 max * sizeof(xmlChar)); 3485 if (tmp == NULL) { 3486 xmlErrMemory(ctxt, NULL); 3487 xmlFree(buffer); 3488 return(NULL); 3489 } 3490 buffer = tmp; 3491 } 3492 COPY_BUF(l,buffer,len,c); 3493 NEXTL(l); 3494 c = CUR_CHAR(l); 3495 } 3496 buffer[len] = 0; 3497 return(buffer); 3498 } 3499 } 3500 if (len == 0) 3501 return(NULL); 3502 return(xmlStrndup(buf, len)); 3503 } 3504 3505 /** 3506 * xmlParseEntityValue: 3507 * @ctxt: an XML parser context 3508 * @orig: if non-NULL store a copy of the original entity value 3509 * 3510 * parse a value for ENTITY declarations 3511 * 3512 * [9] EntityValue ::= '"' ([^%&"] | PEReference | Reference)* '"' | 3513 * "'" ([^%&'] | PEReference | Reference)* "'" 3514 * 3515 * Returns the EntityValue parsed with reference substituted or NULL 3516 */ 3517 3518 xmlChar * 3519 xmlParseEntityValue(xmlParserCtxtPtr ctxt, xmlChar **orig) { 3520 xmlChar *buf = NULL; 3521 int len = 0; 3522 int size = XML_PARSER_BUFFER_SIZE; 3523 int c, l; 3524 xmlChar stop; 3525 xmlChar *ret = NULL; 3526 const xmlChar *cur = NULL; 3527 xmlParserInputPtr input; 3528 3529 if (RAW == '"') stop = '"'; 3530 else if (RAW == '\'') stop = '\''; 3531 else { 3532 xmlFatalErr(ctxt, XML_ERR_ENTITY_NOT_STARTED, NULL); 3533 return(NULL); 3534 } 3535 buf = (xmlChar *) xmlMallocAtomic(size * sizeof(xmlChar)); 3536 if (buf == NULL) { 3537 xmlErrMemory(ctxt, NULL); 3538 return(NULL); 3539 } 3540 3541 /* 3542 * The content of the entity definition is copied in a buffer. 3543 */ 3544 3545 ctxt->instate = XML_PARSER_ENTITY_VALUE; 3546 input = ctxt->input; 3547 GROW; 3548 if (ctxt->instate == XML_PARSER_EOF) { 3549 xmlFree(buf); 3550 return(NULL); 3551 } 3552 NEXT; 3553 c = CUR_CHAR(l); 3554 /* 3555 * NOTE: 4.4.5 Included in Literal 3556 * When a parameter entity reference appears in a literal entity 3557 * value, ... a single or double quote character in the replacement 3558 * text is always treated as a normal data character and will not 3559 * terminate the literal. 3560 * In practice it means we stop the loop only when back at parsing 3561 * the initial entity and the quote is found 3562 */ 3563 while (((IS_CHAR(c)) && ((c != stop) || /* checked */ 3564 (ctxt->input != input))) && (ctxt->instate != XML_PARSER_EOF)) { 3565 if (len + 5 >= size) { 3566 xmlChar *tmp; 3567 3568 size *= 2; 3569 tmp = (xmlChar *) xmlRealloc(buf, size * sizeof(xmlChar)); 3570 if (tmp == NULL) { 3571 xmlErrMemory(ctxt, NULL); 3572 xmlFree(buf); 3573 return(NULL); 3574 } 3575 buf = tmp; 3576 } 3577 COPY_BUF(l,buf,len,c); 3578 NEXTL(l); 3579 /* 3580 * Pop-up of finished entities. 3581 */ 3582 while ((RAW == 0) && (ctxt->inputNr > 1)) /* non input consuming */ 3583 xmlPopInput(ctxt); 3584 3585 GROW; 3586 c = CUR_CHAR(l); 3587 if (c == 0) { 3588 GROW; 3589 c = CUR_CHAR(l); 3590 } 3591 } 3592 buf[len] = 0; 3593 if (ctxt->instate == XML_PARSER_EOF) { 3594 xmlFree(buf); 3595 return(NULL); 3596 } 3597 3598 /* 3599 * Raise problem w.r.t. '&' and '%' being used in non-entities 3600 * reference constructs. Note Charref will be handled in 3601 * xmlStringDecodeEntities() 3602 */ 3603 cur = buf; 3604 while (*cur != 0) { /* non input consuming */ 3605 if ((*cur == '%') || ((*cur == '&') && (cur[1] != '#'))) { 3606 xmlChar *name; 3607 xmlChar tmp = *cur; 3608 3609 cur++; 3610 name = xmlParseStringName(ctxt, &cur); 3611 if ((name == NULL) || (*cur != ';')) { 3612 xmlFatalErrMsgInt(ctxt, XML_ERR_ENTITY_CHAR_ERROR, 3613 "EntityValue: '%c' forbidden except for entities references\n", 3614 tmp); 3615 } 3616 if ((tmp == '%') && (ctxt->inSubset == 1) && 3617 (ctxt->inputNr == 1)) { 3618 xmlFatalErr(ctxt, XML_ERR_ENTITY_PE_INTERNAL, NULL); 3619 } 3620 if (name != NULL) 3621 xmlFree(name); 3622 if (*cur == 0) 3623 break; 3624 } 3625 cur++; 3626 } 3627 3628 /* 3629 * Then PEReference entities are substituted. 3630 */ 3631 if (c != stop) { 3632 xmlFatalErr(ctxt, XML_ERR_ENTITY_NOT_FINISHED, NULL); 3633 xmlFree(buf); 3634 } else { 3635 NEXT; 3636 /* 3637 * NOTE: 4.4.7 Bypassed 3638 * When a general entity reference appears in the EntityValue in 3639 * an entity declaration, it is bypassed and left as is. 3640 * so XML_SUBSTITUTE_REF is not set here. 3641 */ 3642 ret = xmlStringDecodeEntities(ctxt, buf, XML_SUBSTITUTE_PEREF, 3643 0, 0, 0); 3644 if (orig != NULL) 3645 *orig = buf; 3646 else 3647 xmlFree(buf); 3648 } 3649 3650 return(ret); 3651 } 3652 3653 /** 3654 * xmlParseAttValueComplex: 3655 * @ctxt: an XML parser context 3656 * @len: the resulting attribute len 3657 * @normalize: wether to apply the inner normalization 3658 * 3659 * parse a value for an attribute, this is the fallback function 3660 * of xmlParseAttValue() when the attribute parsing requires handling 3661 * of non-ASCII characters, or normalization compaction. 3662 * 3663 * Returns the AttValue parsed or NULL. The value has to be freed by the caller. 3664 */ 3665 static xmlChar * 3666 xmlParseAttValueComplex(xmlParserCtxtPtr ctxt, int *attlen, int normalize) { 3667 xmlChar limit = 0; 3668 xmlChar *buf = NULL; 3669 xmlChar *rep = NULL; 3670 int len = 0; 3671 int buf_size = 0; 3672 int c, l, in_space = 0; 3673 xmlChar *current = NULL; 3674 xmlEntityPtr ent; 3675 3676 if (NXT(0) == '"') { 3677 ctxt->instate = XML_PARSER_ATTRIBUTE_VALUE; 3678 limit = '"'; 3679 NEXT; 3680 } else if (NXT(0) == '\'') { 3681 limit = '\''; 3682 ctxt->instate = XML_PARSER_ATTRIBUTE_VALUE; 3683 NEXT; 3684 } else { 3685 xmlFatalErr(ctxt, XML_ERR_ATTRIBUTE_NOT_STARTED, NULL); 3686 return(NULL); 3687 } 3688 3689 /* 3690 * allocate a translation buffer. 3691 */ 3692 buf_size = XML_PARSER_BUFFER_SIZE; 3693 buf = (xmlChar *) xmlMallocAtomic(buf_size * sizeof(xmlChar)); 3694 if (buf == NULL) goto mem_error; 3695 3696 /* 3697 * OK loop until we reach one of the ending char or a size limit. 3698 */ 3699 c = CUR_CHAR(l); 3700 while (((NXT(0) != limit) && /* checked */ 3701 (IS_CHAR(c)) && (c != '<')) && 3702 (ctxt->instate != XML_PARSER_EOF)) { 3703 if (c == 0) break; 3704 if (c == '&') { 3705 in_space = 0; 3706 if (NXT(1) == '#') { 3707 int val = xmlParseCharRef(ctxt); 3708 3709 if (val == '&') { 3710 if (ctxt->replaceEntities) { 3711 if (len > buf_size - 10) { 3712 growBuffer(buf, 10); 3713 } 3714 buf[len++] = '&'; 3715 } else { 3716 /* 3717 * The reparsing will be done in xmlStringGetNodeList() 3718 * called by the attribute() function in SAX.c 3719 */ 3720 if (len > buf_size - 10) { 3721 growBuffer(buf, 10); 3722 } 3723 buf[len++] = '&'; 3724 buf[len++] = '#'; 3725 buf[len++] = '3'; 3726 buf[len++] = '8'; 3727 buf[len++] = ';'; 3728 } 3729 } else if (val != 0) { 3730 if (len > buf_size - 10) { 3731 growBuffer(buf, 10); 3732 } 3733 len += xmlCopyChar(0, &buf[len], val); 3734 } 3735 } else { 3736 ent = xmlParseEntityRef(ctxt); 3737 ctxt->nbentities++; 3738 if (ent != NULL) 3739 ctxt->nbentities += ent->owner; 3740 if ((ent != NULL) && 3741 (ent->etype == XML_INTERNAL_PREDEFINED_ENTITY)) { 3742 if (len > buf_size - 10) { 3743 growBuffer(buf, 10); 3744 } 3745 if ((ctxt->replaceEntities == 0) && 3746 (ent->content[0] == '&')) { 3747 buf[len++] = '&'; 3748 buf[len++] = '#'; 3749 buf[len++] = '3'; 3750 buf[len++] = '8'; 3751 buf[len++] = ';'; 3752 } else { 3753 buf[len++] = ent->content[0]; 3754 } 3755 } else if ((ent != NULL) && 3756 (ctxt->replaceEntities != 0)) { 3757 if (ent->etype != XML_INTERNAL_PREDEFINED_ENTITY) { 3758 rep = xmlStringDecodeEntities(ctxt, ent->content, 3759 XML_SUBSTITUTE_REF, 3760 0, 0, 0); 3761 if (rep != NULL) { 3762 current = rep; 3763 while (*current != 0) { /* non input consuming */ 3764 if ((*current == 0xD) || (*current == 0xA) || 3765 (*current == 0x9)) { 3766 buf[len++] = 0x20; 3767 current++; 3768 } else 3769 buf[len++] = *current++; 3770 if (len > buf_size - 10) { 3771 growBuffer(buf, 10); 3772 } 3773 } 3774 xmlFree(rep); 3775 rep = NULL; 3776 } 3777 } else { 3778 if (len > buf_size - 10) { 3779 growBuffer(buf, 10); 3780 } 3781 if (ent->content != NULL) 3782 buf[len++] = ent->content[0]; 3783 } 3784 } else if (ent != NULL) { 3785 int i = xmlStrlen(ent->name); 3786 const xmlChar *cur = ent->name; 3787 3788 /* 3789 * This may look absurd but is needed to detect 3790 * entities problems 3791 */ 3792 if ((ent->etype != XML_INTERNAL_PREDEFINED_ENTITY) && 3793 (ent->content != NULL)) { 3794 rep = xmlStringDecodeEntities(ctxt, ent->content, 3795 XML_SUBSTITUTE_REF, 0, 0, 0); 3796 if (rep != NULL) { 3797 xmlFree(rep); 3798 rep = NULL; 3799 } 3800 } 3801 3802 /* 3803 * Just output the reference 3804 */ 3805 buf[len++] = '&'; 3806 while (len > buf_size - i - 10) { 3807 growBuffer(buf, i + 10); 3808 } 3809 for (;i > 0;i--) 3810 buf[len++] = *cur++; 3811 buf[len++] = ';'; 3812 } 3813 } 3814 } else { 3815 if ((c == 0x20) || (c == 0xD) || (c == 0xA) || (c == 0x9)) { 3816 if ((len != 0) || (!normalize)) { 3817 if ((!normalize) || (!in_space)) { 3818 COPY_BUF(l,buf,len,0x20); 3819 while (len > buf_size - 10) { 3820 growBuffer(buf, 10); 3821 } 3822 } 3823 in_space = 1; 3824 } 3825 } else { 3826 in_space = 0; 3827 COPY_BUF(l,buf,len,c); 3828 if (len > buf_size - 10) { 3829 growBuffer(buf, 10); 3830 } 3831 } 3832 NEXTL(l); 3833 } 3834 GROW; 3835 c = CUR_CHAR(l); 3836 } 3837 if (ctxt->instate == XML_PARSER_EOF) 3838 goto error; 3839 3840 if ((in_space) && (normalize)) { 3841 while ((len > 0) && (buf[len - 1] == 0x20)) len--; 3842 } 3843 buf[len] = 0; 3844 if (RAW == '<') { 3845 xmlFatalErr(ctxt, XML_ERR_LT_IN_ATTRIBUTE, NULL); 3846 } else if (RAW != limit) { 3847 if ((c != 0) && (!IS_CHAR(c))) { 3848 xmlFatalErrMsg(ctxt, XML_ERR_INVALID_CHAR, 3849 "invalid character in attribute value\n"); 3850 } else { 3851 xmlFatalErrMsg(ctxt, XML_ERR_ATTRIBUTE_NOT_FINISHED, 3852 "AttValue: ' expected\n"); 3853 } 3854 } else 3855 NEXT; 3856 if (attlen != NULL) *attlen = len; 3857 return(buf); 3858 3859 mem_error: 3860 xmlErrMemory(ctxt, NULL); 3861 error: 3862 if (buf != NULL) 3863 xmlFree(buf); 3864 if (rep != NULL) 3865 xmlFree(rep); 3866 return(NULL); 3867 } 3868 3869 /** 3870 * xmlParseAttValue: 3871 * @ctxt: an XML parser context 3872 * 3873 * parse a value for an attribute 3874 * Note: the parser won't do substitution of entities here, this 3875 * will be handled later in xmlStringGetNodeList 3876 * 3877 * [10] AttValue ::= '"' ([^<&"] | Reference)* '"' | 3878 * "'" ([^<&'] | Reference)* "'" 3879 * 3880 * 3.3.3 Attribute-Value Normalization: 3881 * Before the value of an attribute is passed to the application or 3882 * checked for validity, the XML processor must normalize it as follows: 3883 * - a character reference is processed by appending the referenced 3884 * character to the attribute value 3885 * - an entity reference is processed by recursively processing the 3886 * replacement text of the entity 3887 * - a whitespace character (#x20, #xD, #xA, #x9) is processed by 3888 * appending #x20 to the normalized value, except that only a single 3889 * #x20 is appended for a "#xD#xA" sequence that is part of an external 3890 * parsed entity or the literal entity value of an internal parsed entity 3891 * - other characters are processed by appending them to the normalized value 3892 * If the declared value is not CDATA, then the XML processor must further 3893 * process the normalized attribute value by discarding any leading and 3894 * trailing space (#x20) characters, and by replacing sequences of space 3895 * (#x20) characters by a single space (#x20) character. 3896 * All attributes for which no declaration has been read should be treated 3897 * by a non-validating parser as if declared CDATA. 3898 * 3899 * Returns the AttValue parsed or NULL. The value has to be freed by the caller. 3900 */ 3901 3902 3903 xmlChar * 3904 xmlParseAttValue(xmlParserCtxtPtr ctxt) { 3905 if ((ctxt == NULL) || (ctxt->input == NULL)) return(NULL); 3906 return(xmlParseAttValueInternal(ctxt, NULL, NULL, 0)); 3907 } 3908 3909 /** 3910 * xmlParseSystemLiteral: 3911 * @ctxt: an XML parser context 3912 * 3913 * parse an XML Literal 3914 * 3915 * [11] SystemLiteral ::= ('"' [^"]* '"') | ("'" [^']* "'") 3916 * 3917 * Returns the SystemLiteral parsed or NULL 3918 */ 3919 3920 xmlChar * 3921 xmlParseSystemLiteral(xmlParserCtxtPtr ctxt) { 3922 xmlChar *buf = NULL; 3923 int len = 0; 3924 int size = XML_PARSER_BUFFER_SIZE; 3925 int cur, l; 3926 xmlChar stop; 3927 int state = ctxt->instate; 3928 int count = 0; 3929 3930 SHRINK; 3931 if (RAW == '"') { 3932 NEXT; 3933 stop = '"'; 3934 } else if (RAW == '\'') { 3935 NEXT; 3936 stop = '\''; 3937 } else { 3938 xmlFatalErr(ctxt, XML_ERR_LITERAL_NOT_STARTED, NULL); 3939 return(NULL); 3940 } 3941 3942 buf = (xmlChar *) xmlMallocAtomic(size * sizeof(xmlChar)); 3943 if (buf == NULL) { 3944 xmlErrMemory(ctxt, NULL); 3945 return(NULL); 3946 } 3947 ctxt->instate = XML_PARSER_SYSTEM_LITERAL; 3948 cur = CUR_CHAR(l); 3949 while ((IS_CHAR(cur)) && (cur != stop)) { /* checked */ 3950 if (len + 5 >= size) { 3951 xmlChar *tmp; 3952 3953 size *= 2; 3954 tmp = (xmlChar *) xmlRealloc(buf, size * sizeof(xmlChar)); 3955 if (tmp == NULL) { 3956 xmlFree(buf); 3957 xmlErrMemory(ctxt, NULL); 3958 ctxt->instate = (xmlParserInputState) state; 3959 return(NULL); 3960 } 3961 buf = tmp; 3962 } 3963 count++; 3964 if (count > 50) { 3965 GROW; 3966 count = 0; 3967 if (ctxt->instate == XML_PARSER_EOF) { 3968 xmlFree(buf); 3969 return(NULL); 3970 } 3971 } 3972 COPY_BUF(l,buf,len,cur); 3973 NEXTL(l); 3974 cur = CUR_CHAR(l); 3975 if (cur == 0) { 3976 GROW; 3977 SHRINK; 3978 cur = CUR_CHAR(l); 3979 } 3980 } 3981 buf[len] = 0; 3982 ctxt->instate = (xmlParserInputState) state; 3983 if (!IS_CHAR(cur)) { 3984 xmlFatalErr(ctxt, XML_ERR_LITERAL_NOT_FINISHED, NULL); 3985 } else { 3986 NEXT; 3987 } 3988 return(buf); 3989 } 3990 3991 /** 3992 * xmlParsePubidLiteral: 3993 * @ctxt: an XML parser context 3994 * 3995 * parse an XML public literal 3996 * 3997 * [12] PubidLiteral ::= '"' PubidChar* '"' | "'" (PubidChar - "'")* "'" 3998 * 3999 * Returns the PubidLiteral parsed or NULL. 4000 */ 4001 4002 xmlChar * 4003 xmlParsePubidLiteral(xmlParserCtxtPtr ctxt) { 4004 xmlChar *buf = NULL; 4005 int len = 0; 4006 int size = XML_PARSER_BUFFER_SIZE; 4007 xmlChar cur; 4008 xmlChar stop; 4009 int count = 0; 4010 xmlParserInputState oldstate = ctxt->instate; 4011 4012 SHRINK; 4013 if (RAW == '"') { 4014 NEXT; 4015 stop = '"'; 4016 } else if (RAW == '\'') { 4017 NEXT; 4018 stop = '\''; 4019 } else { 4020 xmlFatalErr(ctxt, XML_ERR_LITERAL_NOT_STARTED, NULL); 4021 return(NULL); 4022 } 4023 buf = (xmlChar *) xmlMallocAtomic(size * sizeof(xmlChar)); 4024 if (buf == NULL) { 4025 xmlErrMemory(ctxt, NULL); 4026 return(NULL); 4027 } 4028 ctxt->instate = XML_PARSER_PUBLIC_LITERAL; 4029 cur = CUR; 4030 while ((IS_PUBIDCHAR_CH(cur)) && (cur != stop)) { /* checked */ 4031 if (len + 1 >= size) { 4032 xmlChar *tmp; 4033 4034 size *= 2; 4035 tmp = (xmlChar *) xmlRealloc(buf, size * sizeof(xmlChar)); 4036 if (tmp == NULL) { 4037 xmlErrMemory(ctxt, NULL); 4038 xmlFree(buf); 4039 return(NULL); 4040 } 4041 buf = tmp; 4042 } 4043 buf[len++] = cur; 4044 count++; 4045 if (count > 50) { 4046 GROW; 4047 count = 0; 4048 if (ctxt->instate == XML_PARSER_EOF) { 4049 xmlFree(buf); 4050 return(NULL); 4051 } 4052 } 4053 NEXT; 4054 cur = CUR; 4055 if (cur == 0) { 4056 GROW; 4057 SHRINK; 4058 cur = CUR; 4059 } 4060 } 4061 buf[len] = 0; 4062 if (cur != stop) { 4063 xmlFatalErr(ctxt, XML_ERR_LITERAL_NOT_FINISHED, NULL); 4064 } else { 4065 NEXT; 4066 } 4067 ctxt->instate = oldstate; 4068 return(buf); 4069 } 4070 4071 static void xmlParseCharDataComplex(xmlParserCtxtPtr ctxt, int cdata); 4072 4073 /* 4074 * used for the test in the inner loop of the char data testing 4075 */ 4076 static const unsigned char test_char_data[256] = { 4077 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 4078 0x00, 0x09, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, /* 0x9, CR/LF separated */ 4079 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 4080 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 4081 0x20, 0x21, 0x22, 0x23, 0x24, 0x25, 0x00, 0x27, /* & */ 4082 0x28, 0x29, 0x2A, 0x2B, 0x2C, 0x2D, 0x2E, 0x2F, 4083 0x30, 0x31, 0x32, 0x33, 0x34, 0x35, 0x36, 0x37, 4084 0x38, 0x39, 0x3A, 0x3B, 0x00, 0x3D, 0x3E, 0x3F, /* < */ 4085 0x40, 0x41, 0x42, 0x43, 0x44, 0x45, 0x46, 0x47, 4086 0x48, 0x49, 0x4A, 0x4B, 0x4C, 0x4D, 0x4E, 0x4F, 4087 0x50, 0x51, 0x52, 0x53, 0x54, 0x55, 0x56, 0x57, 4088 0x58, 0x59, 0x5A, 0x5B, 0x5C, 0x00, 0x5E, 0x5F, /* ] */ 4089 0x60, 0x61, 0x62, 0x63, 0x64, 0x65, 0x66, 0x67, 4090 0x68, 0x69, 0x6A, 0x6B, 0x6C, 0x6D, 0x6E, 0x6F, 4091 0x70, 0x71, 0x72, 0x73, 0x74, 0x75, 0x76, 0x77, 4092 0x78, 0x79, 0x7A, 0x7B, 0x7C, 0x7D, 0x7E, 0x7F, 4093 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, /* non-ascii */ 4094 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 4095 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 4096 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 4097 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 4098 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 4099 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 4100 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 4101 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 4102 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 4103 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 4104 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 4105 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 4106 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 4107 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 4108 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 4109 }; 4110 4111 /** 4112 * xmlParseCharData: 4113 * @ctxt: an XML parser context 4114 * @cdata: int indicating whether we are within a CDATA section 4115 * 4116 * parse a CharData section. 4117 * if we are within a CDATA section ']]>' marks an end of section. 4118 * 4119 * The right angle bracket (>) may be represented using the string ">", 4120 * and must, for compatibility, be escaped using ">" or a character 4121 * reference when it appears in the string "]]>" in content, when that 4122 * string is not marking the end of a CDATA section. 4123 * 4124 * [14] CharData ::= [^<&]* - ([^<&]* ']]>' [^<&]*) 4125 */ 4126 4127 void 4128 xmlParseCharData(xmlParserCtxtPtr ctxt, int cdata) { 4129 const xmlChar *in; 4130 int nbchar = 0; 4131 int line = ctxt->input->line; 4132 int col = ctxt->input->col; 4133 int ccol; 4134 4135 SHRINK; 4136 GROW; 4137 /* 4138 * Accelerated common case where input don't need to be 4139 * modified before passing it to the handler. 4140 */ 4141 if (!cdata) { 4142 in = ctxt->input->cur; 4143 do { 4144 get_more_space: 4145 while (*in == 0x20) { in++; ctxt->input->col++; } 4146 if (*in == 0xA) { 4147 do { 4148 ctxt->input->line++; ctxt->input->col = 1; 4149 in++; 4150 } while (*in == 0xA); 4151 goto get_more_space; 4152 } 4153 if (*in == '<') { 4154 nbchar = in - ctxt->input->cur; 4155 if (nbchar > 0) { 4156 const xmlChar *tmp = ctxt->input->cur; 4157 ctxt->input->cur = in; 4158 4159 if ((ctxt->sax != NULL) && 4160 (ctxt->sax->ignorableWhitespace != 4161 ctxt->sax->characters)) { 4162 if (areBlanks(ctxt, tmp, nbchar, 1)) { 4163 if (ctxt->sax->ignorableWhitespace != NULL) 4164 ctxt->sax->ignorableWhitespace(ctxt->userData, 4165 tmp, nbchar); 4166 } else { 4167 if (ctxt->sax->characters != NULL) 4168 ctxt->sax->characters(ctxt->userData, 4169 tmp, nbchar); 4170 if (*ctxt->space == -1) 4171 *ctxt->space = -2; 4172 } 4173 } else if ((ctxt->sax != NULL) && 4174 (ctxt->sax->characters != NULL)) { 4175 ctxt->sax->characters(ctxt->userData, 4176 tmp, nbchar); 4177 } 4178 } 4179 return; 4180 } 4181 4182 get_more: 4183 ccol = ctxt->input->col; 4184 while (test_char_data[*in]) { 4185 in++; 4186 ccol++; 4187 } 4188 ctxt->input->col = ccol; 4189 if (*in == 0xA) { 4190 do { 4191 ctxt->input->line++; ctxt->input->col = 1; 4192 in++; 4193 } while (*in == 0xA); 4194 goto get_more; 4195 } 4196 if (*in == ']') { 4197 if ((in[1] == ']') && (in[2] == '>')) { 4198 xmlFatalErr(ctxt, XML_ERR_MISPLACED_CDATA_END, NULL); 4199 ctxt->input->cur = in; 4200 return; 4201 } 4202 in++; 4203 ctxt->input->col++; 4204 goto get_more; 4205 } 4206 nbchar = in - ctxt->input->cur; 4207 if (nbchar > 0) { 4208 if ((ctxt->sax != NULL) && 4209 (ctxt->sax->ignorableWhitespace != 4210 ctxt->sax->characters) && 4211 (IS_BLANK_CH(*ctxt->input->cur))) { 4212 const xmlChar *tmp = ctxt->input->cur; 4213 ctxt->input->cur = in; 4214 4215 if (areBlanks(ctxt, tmp, nbchar, 0)) { 4216 if (ctxt->sax->ignorableWhitespace != NULL) 4217 ctxt->sax->ignorableWhitespace(ctxt->userData, 4218 tmp, nbchar); 4219 } else { 4220 if (ctxt->sax->characters != NULL) 4221 ctxt->sax->characters(ctxt->userData, 4222 tmp, nbchar); 4223 if (*ctxt->space == -1) 4224 *ctxt->space = -2; 4225 } 4226 line = ctxt->input->line; 4227 col = ctxt->input->col; 4228 } else if (ctxt->sax != NULL) { 4229 if (ctxt->sax->characters != NULL) 4230 ctxt->sax->characters(ctxt->userData, 4231 ctxt->input->cur, nbchar); 4232 line = ctxt->input->line; 4233 col = ctxt->input->col; 4234 } 4235 /* something really bad happened in the SAX callback */ 4236 if (ctxt->instate != XML_PARSER_CONTENT) 4237 return; 4238 } 4239 ctxt->input->cur = in; 4240 if (*in == 0xD) { 4241 in++; 4242 if (*in == 0xA) { 4243 ctxt->input->cur = in; 4244 in++; 4245 ctxt->input->line++; ctxt->input->col = 1; 4246 continue; /* while */ 4247 } 4248 in--; 4249 } 4250 if (*in == '<') { 4251 return; 4252 } 4253 if (*in == '&') { 4254 return; 4255 } 4256 SHRINK; 4257 GROW; 4258 if (ctxt->instate == XML_PARSER_EOF) 4259 return; 4260 in = ctxt->input->cur; 4261 } while (((*in >= 0x20) && (*in <= 0x7F)) || (*in == 0x09)); 4262 nbchar = 0; 4263 } 4264 ctxt->input->line = line; 4265 ctxt->input->col = col; 4266 xmlParseCharDataComplex(ctxt, cdata); 4267 } 4268 4269 /** 4270 * xmlParseCharDataComplex: 4271 * @ctxt: an XML parser context 4272 * @cdata: int indicating whether we are within a CDATA section 4273 * 4274 * parse a CharData section.this is the fallback function 4275 * of xmlParseCharData() when the parsing requires handling 4276 * of non-ASCII characters. 4277 */ 4278 static void 4279 xmlParseCharDataComplex(xmlParserCtxtPtr ctxt, int cdata) { 4280 xmlChar buf[XML_PARSER_BIG_BUFFER_SIZE + 5]; 4281 int nbchar = 0; 4282 int cur, l; 4283 int count = 0; 4284 4285 SHRINK; 4286 GROW; 4287 cur = CUR_CHAR(l); 4288 while ((cur != '<') && /* checked */ 4289 (cur != '&') && 4290 (IS_CHAR(cur))) /* test also done in xmlCurrentChar() */ { 4291 if ((cur == ']') && (NXT(1) == ']') && 4292 (NXT(2) == '>')) { 4293 if (cdata) break; 4294 else { 4295 xmlFatalErr(ctxt, XML_ERR_MISPLACED_CDATA_END, NULL); 4296 } 4297 } 4298 COPY_BUF(l,buf,nbchar,cur); 4299 if (nbchar >= XML_PARSER_BIG_BUFFER_SIZE) { 4300 buf[nbchar] = 0; 4301 4302 /* 4303 * OK the segment is to be consumed as chars. 4304 */ 4305 if ((ctxt->sax != NULL) && (!ctxt->disableSAX)) { 4306 if (areBlanks(ctxt, buf, nbchar, 0)) { 4307 if (ctxt->sax->ignorableWhitespace != NULL) 4308 ctxt->sax->ignorableWhitespace(ctxt->userData, 4309 buf, nbchar); 4310 } else { 4311 if (ctxt->sax->characters != NULL) 4312 ctxt->sax->characters(ctxt->userData, buf, nbchar); 4313 if ((ctxt->sax->characters != 4314 ctxt->sax->ignorableWhitespace) && 4315 (*ctxt->space == -1)) 4316 *ctxt->space = -2; 4317 } 4318 } 4319 nbchar = 0; 4320 /* something really bad happened in the SAX callback */ 4321 if (ctxt->instate != XML_PARSER_CONTENT) 4322 return; 4323 } 4324 count++; 4325 if (count > 50) { 4326 GROW; 4327 count = 0; 4328 if (ctxt->instate == XML_PARSER_EOF) 4329 return; 4330 } 4331 NEXTL(l); 4332 cur = CUR_CHAR(l); 4333 } 4334 if (nbchar != 0) { 4335 buf[nbchar] = 0; 4336 /* 4337 * OK the segment is to be consumed as chars. 4338 */ 4339 if ((ctxt->sax != NULL) && (!ctxt->disableSAX)) { 4340 if (areBlanks(ctxt, buf, nbchar, 0)) { 4341 if (ctxt->sax->ignorableWhitespace != NULL) 4342 ctxt->sax->ignorableWhitespace(ctxt->userData, buf, nbchar); 4343 } else { 4344 if (ctxt->sax->characters != NULL) 4345 ctxt->sax->characters(ctxt->userData, buf, nbchar); 4346 if ((ctxt->sax->characters != ctxt->sax->ignorableWhitespace) && 4347 (*ctxt->space == -1)) 4348 *ctxt->space = -2; 4349 } 4350 } 4351 } 4352 if ((cur != 0) && (!IS_CHAR(cur))) { 4353 /* Generate the error and skip the offending character */ 4354 xmlFatalErrMsgInt(ctxt, XML_ERR_INVALID_CHAR, 4355 "PCDATA invalid Char value %d\n", 4356 cur); 4357 NEXTL(l); 4358 } 4359 } 4360 4361 /** 4362 * xmlParseExternalID: 4363 * @ctxt: an XML parser context 4364 * @publicID: a xmlChar** receiving PubidLiteral 4365 * @strict: indicate whether we should restrict parsing to only 4366 * production [75], see NOTE below 4367 * 4368 * Parse an External ID or a Public ID 4369 * 4370 * NOTE: Productions [75] and [83] interact badly since [75] can generate 4371 * 'PUBLIC' S PubidLiteral S SystemLiteral 4372 * 4373 * [75] ExternalID ::= 'SYSTEM' S SystemLiteral 4374 * | 'PUBLIC' S PubidLiteral S SystemLiteral 4375 * 4376 * [83] PublicID ::= 'PUBLIC' S PubidLiteral 4377 * 4378 * Returns the function returns SystemLiteral and in the second 4379 * case publicID receives PubidLiteral, is strict is off 4380 * it is possible to return NULL and have publicID set. 4381 */ 4382 4383 xmlChar * 4384 xmlParseExternalID(xmlParserCtxtPtr ctxt, xmlChar **publicID, int strict) { 4385 xmlChar *URI = NULL; 4386 4387 SHRINK; 4388 4389 *publicID = NULL; 4390 if (CMP6(CUR_PTR, 'S', 'Y', 'S', 'T', 'E', 'M')) { 4391 SKIP(6); 4392 if (!IS_BLANK_CH(CUR)) { 4393 xmlFatalErrMsg(ctxt, XML_ERR_SPACE_REQUIRED, 4394 "Space required after 'SYSTEM'\n"); 4395 } 4396 SKIP_BLANKS; 4397 URI = xmlParseSystemLiteral(ctxt); 4398 if (URI == NULL) { 4399 xmlFatalErr(ctxt, XML_ERR_URI_REQUIRED, NULL); 4400 } 4401 } else if (CMP6(CUR_PTR, 'P', 'U', 'B', 'L', 'I', 'C')) { 4402 SKIP(6); 4403 if (!IS_BLANK_CH(CUR)) { 4404 xmlFatalErrMsg(ctxt, XML_ERR_SPACE_REQUIRED, 4405 "Space required after 'PUBLIC'\n"); 4406 } 4407 SKIP_BLANKS; 4408 *publicID = xmlParsePubidLiteral(ctxt); 4409 if (*publicID == NULL) { 4410 xmlFatalErr(ctxt, XML_ERR_PUBID_REQUIRED, NULL); 4411 } 4412 if (strict) { 4413 /* 4414 * We don't handle [83] so "S SystemLiteral" is required. 4415 */ 4416 if (!IS_BLANK_CH(CUR)) { 4417 xmlFatalErrMsg(ctxt, XML_ERR_SPACE_REQUIRED, 4418 "Space required after the Public Identifier\n"); 4419 } 4420 } else { 4421 /* 4422 * We handle [83] so we return immediately, if 4423 * "S SystemLiteral" is not detected. From a purely parsing 4424 * point of view that's a nice mess. 4425 */ 4426 const xmlChar *ptr; 4427 GROW; 4428 4429 ptr = CUR_PTR; 4430 if (!IS_BLANK_CH(*ptr)) return(NULL); 4431 4432 while (IS_BLANK_CH(*ptr)) ptr++; /* TODO: dangerous, fix ! */ 4433 if ((*ptr != '\'') && (*ptr != '"')) return(NULL); 4434 } 4435 SKIP_BLANKS; 4436 URI = xmlParseSystemLiteral(ctxt); 4437 if (URI == NULL) { 4438 xmlFatalErr(ctxt, XML_ERR_URI_REQUIRED, NULL); 4439 } 4440 } 4441 return(URI); 4442 } 4443 4444 /** 4445 * xmlParseCommentComplex: 4446 * @ctxt: an XML parser context 4447 * @buf: the already parsed part of the buffer 4448 * @len: number of bytes filles in the buffer 4449 * @size: allocated size of the buffer 4450 * 4451 * Skip an XML (SGML) comment <!-- .... --> 4452 * The spec says that "For compatibility, the string "--" (double-hyphen) 4453 * must not occur within comments. " 4454 * This is the slow routine in case the accelerator for ascii didn't work 4455 * 4456 * [15] Comment ::= '<!--' ((Char - '-') | ('-' (Char - '-')))* '-->' 4457 */ 4458 static void 4459 xmlParseCommentComplex(xmlParserCtxtPtr ctxt, xmlChar *buf, int len, int size) { 4460 int q, ql; 4461 int r, rl; 4462 int cur, l; 4463 int count = 0; 4464 int inputid; 4465 4466 inputid = ctxt->input->id; 4467 4468 if (buf == NULL) { 4469 len = 0; 4470 size = XML_PARSER_BUFFER_SIZE; 4471 buf = (xmlChar *) xmlMallocAtomic(size * sizeof(xmlChar)); 4472 if (buf == NULL) { 4473 xmlErrMemory(ctxt, NULL); 4474 return; 4475 } 4476 } 4477 GROW; /* Assure there's enough input data */ 4478 q = CUR_CHAR(ql); 4479 if (q == 0) 4480 goto not_terminated; 4481 if (!IS_CHAR(q)) { 4482 xmlFatalErrMsgInt(ctxt, XML_ERR_INVALID_CHAR, 4483 "xmlParseComment: invalid xmlChar value %d\n", 4484 q); 4485 xmlFree (buf); 4486 return; 4487 } 4488 NEXTL(ql); 4489 r = CUR_CHAR(rl); 4490 if (r == 0) 4491 goto not_terminated; 4492 if (!IS_CHAR(r)) { 4493 xmlFatalErrMsgInt(ctxt, XML_ERR_INVALID_CHAR, 4494 "xmlParseComment: invalid xmlChar value %d\n", 4495 q); 4496 xmlFree (buf); 4497 return; 4498 } 4499 NEXTL(rl); 4500 cur = CUR_CHAR(l); 4501 if (cur == 0) 4502 goto not_terminated; 4503 while (IS_CHAR(cur) && /* checked */ 4504 ((cur != '>') || 4505 (r != '-') || (q != '-'))) { 4506 if ((r == '-') && (q == '-')) { 4507 xmlFatalErr(ctxt, XML_ERR_HYPHEN_IN_COMMENT, NULL); 4508 } 4509 if (len + 5 >= size) { 4510 xmlChar *new_buf; 4511 size *= 2; 4512 new_buf = (xmlChar *) xmlRealloc(buf, size * sizeof(xmlChar)); 4513 if (new_buf == NULL) { 4514 xmlFree (buf); 4515 xmlErrMemory(ctxt, NULL); 4516 return; 4517 } 4518 buf = new_buf; 4519 } 4520 COPY_BUF(ql,buf,len,q); 4521 q = r; 4522 ql = rl; 4523 r = cur; 4524 rl = l; 4525 4526 count++; 4527 if (count > 50) { 4528 GROW; 4529 count = 0; 4530 if (ctxt->instate == XML_PARSER_EOF) { 4531 xmlFree(buf); 4532 return; 4533 } 4534 } 4535 NEXTL(l); 4536 cur = CUR_CHAR(l); 4537 if (cur == 0) { 4538 SHRINK; 4539 GROW; 4540 cur = CUR_CHAR(l); 4541 } 4542 } 4543 buf[len] = 0; 4544 if (cur == 0) { 4545 xmlFatalErrMsgStr(ctxt, XML_ERR_COMMENT_NOT_FINISHED, 4546 "Comment not terminated \n<!--%.50s\n", buf); 4547 } else if (!IS_CHAR(cur)) { 4548 xmlFatalErrMsgInt(ctxt, XML_ERR_INVALID_CHAR, 4549 "xmlParseComment: invalid xmlChar value %d\n", 4550 cur); 4551 } else { 4552 if (inputid != ctxt->input->id) { 4553 xmlFatalErrMsg(ctxt, XML_ERR_ENTITY_BOUNDARY, 4554 "Comment doesn't start and stop in the same entity\n"); 4555 } 4556 NEXT; 4557 if ((ctxt->sax != NULL) && (ctxt->sax->comment != NULL) && 4558 (!ctxt->disableSAX)) 4559 ctxt->sax->comment(ctxt->userData, buf); 4560 } 4561 xmlFree(buf); 4562 return; 4563 not_terminated: 4564 xmlFatalErrMsgStr(ctxt, XML_ERR_COMMENT_NOT_FINISHED, 4565 "Comment not terminated\n", NULL); 4566 xmlFree(buf); 4567 return; 4568 } 4569 4570 /** 4571 * xmlParseComment: 4572 * @ctxt: an XML parser context 4573 * 4574 * Skip an XML (SGML) comment <!-- .... --> 4575 * The spec says that "For compatibility, the string "--" (double-hyphen) 4576 * must not occur within comments. " 4577 * 4578 * [15] Comment ::= '<!--' ((Char - '-') | ('-' (Char - '-')))* '-->' 4579 */ 4580 void 4581 xmlParseComment(xmlParserCtxtPtr ctxt) { 4582 xmlChar *buf = NULL; 4583 int size = XML_PARSER_BUFFER_SIZE; 4584 int len = 0; 4585 xmlParserInputState state; 4586 const xmlChar *in; 4587 int nbchar = 0, ccol; 4588 int inputid; 4589 4590 /* 4591 * Check that there is a comment right here. 4592 */ 4593 if ((RAW != '<') || (NXT(1) != '!') || 4594 (NXT(2) != '-') || (NXT(3) != '-')) return; 4595 state = ctxt->instate; 4596 ctxt->instate = XML_PARSER_COMMENT; 4597 inputid = ctxt->input->id; 4598 SKIP(4); 4599 SHRINK; 4600 GROW; 4601 4602 /* 4603 * Accelerated common case where input don't need to be 4604 * modified before passing it to the handler. 4605 */ 4606 in = ctxt->input->cur; 4607 do { 4608 if (*in == 0xA) { 4609 do { 4610 ctxt->input->line++; ctxt->input->col = 1; 4611 in++; 4612 } while (*in == 0xA); 4613 } 4614 get_more: 4615 ccol = ctxt->input->col; 4616 while (((*in > '-') && (*in <= 0x7F)) || 4617 ((*in >= 0x20) && (*in < '-')) || 4618 (*in == 0x09)) { 4619 in++; 4620 ccol++; 4621 } 4622 ctxt->input->col = ccol; 4623 if (*in == 0xA) { 4624 do { 4625 ctxt->input->line++; ctxt->input->col = 1; 4626 in++; 4627 } while (*in == 0xA); 4628 goto get_more; 4629 } 4630 nbchar = in - ctxt->input->cur; 4631 /* 4632 * save current set of data 4633 */ 4634 if (nbchar > 0) { 4635 if ((ctxt->sax != NULL) && 4636 (ctxt->sax->comment != NULL)) { 4637 if (buf == NULL) { 4638 if ((*in == '-') && (in[1] == '-')) 4639 size = nbchar + 1; 4640 else 4641 size = XML_PARSER_BUFFER_SIZE + nbchar; 4642 buf = (xmlChar *) xmlMallocAtomic(size * sizeof(xmlChar)); 4643 if (buf == NULL) { 4644 xmlErrMemory(ctxt, NULL); 4645 ctxt->instate = state; 4646 return; 4647 } 4648 len = 0; 4649 } else if (len + nbchar + 1 >= size) { 4650 xmlChar *new_buf; 4651 size += len + nbchar + XML_PARSER_BUFFER_SIZE; 4652 new_buf = (xmlChar *) xmlRealloc(buf, 4653 size * sizeof(xmlChar)); 4654 if (new_buf == NULL) { 4655 xmlFree (buf); 4656 xmlErrMemory(ctxt, NULL); 4657 ctxt->instate = state; 4658 return; 4659 } 4660 buf = new_buf; 4661 } 4662 memcpy(&buf[len], ctxt->input->cur, nbchar); 4663 len += nbchar; 4664 buf[len] = 0; 4665 } 4666 } 4667 ctxt->input->cur = in; 4668 if (*in == 0xA) { 4669 in++; 4670 ctxt->input->line++; ctxt->input->col = 1; 4671 } 4672 if (*in == 0xD) { 4673 in++; 4674 if (*in == 0xA) { 4675 ctxt->input->cur = in; 4676 in++; 4677 ctxt->input->line++; ctxt->input->col = 1; 4678 continue; /* while */ 4679 } 4680 in--; 4681 } 4682 SHRINK; 4683 GROW; 4684 if (ctxt->instate == XML_PARSER_EOF) { 4685 xmlFree(buf); 4686 return; 4687 } 4688 in = ctxt->input->cur; 4689 if (*in == '-') { 4690 if (in[1] == '-') { 4691 if (in[2] == '>') { 4692 if (ctxt->input->id != inputid) { 4693 xmlFatalErrMsg(ctxt, XML_ERR_ENTITY_BOUNDARY, 4694 "comment doesn't start and stop in the same entity\n"); 4695 } 4696 SKIP(3); 4697 if ((ctxt->sax != NULL) && (ctxt->sax->comment != NULL) && 4698 (!ctxt->disableSAX)) { 4699 if (buf != NULL) 4700 ctxt->sax->comment(ctxt->userData, buf); 4701 else 4702 ctxt->sax->comment(ctxt->userData, BAD_CAST ""); 4703 } 4704 if (buf != NULL) 4705 xmlFree(buf); 4706 if (ctxt->instate != XML_PARSER_EOF) 4707 ctxt->instate = state; 4708 return; 4709 } 4710 if (buf != NULL) 4711 xmlFatalErrMsgStr(ctxt, XML_ERR_COMMENT_NOT_FINISHED, 4712 "Comment not terminated \n<!--%.50s\n", 4713 buf); 4714 else 4715 xmlFatalErrMsgStr(ctxt, XML_ERR_COMMENT_NOT_FINISHED, 4716 "Comment not terminated \n", NULL); 4717 in++; 4718 ctxt->input->col++; 4719 } 4720 in++; 4721 ctxt->input->col++; 4722 goto get_more; 4723 } 4724 } while (((*in >= 0x20) && (*in <= 0x7F)) || (*in == 0x09)); 4725 xmlParseCommentComplex(ctxt, buf, len, size); 4726 ctxt->instate = state; 4727 return; 4728 } 4729 4730 4731 /** 4732 * xmlParsePITarget: 4733 * @ctxt: an XML parser context 4734 * 4735 * parse the name of a PI 4736 * 4737 * [17] PITarget ::= Name - (('X' | 'x') ('M' | 'm') ('L' | 'l')) 4738 * 4739 * Returns the PITarget name or NULL 4740 */ 4741 4742 const xmlChar * 4743 xmlParsePITarget(xmlParserCtxtPtr ctxt) { 4744 const xmlChar *name; 4745 4746 name = xmlParseName(ctxt); 4747 if ((name != NULL) && 4748 ((name[0] == 'x') || (name[0] == 'X')) && 4749 ((name[1] == 'm') || (name[1] == 'M')) && 4750 ((name[2] == 'l') || (name[2] == 'L'))) { 4751 int i; 4752 if ((name[0] == 'x') && (name[1] == 'm') && 4753 (name[2] == 'l') && (name[3] == 0)) { 4754 xmlFatalErrMsg(ctxt, XML_ERR_RESERVED_XML_NAME, 4755 "XML declaration allowed only at the start of the document\n"); 4756 return(name); 4757 } else if (name[3] == 0) { 4758 xmlFatalErr(ctxt, XML_ERR_RESERVED_XML_NAME, NULL); 4759 return(name); 4760 } 4761 for (i = 0;;i++) { 4762 if (xmlW3CPIs[i] == NULL) break; 4763 if (xmlStrEqual(name, (const xmlChar *)xmlW3CPIs[i])) 4764 return(name); 4765 } 4766 xmlWarningMsg(ctxt, XML_ERR_RESERVED_XML_NAME, 4767 "xmlParsePITarget: invalid name prefix 'xml'\n", 4768 NULL, NULL); 4769 } 4770 if ((name != NULL) && (xmlStrchr(name, ':') != NULL)) { 4771 xmlNsErr(ctxt, XML_NS_ERR_COLON, 4772 "colon are forbidden from PI names '%s'\n", name, NULL, NULL); 4773 } 4774 return(name); 4775 } 4776 4777 #ifdef LIBXML_CATALOG_ENABLED 4778 /** 4779 * xmlParseCatalogPI: 4780 * @ctxt: an XML parser context 4781 * @catalog: the PI value string 4782 * 4783 * parse an XML Catalog Processing Instruction. 4784 * 4785 * <?oasis-xml-catalog catalog="http://example.com/catalog.xml"?> 4786 * 4787 * Occurs only if allowed by the user and if happening in the Misc 4788 * part of the document before any doctype informations 4789 * This will add the given catalog to the parsing context in order 4790 * to be used if there is a resolution need further down in the document 4791 */ 4792 4793 static void 4794 xmlParseCatalogPI(xmlParserCtxtPtr ctxt, const xmlChar *catalog) { 4795 xmlChar *URL = NULL; 4796 const xmlChar *tmp, *base; 4797 xmlChar marker; 4798 4799 tmp = catalog; 4800 while (IS_BLANK_CH(*tmp)) tmp++; 4801 if (xmlStrncmp(tmp, BAD_CAST"catalog", 7)) 4802 goto error; 4803 tmp += 7; 4804 while (IS_BLANK_CH(*tmp)) tmp++; 4805 if (*tmp != '=') { 4806 return; 4807 } 4808 tmp++; 4809 while (IS_BLANK_CH(*tmp)) tmp++; 4810 marker = *tmp; 4811 if ((marker != '\'') && (marker != '"')) 4812 goto error; 4813 tmp++; 4814 base = tmp; 4815 while ((*tmp != 0) && (*tmp != marker)) tmp++; 4816 if (*tmp == 0) 4817 goto error; 4818 URL = xmlStrndup(base, tmp - base); 4819 tmp++; 4820 while (IS_BLANK_CH(*tmp)) tmp++; 4821 if (*tmp != 0) 4822 goto error; 4823 4824 if (URL != NULL) { 4825 ctxt->catalogs = xmlCatalogAddLocal(ctxt->catalogs, URL); 4826 xmlFree(URL); 4827 } 4828 return; 4829 4830 error: 4831 xmlWarningMsg(ctxt, XML_WAR_CATALOG_PI, 4832 "Catalog PI syntax error: %s\n", 4833 catalog, NULL); 4834 if (URL != NULL) 4835 xmlFree(URL); 4836 } 4837 #endif 4838 4839 /** 4840 * xmlParsePI: 4841 * @ctxt: an XML parser context 4842 * 4843 * parse an XML Processing Instruction. 4844 * 4845 * [16] PI ::= '<?' PITarget (S (Char* - (Char* '?>' Char*)))? '?>' 4846 * 4847 * The processing is transfered to SAX once parsed. 4848 */ 4849 4850 void 4851 xmlParsePI(xmlParserCtxtPtr ctxt) { 4852 xmlChar *buf = NULL; 4853 int len = 0; 4854 int size = XML_PARSER_BUFFER_SIZE; 4855 int cur, l; 4856 const xmlChar *target; 4857 xmlParserInputState state; 4858 int count = 0; 4859 4860 if ((RAW == '<') && (NXT(1) == '?')) { 4861 xmlParserInputPtr input = ctxt->input; 4862 state = ctxt->instate; 4863 ctxt->instate = XML_PARSER_PI; 4864 /* 4865 * this is a Processing Instruction. 4866 */ 4867 SKIP(2); 4868 SHRINK; 4869 4870 /* 4871 * Parse the target name and check for special support like 4872 * namespace. 4873 */ 4874 target = xmlParsePITarget(ctxt); 4875 if (target != NULL) { 4876 if ((RAW == '?') && (NXT(1) == '>')) { 4877 if (input != ctxt->input) { 4878 xmlFatalErrMsg(ctxt, XML_ERR_ENTITY_BOUNDARY, 4879 "PI declaration doesn't start and stop in the same entity\n"); 4880 } 4881 SKIP(2); 4882 4883 /* 4884 * SAX: PI detected. 4885 */ 4886 if ((ctxt->sax) && (!ctxt->disableSAX) && 4887 (ctxt->sax->processingInstruction != NULL)) 4888 ctxt->sax->processingInstruction(ctxt->userData, 4889 target, NULL); 4890 if (ctxt->instate != XML_PARSER_EOF) 4891 ctxt->instate = state; 4892 return; 4893 } 4894 buf = (xmlChar *) xmlMallocAtomic(size * sizeof(xmlChar)); 4895 if (buf == NULL) { 4896 xmlErrMemory(ctxt, NULL); 4897 ctxt->instate = state; 4898 return; 4899 } 4900 cur = CUR; 4901 if (!IS_BLANK(cur)) { 4902 xmlFatalErrMsgStr(ctxt, XML_ERR_SPACE_REQUIRED, 4903 "ParsePI: PI %s space expected\n", target); 4904 } 4905 SKIP_BLANKS; 4906 cur = CUR_CHAR(l); 4907 while (IS_CHAR(cur) && /* checked */ 4908 ((cur != '?') || (NXT(1) != '>'))) { 4909 if (len + 5 >= size) { 4910 xmlChar *tmp; 4911 4912 size *= 2; 4913 tmp = (xmlChar *) xmlRealloc(buf, size * sizeof(xmlChar)); 4914 if (tmp == NULL) { 4915 xmlErrMemory(ctxt, NULL); 4916 xmlFree(buf); 4917 ctxt->instate = state; 4918 return; 4919 } 4920 buf = tmp; 4921 } 4922 count++; 4923 if (count > 50) { 4924 GROW; 4925 if (ctxt->instate == XML_PARSER_EOF) { 4926 xmlFree(buf); 4927 return; 4928 } 4929 count = 0; 4930 } 4931 COPY_BUF(l,buf,len,cur); 4932 NEXTL(l); 4933 cur = CUR_CHAR(l); 4934 if (cur == 0) { 4935 SHRINK; 4936 GROW; 4937 cur = CUR_CHAR(l); 4938 } 4939 } 4940 buf[len] = 0; 4941 if (cur != '?') { 4942 xmlFatalErrMsgStr(ctxt, XML_ERR_PI_NOT_FINISHED, 4943 "ParsePI: PI %s never end ...\n", target); 4944 } else { 4945 if (input != ctxt->input) { 4946 xmlFatalErrMsg(ctxt, XML_ERR_SPACE_REQUIRED, 4947 "PI declaration doesn't start and stop in the same entity\n"); 4948 } 4949 SKIP(2); 4950 4951 #ifdef LIBXML_CATALOG_ENABLED 4952 if (((state == XML_PARSER_MISC) || 4953 (state == XML_PARSER_START)) && 4954 (xmlStrEqual(target, XML_CATALOG_PI))) { 4955 xmlCatalogAllow allow = xmlCatalogGetDefaults(); 4956 if ((allow == XML_CATA_ALLOW_DOCUMENT) || 4957 (allow == XML_CATA_ALLOW_ALL)) 4958 xmlParseCatalogPI(ctxt, buf); 4959 } 4960 #endif 4961 4962 4963 /* 4964 * SAX: PI detected. 4965 */ 4966 if ((ctxt->sax) && (!ctxt->disableSAX) && 4967 (ctxt->sax->processingInstruction != NULL)) 4968 ctxt->sax->processingInstruction(ctxt->userData, 4969 target, buf); 4970 } 4971 xmlFree(buf); 4972 } else { 4973 xmlFatalErr(ctxt, XML_ERR_PI_NOT_STARTED, NULL); 4974 } 4975 if (ctxt->instate != XML_PARSER_EOF) 4976 ctxt->instate = state; 4977 } 4978 } 4979 4980 /** 4981 * xmlParseNotationDecl: 4982 * @ctxt: an XML parser context 4983 * 4984 * parse a notation declaration 4985 * 4986 * [82] NotationDecl ::= '<!NOTATION' S Name S (ExternalID | PublicID) S? '>' 4987 * 4988 * Hence there is actually 3 choices: 4989 * 'PUBLIC' S PubidLiteral 4990 * 'PUBLIC' S PubidLiteral S SystemLiteral 4991 * and 'SYSTEM' S SystemLiteral 4992 * 4993 * See the NOTE on xmlParseExternalID(). 4994 */ 4995 4996 void 4997 xmlParseNotationDecl(xmlParserCtxtPtr ctxt) { 4998 const xmlChar *name; 4999 xmlChar *Pubid; 5000 xmlChar *Systemid; 5001 5002 if (CMP10(CUR_PTR, '<', '!', 'N', 'O', 'T', 'A', 'T', 'I', 'O', 'N')) { 5003 xmlParserInputPtr input = ctxt->input; 5004 SHRINK; 5005 SKIP(10); 5006 if (!IS_BLANK_CH(CUR)) { 5007 xmlFatalErrMsg(ctxt, XML_ERR_SPACE_REQUIRED, 5008 "Space required after '<!NOTATION'\n"); 5009 return; 5010 } 5011 SKIP_BLANKS; 5012 5013 name = xmlParseName(ctxt); 5014 if (name == NULL) { 5015 xmlFatalErr(ctxt, XML_ERR_NOTATION_NOT_STARTED, NULL); 5016 return; 5017 } 5018 if (!IS_BLANK_CH(CUR)) { 5019 xmlFatalErrMsg(ctxt, XML_ERR_SPACE_REQUIRED, 5020 "Space required after the NOTATION name'\n"); 5021 return; 5022 } 5023 if (xmlStrchr(name, ':') != NULL) { 5024 xmlNsErr(ctxt, XML_NS_ERR_COLON, 5025 "colon are forbidden from notation names '%s'\n", 5026 name, NULL, NULL); 5027 } 5028 SKIP_BLANKS; 5029 5030 /* 5031 * Parse the IDs. 5032 */ 5033 Systemid = xmlParseExternalID(ctxt, &Pubid, 0); 5034 SKIP_BLANKS; 5035 5036 if (RAW == '>') { 5037 if (input != ctxt->input) { 5038 xmlFatalErrMsg(ctxt, XML_ERR_SPACE_REQUIRED, 5039 "Notation declaration doesn't start and stop in the same entity\n"); 5040 } 5041 NEXT; 5042 if ((ctxt->sax != NULL) && (!ctxt->disableSAX) && 5043 (ctxt->sax->notationDecl != NULL)) 5044 ctxt->sax->notationDecl(ctxt->userData, name, Pubid, Systemid); 5045 } else { 5046 xmlFatalErr(ctxt, XML_ERR_NOTATION_NOT_FINISHED, NULL); 5047 } 5048 if (Systemid != NULL) xmlFree(Systemid); 5049 if (Pubid != NULL) xmlFree(Pubid); 5050 } 5051 } 5052 5053 /** 5054 * xmlParseEntityDecl: 5055 * @ctxt: an XML parser context 5056 * 5057 * parse <!ENTITY declarations 5058 * 5059 * [70] EntityDecl ::= GEDecl | PEDecl 5060 * 5061 * [71] GEDecl ::= '<!ENTITY' S Name S EntityDef S? '>' 5062 * 5063 * [72] PEDecl ::= '<!ENTITY' S '%' S Name S PEDef S? '>' 5064 * 5065 * [73] EntityDef ::= EntityValue | (ExternalID NDataDecl?) 5066 * 5067 * [74] PEDef ::= EntityValue | ExternalID 5068 * 5069 * [76] NDataDecl ::= S 'NDATA' S Name 5070 * 5071 * [ VC: Notation Declared ] 5072 * The Name must match the declared name of a notation. 5073 */ 5074 5075 void 5076 xmlParseEntityDecl(xmlParserCtxtPtr ctxt) { 5077 const xmlChar *name = NULL; 5078 xmlChar *value = NULL; 5079 xmlChar *URI = NULL, *literal = NULL; 5080 const xmlChar *ndata = NULL; 5081 int isParameter = 0; 5082 xmlChar *orig = NULL; 5083 int skipped; 5084 5085 /* GROW; done in the caller */ 5086 if (CMP8(CUR_PTR, '<', '!', 'E', 'N', 'T', 'I', 'T', 'Y')) { 5087 xmlParserInputPtr input = ctxt->input; 5088 SHRINK; 5089 SKIP(8); 5090 skipped = SKIP_BLANKS; 5091 if (skipped == 0) { 5092 xmlFatalErrMsg(ctxt, XML_ERR_SPACE_REQUIRED, 5093 "Space required after '<!ENTITY'\n"); 5094 } 5095 5096 if (RAW == '%') { 5097 NEXT; 5098 skipped = SKIP_BLANKS; 5099 if (skipped == 0) { 5100 xmlFatalErrMsg(ctxt, XML_ERR_SPACE_REQUIRED, 5101 "Space required after '%'\n"); 5102 } 5103 isParameter = 1; 5104 } 5105 5106 name = xmlParseName(ctxt); 5107 if (name == NULL) { 5108 xmlFatalErrMsg(ctxt, XML_ERR_NAME_REQUIRED, 5109 "xmlParseEntityDecl: no name\n"); 5110 return; 5111 } 5112 if (xmlStrchr(name, ':') != NULL) { 5113 xmlNsErr(ctxt, XML_NS_ERR_COLON, 5114 "colon are forbidden from entities names '%s'\n", 5115 name, NULL, NULL); 5116 } 5117 skipped = SKIP_BLANKS; 5118 if (skipped == 0) { 5119 xmlFatalErrMsg(ctxt, XML_ERR_SPACE_REQUIRED, 5120 "Space required after the entity name\n"); 5121 } 5122 5123 ctxt->instate = XML_PARSER_ENTITY_DECL; 5124 /* 5125 * handle the various case of definitions... 5126 */ 5127 if (isParameter) { 5128 if ((RAW == '"') || (RAW == '\'')) { 5129 value = xmlParseEntityValue(ctxt, &orig); 5130 if (value) { 5131 if ((ctxt->sax != NULL) && 5132 (!ctxt->disableSAX) && (ctxt->sax->entityDecl != NULL)) 5133 ctxt->sax->entityDecl(ctxt->userData, name, 5134 XML_INTERNAL_PARAMETER_ENTITY, 5135 NULL, NULL, value); 5136 } 5137 } else { 5138 URI = xmlParseExternalID(ctxt, &literal, 1); 5139 if ((URI == NULL) && (literal == NULL)) { 5140 xmlFatalErr(ctxt, XML_ERR_VALUE_REQUIRED, NULL); 5141 } 5142 if (URI) { 5143 xmlURIPtr uri; 5144 5145 uri = xmlParseURI((const char *) URI); 5146 if (uri == NULL) { 5147 xmlErrMsgStr(ctxt, XML_ERR_INVALID_URI, 5148 "Invalid URI: %s\n", URI); 5149 /* 5150 * This really ought to be a well formedness error 5151 * but the XML Core WG decided otherwise c.f. issue 5152 * E26 of the XML erratas. 5153 */ 5154 } else { 5155 if (uri->fragment != NULL) { 5156 /* 5157 * Okay this is foolish to block those but not 5158 * invalid URIs. 5159 */ 5160 xmlFatalErr(ctxt, XML_ERR_URI_FRAGMENT, NULL); 5161 } else { 5162 if ((ctxt->sax != NULL) && 5163 (!ctxt->disableSAX) && 5164 (ctxt->sax->entityDecl != NULL)) 5165 ctxt->sax->entityDecl(ctxt->userData, name, 5166 XML_EXTERNAL_PARAMETER_ENTITY, 5167 literal, URI, NULL); 5168 } 5169 xmlFreeURI(uri); 5170 } 5171 } 5172 } 5173 } else { 5174 if ((RAW == '"') || (RAW == '\'')) { 5175 value = xmlParseEntityValue(ctxt, &orig); 5176 if ((ctxt->sax != NULL) && 5177 (!ctxt->disableSAX) && (ctxt->sax->entityDecl != NULL)) 5178 ctxt->sax->entityDecl(ctxt->userData, name, 5179 XML_INTERNAL_GENERAL_ENTITY, 5180 NULL, NULL, value); 5181 /* 5182 * For expat compatibility in SAX mode. 5183 */ 5184 if ((ctxt->myDoc == NULL) || 5185 (xmlStrEqual(ctxt->myDoc->version, SAX_COMPAT_MODE))) { 5186 if (ctxt->myDoc == NULL) { 5187 ctxt->myDoc = xmlNewDoc(SAX_COMPAT_MODE); 5188 if (ctxt->myDoc == NULL) { 5189 xmlErrMemory(ctxt, "New Doc failed"); 5190 return; 5191 } 5192 ctxt->myDoc->properties = XML_DOC_INTERNAL; 5193 } 5194 if (ctxt->myDoc->intSubset == NULL) 5195 ctxt->myDoc->intSubset = xmlNewDtd(ctxt->myDoc, 5196 BAD_CAST "fake", NULL, NULL); 5197 5198 xmlSAX2EntityDecl(ctxt, name, XML_INTERNAL_GENERAL_ENTITY, 5199 NULL, NULL, value); 5200 } 5201 } else { 5202 URI = xmlParseExternalID(ctxt, &literal, 1); 5203 if ((URI == NULL) && (literal == NULL)) { 5204 xmlFatalErr(ctxt, XML_ERR_VALUE_REQUIRED, NULL); 5205 } 5206 if (URI) { 5207 xmlURIPtr uri; 5208 5209 uri = xmlParseURI((const char *)URI); 5210 if (uri == NULL) { 5211 xmlErrMsgStr(ctxt, XML_ERR_INVALID_URI, 5212 "Invalid URI: %s\n", URI); 5213 /* 5214 * This really ought to be a well formedness error 5215 * but the XML Core WG decided otherwise c.f. issue 5216 * E26 of the XML erratas. 5217 */ 5218 } else { 5219 if (uri->fragment != NULL) { 5220 /* 5221 * Okay this is foolish to block those but not 5222 * invalid URIs. 5223 */ 5224 xmlFatalErr(ctxt, XML_ERR_URI_FRAGMENT, NULL); 5225 } 5226 xmlFreeURI(uri); 5227 } 5228 } 5229 if ((RAW != '>') && (!IS_BLANK_CH(CUR))) { 5230 xmlFatalErrMsg(ctxt, XML_ERR_SPACE_REQUIRED, 5231 "Space required before 'NDATA'\n"); 5232 } 5233 SKIP_BLANKS; 5234 if (CMP5(CUR_PTR, 'N', 'D', 'A', 'T', 'A')) { 5235 SKIP(5); 5236 if (!IS_BLANK_CH(CUR)) { 5237 xmlFatalErrMsg(ctxt, XML_ERR_SPACE_REQUIRED, 5238 "Space required after 'NDATA'\n"); 5239 } 5240 SKIP_BLANKS; 5241 ndata = xmlParseName(ctxt); 5242 if ((ctxt->sax != NULL) && (!ctxt->disableSAX) && 5243 (ctxt->sax->unparsedEntityDecl != NULL)) 5244 ctxt->sax->unparsedEntityDecl(ctxt->userData, name, 5245 literal, URI, ndata); 5246 } else { 5247 if ((ctxt->sax != NULL) && 5248 (!ctxt->disableSAX) && (ctxt->sax->entityDecl != NULL)) 5249 ctxt->sax->entityDecl(ctxt->userData, name, 5250 XML_EXTERNAL_GENERAL_PARSED_ENTITY, 5251 literal, URI, NULL); 5252 /* 5253 * For expat compatibility in SAX mode. 5254 * assuming the entity repalcement was asked for 5255 */ 5256 if ((ctxt->replaceEntities != 0) && 5257 ((ctxt->myDoc == NULL) || 5258 (xmlStrEqual(ctxt->myDoc->version, SAX_COMPAT_MODE)))) { 5259 if (ctxt->myDoc == NULL) { 5260 ctxt->myDoc = xmlNewDoc(SAX_COMPAT_MODE); 5261 if (ctxt->myDoc == NULL) { 5262 xmlErrMemory(ctxt, "New Doc failed"); 5263 return; 5264 } 5265 ctxt->myDoc->properties = XML_DOC_INTERNAL; 5266 } 5267 5268 if (ctxt->myDoc->intSubset == NULL) 5269 ctxt->myDoc->intSubset = xmlNewDtd(ctxt->myDoc, 5270 BAD_CAST "fake", NULL, NULL); 5271 xmlSAX2EntityDecl(ctxt, name, 5272 XML_EXTERNAL_GENERAL_PARSED_ENTITY, 5273 literal, URI, NULL); 5274 } 5275 } 5276 } 5277 } 5278 if (ctxt->instate == XML_PARSER_EOF) 5279 return; 5280 SKIP_BLANKS; 5281 if (RAW != '>') { 5282 xmlFatalErrMsgStr(ctxt, XML_ERR_ENTITY_NOT_FINISHED, 5283 "xmlParseEntityDecl: entity %s not terminated\n", name); 5284 } else { 5285 if (input != ctxt->input) { 5286 xmlFatalErrMsg(ctxt, XML_ERR_ENTITY_BOUNDARY, 5287 "Entity declaration doesn't start and stop in the same entity\n"); 5288 } 5289 NEXT; 5290 } 5291 if (orig != NULL) { 5292 /* 5293 * Ugly mechanism to save the raw entity value. 5294 */ 5295 xmlEntityPtr cur = NULL; 5296 5297 if (isParameter) { 5298 if ((ctxt->sax != NULL) && 5299 (ctxt->sax->getParameterEntity != NULL)) 5300 cur = ctxt->sax->getParameterEntity(ctxt->userData, name); 5301 } else { 5302 if ((ctxt->sax != NULL) && 5303 (ctxt->sax->getEntity != NULL)) 5304 cur = ctxt->sax->getEntity(ctxt->userData, name); 5305 if ((cur == NULL) && (ctxt->userData==ctxt)) { 5306 cur = xmlSAX2GetEntity(ctxt, name); 5307 } 5308 } 5309 if (cur != NULL) { 5310 if (cur->orig != NULL) 5311 xmlFree(orig); 5312 else 5313 cur->orig = orig; 5314 } else 5315 xmlFree(orig); 5316 } 5317 if (value != NULL) xmlFree(value); 5318 if (URI != NULL) xmlFree(URI); 5319 if (literal != NULL) xmlFree(literal); 5320 } 5321 } 5322 5323 /** 5324 * xmlParseDefaultDecl: 5325 * @ctxt: an XML parser context 5326 * @value: Receive a possible fixed default value for the attribute 5327 * 5328 * Parse an attribute default declaration 5329 * 5330 * [60] DefaultDecl ::= '#REQUIRED' | '#IMPLIED' | (('#FIXED' S)? AttValue) 5331 * 5332 * [ VC: Required Attribute ] 5333 * if the default declaration is the keyword #REQUIRED, then the 5334 * attribute must be specified for all elements of the type in the 5335 * attribute-list declaration. 5336 * 5337 * [ VC: Attribute Default Legal ] 5338 * The declared default value must meet the lexical constraints of 5339 * the declared attribute type c.f. xmlValidateAttributeDecl() 5340 * 5341 * [ VC: Fixed Attribute Default ] 5342 * if an attribute has a default value declared with the #FIXED 5343 * keyword, instances of that attribute must match the default value. 5344 * 5345 * [ WFC: No < in Attribute Values ] 5346 * handled in xmlParseAttValue() 5347 * 5348 * returns: XML_ATTRIBUTE_NONE, XML_ATTRIBUTE_REQUIRED, XML_ATTRIBUTE_IMPLIED 5349 * or XML_ATTRIBUTE_FIXED. 5350 */ 5351 5352 int 5353 xmlParseDefaultDecl(xmlParserCtxtPtr ctxt, xmlChar **value) { 5354 int val; 5355 xmlChar *ret; 5356 5357 *value = NULL; 5358 if (CMP9(CUR_PTR, '#', 'R', 'E', 'Q', 'U', 'I', 'R', 'E', 'D')) { 5359 SKIP(9); 5360 return(XML_ATTRIBUTE_REQUIRED); 5361 } 5362 if (CMP8(CUR_PTR, '#', 'I', 'M', 'P', 'L', 'I', 'E', 'D')) { 5363 SKIP(8); 5364 return(XML_ATTRIBUTE_IMPLIED); 5365 } 5366 val = XML_ATTRIBUTE_NONE; 5367 if (CMP6(CUR_PTR, '#', 'F', 'I', 'X', 'E', 'D')) { 5368 SKIP(6); 5369 val = XML_ATTRIBUTE_FIXED; 5370 if (!IS_BLANK_CH(CUR)) { 5371 xmlFatalErrMsg(ctxt, XML_ERR_SPACE_REQUIRED, 5372 "Space required after '#FIXED'\n"); 5373 } 5374 SKIP_BLANKS; 5375 } 5376 ret = xmlParseAttValue(ctxt); 5377 ctxt->instate = XML_PARSER_DTD; 5378 if (ret == NULL) { 5379 xmlFatalErrMsg(ctxt, (xmlParserErrors)ctxt->errNo, 5380 "Attribute default value declaration error\n"); 5381 } else 5382 *value = ret; 5383 return(val); 5384 } 5385 5386 /** 5387 * xmlParseNotationType: 5388 * @ctxt: an XML parser context 5389 * 5390 * parse an Notation attribute type. 5391 * 5392 * Note: the leading 'NOTATION' S part has already being parsed... 5393 * 5394 * [58] NotationType ::= 'NOTATION' S '(' S? Name (S? '|' S? Name)* S? ')' 5395 * 5396 * [ VC: Notation Attributes ] 5397 * Values of this type must match one of the notation names included 5398 * in the declaration; all notation names in the declaration must be declared. 5399 * 5400 * Returns: the notation attribute tree built while parsing 5401 */ 5402 5403 xmlEnumerationPtr 5404 xmlParseNotationType(xmlParserCtxtPtr ctxt) { 5405 const xmlChar *name; 5406 xmlEnumerationPtr ret = NULL, last = NULL, cur, tmp; 5407 5408 if (RAW != '(') { 5409 xmlFatalErr(ctxt, XML_ERR_NOTATION_NOT_STARTED, NULL); 5410 return(NULL); 5411 } 5412 SHRINK; 5413 do { 5414 NEXT; 5415 SKIP_BLANKS; 5416 name = xmlParseName(ctxt); 5417 if (name == NULL) { 5418 xmlFatalErrMsg(ctxt, XML_ERR_NAME_REQUIRED, 5419 "Name expected in NOTATION declaration\n"); 5420 xmlFreeEnumeration(ret); 5421 return(NULL); 5422 } 5423 tmp = ret; 5424 while (tmp != NULL) { 5425 if (xmlStrEqual(name, tmp->name)) { 5426 xmlValidityError(ctxt, XML_DTD_DUP_TOKEN, 5427 "standalone: attribute notation value token %s duplicated\n", 5428 name, NULL); 5429 if (!xmlDictOwns(ctxt->dict, name)) 5430 xmlFree((xmlChar *) name); 5431 break; 5432 } 5433 tmp = tmp->next; 5434 } 5435 if (tmp == NULL) { 5436 cur = xmlCreateEnumeration(name); 5437 if (cur == NULL) { 5438 xmlFreeEnumeration(ret); 5439 return(NULL); 5440 } 5441 if (last == NULL) ret = last = cur; 5442 else { 5443 last->next = cur; 5444 last = cur; 5445 } 5446 } 5447 SKIP_BLANKS; 5448 } while (RAW == '|'); 5449 if (RAW != ')') { 5450 xmlFatalErr(ctxt, XML_ERR_NOTATION_NOT_FINISHED, NULL); 5451 xmlFreeEnumeration(ret); 5452 return(NULL); 5453 } 5454 NEXT; 5455 return(ret); 5456 } 5457 5458 /** 5459 * xmlParseEnumerationType: 5460 * @ctxt: an XML parser context 5461 * 5462 * parse an Enumeration attribute type. 5463 * 5464 * [59] Enumeration ::= '(' S? Nmtoken (S? '|' S? Nmtoken)* S? ')' 5465 * 5466 * [ VC: Enumeration ] 5467 * Values of this type must match one of the Nmtoken tokens in 5468 * the declaration 5469 * 5470 * Returns: the enumeration attribute tree built while parsing 5471 */ 5472 5473 xmlEnumerationPtr 5474 xmlParseEnumerationType(xmlParserCtxtPtr ctxt) { 5475 xmlChar *name; 5476 xmlEnumerationPtr ret = NULL, last = NULL, cur, tmp; 5477 5478 if (RAW != '(') { 5479 xmlFatalErr(ctxt, XML_ERR_ATTLIST_NOT_STARTED, NULL); 5480 return(NULL); 5481 } 5482 SHRINK; 5483 do { 5484 NEXT; 5485 SKIP_BLANKS; 5486 name = xmlParseNmtoken(ctxt); 5487 if (name == NULL) { 5488 xmlFatalErr(ctxt, XML_ERR_NMTOKEN_REQUIRED, NULL); 5489 return(ret); 5490 } 5491 tmp = ret; 5492 while (tmp != NULL) { 5493 if (xmlStrEqual(name, tmp->name)) { 5494 xmlValidityError(ctxt, XML_DTD_DUP_TOKEN, 5495 "standalone: attribute enumeration value token %s duplicated\n", 5496 name, NULL); 5497 if (!xmlDictOwns(ctxt->dict, name)) 5498 xmlFree(name); 5499 break; 5500 } 5501 tmp = tmp->next; 5502 } 5503 if (tmp == NULL) { 5504 cur = xmlCreateEnumeration(name); 5505 if (!xmlDictOwns(ctxt->dict, name)) 5506 xmlFree(name); 5507 if (cur == NULL) { 5508 xmlFreeEnumeration(ret); 5509 return(NULL); 5510 } 5511 if (last == NULL) ret = last = cur; 5512 else { 5513 last->next = cur; 5514 last = cur; 5515 } 5516 } 5517 SKIP_BLANKS; 5518 } while (RAW == '|'); 5519 if (RAW != ')') { 5520 xmlFatalErr(ctxt, XML_ERR_ATTLIST_NOT_FINISHED, NULL); 5521 return(ret); 5522 } 5523 NEXT; 5524 return(ret); 5525 } 5526 5527 /** 5528 * xmlParseEnumeratedType: 5529 * @ctxt: an XML parser context 5530 * @tree: the enumeration tree built while parsing 5531 * 5532 * parse an Enumerated attribute type. 5533 * 5534 * [57] EnumeratedType ::= NotationType | Enumeration 5535 * 5536 * [58] NotationType ::= 'NOTATION' S '(' S? Name (S? '|' S? Name)* S? ')' 5537 * 5538 * 5539 * Returns: XML_ATTRIBUTE_ENUMERATION or XML_ATTRIBUTE_NOTATION 5540 */ 5541 5542 int 5543 xmlParseEnumeratedType(xmlParserCtxtPtr ctxt, xmlEnumerationPtr *tree) { 5544 if (CMP8(CUR_PTR, 'N', 'O', 'T', 'A', 'T', 'I', 'O', 'N')) { 5545 SKIP(8); 5546 if (!IS_BLANK_CH(CUR)) { 5547 xmlFatalErrMsg(ctxt, XML_ERR_SPACE_REQUIRED, 5548 "Space required after 'NOTATION'\n"); 5549 return(0); 5550 } 5551 SKIP_BLANKS; 5552 *tree = xmlParseNotationType(ctxt); 5553 if (*tree == NULL) return(0); 5554 return(XML_ATTRIBUTE_NOTATION); 5555 } 5556 *tree = xmlParseEnumerationType(ctxt); 5557 if (*tree == NULL) return(0); 5558 return(XML_ATTRIBUTE_ENUMERATION); 5559 } 5560 5561 /** 5562 * xmlParseAttributeType: 5563 * @ctxt: an XML parser context 5564 * @tree: the enumeration tree built while parsing 5565 * 5566 * parse the Attribute list def for an element 5567 * 5568 * [54] AttType ::= StringType | TokenizedType | EnumeratedType 5569 * 5570 * [55] StringType ::= 'CDATA' 5571 * 5572 * [56] TokenizedType ::= 'ID' | 'IDREF' | 'IDREFS' | 'ENTITY' | 5573 * 'ENTITIES' | 'NMTOKEN' | 'NMTOKENS' 5574 * 5575 * Validity constraints for attribute values syntax are checked in 5576 * xmlValidateAttributeValue() 5577 * 5578 * [ VC: ID ] 5579 * Values of type ID must match the Name production. A name must not 5580 * appear more than once in an XML document as a value of this type; 5581 * i.e., ID values must uniquely identify the elements which bear them. 5582 * 5583 * [ VC: One ID per Element Type ] 5584 * No element type may have more than one ID attribute specified. 5585 * 5586 * [ VC: ID Attribute Default ] 5587 * An ID attribute must have a declared default of #IMPLIED or #REQUIRED. 5588 * 5589 * [ VC: IDREF ] 5590 * Values of type IDREF must match the Name production, and values 5591 * of type IDREFS must match Names; each IDREF Name must match the value 5592 * of an ID attribute on some element in the XML document; i.e. IDREF 5593 * values must match the value of some ID attribute. 5594 * 5595 * [ VC: Entity Name ] 5596 * Values of type ENTITY must match the Name production, values 5597 * of type ENTITIES must match Names; each Entity Name must match the 5598 * name of an unparsed entity declared in the DTD. 5599 * 5600 * [ VC: Name Token ] 5601 * Values of type NMTOKEN must match the Nmtoken production; values 5602 * of type NMTOKENS must match Nmtokens. 5603 * 5604 * Returns the attribute type 5605 */ 5606 int 5607 xmlParseAttributeType(xmlParserCtxtPtr ctxt, xmlEnumerationPtr *tree) { 5608 SHRINK; 5609 if (CMP5(CUR_PTR, 'C', 'D', 'A', 'T', 'A')) { 5610 SKIP(5); 5611 return(XML_ATTRIBUTE_CDATA); 5612 } else if (CMP6(CUR_PTR, 'I', 'D', 'R', 'E', 'F', 'S')) { 5613 SKIP(6); 5614 return(XML_ATTRIBUTE_IDREFS); 5615 } else if (CMP5(CUR_PTR, 'I', 'D', 'R', 'E', 'F')) { 5616 SKIP(5); 5617 return(XML_ATTRIBUTE_IDREF); 5618 } else if ((RAW == 'I') && (NXT(1) == 'D')) { 5619 SKIP(2); 5620 return(XML_ATTRIBUTE_ID); 5621 } else if (CMP6(CUR_PTR, 'E', 'N', 'T', 'I', 'T', 'Y')) { 5622 SKIP(6); 5623 return(XML_ATTRIBUTE_ENTITY); 5624 } else if (CMP8(CUR_PTR, 'E', 'N', 'T', 'I', 'T', 'I', 'E', 'S')) { 5625 SKIP(8); 5626 return(XML_ATTRIBUTE_ENTITIES); 5627 } else if (CMP8(CUR_PTR, 'N', 'M', 'T', 'O', 'K', 'E', 'N', 'S')) { 5628 SKIP(8); 5629 return(XML_ATTRIBUTE_NMTOKENS); 5630 } else if (CMP7(CUR_PTR, 'N', 'M', 'T', 'O', 'K', 'E', 'N')) { 5631 SKIP(7); 5632 return(XML_ATTRIBUTE_NMTOKEN); 5633 } 5634 return(xmlParseEnumeratedType(ctxt, tree)); 5635 } 5636 5637 /** 5638 * xmlParseAttributeListDecl: 5639 * @ctxt: an XML parser context 5640 * 5641 * : parse the Attribute list def for an element 5642 * 5643 * [52] AttlistDecl ::= '<!ATTLIST' S Name AttDef* S? '>' 5644 * 5645 * [53] AttDef ::= S Name S AttType S DefaultDecl 5646 * 5647 */ 5648 void 5649 xmlParseAttributeListDecl(xmlParserCtxtPtr ctxt) { 5650 const xmlChar *elemName; 5651 const xmlChar *attrName; 5652 xmlEnumerationPtr tree; 5653 5654 if (CMP9(CUR_PTR, '<', '!', 'A', 'T', 'T', 'L', 'I', 'S', 'T')) { 5655 xmlParserInputPtr input = ctxt->input; 5656 5657 SKIP(9); 5658 if (!IS_BLANK_CH(CUR)) { 5659 xmlFatalErrMsg(ctxt, XML_ERR_SPACE_REQUIRED, 5660 "Space required after '<!ATTLIST'\n"); 5661 } 5662 SKIP_BLANKS; 5663 elemName = xmlParseName(ctxt); 5664 if (elemName == NULL) { 5665 xmlFatalErrMsg(ctxt, XML_ERR_NAME_REQUIRED, 5666 "ATTLIST: no name for Element\n"); 5667 return; 5668 } 5669 SKIP_BLANKS; 5670 GROW; 5671 while ((RAW != '>') && (ctxt->instate != XML_PARSER_EOF)) { 5672 const xmlChar *check = CUR_PTR; 5673 int type; 5674 int def; 5675 xmlChar *defaultValue = NULL; 5676 5677 GROW; 5678 tree = NULL; 5679 attrName = xmlParseName(ctxt); 5680 if (attrName == NULL) { 5681 xmlFatalErrMsg(ctxt, XML_ERR_NAME_REQUIRED, 5682 "ATTLIST: no name for Attribute\n"); 5683 break; 5684 } 5685 GROW; 5686 if (!IS_BLANK_CH(CUR)) { 5687 xmlFatalErrMsg(ctxt, XML_ERR_SPACE_REQUIRED, 5688 "Space required after the attribute name\n"); 5689 break; 5690 } 5691 SKIP_BLANKS; 5692 5693 type = xmlParseAttributeType(ctxt, &tree); 5694 if (type <= 0) { 5695 break; 5696 } 5697 5698 GROW; 5699 if (!IS_BLANK_CH(CUR)) { 5700 xmlFatalErrMsg(ctxt, XML_ERR_SPACE_REQUIRED, 5701 "Space required after the attribute type\n"); 5702 if (tree != NULL) 5703 xmlFreeEnumeration(tree); 5704 break; 5705 } 5706 SKIP_BLANKS; 5707 5708 def = xmlParseDefaultDecl(ctxt, &defaultValue); 5709 if (def <= 0) { 5710 if (defaultValue != NULL) 5711 xmlFree(defaultValue); 5712 if (tree != NULL) 5713 xmlFreeEnumeration(tree); 5714 break; 5715 } 5716 if ((type != XML_ATTRIBUTE_CDATA) && (defaultValue != NULL)) 5717 xmlAttrNormalizeSpace(defaultValue, defaultValue); 5718 5719 GROW; 5720 if (RAW != '>') { 5721 if (!IS_BLANK_CH(CUR)) { 5722 xmlFatalErrMsg(ctxt, XML_ERR_SPACE_REQUIRED, 5723 "Space required after the attribute default value\n"); 5724 if (defaultValue != NULL) 5725 xmlFree(defaultValue); 5726 if (tree != NULL) 5727 xmlFreeEnumeration(tree); 5728 break; 5729 } 5730 SKIP_BLANKS; 5731 } 5732 if (check == CUR_PTR) { 5733 xmlFatalErr(ctxt, XML_ERR_INTERNAL_ERROR, 5734 "in xmlParseAttributeListDecl\n"); 5735 if (defaultValue != NULL) 5736 xmlFree(defaultValue); 5737 if (tree != NULL) 5738 xmlFreeEnumeration(tree); 5739 break; 5740 } 5741 if ((ctxt->sax != NULL) && (!ctxt->disableSAX) && 5742 (ctxt->sax->attributeDecl != NULL)) 5743 ctxt->sax->attributeDecl(ctxt->userData, elemName, attrName, 5744 type, def, defaultValue, tree); 5745 else if (tree != NULL) 5746 xmlFreeEnumeration(tree); 5747 5748 if ((ctxt->sax2) && (defaultValue != NULL) && 5749 (def != XML_ATTRIBUTE_IMPLIED) && 5750 (def != XML_ATTRIBUTE_REQUIRED)) { 5751 xmlAddDefAttrs(ctxt, elemName, attrName, defaultValue); 5752 } 5753 if (ctxt->sax2) { 5754 xmlAddSpecialAttr(ctxt, elemName, attrName, type); 5755 } 5756 if (defaultValue != NULL) 5757 xmlFree(defaultValue); 5758 GROW; 5759 } 5760 if (RAW == '>') { 5761 if (input != ctxt->input) { 5762 xmlValidityError(ctxt, XML_ERR_ENTITY_BOUNDARY, 5763 "Attribute list declaration doesn't start and stop in the same entity\n", 5764 NULL, NULL); 5765 } 5766 NEXT; 5767 } 5768 } 5769 } 5770 5771 /** 5772 * xmlParseElementMixedContentDecl: 5773 * @ctxt: an XML parser context 5774 * @inputchk: the input used for the current entity, needed for boundary checks 5775 * 5776 * parse the declaration for a Mixed Element content 5777 * The leading '(' and spaces have been skipped in xmlParseElementContentDecl 5778 * 5779 * [51] Mixed ::= '(' S? '#PCDATA' (S? '|' S? Name)* S? ')*' | 5780 * '(' S? '#PCDATA' S? ')' 5781 * 5782 * [ VC: Proper Group/PE Nesting ] applies to [51] too (see [49]) 5783 * 5784 * [ VC: No Duplicate Types ] 5785 * The same name must not appear more than once in a single 5786 * mixed-content declaration. 5787 * 5788 * returns: the list of the xmlElementContentPtr describing the element choices 5789 */ 5790 xmlElementContentPtr 5791 xmlParseElementMixedContentDecl(xmlParserCtxtPtr ctxt, int inputchk) { 5792 xmlElementContentPtr ret = NULL, cur = NULL, n; 5793 const xmlChar *elem = NULL; 5794 5795 GROW; 5796 if (CMP7(CUR_PTR, '#', 'P', 'C', 'D', 'A', 'T', 'A')) { 5797 SKIP(7); 5798 SKIP_BLANKS; 5799 SHRINK; 5800 if (RAW == ')') { 5801 if ((ctxt->validate) && (ctxt->input->id != inputchk)) { 5802 xmlValidityError(ctxt, XML_ERR_ENTITY_BOUNDARY, 5803 "Element content declaration doesn't start and stop in the same entity\n", 5804 NULL, NULL); 5805 } 5806 NEXT; 5807 ret = xmlNewDocElementContent(ctxt->myDoc, NULL, XML_ELEMENT_CONTENT_PCDATA); 5808 if (ret == NULL) 5809 return(NULL); 5810 if (RAW == '*') { 5811 ret->ocur = XML_ELEMENT_CONTENT_MULT; 5812 NEXT; 5813 } 5814 return(ret); 5815 } 5816 if ((RAW == '(') || (RAW == '|')) { 5817 ret = cur = xmlNewDocElementContent(ctxt->myDoc, NULL, XML_ELEMENT_CONTENT_PCDATA); 5818 if (ret == NULL) return(NULL); 5819 } 5820 while ((RAW == '|') && (ctxt->instate != XML_PARSER_EOF)) { 5821 NEXT; 5822 if (elem == NULL) { 5823 ret = xmlNewDocElementContent(ctxt->myDoc, NULL, XML_ELEMENT_CONTENT_OR); 5824 if (ret == NULL) return(NULL); 5825 ret->c1 = cur; 5826 if (cur != NULL) 5827 cur->parent = ret; 5828 cur = ret; 5829 } else { 5830 n = xmlNewDocElementContent(ctxt->myDoc, NULL, XML_ELEMENT_CONTENT_OR); 5831 if (n == NULL) return(NULL); 5832 n->c1 = xmlNewDocElementContent(ctxt->myDoc, elem, XML_ELEMENT_CONTENT_ELEMENT); 5833 if (n->c1 != NULL) 5834 n->c1->parent = n; 5835 cur->c2 = n; 5836 if (n != NULL) 5837 n->parent = cur; 5838 cur = n; 5839 } 5840 SKIP_BLANKS; 5841 elem = xmlParseName(ctxt); 5842 if (elem == NULL) { 5843 xmlFatalErrMsg(ctxt, XML_ERR_NAME_REQUIRED, 5844 "xmlParseElementMixedContentDecl : Name expected\n"); 5845 xmlFreeDocElementContent(ctxt->myDoc, cur); 5846 return(NULL); 5847 } 5848 SKIP_BLANKS; 5849 GROW; 5850 } 5851 if ((RAW == ')') && (NXT(1) == '*')) { 5852 if (elem != NULL) { 5853 cur->c2 = xmlNewDocElementContent(ctxt->myDoc, elem, 5854 XML_ELEMENT_CONTENT_ELEMENT); 5855 if (cur->c2 != NULL) 5856 cur->c2->parent = cur; 5857 } 5858 if (ret != NULL) 5859 ret->ocur = XML_ELEMENT_CONTENT_MULT; 5860 if ((ctxt->validate) && (ctxt->input->id != inputchk)) { 5861 xmlValidityError(ctxt, XML_ERR_ENTITY_BOUNDARY, 5862 "Element content declaration doesn't start and stop in the same entity\n", 5863 NULL, NULL); 5864 } 5865 SKIP(2); 5866 } else { 5867 xmlFreeDocElementContent(ctxt->myDoc, ret); 5868 xmlFatalErr(ctxt, XML_ERR_MIXED_NOT_STARTED, NULL); 5869 return(NULL); 5870 } 5871 5872 } else { 5873 xmlFatalErr(ctxt, XML_ERR_PCDATA_REQUIRED, NULL); 5874 } 5875 return(ret); 5876 } 5877 5878 /** 5879 * xmlParseElementChildrenContentDeclPriv: 5880 * @ctxt: an XML parser context 5881 * @inputchk: the input used for the current entity, needed for boundary checks 5882 * @depth: the level of recursion 5883 * 5884 * parse the declaration for a Mixed Element content 5885 * The leading '(' and spaces have been skipped in xmlParseElementContentDecl 5886 * 5887 * 5888 * [47] children ::= (choice | seq) ('?' | '*' | '+')? 5889 * 5890 * [48] cp ::= (Name | choice | seq) ('?' | '*' | '+')? 5891 * 5892 * [49] choice ::= '(' S? cp ( S? '|' S? cp )* S? ')' 5893 * 5894 * [50] seq ::= '(' S? cp ( S? ',' S? cp )* S? ')' 5895 * 5896 * [ VC: Proper Group/PE Nesting ] applies to [49] and [50] 5897 * TODO Parameter-entity replacement text must be properly nested 5898 * with parenthesized groups. That is to say, if either of the 5899 * opening or closing parentheses in a choice, seq, or Mixed 5900 * construct is contained in the replacement text for a parameter 5901 * entity, both must be contained in the same replacement text. For 5902 * interoperability, if a parameter-entity reference appears in a 5903 * choice, seq, or Mixed construct, its replacement text should not 5904 * be empty, and neither the first nor last non-blank character of 5905 * the replacement text should be a connector (| or ,). 5906 * 5907 * Returns the tree of xmlElementContentPtr describing the element 5908 * hierarchy. 5909 */ 5910 static xmlElementContentPtr 5911 xmlParseElementChildrenContentDeclPriv(xmlParserCtxtPtr ctxt, int inputchk, 5912 int depth) { 5913 xmlElementContentPtr ret = NULL, cur = NULL, last = NULL, op = NULL; 5914 const xmlChar *elem; 5915 xmlChar type = 0; 5916 5917 if (((depth > 128) && ((ctxt->options & XML_PARSE_HUGE) == 0)) || 5918 (depth > 2048)) { 5919 xmlFatalErrMsgInt(ctxt, XML_ERR_ELEMCONTENT_NOT_FINISHED, 5920 "xmlParseElementChildrenContentDecl : depth %d too deep, use XML_PARSE_HUGE\n", 5921 depth); 5922 return(NULL); 5923 } 5924 SKIP_BLANKS; 5925 GROW; 5926 if (RAW == '(') { 5927 int inputid = ctxt->input->id; 5928 5929 /* Recurse on first child */ 5930 NEXT; 5931 SKIP_BLANKS; 5932 cur = ret = xmlParseElementChildrenContentDeclPriv(ctxt, inputid, 5933 depth + 1); 5934 SKIP_BLANKS; 5935 GROW; 5936 } else { 5937 elem = xmlParseName(ctxt); 5938 if (elem == NULL) { 5939 xmlFatalErr(ctxt, XML_ERR_ELEMCONTENT_NOT_STARTED, NULL); 5940 return(NULL); 5941 } 5942 cur = ret = xmlNewDocElementContent(ctxt->myDoc, elem, XML_ELEMENT_CONTENT_ELEMENT); 5943 if (cur == NULL) { 5944 xmlErrMemory(ctxt, NULL); 5945 return(NULL); 5946 } 5947 GROW; 5948 if (RAW == '?') { 5949 cur->ocur = XML_ELEMENT_CONTENT_OPT; 5950 NEXT; 5951 } else if (RAW == '*') { 5952 cur->ocur = XML_ELEMENT_CONTENT_MULT; 5953 NEXT; 5954 } else if (RAW == '+') { 5955 cur->ocur = XML_ELEMENT_CONTENT_PLUS; 5956 NEXT; 5957 } else { 5958 cur->ocur = XML_ELEMENT_CONTENT_ONCE; 5959 } 5960 GROW; 5961 } 5962 SKIP_BLANKS; 5963 SHRINK; 5964 while ((RAW != ')') && (ctxt->instate != XML_PARSER_EOF)) { 5965 /* 5966 * Each loop we parse one separator and one element. 5967 */ 5968 if (RAW == ',') { 5969 if (type == 0) type = CUR; 5970 5971 /* 5972 * Detect "Name | Name , Name" error 5973 */ 5974 else if (type != CUR) { 5975 xmlFatalErrMsgInt(ctxt, XML_ERR_SEPARATOR_REQUIRED, 5976 "xmlParseElementChildrenContentDecl : '%c' expected\n", 5977 type); 5978 if ((last != NULL) && (last != ret)) 5979 xmlFreeDocElementContent(ctxt->myDoc, last); 5980 if (ret != NULL) 5981 xmlFreeDocElementContent(ctxt->myDoc, ret); 5982 return(NULL); 5983 } 5984 NEXT; 5985 5986 op = xmlNewDocElementContent(ctxt->myDoc, NULL, XML_ELEMENT_CONTENT_SEQ); 5987 if (op == NULL) { 5988 if ((last != NULL) && (last != ret)) 5989 xmlFreeDocElementContent(ctxt->myDoc, last); 5990 xmlFreeDocElementContent(ctxt->myDoc, ret); 5991 return(NULL); 5992 } 5993 if (last == NULL) { 5994 op->c1 = ret; 5995 if (ret != NULL) 5996 ret->parent = op; 5997 ret = cur = op; 5998 } else { 5999 cur->c2 = op; 6000 if (op != NULL) 6001 op->parent = cur; 6002 op->c1 = last; 6003 if (last != NULL) 6004 last->parent = op; 6005 cur =op; 6006 last = NULL; 6007 } 6008 } else if (RAW == '|') { 6009 if (type == 0) type = CUR; 6010 6011 /* 6012 * Detect "Name , Name | Name" error 6013 */ 6014 else if (type != CUR) { 6015 xmlFatalErrMsgInt(ctxt, XML_ERR_SEPARATOR_REQUIRED, 6016 "xmlParseElementChildrenContentDecl : '%c' expected\n", 6017 type); 6018 if ((last != NULL) && (last != ret)) 6019 xmlFreeDocElementContent(ctxt->myDoc, last); 6020 if (ret != NULL) 6021 xmlFreeDocElementContent(ctxt->myDoc, ret); 6022 return(NULL); 6023 } 6024 NEXT; 6025 6026 op = xmlNewDocElementContent(ctxt->myDoc, NULL, XML_ELEMENT_CONTENT_OR); 6027 if (op == NULL) { 6028 if ((last != NULL) && (last != ret)) 6029 xmlFreeDocElementContent(ctxt->myDoc, last); 6030 if (ret != NULL) 6031 xmlFreeDocElementContent(ctxt->myDoc, ret); 6032 return(NULL); 6033 } 6034 if (last == NULL) { 6035 op->c1 = ret; 6036 if (ret != NULL) 6037 ret->parent = op; 6038 ret = cur = op; 6039 } else { 6040 cur->c2 = op; 6041 if (op != NULL) 6042 op->parent = cur; 6043 op->c1 = last; 6044 if (last != NULL) 6045 last->parent = op; 6046 cur =op; 6047 last = NULL; 6048 } 6049 } else { 6050 xmlFatalErr(ctxt, XML_ERR_ELEMCONTENT_NOT_FINISHED, NULL); 6051 if ((last != NULL) && (last != ret)) 6052 xmlFreeDocElementContent(ctxt->myDoc, last); 6053 if (ret != NULL) 6054 xmlFreeDocElementContent(ctxt->myDoc, ret); 6055 return(NULL); 6056 } 6057 GROW; 6058 SKIP_BLANKS; 6059 GROW; 6060 if (RAW == '(') { 6061 int inputid = ctxt->input->id; 6062 /* Recurse on second child */ 6063 NEXT; 6064 SKIP_BLANKS; 6065 last = xmlParseElementChildrenContentDeclPriv(ctxt, inputid, 6066 depth + 1); 6067 SKIP_BLANKS; 6068 } else { 6069 elem = xmlParseName(ctxt); 6070 if (elem == NULL) { 6071 xmlFatalErr(ctxt, XML_ERR_ELEMCONTENT_NOT_STARTED, NULL); 6072 if (ret != NULL) 6073 xmlFreeDocElementContent(ctxt->myDoc, ret); 6074 return(NULL); 6075 } 6076 last = xmlNewDocElementContent(ctxt->myDoc, elem, XML_ELEMENT_CONTENT_ELEMENT); 6077 if (last == NULL) { 6078 if (ret != NULL) 6079 xmlFreeDocElementContent(ctxt->myDoc, ret); 6080 return(NULL); 6081 } 6082 if (RAW == '?') { 6083 last->ocur = XML_ELEMENT_CONTENT_OPT; 6084 NEXT; 6085 } else if (RAW == '*') { 6086 last->ocur = XML_ELEMENT_CONTENT_MULT; 6087 NEXT; 6088 } else if (RAW == '+') { 6089 last->ocur = XML_ELEMENT_CONTENT_PLUS; 6090 NEXT; 6091 } else { 6092 last->ocur = XML_ELEMENT_CONTENT_ONCE; 6093 } 6094 } 6095 SKIP_BLANKS; 6096 GROW; 6097 } 6098 if ((cur != NULL) && (last != NULL)) { 6099 cur->c2 = last; 6100 if (last != NULL) 6101 last->parent = cur; 6102 } 6103 if ((ctxt->validate) && (ctxt->input->id != inputchk)) { 6104 xmlValidityError(ctxt, XML_ERR_ENTITY_BOUNDARY, 6105 "Element content declaration doesn't start and stop in the same entity\n", 6106 NULL, NULL); 6107 } 6108 NEXT; 6109 if (RAW == '?') { 6110 if (ret != NULL) { 6111 if ((ret->ocur == XML_ELEMENT_CONTENT_PLUS) || 6112 (ret->ocur == XML_ELEMENT_CONTENT_MULT)) 6113 ret->ocur = XML_ELEMENT_CONTENT_MULT; 6114 else 6115 ret->ocur = XML_ELEMENT_CONTENT_OPT; 6116 } 6117 NEXT; 6118 } else if (RAW == '*') { 6119 if (ret != NULL) { 6120 ret->ocur = XML_ELEMENT_CONTENT_MULT; 6121 cur = ret; 6122 /* 6123 * Some normalization: 6124 * (a | b* | c?)* == (a | b | c)* 6125 */ 6126 while ((cur != NULL) && (cur->type == XML_ELEMENT_CONTENT_OR)) { 6127 if ((cur->c1 != NULL) && 6128 ((cur->c1->ocur == XML_ELEMENT_CONTENT_OPT) || 6129 (cur->c1->ocur == XML_ELEMENT_CONTENT_MULT))) 6130 cur->c1->ocur = XML_ELEMENT_CONTENT_ONCE; 6131 if ((cur->c2 != NULL) && 6132 ((cur->c2->ocur == XML_ELEMENT_CONTENT_OPT) || 6133 (cur->c2->ocur == XML_ELEMENT_CONTENT_MULT))) 6134 cur->c2->ocur = XML_ELEMENT_CONTENT_ONCE; 6135 cur = cur->c2; 6136 } 6137 } 6138 NEXT; 6139 } else if (RAW == '+') { 6140 if (ret != NULL) { 6141 int found = 0; 6142 6143 if ((ret->ocur == XML_ELEMENT_CONTENT_OPT) || 6144 (ret->ocur == XML_ELEMENT_CONTENT_MULT)) 6145 ret->ocur = XML_ELEMENT_CONTENT_MULT; 6146 else 6147 ret->ocur = XML_ELEMENT_CONTENT_PLUS; 6148 /* 6149 * Some normalization: 6150 * (a | b*)+ == (a | b)* 6151 * (a | b?)+ == (a | b)* 6152 */ 6153 while ((cur != NULL) && (cur->type == XML_ELEMENT_CONTENT_OR)) { 6154 if ((cur->c1 != NULL) && 6155 ((cur->c1->ocur == XML_ELEMENT_CONTENT_OPT) || 6156 (cur->c1->ocur == XML_ELEMENT_CONTENT_MULT))) { 6157 cur->c1->ocur = XML_ELEMENT_CONTENT_ONCE; 6158 found = 1; 6159 } 6160 if ((cur->c2 != NULL) && 6161 ((cur->c2->ocur == XML_ELEMENT_CONTENT_OPT) || 6162 (cur->c2->ocur == XML_ELEMENT_CONTENT_MULT))) { 6163 cur->c2->ocur = XML_ELEMENT_CONTENT_ONCE; 6164 found = 1; 6165 } 6166 cur = cur->c2; 6167 } 6168 if (found) 6169 ret->ocur = XML_ELEMENT_CONTENT_MULT; 6170 } 6171 NEXT; 6172 } 6173 return(ret); 6174 } 6175 6176 /** 6177 * xmlParseElementChildrenContentDecl: 6178 * @ctxt: an XML parser context 6179 * @inputchk: the input used for the current entity, needed for boundary checks 6180 * 6181 * parse the declaration for a Mixed Element content 6182 * The leading '(' and spaces have been skipped in xmlParseElementContentDecl 6183 * 6184 * [47] children ::= (choice | seq) ('?' | '*' | '+')? 6185 * 6186 * [48] cp ::= (Name | choice | seq) ('?' | '*' | '+')? 6187 * 6188 * [49] choice ::= '(' S? cp ( S? '|' S? cp )* S? ')' 6189 * 6190 * [50] seq ::= '(' S? cp ( S? ',' S? cp )* S? ')' 6191 * 6192 * [ VC: Proper Group/PE Nesting ] applies to [49] and [50] 6193 * TODO Parameter-entity replacement text must be properly nested 6194 * with parenthesized groups. That is to say, if either of the 6195 * opening or closing parentheses in a choice, seq, or Mixed 6196 * construct is contained in the replacement text for a parameter 6197 * entity, both must be contained in the same replacement text. For 6198 * interoperability, if a parameter-entity reference appears in a 6199 * choice, seq, or Mixed construct, its replacement text should not 6200 * be empty, and neither the first nor last non-blank character of 6201 * the replacement text should be a connector (| or ,). 6202 * 6203 * Returns the tree of xmlElementContentPtr describing the element 6204 * hierarchy. 6205 */ 6206 xmlElementContentPtr 6207 xmlParseElementChildrenContentDecl(xmlParserCtxtPtr ctxt, int inputchk) { 6208 /* stub left for API/ABI compat */ 6209 return(xmlParseElementChildrenContentDeclPriv(ctxt, inputchk, 1)); 6210 } 6211 6212 /** 6213 * xmlParseElementContentDecl: 6214 * @ctxt: an XML parser context 6215 * @name: the name of the element being defined. 6216 * @result: the Element Content pointer will be stored here if any 6217 * 6218 * parse the declaration for an Element content either Mixed or Children, 6219 * the cases EMPTY and ANY are handled directly in xmlParseElementDecl 6220 * 6221 * [46] contentspec ::= 'EMPTY' | 'ANY' | Mixed | children 6222 * 6223 * returns: the type of element content XML_ELEMENT_TYPE_xxx 6224 */ 6225 6226 int 6227 xmlParseElementContentDecl(xmlParserCtxtPtr ctxt, const xmlChar *name, 6228 xmlElementContentPtr *result) { 6229 6230 xmlElementContentPtr tree = NULL; 6231 int inputid = ctxt->input->id; 6232 int res; 6233 6234 *result = NULL; 6235 6236 if (RAW != '(') { 6237 xmlFatalErrMsgStr(ctxt, XML_ERR_ELEMCONTENT_NOT_STARTED, 6238 "xmlParseElementContentDecl : %s '(' expected\n", name); 6239 return(-1); 6240 } 6241 NEXT; 6242 GROW; 6243 if (ctxt->instate == XML_PARSER_EOF) 6244 return(-1); 6245 SKIP_BLANKS; 6246 if (CMP7(CUR_PTR, '#', 'P', 'C', 'D', 'A', 'T', 'A')) { 6247 tree = xmlParseElementMixedContentDecl(ctxt, inputid); 6248 res = XML_ELEMENT_TYPE_MIXED; 6249 } else { 6250 tree = xmlParseElementChildrenContentDeclPriv(ctxt, inputid, 1); 6251 res = XML_ELEMENT_TYPE_ELEMENT; 6252 } 6253 SKIP_BLANKS; 6254 *result = tree; 6255 return(res); 6256 } 6257 6258 /** 6259 * xmlParseElementDecl: 6260 * @ctxt: an XML parser context 6261 * 6262 * parse an Element declaration. 6263 * 6264 * [45] elementdecl ::= '<!ELEMENT' S Name S contentspec S? '>' 6265 * 6266 * [ VC: Unique Element Type Declaration ] 6267 * No element type may be declared more than once 6268 * 6269 * Returns the type of the element, or -1 in case of error 6270 */ 6271 int 6272 xmlParseElementDecl(xmlParserCtxtPtr ctxt) { 6273 const xmlChar *name; 6274 int ret = -1; 6275 xmlElementContentPtr content = NULL; 6276 6277 /* GROW; done in the caller */ 6278 if (CMP9(CUR_PTR, '<', '!', 'E', 'L', 'E', 'M', 'E', 'N', 'T')) { 6279 xmlParserInputPtr input = ctxt->input; 6280 6281 SKIP(9); 6282 if (!IS_BLANK_CH(CUR)) { 6283 xmlFatalErrMsg(ctxt, XML_ERR_SPACE_REQUIRED, 6284 "Space required after 'ELEMENT'\n"); 6285 } 6286 SKIP_BLANKS; 6287 name = xmlParseName(ctxt); 6288 if (name == NULL) { 6289 xmlFatalErrMsg(ctxt, XML_ERR_NAME_REQUIRED, 6290 "xmlParseElementDecl: no name for Element\n"); 6291 return(-1); 6292 } 6293 while ((RAW == 0) && (ctxt->inputNr > 1)) 6294 xmlPopInput(ctxt); 6295 if (!IS_BLANK_CH(CUR)) { 6296 xmlFatalErrMsg(ctxt, XML_ERR_SPACE_REQUIRED, 6297 "Space required after the element name\n"); 6298 } 6299 SKIP_BLANKS; 6300 if (CMP5(CUR_PTR, 'E', 'M', 'P', 'T', 'Y')) { 6301 SKIP(5); 6302 /* 6303 * Element must always be empty. 6304 */ 6305 ret = XML_ELEMENT_TYPE_EMPTY; 6306 } else if ((RAW == 'A') && (NXT(1) == 'N') && 6307 (NXT(2) == 'Y')) { 6308 SKIP(3); 6309 /* 6310 * Element is a generic container. 6311 */ 6312 ret = XML_ELEMENT_TYPE_ANY; 6313 } else if (RAW == '(') { 6314 ret = xmlParseElementContentDecl(ctxt, name, &content); 6315 } else { 6316 /* 6317 * [ WFC: PEs in Internal Subset ] error handling. 6318 */ 6319 if ((RAW == '%') && (ctxt->external == 0) && 6320 (ctxt->inputNr == 1)) { 6321 xmlFatalErrMsg(ctxt, XML_ERR_PEREF_IN_INT_SUBSET, 6322 "PEReference: forbidden within markup decl in internal subset\n"); 6323 } else { 6324 xmlFatalErrMsg(ctxt, XML_ERR_ELEMCONTENT_NOT_STARTED, 6325 "xmlParseElementDecl: 'EMPTY', 'ANY' or '(' expected\n"); 6326 } 6327 return(-1); 6328 } 6329 6330 SKIP_BLANKS; 6331 /* 6332 * Pop-up of finished entities. 6333 */ 6334 while ((RAW == 0) && (ctxt->inputNr > 1)) 6335 xmlPopInput(ctxt); 6336 SKIP_BLANKS; 6337 6338 if (RAW != '>') { 6339 xmlFatalErr(ctxt, XML_ERR_GT_REQUIRED, NULL); 6340 if (content != NULL) { 6341 xmlFreeDocElementContent(ctxt->myDoc, content); 6342 } 6343 } else { 6344 if (input != ctxt->input) { 6345 xmlFatalErrMsg(ctxt, XML_ERR_ENTITY_BOUNDARY, 6346 "Element declaration doesn't start and stop in the same entity\n"); 6347 } 6348 6349 NEXT; 6350 if ((ctxt->sax != NULL) && (!ctxt->disableSAX) && 6351 (ctxt->sax->elementDecl != NULL)) { 6352 if (content != NULL) 6353 content->parent = NULL; 6354 ctxt->sax->elementDecl(ctxt->userData, name, ret, 6355 content); 6356 if ((content != NULL) && (content->parent == NULL)) { 6357 /* 6358 * this is a trick: if xmlAddElementDecl is called, 6359 * instead of copying the full tree it is plugged directly 6360 * if called from the parser. Avoid duplicating the 6361 * interfaces or change the API/ABI 6362 */ 6363 xmlFreeDocElementContent(ctxt->myDoc, content); 6364 } 6365 } else if (content != NULL) { 6366 xmlFreeDocElementContent(ctxt->myDoc, content); 6367 } 6368 } 6369 } 6370 return(ret); 6371 } 6372 6373 /** 6374 * xmlParseConditionalSections 6375 * @ctxt: an XML parser context 6376 * 6377 * [61] conditionalSect ::= includeSect | ignoreSect 6378 * [62] includeSect ::= '<![' S? 'INCLUDE' S? '[' extSubsetDecl ']]>' 6379 * [63] ignoreSect ::= '<![' S? 'IGNORE' S? '[' ignoreSectContents* ']]>' 6380 * [64] ignoreSectContents ::= Ignore ('<![' ignoreSectContents ']]>' Ignore)* 6381 * [65] Ignore ::= Char* - (Char* ('<![' | ']]>') Char*) 6382 */ 6383 6384 static void 6385 xmlParseConditionalSections(xmlParserCtxtPtr ctxt) { 6386 int id = ctxt->input->id; 6387 6388 SKIP(3); 6389 SKIP_BLANKS; 6390 if (CMP7(CUR_PTR, 'I', 'N', 'C', 'L', 'U', 'D', 'E')) { 6391 SKIP(7); 6392 SKIP_BLANKS; 6393 if (RAW != '[') { 6394 xmlFatalErr(ctxt, XML_ERR_CONDSEC_INVALID, NULL); 6395 } else { 6396 if (ctxt->input->id != id) { 6397 xmlValidityError(ctxt, XML_ERR_ENTITY_BOUNDARY, 6398 "All markup of the conditional section is not in the same entity\n", 6399 NULL, NULL); 6400 } 6401 NEXT; 6402 } 6403 if (xmlParserDebugEntities) { 6404 if ((ctxt->input != NULL) && (ctxt->input->filename)) 6405 xmlGenericError(xmlGenericErrorContext, 6406 "%s(%d): ", ctxt->input->filename, 6407 ctxt->input->line); 6408 xmlGenericError(xmlGenericErrorContext, 6409 "Entering INCLUDE Conditional Section\n"); 6410 } 6411 6412 while (((RAW != 0) && ((RAW != ']') || (NXT(1) != ']') || 6413 (NXT(2) != '>'))) && (ctxt->instate != XML_PARSER_EOF)) { 6414 const xmlChar *check = CUR_PTR; 6415 unsigned int cons = ctxt->input->consumed; 6416 6417 if ((RAW == '<') && (NXT(1) == '!') && (NXT(2) == '[')) { 6418 xmlParseConditionalSections(ctxt); 6419 } else if (IS_BLANK_CH(CUR)) { 6420 NEXT; 6421 } else if (RAW == '%') { 6422 xmlParsePEReference(ctxt); 6423 } else 6424 xmlParseMarkupDecl(ctxt); 6425 6426 /* 6427 * Pop-up of finished entities. 6428 */ 6429 while ((RAW == 0) && (ctxt->inputNr > 1)) 6430 xmlPopInput(ctxt); 6431 6432 if ((CUR_PTR == check) && (cons == ctxt->input->consumed)) { 6433 xmlFatalErr(ctxt, XML_ERR_EXT_SUBSET_NOT_FINISHED, NULL); 6434 break; 6435 } 6436 } 6437 if (xmlParserDebugEntities) { 6438 if ((ctxt->input != NULL) && (ctxt->input->filename)) 6439 xmlGenericError(xmlGenericErrorContext, 6440 "%s(%d): ", ctxt->input->filename, 6441 ctxt->input->line); 6442 xmlGenericError(xmlGenericErrorContext, 6443 "Leaving INCLUDE Conditional Section\n"); 6444 } 6445 6446 } else if (CMP6(CUR_PTR, 'I', 'G', 'N', 'O', 'R', 'E')) { 6447 int state; 6448 xmlParserInputState instate; 6449 int depth = 0; 6450 6451 SKIP(6); 6452 SKIP_BLANKS; 6453 if (RAW != '[') { 6454 xmlFatalErr(ctxt, XML_ERR_CONDSEC_INVALID, NULL); 6455 } else { 6456 if (ctxt->input->id != id) { 6457 xmlValidityError(ctxt, XML_ERR_ENTITY_BOUNDARY, 6458 "All markup of the conditional section is not in the same entity\n", 6459 NULL, NULL); 6460 } 6461 NEXT; 6462 } 6463 if (xmlParserDebugEntities) { 6464 if ((ctxt->input != NULL) && (ctxt->input->filename)) 6465 xmlGenericError(xmlGenericErrorContext, 6466 "%s(%d): ", ctxt->input->filename, 6467 ctxt->input->line); 6468 xmlGenericError(xmlGenericErrorContext, 6469 "Entering IGNORE Conditional Section\n"); 6470 } 6471 6472 /* 6473 * Parse up to the end of the conditional section 6474 * But disable SAX event generating DTD building in the meantime 6475 */ 6476 state = ctxt->disableSAX; 6477 instate = ctxt->instate; 6478 if (ctxt->recovery == 0) ctxt->disableSAX = 1; 6479 ctxt->instate = XML_PARSER_IGNORE; 6480 6481 while (((depth >= 0) && (RAW != 0)) && 6482 (ctxt->instate != XML_PARSER_EOF)) { 6483 if ((RAW == '<') && (NXT(1) == '!') && (NXT(2) == '[')) { 6484 depth++; 6485 SKIP(3); 6486 continue; 6487 } 6488 if ((RAW == ']') && (NXT(1) == ']') && (NXT(2) == '>')) { 6489 if (--depth >= 0) SKIP(3); 6490 continue; 6491 } 6492 NEXT; 6493 continue; 6494 } 6495 6496 ctxt->disableSAX = state; 6497 ctxt->instate = instate; 6498 6499 if (xmlParserDebugEntities) { 6500 if ((ctxt->input != NULL) && (ctxt->input->filename)) 6501 xmlGenericError(xmlGenericErrorContext, 6502 "%s(%d): ", ctxt->input->filename, 6503 ctxt->input->line); 6504 xmlGenericError(xmlGenericErrorContext, 6505 "Leaving IGNORE Conditional Section\n"); 6506 } 6507 6508 } else { 6509 xmlFatalErr(ctxt, XML_ERR_CONDSEC_INVALID_KEYWORD, NULL); 6510 } 6511 6512 if (RAW == 0) 6513 SHRINK; 6514 6515 if (RAW == 0) { 6516 xmlFatalErr(ctxt, XML_ERR_CONDSEC_NOT_FINISHED, NULL); 6517 } else { 6518 if (ctxt->input->id != id) { 6519 xmlValidityError(ctxt, XML_ERR_ENTITY_BOUNDARY, 6520 "All markup of the conditional section is not in the same entity\n", 6521 NULL, NULL); 6522 } 6523 SKIP(3); 6524 } 6525 } 6526 6527 /** 6528 * xmlParseMarkupDecl: 6529 * @ctxt: an XML parser context 6530 * 6531 * parse Markup declarations 6532 * 6533 * [29] markupdecl ::= elementdecl | AttlistDecl | EntityDecl | 6534 * NotationDecl | PI | Comment 6535 * 6536 * [ VC: Proper Declaration/PE Nesting ] 6537 * Parameter-entity replacement text must be properly nested with 6538 * markup declarations. That is to say, if either the first character 6539 * or the last character of a markup declaration (markupdecl above) is 6540 * contained in the replacement text for a parameter-entity reference, 6541 * both must be contained in the same replacement text. 6542 * 6543 * [ WFC: PEs in Internal Subset ] 6544 * In the internal DTD subset, parameter-entity references can occur 6545 * only where markup declarations can occur, not within markup declarations. 6546 * (This does not apply to references that occur in external parameter 6547 * entities or to the external subset.) 6548 */ 6549 void 6550 xmlParseMarkupDecl(xmlParserCtxtPtr ctxt) { 6551 GROW; 6552 if (CUR == '<') { 6553 if (NXT(1) == '!') { 6554 switch (NXT(2)) { 6555 case 'E': 6556 if (NXT(3) == 'L') 6557 xmlParseElementDecl(ctxt); 6558 else if (NXT(3) == 'N') 6559 xmlParseEntityDecl(ctxt); 6560 break; 6561 case 'A': 6562 xmlParseAttributeListDecl(ctxt); 6563 break; 6564 case 'N': 6565 xmlParseNotationDecl(ctxt); 6566 break; 6567 case '-': 6568 xmlParseComment(ctxt); 6569 break; 6570 default: 6571 /* there is an error but it will be detected later */ 6572 break; 6573 } 6574 } else if (NXT(1) == '?') { 6575 xmlParsePI(ctxt); 6576 } 6577 } 6578 /* 6579 * This is only for internal subset. On external entities, 6580 * the replacement is done before parsing stage 6581 */ 6582 if ((ctxt->external == 0) && (ctxt->inputNr == 1)) 6583 xmlParsePEReference(ctxt); 6584 6585 /* 6586 * Conditional sections are allowed from entities included 6587 * by PE References in the internal subset. 6588 */ 6589 if ((ctxt->external == 0) && (ctxt->inputNr > 1)) { 6590 if ((RAW == '<') && (NXT(1) == '!') && (NXT(2) == '[')) { 6591 xmlParseConditionalSections(ctxt); 6592 } 6593 } 6594 6595 ctxt->instate = XML_PARSER_DTD; 6596 } 6597 6598 /** 6599 * xmlParseTextDecl: 6600 * @ctxt: an XML parser context 6601 * 6602 * parse an XML declaration header for external entities 6603 * 6604 * [77] TextDecl ::= '<?xml' VersionInfo? EncodingDecl S? '?>' 6605 */ 6606 6607 void 6608 xmlParseTextDecl(xmlParserCtxtPtr ctxt) { 6609 xmlChar *version; 6610 const xmlChar *encoding; 6611 6612 /* 6613 * We know that '<?xml' is here. 6614 */ 6615 if ((CMP5(CUR_PTR, '<', '?', 'x', 'm', 'l')) && (IS_BLANK_CH(NXT(5)))) { 6616 SKIP(5); 6617 } else { 6618 xmlFatalErr(ctxt, XML_ERR_XMLDECL_NOT_STARTED, NULL); 6619 return; 6620 } 6621 6622 if (!IS_BLANK_CH(CUR)) { 6623 xmlFatalErrMsg(ctxt, XML_ERR_SPACE_REQUIRED, 6624 "Space needed after '<?xml'\n"); 6625 } 6626 SKIP_BLANKS; 6627 6628 /* 6629 * We may have the VersionInfo here. 6630 */ 6631 version = xmlParseVersionInfo(ctxt); 6632 if (version == NULL) 6633 version = xmlCharStrdup(XML_DEFAULT_VERSION); 6634 else { 6635 if (!IS_BLANK_CH(CUR)) { 6636 xmlFatalErrMsg(ctxt, XML_ERR_SPACE_REQUIRED, 6637 "Space needed here\n"); 6638 } 6639 } 6640 ctxt->input->version = version; 6641 6642 /* 6643 * We must have the encoding declaration 6644 */ 6645 encoding = xmlParseEncodingDecl(ctxt); 6646 if (ctxt->errNo == XML_ERR_UNSUPPORTED_ENCODING) { 6647 /* 6648 * The XML REC instructs us to stop parsing right here 6649 */ 6650 return; 6651 } 6652 if ((encoding == NULL) && (ctxt->errNo == XML_ERR_OK)) { 6653 xmlFatalErrMsg(ctxt, XML_ERR_MISSING_ENCODING, 6654 "Missing encoding in text declaration\n"); 6655 } 6656 6657 SKIP_BLANKS; 6658 if ((RAW == '?') && (NXT(1) == '>')) { 6659 SKIP(2); 6660 } else if (RAW == '>') { 6661 /* Deprecated old WD ... */ 6662 xmlFatalErr(ctxt, XML_ERR_XMLDECL_NOT_FINISHED, NULL); 6663 NEXT; 6664 } else { 6665 xmlFatalErr(ctxt, XML_ERR_XMLDECL_NOT_FINISHED, NULL); 6666 MOVETO_ENDTAG(CUR_PTR); 6667 NEXT; 6668 } 6669 } 6670 6671 /** 6672 * xmlParseExternalSubset: 6673 * @ctxt: an XML parser context 6674 * @ExternalID: the external identifier 6675 * @SystemID: the system identifier (or URL) 6676 * 6677 * parse Markup declarations from an external subset 6678 * 6679 * [30] extSubset ::= textDecl? extSubsetDecl 6680 * 6681 * [31] extSubsetDecl ::= (markupdecl | conditionalSect | PEReference | S) * 6682 */ 6683 void 6684 xmlParseExternalSubset(xmlParserCtxtPtr ctxt, const xmlChar *ExternalID, 6685 const xmlChar *SystemID) { 6686 xmlDetectSAX2(ctxt); 6687 GROW; 6688 6689 if ((ctxt->encoding == (const xmlChar *)XML_CHAR_ENCODING_NONE) && 6690 (ctxt->input->end - ctxt->input->cur >= 4)) { 6691 xmlChar start[4]; 6692 xmlCharEncoding enc; 6693 6694 start[0] = RAW; 6695 start[1] = NXT(1); 6696 start[2] = NXT(2); 6697 start[3] = NXT(3); 6698 enc = xmlDetectCharEncoding(start, 4); 6699 if (enc != XML_CHAR_ENCODING_NONE) 6700 xmlSwitchEncoding(ctxt, enc); 6701 } 6702 6703 if (CMP5(CUR_PTR, '<', '?', 'x', 'm', 'l')) { 6704 xmlParseTextDecl(ctxt); 6705 if (ctxt->errNo == XML_ERR_UNSUPPORTED_ENCODING) { 6706 /* 6707 * The XML REC instructs us to stop parsing right here 6708 */ 6709 ctxt->instate = XML_PARSER_EOF; 6710 return; 6711 } 6712 } 6713 if (ctxt->myDoc == NULL) { 6714 ctxt->myDoc = xmlNewDoc(BAD_CAST "1.0"); 6715 if (ctxt->myDoc == NULL) { 6716 xmlErrMemory(ctxt, "New Doc failed"); 6717 return; 6718 } 6719 ctxt->myDoc->properties = XML_DOC_INTERNAL; 6720 } 6721 if ((ctxt->myDoc != NULL) && (ctxt->myDoc->intSubset == NULL)) 6722 xmlCreateIntSubset(ctxt->myDoc, NULL, ExternalID, SystemID); 6723 6724 ctxt->instate = XML_PARSER_DTD; 6725 ctxt->external = 1; 6726 while (((RAW == '<') && (NXT(1) == '?')) || 6727 ((RAW == '<') && (NXT(1) == '!')) || 6728 (RAW == '%') || IS_BLANK_CH(CUR)) { 6729 const xmlChar *check = CUR_PTR; 6730 unsigned int cons = ctxt->input->consumed; 6731 6732 GROW; 6733 if ((RAW == '<') && (NXT(1) == '!') && (NXT(2) == '[')) { 6734 xmlParseConditionalSections(ctxt); 6735 } else if (IS_BLANK_CH(CUR)) { 6736 NEXT; 6737 } else if (RAW == '%') { 6738 xmlParsePEReference(ctxt); 6739 } else 6740 xmlParseMarkupDecl(ctxt); 6741 6742 /* 6743 * Pop-up of finished entities. 6744 */ 6745 while ((RAW == 0) && (ctxt->inputNr > 1)) 6746 xmlPopInput(ctxt); 6747 6748 if ((CUR_PTR == check) && (cons == ctxt->input->consumed)) { 6749 xmlFatalErr(ctxt, XML_ERR_EXT_SUBSET_NOT_FINISHED, NULL); 6750 break; 6751 } 6752 } 6753 6754 if (RAW != 0) { 6755 xmlFatalErr(ctxt, XML_ERR_EXT_SUBSET_NOT_FINISHED, NULL); 6756 } 6757 6758 } 6759 6760 /** 6761 * xmlParseReference: 6762 * @ctxt: an XML parser context 6763 * 6764 * parse and handle entity references in content, depending on the SAX 6765 * interface, this may end-up in a call to character() if this is a 6766 * CharRef, a predefined entity, if there is no reference() callback. 6767 * or if the parser was asked to switch to that mode. 6768 * 6769 * [67] Reference ::= EntityRef | CharRef 6770 */ 6771 void 6772 xmlParseReference(xmlParserCtxtPtr ctxt) { 6773 xmlEntityPtr ent; 6774 xmlChar *val; 6775 int was_checked; 6776 xmlNodePtr list = NULL; 6777 xmlParserErrors ret = XML_ERR_OK; 6778 6779 6780 if (RAW != '&') 6781 return; 6782 6783 /* 6784 * Simple case of a CharRef 6785 */ 6786 if (NXT(1) == '#') { 6787 int i = 0; 6788 xmlChar out[10]; 6789 int hex = NXT(2); 6790 int value = xmlParseCharRef(ctxt); 6791 6792 if (value == 0) 6793 return; 6794 if (ctxt->charset != XML_CHAR_ENCODING_UTF8) { 6795 /* 6796 * So we are using non-UTF-8 buffers 6797 * Check that the char fit on 8bits, if not 6798 * generate a CharRef. 6799 */ 6800 if (value <= 0xFF) { 6801 out[0] = value; 6802 out[1] = 0; 6803 if ((ctxt->sax != NULL) && (ctxt->sax->characters != NULL) && 6804 (!ctxt->disableSAX)) 6805 ctxt->sax->characters(ctxt->userData, out, 1); 6806 } else { 6807 if ((hex == 'x') || (hex == 'X')) 6808 snprintf((char *)out, sizeof(out), "#x%X", value); 6809 else 6810 snprintf((char *)out, sizeof(out), "#%d", value); 6811 if ((ctxt->sax != NULL) && (ctxt->sax->reference != NULL) && 6812 (!ctxt->disableSAX)) 6813 ctxt->sax->reference(ctxt->userData, out); 6814 } 6815 } else { 6816 /* 6817 * Just encode the value in UTF-8 6818 */ 6819 COPY_BUF(0 ,out, i, value); 6820 out[i] = 0; 6821 if ((ctxt->sax != NULL) && (ctxt->sax->characters != NULL) && 6822 (!ctxt->disableSAX)) 6823 ctxt->sax->characters(ctxt->userData, out, i); 6824 } 6825 return; 6826 } 6827 6828 /* 6829 * We are seeing an entity reference 6830 */ 6831 ent = xmlParseEntityRef(ctxt); 6832 if (ent == NULL) return; 6833 if (!ctxt->wellFormed) 6834 return; 6835 was_checked = ent->checked; 6836 6837 /* special case of predefined entities */ 6838 if ((ent->name == NULL) || 6839 (ent->etype == XML_INTERNAL_PREDEFINED_ENTITY)) { 6840 val = ent->content; 6841 if (val == NULL) return; 6842 /* 6843 * inline the entity. 6844 */ 6845 if ((ctxt->sax != NULL) && (ctxt->sax->characters != NULL) && 6846 (!ctxt->disableSAX)) 6847 ctxt->sax->characters(ctxt->userData, val, xmlStrlen(val)); 6848 return; 6849 } 6850 6851 /* 6852 * The first reference to the entity trigger a parsing phase 6853 * where the ent->children is filled with the result from 6854 * the parsing. 6855 */ 6856 if (ent->checked == 0) { 6857 unsigned long oldnbent = ctxt->nbentities; 6858 6859 /* 6860 * This is a bit hackish but this seems the best 6861 * way to make sure both SAX and DOM entity support 6862 * behaves okay. 6863 */ 6864 void *user_data; 6865 if (ctxt->userData == ctxt) 6866 user_data = NULL; 6867 else 6868 user_data = ctxt->userData; 6869 6870 /* 6871 * Check that this entity is well formed 6872 * 4.3.2: An internal general parsed entity is well-formed 6873 * if its replacement text matches the production labeled 6874 * content. 6875 */ 6876 if (ent->etype == XML_INTERNAL_GENERAL_ENTITY) { 6877 ctxt->depth++; 6878 ret = xmlParseBalancedChunkMemoryInternal(ctxt, ent->content, 6879 user_data, &list); 6880 ctxt->depth--; 6881 6882 } else if (ent->etype == XML_EXTERNAL_GENERAL_PARSED_ENTITY) { 6883 ctxt->depth++; 6884 ret = xmlParseExternalEntityPrivate(ctxt->myDoc, ctxt, ctxt->sax, 6885 user_data, ctxt->depth, ent->URI, 6886 ent->ExternalID, &list); 6887 ctxt->depth--; 6888 } else { 6889 ret = XML_ERR_ENTITY_PE_INTERNAL; 6890 xmlErrMsgStr(ctxt, XML_ERR_INTERNAL_ERROR, 6891 "invalid entity type found\n", NULL); 6892 } 6893 6894 /* 6895 * Store the number of entities needing parsing for this entity 6896 * content and do checkings 6897 */ 6898 ent->checked = ctxt->nbentities - oldnbent; 6899 if (ret == XML_ERR_ENTITY_LOOP) { 6900 xmlFatalErr(ctxt, XML_ERR_ENTITY_LOOP, NULL); 6901 xmlFreeNodeList(list); 6902 return; 6903 } 6904 if (xmlParserEntityCheck(ctxt, 0, ent)) { 6905 xmlFreeNodeList(list); 6906 return; 6907 } 6908 6909 if ((ret == XML_ERR_OK) && (list != NULL)) { 6910 if (((ent->etype == XML_INTERNAL_GENERAL_ENTITY) || 6911 (ent->etype == XML_EXTERNAL_GENERAL_PARSED_ENTITY))&& 6912 (ent->children == NULL)) { 6913 ent->children = list; 6914 if (ctxt->replaceEntities) { 6915 /* 6916 * Prune it directly in the generated document 6917 * except for single text nodes. 6918 */ 6919 if (((list->type == XML_TEXT_NODE) && 6920 (list->next == NULL)) || 6921 (ctxt->parseMode == XML_PARSE_READER)) { 6922 list->parent = (xmlNodePtr) ent; 6923 list = NULL; 6924 ent->owner = 1; 6925 } else { 6926 ent->owner = 0; 6927 while (list != NULL) { 6928 list->parent = (xmlNodePtr) ctxt->node; 6929 list->doc = ctxt->myDoc; 6930 if (list->next == NULL) 6931 ent->last = list; 6932 list = list->next; 6933 } 6934 list = ent->children; 6935 #ifdef LIBXML_LEGACY_ENABLED 6936 if (ent->etype == XML_EXTERNAL_GENERAL_PARSED_ENTITY) 6937 xmlAddEntityReference(ent, list, NULL); 6938 #endif /* LIBXML_LEGACY_ENABLED */ 6939 } 6940 } else { 6941 ent->owner = 1; 6942 while (list != NULL) { 6943 list->parent = (xmlNodePtr) ent; 6944 if (list->next == NULL) 6945 ent->last = list; 6946 list = list->next; 6947 } 6948 } 6949 } else { 6950 xmlFreeNodeList(list); 6951 list = NULL; 6952 } 6953 } else if ((ret != XML_ERR_OK) && 6954 (ret != XML_WAR_UNDECLARED_ENTITY)) { 6955 xmlFatalErrMsgStr(ctxt, XML_ERR_UNDECLARED_ENTITY, 6956 "Entity '%s' failed to parse\n", ent->name); 6957 } else if (list != NULL) { 6958 xmlFreeNodeList(list); 6959 list = NULL; 6960 } 6961 if (ent->checked == 0) 6962 ent->checked = 1; 6963 } else if (ent->checked != 1) { 6964 ctxt->nbentities += ent->checked; 6965 } 6966 6967 /* 6968 * Now that the entity content has been gathered 6969 * provide it to the application, this can take different forms based 6970 * on the parsing modes. 6971 */ 6972 if (ent->children == NULL) { 6973 /* 6974 * Probably running in SAX mode and the callbacks don't 6975 * build the entity content. So unless we already went 6976 * though parsing for first checking go though the entity 6977 * content to generate callbacks associated to the entity 6978 */ 6979 if (was_checked != 0) { 6980 void *user_data; 6981 /* 6982 * This is a bit hackish but this seems the best 6983 * way to make sure both SAX and DOM entity support 6984 * behaves okay. 6985 */ 6986 if (ctxt->userData == ctxt) 6987 user_data = NULL; 6988 else 6989 user_data = ctxt->userData; 6990 6991 if (ent->etype == XML_INTERNAL_GENERAL_ENTITY) { 6992 ctxt->depth++; 6993 ret = xmlParseBalancedChunkMemoryInternal(ctxt, 6994 ent->content, user_data, NULL); 6995 ctxt->depth--; 6996 } else if (ent->etype == 6997 XML_EXTERNAL_GENERAL_PARSED_ENTITY) { 6998 ctxt->depth++; 6999 ret = xmlParseExternalEntityPrivate(ctxt->myDoc, ctxt, 7000 ctxt->sax, user_data, ctxt->depth, 7001 ent->URI, ent->ExternalID, NULL); 7002 ctxt->depth--; 7003 } else { 7004 ret = XML_ERR_ENTITY_PE_INTERNAL; 7005 xmlErrMsgStr(ctxt, XML_ERR_INTERNAL_ERROR, 7006 "invalid entity type found\n", NULL); 7007 } 7008 if (ret == XML_ERR_ENTITY_LOOP) { 7009 xmlFatalErr(ctxt, XML_ERR_ENTITY_LOOP, NULL); 7010 return; 7011 } 7012 } 7013 if ((ctxt->sax != NULL) && (ctxt->sax->reference != NULL) && 7014 (ctxt->replaceEntities == 0) && (!ctxt->disableSAX)) { 7015 /* 7016 * Entity reference callback comes second, it's somewhat 7017 * superfluous but a compatibility to historical behaviour 7018 */ 7019 ctxt->sax->reference(ctxt->userData, ent->name); 7020 } 7021 return; 7022 } 7023 7024 /* 7025 * If we didn't get any children for the entity being built 7026 */ 7027 if ((ctxt->sax != NULL) && (ctxt->sax->reference != NULL) && 7028 (ctxt->replaceEntities == 0) && (!ctxt->disableSAX)) { 7029 /* 7030 * Create a node. 7031 */ 7032 ctxt->sax->reference(ctxt->userData, ent->name); 7033 return; 7034 } 7035 7036 if ((ctxt->replaceEntities) || (ent->children == NULL)) { 7037 /* 7038 * There is a problem on the handling of _private for entities 7039 * (bug 155816): Should we copy the content of the field from 7040 * the entity (possibly overwriting some value set by the user 7041 * when a copy is created), should we leave it alone, or should 7042 * we try to take care of different situations? The problem 7043 * is exacerbated by the usage of this field by the xmlReader. 7044 * To fix this bug, we look at _private on the created node 7045 * and, if it's NULL, we copy in whatever was in the entity. 7046 * If it's not NULL we leave it alone. This is somewhat of a 7047 * hack - maybe we should have further tests to determine 7048 * what to do. 7049 */ 7050 if ((ctxt->node != NULL) && (ent->children != NULL)) { 7051 /* 7052 * Seems we are generating the DOM content, do 7053 * a simple tree copy for all references except the first 7054 * In the first occurrence list contains the replacement. 7055 * progressive == 2 means we are operating on the Reader 7056 * and since nodes are discarded we must copy all the time. 7057 */ 7058 if (((list == NULL) && (ent->owner == 0)) || 7059 (ctxt->parseMode == XML_PARSE_READER)) { 7060 xmlNodePtr nw = NULL, cur, firstChild = NULL; 7061 7062 /* 7063 * when operating on a reader, the entities definitions 7064 * are always owning the entities subtree. 7065 if (ctxt->parseMode == XML_PARSE_READER) 7066 ent->owner = 1; 7067 */ 7068 7069 cur = ent->children; 7070 while (cur != NULL) { 7071 nw = xmlDocCopyNode(cur, ctxt->myDoc, 1); 7072 if (nw != NULL) { 7073 if (nw->_private == NULL) 7074 nw->_private = cur->_private; 7075 if (firstChild == NULL){ 7076 firstChild = nw; 7077 } 7078 nw = xmlAddChild(ctxt->node, nw); 7079 } 7080 if (cur == ent->last) { 7081 /* 7082 * needed to detect some strange empty 7083 * node cases in the reader tests 7084 */ 7085 if ((ctxt->parseMode == XML_PARSE_READER) && 7086 (nw != NULL) && 7087 (nw->type == XML_ELEMENT_NODE) && 7088 (nw->children == NULL)) 7089 nw->extra = 1; 7090 7091 break; 7092 } 7093 cur = cur->next; 7094 } 7095 #ifdef LIBXML_LEGACY_ENABLED 7096 if (ent->etype == XML_EXTERNAL_GENERAL_PARSED_ENTITY) 7097 xmlAddEntityReference(ent, firstChild, nw); 7098 #endif /* LIBXML_LEGACY_ENABLED */ 7099 } else if (list == NULL) { 7100 xmlNodePtr nw = NULL, cur, next, last, 7101 firstChild = NULL; 7102 /* 7103 * Copy the entity child list and make it the new 7104 * entity child list. The goal is to make sure any 7105 * ID or REF referenced will be the one from the 7106 * document content and not the entity copy. 7107 */ 7108 cur = ent->children; 7109 ent->children = NULL; 7110 last = ent->last; 7111 ent->last = NULL; 7112 while (cur != NULL) { 7113 next = cur->next; 7114 cur->next = NULL; 7115 cur->parent = NULL; 7116 nw = xmlDocCopyNode(cur, ctxt->myDoc, 1); 7117 if (nw != NULL) { 7118 if (nw->_private == NULL) 7119 nw->_private = cur->_private; 7120 if (firstChild == NULL){ 7121 firstChild = cur; 7122 } 7123 xmlAddChild((xmlNodePtr) ent, nw); 7124 xmlAddChild(ctxt->node, cur); 7125 } 7126 if (cur == last) 7127 break; 7128 cur = next; 7129 } 7130 if (ent->owner == 0) 7131 ent->owner = 1; 7132 #ifdef LIBXML_LEGACY_ENABLED 7133 if (ent->etype == XML_EXTERNAL_GENERAL_PARSED_ENTITY) 7134 xmlAddEntityReference(ent, firstChild, nw); 7135 #endif /* LIBXML_LEGACY_ENABLED */ 7136 } else { 7137 const xmlChar *nbktext; 7138 7139 /* 7140 * the name change is to avoid coalescing of the 7141 * node with a possible previous text one which 7142 * would make ent->children a dangling pointer 7143 */ 7144 nbktext = xmlDictLookup(ctxt->dict, BAD_CAST "nbktext", 7145 -1); 7146 if (ent->children->type == XML_TEXT_NODE) 7147 ent->children->name = nbktext; 7148 if ((ent->last != ent->children) && 7149 (ent->last->type == XML_TEXT_NODE)) 7150 ent->last->name = nbktext; 7151 xmlAddChildList(ctxt->node, ent->children); 7152 } 7153 7154 /* 7155 * This is to avoid a nasty side effect, see 7156 * characters() in SAX.c 7157 */ 7158 ctxt->nodemem = 0; 7159 ctxt->nodelen = 0; 7160 return; 7161 } 7162 } 7163 } 7164 7165 /** 7166 * xmlParseEntityRef: 7167 * @ctxt: an XML parser context 7168 * 7169 * parse ENTITY references declarations 7170 * 7171 * [68] EntityRef ::= '&' Name ';' 7172 * 7173 * [ WFC: Entity Declared ] 7174 * In a document without any DTD, a document with only an internal DTD 7175 * subset which contains no parameter entity references, or a document 7176 * with "standalone='yes'", the Name given in the entity reference 7177 * must match that in an entity declaration, except that well-formed 7178 * documents need not declare any of the following entities: amp, lt, 7179 * gt, apos, quot. The declaration of a parameter entity must precede 7180 * any reference to it. Similarly, the declaration of a general entity 7181 * must precede any reference to it which appears in a default value in an 7182 * attribute-list declaration. Note that if entities are declared in the 7183 * external subset or in external parameter entities, a non-validating 7184 * processor is not obligated to read and process their declarations; 7185 * for such documents, the rule that an entity must be declared is a 7186 * well-formedness constraint only if standalone='yes'. 7187 * 7188 * [ WFC: Parsed Entity ] 7189 * An entity reference must not contain the name of an unparsed entity 7190 * 7191 * Returns the xmlEntityPtr if found, or NULL otherwise. 7192 */ 7193 xmlEntityPtr 7194 xmlParseEntityRef(xmlParserCtxtPtr ctxt) { 7195 const xmlChar *name; 7196 xmlEntityPtr ent = NULL; 7197 7198 GROW; 7199 if (ctxt->instate == XML_PARSER_EOF) 7200 return(NULL); 7201 7202 if (RAW != '&') 7203 return(NULL); 7204 NEXT; 7205 name = xmlParseName(ctxt); 7206 if (name == NULL) { 7207 xmlFatalErrMsg(ctxt, XML_ERR_NAME_REQUIRED, 7208 "xmlParseEntityRef: no name\n"); 7209 return(NULL); 7210 } 7211 if (RAW != ';') { 7212 xmlFatalErr(ctxt, XML_ERR_ENTITYREF_SEMICOL_MISSING, NULL); 7213 return(NULL); 7214 } 7215 NEXT; 7216 7217 /* 7218 * Predefined entites override any extra definition 7219 */ 7220 if ((ctxt->options & XML_PARSE_OLDSAX) == 0) { 7221 ent = xmlGetPredefinedEntity(name); 7222 if (ent != NULL) 7223 return(ent); 7224 } 7225 7226 /* 7227 * Increate the number of entity references parsed 7228 */ 7229 ctxt->nbentities++; 7230 7231 /* 7232 * Ask first SAX for entity resolution, otherwise try the 7233 * entities which may have stored in the parser context. 7234 */ 7235 if (ctxt->sax != NULL) { 7236 if (ctxt->sax->getEntity != NULL) 7237 ent = ctxt->sax->getEntity(ctxt->userData, name); 7238 if ((ctxt->wellFormed == 1 ) && (ent == NULL) && 7239 (ctxt->options & XML_PARSE_OLDSAX)) 7240 ent = xmlGetPredefinedEntity(name); 7241 if ((ctxt->wellFormed == 1 ) && (ent == NULL) && 7242 (ctxt->userData==ctxt)) { 7243 ent = xmlSAX2GetEntity(ctxt, name); 7244 } 7245 } 7246 if (ctxt->instate == XML_PARSER_EOF) 7247 return(NULL); 7248 /* 7249 * [ WFC: Entity Declared ] 7250 * In a document without any DTD, a document with only an 7251 * internal DTD subset which contains no parameter entity 7252 * references, or a document with "standalone='yes'", the 7253 * Name given in the entity reference must match that in an 7254 * entity declaration, except that well-formed documents 7255 * need not declare any of the following entities: amp, lt, 7256 * gt, apos, quot. 7257 * The declaration of a parameter entity must precede any 7258 * reference to it. 7259 * Similarly, the declaration of a general entity must 7260 * precede any reference to it which appears in a default 7261 * value in an attribute-list declaration. Note that if 7262 * entities are declared in the external subset or in 7263 * external parameter entities, a non-validating processor 7264 * is not obligated to read and process their declarations; 7265 * for such documents, the rule that an entity must be 7266 * declared is a well-formedness constraint only if 7267 * standalone='yes'. 7268 */ 7269 if (ent == NULL) { 7270 if ((ctxt->standalone == 1) || 7271 ((ctxt->hasExternalSubset == 0) && 7272 (ctxt->hasPErefs == 0))) { 7273 xmlFatalErrMsgStr(ctxt, XML_ERR_UNDECLARED_ENTITY, 7274 "Entity '%s' not defined\n", name); 7275 } else { 7276 xmlErrMsgStr(ctxt, XML_WAR_UNDECLARED_ENTITY, 7277 "Entity '%s' not defined\n", name); 7278 if ((ctxt->inSubset == 0) && 7279 (ctxt->sax != NULL) && 7280 (ctxt->sax->reference != NULL)) { 7281 ctxt->sax->reference(ctxt->userData, name); 7282 } 7283 } 7284 ctxt->valid = 0; 7285 } 7286 7287 /* 7288 * [ WFC: Parsed Entity ] 7289 * An entity reference must not contain the name of an 7290 * unparsed entity 7291 */ 7292 else if (ent->etype == XML_EXTERNAL_GENERAL_UNPARSED_ENTITY) { 7293 xmlFatalErrMsgStr(ctxt, XML_ERR_UNPARSED_ENTITY, 7294 "Entity reference to unparsed entity %s\n", name); 7295 } 7296 7297 /* 7298 * [ WFC: No External Entity References ] 7299 * Attribute values cannot contain direct or indirect 7300 * entity references to external entities. 7301 */ 7302 else if ((ctxt->instate == XML_PARSER_ATTRIBUTE_VALUE) && 7303 (ent->etype == XML_EXTERNAL_GENERAL_PARSED_ENTITY)) { 7304 xmlFatalErrMsgStr(ctxt, XML_ERR_ENTITY_IS_EXTERNAL, 7305 "Attribute references external entity '%s'\n", name); 7306 } 7307 /* 7308 * [ WFC: No < in Attribute Values ] 7309 * The replacement text of any entity referred to directly or 7310 * indirectly in an attribute value (other than "<") must 7311 * not contain a <. 7312 */ 7313 else if ((ctxt->instate == XML_PARSER_ATTRIBUTE_VALUE) && 7314 (ent != NULL) && (ent->content != NULL) && 7315 (ent->etype != XML_INTERNAL_PREDEFINED_ENTITY) && 7316 (xmlStrchr(ent->content, '<'))) { 7317 xmlFatalErrMsgStr(ctxt, XML_ERR_LT_IN_ATTRIBUTE, 7318 "'<' in entity '%s' is not allowed in attributes values\n", name); 7319 } 7320 7321 /* 7322 * Internal check, no parameter entities here ... 7323 */ 7324 else { 7325 switch (ent->etype) { 7326 case XML_INTERNAL_PARAMETER_ENTITY: 7327 case XML_EXTERNAL_PARAMETER_ENTITY: 7328 xmlFatalErrMsgStr(ctxt, XML_ERR_ENTITY_IS_PARAMETER, 7329 "Attempt to reference the parameter entity '%s'\n", 7330 name); 7331 break; 7332 default: 7333 break; 7334 } 7335 } 7336 7337 /* 7338 * [ WFC: No Recursion ] 7339 * A parsed entity must not contain a recursive reference 7340 * to itself, either directly or indirectly. 7341 * Done somewhere else 7342 */ 7343 return(ent); 7344 } 7345 7346 /** 7347 * xmlParseStringEntityRef: 7348 * @ctxt: an XML parser context 7349 * @str: a pointer to an index in the string 7350 * 7351 * parse ENTITY references declarations, but this version parses it from 7352 * a string value. 7353 * 7354 * [68] EntityRef ::= '&' Name ';' 7355 * 7356 * [ WFC: Entity Declared ] 7357 * In a document without any DTD, a document with only an internal DTD 7358 * subset which contains no parameter entity references, or a document 7359 * with "standalone='yes'", the Name given in the entity reference 7360 * must match that in an entity declaration, except that well-formed 7361 * documents need not declare any of the following entities: amp, lt, 7362 * gt, apos, quot. The declaration of a parameter entity must precede 7363 * any reference to it. Similarly, the declaration of a general entity 7364 * must precede any reference to it which appears in a default value in an 7365 * attribute-list declaration. Note that if entities are declared in the 7366 * external subset or in external parameter entities, a non-validating 7367 * processor is not obligated to read and process their declarations; 7368 * for such documents, the rule that an entity must be declared is a 7369 * well-formedness constraint only if standalone='yes'. 7370 * 7371 * [ WFC: Parsed Entity ] 7372 * An entity reference must not contain the name of an unparsed entity 7373 * 7374 * Returns the xmlEntityPtr if found, or NULL otherwise. The str pointer 7375 * is updated to the current location in the string. 7376 */ 7377 static xmlEntityPtr 7378 xmlParseStringEntityRef(xmlParserCtxtPtr ctxt, const xmlChar ** str) { 7379 xmlChar *name; 7380 const xmlChar *ptr; 7381 xmlChar cur; 7382 xmlEntityPtr ent = NULL; 7383 7384 if ((str == NULL) || (*str == NULL)) 7385 return(NULL); 7386 ptr = *str; 7387 cur = *ptr; 7388 if (cur != '&') 7389 return(NULL); 7390 7391 ptr++; 7392 name = xmlParseStringName(ctxt, &ptr); 7393 if (name == NULL) { 7394 xmlFatalErrMsg(ctxt, XML_ERR_NAME_REQUIRED, 7395 "xmlParseStringEntityRef: no name\n"); 7396 *str = ptr; 7397 return(NULL); 7398 } 7399 if (*ptr != ';') { 7400 xmlFatalErr(ctxt, XML_ERR_ENTITYREF_SEMICOL_MISSING, NULL); 7401 xmlFree(name); 7402 *str = ptr; 7403 return(NULL); 7404 } 7405 ptr++; 7406 7407 7408 /* 7409 * Predefined entites override any extra definition 7410 */ 7411 if ((ctxt->options & XML_PARSE_OLDSAX) == 0) { 7412 ent = xmlGetPredefinedEntity(name); 7413 if (ent != NULL) { 7414 xmlFree(name); 7415 *str = ptr; 7416 return(ent); 7417 } 7418 } 7419 7420 /* 7421 * Increate the number of entity references parsed 7422 */ 7423 ctxt->nbentities++; 7424 7425 /* 7426 * Ask first SAX for entity resolution, otherwise try the 7427 * entities which may have stored in the parser context. 7428 */ 7429 if (ctxt->sax != NULL) { 7430 if (ctxt->sax->getEntity != NULL) 7431 ent = ctxt->sax->getEntity(ctxt->userData, name); 7432 if ((ent == NULL) && (ctxt->options & XML_PARSE_OLDSAX)) 7433 ent = xmlGetPredefinedEntity(name); 7434 if ((ent == NULL) && (ctxt->userData==ctxt)) { 7435 ent = xmlSAX2GetEntity(ctxt, name); 7436 } 7437 } 7438 if (ctxt->instate == XML_PARSER_EOF) { 7439 xmlFree(name); 7440 return(NULL); 7441 } 7442 7443 /* 7444 * [ WFC: Entity Declared ] 7445 * In a document without any DTD, a document with only an 7446 * internal DTD subset which contains no parameter entity 7447 * references, or a document with "standalone='yes'", the 7448 * Name given in the entity reference must match that in an 7449 * entity declaration, except that well-formed documents 7450 * need not declare any of the following entities: amp, lt, 7451 * gt, apos, quot. 7452 * The declaration of a parameter entity must precede any 7453 * reference to it. 7454 * Similarly, the declaration of a general entity must 7455 * precede any reference to it which appears in a default 7456 * value in an attribute-list declaration. Note that if 7457 * entities are declared in the external subset or in 7458 * external parameter entities, a non-validating processor 7459 * is not obligated to read and process their declarations; 7460 * for such documents, the rule that an entity must be 7461 * declared is a well-formedness constraint only if 7462 * standalone='yes'. 7463 */ 7464 if (ent == NULL) { 7465 if ((ctxt->standalone == 1) || 7466 ((ctxt->hasExternalSubset == 0) && 7467 (ctxt->hasPErefs == 0))) { 7468 xmlFatalErrMsgStr(ctxt, XML_ERR_UNDECLARED_ENTITY, 7469 "Entity '%s' not defined\n", name); 7470 } else { 7471 xmlErrMsgStr(ctxt, XML_WAR_UNDECLARED_ENTITY, 7472 "Entity '%s' not defined\n", 7473 name); 7474 } 7475 /* TODO ? check regressions ctxt->valid = 0; */ 7476 } 7477 7478 /* 7479 * [ WFC: Parsed Entity ] 7480 * An entity reference must not contain the name of an 7481 * unparsed entity 7482 */ 7483 else if (ent->etype == XML_EXTERNAL_GENERAL_UNPARSED_ENTITY) { 7484 xmlFatalErrMsgStr(ctxt, XML_ERR_UNPARSED_ENTITY, 7485 "Entity reference to unparsed entity %s\n", name); 7486 } 7487 7488 /* 7489 * [ WFC: No External Entity References ] 7490 * Attribute values cannot contain direct or indirect 7491 * entity references to external entities. 7492 */ 7493 else if ((ctxt->instate == XML_PARSER_ATTRIBUTE_VALUE) && 7494 (ent->etype == XML_EXTERNAL_GENERAL_PARSED_ENTITY)) { 7495 xmlFatalErrMsgStr(ctxt, XML_ERR_ENTITY_IS_EXTERNAL, 7496 "Attribute references external entity '%s'\n", name); 7497 } 7498 /* 7499 * [ WFC: No < in Attribute Values ] 7500 * The replacement text of any entity referred to directly or 7501 * indirectly in an attribute value (other than "<") must 7502 * not contain a <. 7503 */ 7504 else if ((ctxt->instate == XML_PARSER_ATTRIBUTE_VALUE) && 7505 (ent != NULL) && (ent->content != NULL) && 7506 (ent->etype != XML_INTERNAL_PREDEFINED_ENTITY) && 7507 (xmlStrchr(ent->content, '<'))) { 7508 xmlFatalErrMsgStr(ctxt, XML_ERR_LT_IN_ATTRIBUTE, 7509 "'<' in entity '%s' is not allowed in attributes values\n", 7510 name); 7511 } 7512 7513 /* 7514 * Internal check, no parameter entities here ... 7515 */ 7516 else { 7517 switch (ent->etype) { 7518 case XML_INTERNAL_PARAMETER_ENTITY: 7519 case XML_EXTERNAL_PARAMETER_ENTITY: 7520 xmlFatalErrMsgStr(ctxt, XML_ERR_ENTITY_IS_PARAMETER, 7521 "Attempt to reference the parameter entity '%s'\n", 7522 name); 7523 break; 7524 default: 7525 break; 7526 } 7527 } 7528 7529 /* 7530 * [ WFC: No Recursion ] 7531 * A parsed entity must not contain a recursive reference 7532 * to itself, either directly or indirectly. 7533 * Done somewhere else 7534 */ 7535 7536 xmlFree(name); 7537 *str = ptr; 7538 return(ent); 7539 } 7540 7541 /** 7542 * xmlParsePEReference: 7543 * @ctxt: an XML parser context 7544 * 7545 * parse PEReference declarations 7546 * The entity content is handled directly by pushing it's content as 7547 * a new input stream. 7548 * 7549 * [69] PEReference ::= '%' Name ';' 7550 * 7551 * [ WFC: No Recursion ] 7552 * A parsed entity must not contain a recursive 7553 * reference to itself, either directly or indirectly. 7554 * 7555 * [ WFC: Entity Declared ] 7556 * In a document without any DTD, a document with only an internal DTD 7557 * subset which contains no parameter entity references, or a document 7558 * with "standalone='yes'", ... ... The declaration of a parameter 7559 * entity must precede any reference to it... 7560 * 7561 * [ VC: Entity Declared ] 7562 * In a document with an external subset or external parameter entities 7563 * with "standalone='no'", ... ... The declaration of a parameter entity 7564 * must precede any reference to it... 7565 * 7566 * [ WFC: In DTD ] 7567 * Parameter-entity references may only appear in the DTD. 7568 * NOTE: misleading but this is handled. 7569 */ 7570 void 7571 xmlParsePEReference(xmlParserCtxtPtr ctxt) 7572 { 7573 const xmlChar *name; 7574 xmlEntityPtr entity = NULL; 7575 xmlParserInputPtr input; 7576 7577 if (RAW != '%') 7578 return; 7579 NEXT; 7580 name = xmlParseName(ctxt); 7581 if (name == NULL) { 7582 xmlFatalErrMsg(ctxt, XML_ERR_NAME_REQUIRED, 7583 "xmlParsePEReference: no name\n"); 7584 return; 7585 } 7586 if (RAW != ';') { 7587 xmlFatalErr(ctxt, XML_ERR_ENTITYREF_SEMICOL_MISSING, NULL); 7588 return; 7589 } 7590 7591 NEXT; 7592 7593 /* 7594 * Increate the number of entity references parsed 7595 */ 7596 ctxt->nbentities++; 7597 7598 /* 7599 * Request the entity from SAX 7600 */ 7601 if ((ctxt->sax != NULL) && 7602 (ctxt->sax->getParameterEntity != NULL)) 7603 entity = ctxt->sax->getParameterEntity(ctxt->userData, name); 7604 if (ctxt->instate == XML_PARSER_EOF) 7605 return; 7606 if (entity == NULL) { 7607 /* 7608 * [ WFC: Entity Declared ] 7609 * In a document without any DTD, a document with only an 7610 * internal DTD subset which contains no parameter entity 7611 * references, or a document with "standalone='yes'", ... 7612 * ... The declaration of a parameter entity must precede 7613 * any reference to it... 7614 */ 7615 if ((ctxt->standalone == 1) || 7616 ((ctxt->hasExternalSubset == 0) && 7617 (ctxt->hasPErefs == 0))) { 7618 xmlFatalErrMsgStr(ctxt, XML_ERR_UNDECLARED_ENTITY, 7619 "PEReference: %%%s; not found\n", 7620 name); 7621 } else { 7622 /* 7623 * [ VC: Entity Declared ] 7624 * In a document with an external subset or external 7625 * parameter entities with "standalone='no'", ... 7626 * ... The declaration of a parameter entity must 7627 * precede any reference to it... 7628 */ 7629 xmlWarningMsg(ctxt, XML_WAR_UNDECLARED_ENTITY, 7630 "PEReference: %%%s; not found\n", 7631 name, NULL); 7632 ctxt->valid = 0; 7633 } 7634 } else { 7635 /* 7636 * Internal checking in case the entity quest barfed 7637 */ 7638 if ((entity->etype != XML_INTERNAL_PARAMETER_ENTITY) && 7639 (entity->etype != XML_EXTERNAL_PARAMETER_ENTITY)) { 7640 xmlWarningMsg(ctxt, XML_WAR_UNDECLARED_ENTITY, 7641 "Internal: %%%s; is not a parameter entity\n", 7642 name, NULL); 7643 } else if (ctxt->input->free != deallocblankswrapper) { 7644 input = xmlNewBlanksWrapperInputStream(ctxt, entity); 7645 if (xmlPushInput(ctxt, input) < 0) 7646 return; 7647 } else { 7648 /* 7649 * TODO !!! 7650 * handle the extra spaces added before and after 7651 * c.f. http://www.w3.org/TR/REC-xml#as-PE 7652 */ 7653 input = xmlNewEntityInputStream(ctxt, entity); 7654 if (xmlPushInput(ctxt, input) < 0) 7655 return; 7656 if ((entity->etype == XML_EXTERNAL_PARAMETER_ENTITY) && 7657 (CMP5(CUR_PTR, '<', '?', 'x', 'm', 'l')) && 7658 (IS_BLANK_CH(NXT(5)))) { 7659 xmlParseTextDecl(ctxt); 7660 if (ctxt->errNo == 7661 XML_ERR_UNSUPPORTED_ENCODING) { 7662 /* 7663 * The XML REC instructs us to stop parsing 7664 * right here 7665 */ 7666 ctxt->instate = XML_PARSER_EOF; 7667 return; 7668 } 7669 } 7670 } 7671 } 7672 ctxt->hasPErefs = 1; 7673 } 7674 7675 /** 7676 * xmlLoadEntityContent: 7677 * @ctxt: an XML parser context 7678 * @entity: an unloaded system entity 7679 * 7680 * Load the original content of the given system entity from the 7681 * ExternalID/SystemID given. This is to be used for Included in Literal 7682 * http://www.w3.org/TR/REC-xml/#inliteral processing of entities references 7683 * 7684 * Returns 0 in case of success and -1 in case of failure 7685 */ 7686 static int 7687 xmlLoadEntityContent(xmlParserCtxtPtr ctxt, xmlEntityPtr entity) { 7688 xmlParserInputPtr input; 7689 xmlBufferPtr buf; 7690 int l, c; 7691 int count = 0; 7692 7693 if ((ctxt == NULL) || (entity == NULL) || 7694 ((entity->etype != XML_EXTERNAL_PARAMETER_ENTITY) && 7695 (entity->etype != XML_EXTERNAL_GENERAL_PARSED_ENTITY)) || 7696 (entity->content != NULL)) { 7697 xmlFatalErr(ctxt, XML_ERR_INTERNAL_ERROR, 7698 "xmlLoadEntityContent parameter error"); 7699 return(-1); 7700 } 7701 7702 if (xmlParserDebugEntities) 7703 xmlGenericError(xmlGenericErrorContext, 7704 "Reading %s entity content input\n", entity->name); 7705 7706 buf = xmlBufferCreate(); 7707 if (buf == NULL) { 7708 xmlFatalErr(ctxt, XML_ERR_INTERNAL_ERROR, 7709 "xmlLoadEntityContent parameter error"); 7710 return(-1); 7711 } 7712 7713 input = xmlNewEntityInputStream(ctxt, entity); 7714 if (input == NULL) { 7715 xmlFatalErr(ctxt, XML_ERR_INTERNAL_ERROR, 7716 "xmlLoadEntityContent input error"); 7717 xmlBufferFree(buf); 7718 return(-1); 7719 } 7720 7721 /* 7722 * Push the entity as the current input, read char by char 7723 * saving to the buffer until the end of the entity or an error 7724 */ 7725 if (xmlPushInput(ctxt, input) < 0) { 7726 xmlBufferFree(buf); 7727 return(-1); 7728 } 7729 7730 GROW; 7731 c = CUR_CHAR(l); 7732 while ((ctxt->input == input) && (ctxt->input->cur < ctxt->input->end) && 7733 (IS_CHAR(c))) { 7734 xmlBufferAdd(buf, ctxt->input->cur, l); 7735 if (count++ > 100) { 7736 count = 0; 7737 GROW; 7738 if (ctxt->instate == XML_PARSER_EOF) { 7739 xmlBufferFree(buf); 7740 return(-1); 7741 } 7742 } 7743 NEXTL(l); 7744 c = CUR_CHAR(l); 7745 } 7746 7747 if ((ctxt->input == input) && (ctxt->input->cur >= ctxt->input->end)) { 7748 xmlPopInput(ctxt); 7749 } else if (!IS_CHAR(c)) { 7750 xmlFatalErrMsgInt(ctxt, XML_ERR_INVALID_CHAR, 7751 "xmlLoadEntityContent: invalid char value %d\n", 7752 c); 7753 xmlBufferFree(buf); 7754 return(-1); 7755 } 7756 entity->content = buf->content; 7757 buf->content = NULL; 7758 xmlBufferFree(buf); 7759 7760 return(0); 7761 } 7762 7763 /** 7764 * xmlParseStringPEReference: 7765 * @ctxt: an XML parser context 7766 * @str: a pointer to an index in the string 7767 * 7768 * parse PEReference declarations 7769 * 7770 * [69] PEReference ::= '%' Name ';' 7771 * 7772 * [ WFC: No Recursion ] 7773 * A parsed entity must not contain a recursive 7774 * reference to itself, either directly or indirectly. 7775 * 7776 * [ WFC: Entity Declared ] 7777 * In a document without any DTD, a document with only an internal DTD 7778 * subset which contains no parameter entity references, or a document 7779 * with "standalone='yes'", ... ... The declaration of a parameter 7780 * entity must precede any reference to it... 7781 * 7782 * [ VC: Entity Declared ] 7783 * In a document with an external subset or external parameter entities 7784 * with "standalone='no'", ... ... The declaration of a parameter entity 7785 * must precede any reference to it... 7786 * 7787 * [ WFC: In DTD ] 7788 * Parameter-entity references may only appear in the DTD. 7789 * NOTE: misleading but this is handled. 7790 * 7791 * Returns the string of the entity content. 7792 * str is updated to the current value of the index 7793 */ 7794 static xmlEntityPtr 7795 xmlParseStringPEReference(xmlParserCtxtPtr ctxt, const xmlChar **str) { 7796 const xmlChar *ptr; 7797 xmlChar cur; 7798 xmlChar *name; 7799 xmlEntityPtr entity = NULL; 7800 7801 if ((str == NULL) || (*str == NULL)) return(NULL); 7802 ptr = *str; 7803 cur = *ptr; 7804 if (cur != '%') 7805 return(NULL); 7806 ptr++; 7807 name = xmlParseStringName(ctxt, &ptr); 7808 if (name == NULL) { 7809 xmlFatalErrMsg(ctxt, XML_ERR_NAME_REQUIRED, 7810 "xmlParseStringPEReference: no name\n"); 7811 *str = ptr; 7812 return(NULL); 7813 } 7814 cur = *ptr; 7815 if (cur != ';') { 7816 xmlFatalErr(ctxt, XML_ERR_ENTITYREF_SEMICOL_MISSING, NULL); 7817 xmlFree(name); 7818 *str = ptr; 7819 return(NULL); 7820 } 7821 ptr++; 7822 7823 /* 7824 * Increate the number of entity references parsed 7825 */ 7826 ctxt->nbentities++; 7827 7828 /* 7829 * Request the entity from SAX 7830 */ 7831 if ((ctxt->sax != NULL) && 7832 (ctxt->sax->getParameterEntity != NULL)) 7833 entity = ctxt->sax->getParameterEntity(ctxt->userData, name); 7834 if (ctxt->instate == XML_PARSER_EOF) { 7835 xmlFree(name); 7836 return(NULL); 7837 } 7838 if (entity == NULL) { 7839 /* 7840 * [ WFC: Entity Declared ] 7841 * In a document without any DTD, a document with only an 7842 * internal DTD subset which contains no parameter entity 7843 * references, or a document with "standalone='yes'", ... 7844 * ... The declaration of a parameter entity must precede 7845 * any reference to it... 7846 */ 7847 if ((ctxt->standalone == 1) || 7848 ((ctxt->hasExternalSubset == 0) && (ctxt->hasPErefs == 0))) { 7849 xmlFatalErrMsgStr(ctxt, XML_ERR_UNDECLARED_ENTITY, 7850 "PEReference: %%%s; not found\n", name); 7851 } else { 7852 /* 7853 * [ VC: Entity Declared ] 7854 * In a document with an external subset or external 7855 * parameter entities with "standalone='no'", ... 7856 * ... The declaration of a parameter entity must 7857 * precede any reference to it... 7858 */ 7859 xmlWarningMsg(ctxt, XML_WAR_UNDECLARED_ENTITY, 7860 "PEReference: %%%s; not found\n", 7861 name, NULL); 7862 ctxt->valid = 0; 7863 } 7864 } else { 7865 /* 7866 * Internal checking in case the entity quest barfed 7867 */ 7868 if ((entity->etype != XML_INTERNAL_PARAMETER_ENTITY) && 7869 (entity->etype != XML_EXTERNAL_PARAMETER_ENTITY)) { 7870 xmlWarningMsg(ctxt, XML_WAR_UNDECLARED_ENTITY, 7871 "%%%s; is not a parameter entity\n", 7872 name, NULL); 7873 } 7874 } 7875 ctxt->hasPErefs = 1; 7876 xmlFree(name); 7877 *str = ptr; 7878 return(entity); 7879 } 7880 7881 /** 7882 * xmlParseDocTypeDecl: 7883 * @ctxt: an XML parser context 7884 * 7885 * parse a DOCTYPE declaration 7886 * 7887 * [28] doctypedecl ::= '<!DOCTYPE' S Name (S ExternalID)? S? 7888 * ('[' (markupdecl | PEReference | S)* ']' S?)? '>' 7889 * 7890 * [ VC: Root Element Type ] 7891 * The Name in the document type declaration must match the element 7892 * type of the root element. 7893 */ 7894 7895 void 7896 xmlParseDocTypeDecl(xmlParserCtxtPtr ctxt) { 7897 const xmlChar *name = NULL; 7898 xmlChar *ExternalID = NULL; 7899 xmlChar *URI = NULL; 7900 7901 /* 7902 * We know that '<!DOCTYPE' has been detected. 7903 */ 7904 SKIP(9); 7905 7906 SKIP_BLANKS; 7907 7908 /* 7909 * Parse the DOCTYPE name. 7910 */ 7911 name = xmlParseName(ctxt); 7912 if (name == NULL) { 7913 xmlFatalErrMsg(ctxt, XML_ERR_NAME_REQUIRED, 7914 "xmlParseDocTypeDecl : no DOCTYPE name !\n"); 7915 } 7916 ctxt->intSubName = name; 7917 7918 SKIP_BLANKS; 7919 7920 /* 7921 * Check for SystemID and ExternalID 7922 */ 7923 URI = xmlParseExternalID(ctxt, &ExternalID, 1); 7924 7925 if ((URI != NULL) || (ExternalID != NULL)) { 7926 ctxt->hasExternalSubset = 1; 7927 } 7928 ctxt->extSubURI = URI; 7929 ctxt->extSubSystem = ExternalID; 7930 7931 SKIP_BLANKS; 7932 7933 /* 7934 * Create and update the internal subset. 7935 */ 7936 if ((ctxt->sax != NULL) && (ctxt->sax->internalSubset != NULL) && 7937 (!ctxt->disableSAX)) 7938 ctxt->sax->internalSubset(ctxt->userData, name, ExternalID, URI); 7939 if (ctxt->instate == XML_PARSER_EOF) 7940 return; 7941 7942 /* 7943 * Is there any internal subset declarations ? 7944 * they are handled separately in xmlParseInternalSubset() 7945 */ 7946 if (RAW == '[') 7947 return; 7948 7949 /* 7950 * We should be at the end of the DOCTYPE declaration. 7951 */ 7952 if (RAW != '>') { 7953 xmlFatalErr(ctxt, XML_ERR_DOCTYPE_NOT_FINISHED, NULL); 7954 } 7955 NEXT; 7956 } 7957 7958 /** 7959 * xmlParseInternalSubset: 7960 * @ctxt: an XML parser context 7961 * 7962 * parse the internal subset declaration 7963 * 7964 * [28 end] ('[' (markupdecl | PEReference | S)* ']' S?)? '>' 7965 */ 7966 7967 static void 7968 xmlParseInternalSubset(xmlParserCtxtPtr ctxt) { 7969 /* 7970 * Is there any DTD definition ? 7971 */ 7972 if (RAW == '[') { 7973 ctxt->instate = XML_PARSER_DTD; 7974 NEXT; 7975 /* 7976 * Parse the succession of Markup declarations and 7977 * PEReferences. 7978 * Subsequence (markupdecl | PEReference | S)* 7979 */ 7980 while ((RAW != ']') && (ctxt->instate != XML_PARSER_EOF)) { 7981 const xmlChar *check = CUR_PTR; 7982 unsigned int cons = ctxt->input->consumed; 7983 7984 SKIP_BLANKS; 7985 xmlParseMarkupDecl(ctxt); 7986 xmlParsePEReference(ctxt); 7987 7988 /* 7989 * Pop-up of finished entities. 7990 */ 7991 while ((RAW == 0) && (ctxt->inputNr > 1)) 7992 xmlPopInput(ctxt); 7993 7994 if ((CUR_PTR == check) && (cons == ctxt->input->consumed)) { 7995 xmlFatalErr(ctxt, XML_ERR_INTERNAL_ERROR, 7996 "xmlParseInternalSubset: error detected in Markup declaration\n"); 7997 break; 7998 } 7999 } 8000 if (RAW == ']') { 8001 NEXT; 8002 SKIP_BLANKS; 8003 } 8004 } 8005 8006 /* 8007 * We should be at the end of the DOCTYPE declaration. 8008 */ 8009 if (RAW != '>') { 8010 xmlFatalErr(ctxt, XML_ERR_DOCTYPE_NOT_FINISHED, NULL); 8011 } 8012 NEXT; 8013 } 8014 8015 #ifdef LIBXML_SAX1_ENABLED 8016 /** 8017 * xmlParseAttribute: 8018 * @ctxt: an XML parser context 8019 * @value: a xmlChar ** used to store the value of the attribute 8020 * 8021 * parse an attribute 8022 * 8023 * [41] Attribute ::= Name Eq AttValue 8024 * 8025 * [ WFC: No External Entity References ] 8026 * Attribute values cannot contain direct or indirect entity references 8027 * to external entities. 8028 * 8029 * [ WFC: No < in Attribute Values ] 8030 * The replacement text of any entity referred to directly or indirectly in 8031 * an attribute value (other than "<") must not contain a <. 8032 * 8033 * [ VC: Attribute Value Type ] 8034 * The attribute must have been declared; the value must be of the type 8035 * declared for it. 8036 * 8037 * [25] Eq ::= S? '=' S? 8038 * 8039 * With namespace: 8040 * 8041 * [NS 11] Attribute ::= QName Eq AttValue 8042 * 8043 * Also the case QName == xmlns:??? is handled independently as a namespace 8044 * definition. 8045 * 8046 * Returns the attribute name, and the value in *value. 8047 */ 8048 8049 const xmlChar * 8050 xmlParseAttribute(xmlParserCtxtPtr ctxt, xmlChar **value) { 8051 const xmlChar *name; 8052 xmlChar *val; 8053 8054 *value = NULL; 8055 GROW; 8056 name = xmlParseName(ctxt); 8057 if (name == NULL) { 8058 xmlFatalErrMsg(ctxt, XML_ERR_NAME_REQUIRED, 8059 "error parsing attribute name\n"); 8060 return(NULL); 8061 } 8062 8063 /* 8064 * read the value 8065 */ 8066 SKIP_BLANKS; 8067 if (RAW == '=') { 8068 NEXT; 8069 SKIP_BLANKS; 8070 val = xmlParseAttValue(ctxt); 8071 ctxt->instate = XML_PARSER_CONTENT; 8072 } else { 8073 xmlFatalErrMsgStr(ctxt, XML_ERR_ATTRIBUTE_WITHOUT_VALUE, 8074 "Specification mandate value for attribute %s\n", name); 8075 return(NULL); 8076 } 8077 8078 /* 8079 * Check that xml:lang conforms to the specification 8080 * No more registered as an error, just generate a warning now 8081 * since this was deprecated in XML second edition 8082 */ 8083 if ((ctxt->pedantic) && (xmlStrEqual(name, BAD_CAST "xml:lang"))) { 8084 if (!xmlCheckLanguageID(val)) { 8085 xmlWarningMsg(ctxt, XML_WAR_LANG_VALUE, 8086 "Malformed value for xml:lang : %s\n", 8087 val, NULL); 8088 } 8089 } 8090 8091 /* 8092 * Check that xml:space conforms to the specification 8093 */ 8094 if (xmlStrEqual(name, BAD_CAST "xml:space")) { 8095 if (xmlStrEqual(val, BAD_CAST "default")) 8096 *(ctxt->space) = 0; 8097 else if (xmlStrEqual(val, BAD_CAST "preserve")) 8098 *(ctxt->space) = 1; 8099 else { 8100 xmlWarningMsg(ctxt, XML_WAR_SPACE_VALUE, 8101 "Invalid value \"%s\" for xml:space : \"default\" or \"preserve\" expected\n", 8102 val, NULL); 8103 } 8104 } 8105 8106 *value = val; 8107 return(name); 8108 } 8109 8110 /** 8111 * xmlParseStartTag: 8112 * @ctxt: an XML parser context 8113 * 8114 * parse a start of tag either for rule element or 8115 * EmptyElement. In both case we don't parse the tag closing chars. 8116 * 8117 * [40] STag ::= '<' Name (S Attribute)* S? '>' 8118 * 8119 * [ WFC: Unique Att Spec ] 8120 * No attribute name may appear more than once in the same start-tag or 8121 * empty-element tag. 8122 * 8123 * [44] EmptyElemTag ::= '<' Name (S Attribute)* S? '/>' 8124 * 8125 * [ WFC: Unique Att Spec ] 8126 * No attribute name may appear more than once in the same start-tag or 8127 * empty-element tag. 8128 * 8129 * With namespace: 8130 * 8131 * [NS 8] STag ::= '<' QName (S Attribute)* S? '>' 8132 * 8133 * [NS 10] EmptyElement ::= '<' QName (S Attribute)* S? '/>' 8134 * 8135 * Returns the element name parsed 8136 */ 8137 8138 const xmlChar * 8139 xmlParseStartTag(xmlParserCtxtPtr ctxt) { 8140 const xmlChar *name; 8141 const xmlChar *attname; 8142 xmlChar *attvalue; 8143 const xmlChar **atts = ctxt->atts; 8144 int nbatts = 0; 8145 int maxatts = ctxt->maxatts; 8146 int i; 8147 8148 if (RAW != '<') return(NULL); 8149 NEXT1; 8150 8151 name = xmlParseName(ctxt); 8152 if (name == NULL) { 8153 xmlFatalErrMsg(ctxt, XML_ERR_NAME_REQUIRED, 8154 "xmlParseStartTag: invalid element name\n"); 8155 return(NULL); 8156 } 8157 8158 /* 8159 * Now parse the attributes, it ends up with the ending 8160 * 8161 * (S Attribute)* S? 8162 */ 8163 SKIP_BLANKS; 8164 GROW; 8165 8166 while (((RAW != '>') && 8167 ((RAW != '/') || (NXT(1) != '>')) && 8168 (IS_BYTE_CHAR(RAW))) && (ctxt->instate != XML_PARSER_EOF)) { 8169 const xmlChar *q = CUR_PTR; 8170 unsigned int cons = ctxt->input->consumed; 8171 8172 attname = xmlParseAttribute(ctxt, &attvalue); 8173 if ((attname != NULL) && (attvalue != NULL)) { 8174 /* 8175 * [ WFC: Unique Att Spec ] 8176 * No attribute name may appear more than once in the same 8177 * start-tag or empty-element tag. 8178 */ 8179 for (i = 0; i < nbatts;i += 2) { 8180 if (xmlStrEqual(atts[i], attname)) { 8181 xmlErrAttributeDup(ctxt, NULL, attname); 8182 xmlFree(attvalue); 8183 goto failed; 8184 } 8185 } 8186 /* 8187 * Add the pair to atts 8188 */ 8189 if (atts == NULL) { 8190 maxatts = 22; /* allow for 10 attrs by default */ 8191 atts = (const xmlChar **) 8192 xmlMalloc(maxatts * sizeof(xmlChar *)); 8193 if (atts == NULL) { 8194 xmlErrMemory(ctxt, NULL); 8195 if (attvalue != NULL) 8196 xmlFree(attvalue); 8197 goto failed; 8198 } 8199 ctxt->atts = atts; 8200 ctxt->maxatts = maxatts; 8201 } else if (nbatts + 4 > maxatts) { 8202 const xmlChar **n; 8203 8204 maxatts *= 2; 8205 n = (const xmlChar **) xmlRealloc((void *) atts, 8206 maxatts * sizeof(const xmlChar *)); 8207 if (n == NULL) { 8208 xmlErrMemory(ctxt, NULL); 8209 if (attvalue != NULL) 8210 xmlFree(attvalue); 8211 goto failed; 8212 } 8213 atts = n; 8214 ctxt->atts = atts; 8215 ctxt->maxatts = maxatts; 8216 } 8217 atts[nbatts++] = attname; 8218 atts[nbatts++] = attvalue; 8219 atts[nbatts] = NULL; 8220 atts[nbatts + 1] = NULL; 8221 } else { 8222 if (attvalue != NULL) 8223 xmlFree(attvalue); 8224 } 8225 8226 failed: 8227 8228 GROW 8229 if ((RAW == '>') || (((RAW == '/') && (NXT(1) == '>')))) 8230 break; 8231 if (!IS_BLANK_CH(RAW)) { 8232 xmlFatalErrMsg(ctxt, XML_ERR_SPACE_REQUIRED, 8233 "attributes construct error\n"); 8234 } 8235 SKIP_BLANKS; 8236 if ((cons == ctxt->input->consumed) && (q == CUR_PTR) && 8237 (attname == NULL) && (attvalue == NULL)) { 8238 xmlFatalErrMsg(ctxt, XML_ERR_INTERNAL_ERROR, 8239 "xmlParseStartTag: problem parsing attributes\n"); 8240 break; 8241 } 8242 SHRINK; 8243 GROW; 8244 } 8245 8246 /* 8247 * SAX: Start of Element ! 8248 */ 8249 if ((ctxt->sax != NULL) && (ctxt->sax->startElement != NULL) && 8250 (!ctxt->disableSAX)) { 8251 if (nbatts > 0) 8252 ctxt->sax->startElement(ctxt->userData, name, atts); 8253 else 8254 ctxt->sax->startElement(ctxt->userData, name, NULL); 8255 } 8256 8257 if (atts != NULL) { 8258 /* Free only the content strings */ 8259 for (i = 1;i < nbatts;i+=2) 8260 if (atts[i] != NULL) 8261 xmlFree((xmlChar *) atts[i]); 8262 } 8263 return(name); 8264 } 8265 8266 /** 8267 * xmlParseEndTag1: 8268 * @ctxt: an XML parser context 8269 * @line: line of the start tag 8270 * @nsNr: number of namespaces on the start tag 8271 * 8272 * parse an end of tag 8273 * 8274 * [42] ETag ::= '</' Name S? '>' 8275 * 8276 * With namespace 8277 * 8278 * [NS 9] ETag ::= '</' QName S? '>' 8279 */ 8280 8281 static void 8282 xmlParseEndTag1(xmlParserCtxtPtr ctxt, int line) { 8283 const xmlChar *name; 8284 8285 GROW; 8286 if ((RAW != '<') || (NXT(1) != '/')) { 8287 xmlFatalErrMsg(ctxt, XML_ERR_LTSLASH_REQUIRED, 8288 "xmlParseEndTag: '</' not found\n"); 8289 return; 8290 } 8291 SKIP(2); 8292 8293 name = xmlParseNameAndCompare(ctxt,ctxt->name); 8294 8295 /* 8296 * We should definitely be at the ending "S? '>'" part 8297 */ 8298 GROW; 8299 SKIP_BLANKS; 8300 if ((!IS_BYTE_CHAR(RAW)) || (RAW != '>')) { 8301 xmlFatalErr(ctxt, XML_ERR_GT_REQUIRED, NULL); 8302 } else 8303 NEXT1; 8304 8305 /* 8306 * [ WFC: Element Type Match ] 8307 * The Name in an element's end-tag must match the element type in the 8308 * start-tag. 8309 * 8310 */ 8311 if (name != (xmlChar*)1) { 8312 if (name == NULL) name = BAD_CAST "unparseable"; 8313 xmlFatalErrMsgStrIntStr(ctxt, XML_ERR_TAG_NAME_MISMATCH, 8314 "Opening and ending tag mismatch: %s line %d and %s\n", 8315 ctxt->name, line, name); 8316 } 8317 8318 /* 8319 * SAX: End of Tag 8320 */ 8321 if ((ctxt->sax != NULL) && (ctxt->sax->endElement != NULL) && 8322 (!ctxt->disableSAX)) 8323 ctxt->sax->endElement(ctxt->userData, ctxt->name); 8324 8325 namePop(ctxt); 8326 spacePop(ctxt); 8327 return; 8328 } 8329 8330 /** 8331 * xmlParseEndTag: 8332 * @ctxt: an XML parser context 8333 * 8334 * parse an end of tag 8335 * 8336 * [42] ETag ::= '</' Name S? '>' 8337 * 8338 * With namespace 8339 * 8340 * [NS 9] ETag ::= '</' QName S? '>' 8341 */ 8342 8343 void 8344 xmlParseEndTag(xmlParserCtxtPtr ctxt) { 8345 xmlParseEndTag1(ctxt, 0); 8346 } 8347 #endif /* LIBXML_SAX1_ENABLED */ 8348 8349 /************************************************************************ 8350 * * 8351 * SAX 2 specific operations * 8352 * * 8353 ************************************************************************/ 8354 8355 /* 8356 * xmlGetNamespace: 8357 * @ctxt: an XML parser context 8358 * @prefix: the prefix to lookup 8359 * 8360 * Lookup the namespace name for the @prefix (which ca be NULL) 8361 * The prefix must come from the @ctxt->dict dictionnary 8362 * 8363 * Returns the namespace name or NULL if not bound 8364 */ 8365 static const xmlChar * 8366 xmlGetNamespace(xmlParserCtxtPtr ctxt, const xmlChar *prefix) { 8367 int i; 8368 8369 if (prefix == ctxt->str_xml) return(ctxt->str_xml_ns); 8370 for (i = ctxt->nsNr - 2;i >= 0;i-=2) 8371 if (ctxt->nsTab[i] == prefix) { 8372 if ((prefix == NULL) && (*ctxt->nsTab[i + 1] == 0)) 8373 return(NULL); 8374 return(ctxt->nsTab[i + 1]); 8375 } 8376 return(NULL); 8377 } 8378 8379 /** 8380 * xmlParseQName: 8381 * @ctxt: an XML parser context 8382 * @prefix: pointer to store the prefix part 8383 * 8384 * parse an XML Namespace QName 8385 * 8386 * [6] QName ::= (Prefix ':')? LocalPart 8387 * [7] Prefix ::= NCName 8388 * [8] LocalPart ::= NCName 8389 * 8390 * Returns the Name parsed or NULL 8391 */ 8392 8393 static const xmlChar * 8394 xmlParseQName(xmlParserCtxtPtr ctxt, const xmlChar **prefix) { 8395 const xmlChar *l, *p; 8396 8397 GROW; 8398 8399 l = xmlParseNCName(ctxt); 8400 if (l == NULL) { 8401 if (CUR == ':') { 8402 l = xmlParseName(ctxt); 8403 if (l != NULL) { 8404 xmlNsErr(ctxt, XML_NS_ERR_QNAME, 8405 "Failed to parse QName '%s'\n", l, NULL, NULL); 8406 *prefix = NULL; 8407 return(l); 8408 } 8409 } 8410 return(NULL); 8411 } 8412 if (CUR == ':') { 8413 NEXT; 8414 p = l; 8415 l = xmlParseNCName(ctxt); 8416 if (l == NULL) { 8417 xmlChar *tmp; 8418 8419 xmlNsErr(ctxt, XML_NS_ERR_QNAME, 8420 "Failed to parse QName '%s:'\n", p, NULL, NULL); 8421 l = xmlParseNmtoken(ctxt); 8422 if (l == NULL) 8423 tmp = xmlBuildQName(BAD_CAST "", p, NULL, 0); 8424 else { 8425 tmp = xmlBuildQName(l, p, NULL, 0); 8426 xmlFree((char *)l); 8427 } 8428 p = xmlDictLookup(ctxt->dict, tmp, -1); 8429 if (tmp != NULL) xmlFree(tmp); 8430 *prefix = NULL; 8431 return(p); 8432 } 8433 if (CUR == ':') { 8434 xmlChar *tmp; 8435 8436 xmlNsErr(ctxt, XML_NS_ERR_QNAME, 8437 "Failed to parse QName '%s:%s:'\n", p, l, NULL); 8438 NEXT; 8439 tmp = (xmlChar *) xmlParseName(ctxt); 8440 if (tmp != NULL) { 8441 tmp = xmlBuildQName(tmp, l, NULL, 0); 8442 l = xmlDictLookup(ctxt->dict, tmp, -1); 8443 if (tmp != NULL) xmlFree(tmp); 8444 *prefix = p; 8445 return(l); 8446 } 8447 tmp = xmlBuildQName(BAD_CAST "", l, NULL, 0); 8448 l = xmlDictLookup(ctxt->dict, tmp, -1); 8449 if (tmp != NULL) xmlFree(tmp); 8450 *prefix = p; 8451 return(l); 8452 } 8453 *prefix = p; 8454 } else 8455 *prefix = NULL; 8456 return(l); 8457 } 8458 8459 /** 8460 * xmlParseQNameAndCompare: 8461 * @ctxt: an XML parser context 8462 * @name: the localname 8463 * @prefix: the prefix, if any. 8464 * 8465 * parse an XML name and compares for match 8466 * (specialized for endtag parsing) 8467 * 8468 * Returns NULL for an illegal name, (xmlChar*) 1 for success 8469 * and the name for mismatch 8470 */ 8471 8472 static const xmlChar * 8473 xmlParseQNameAndCompare(xmlParserCtxtPtr ctxt, xmlChar const *name, 8474 xmlChar const *prefix) { 8475 const xmlChar *cmp; 8476 const xmlChar *in; 8477 const xmlChar *ret; 8478 const xmlChar *prefix2; 8479 8480 if (prefix == NULL) return(xmlParseNameAndCompare(ctxt, name)); 8481 8482 GROW; 8483 in = ctxt->input->cur; 8484 8485 cmp = prefix; 8486 while (*in != 0 && *in == *cmp) { 8487 ++in; 8488 ++cmp; 8489 } 8490 if ((*cmp == 0) && (*in == ':')) { 8491 in++; 8492 cmp = name; 8493 while (*in != 0 && *in == *cmp) { 8494 ++in; 8495 ++cmp; 8496 } 8497 if (*cmp == 0 && (*in == '>' || IS_BLANK_CH (*in))) { 8498 /* success */ 8499 ctxt->input->cur = in; 8500 return((const xmlChar*) 1); 8501 } 8502 } 8503 /* 8504 * all strings coms from the dictionary, equality can be done directly 8505 */ 8506 ret = xmlParseQName (ctxt, &prefix2); 8507 if ((ret == name) && (prefix == prefix2)) 8508 return((const xmlChar*) 1); 8509 return ret; 8510 } 8511 8512 /** 8513 * xmlParseAttValueInternal: 8514 * @ctxt: an XML parser context 8515 * @len: attribute len result 8516 * @alloc: whether the attribute was reallocated as a new string 8517 * @normalize: if 1 then further non-CDATA normalization must be done 8518 * 8519 * parse a value for an attribute. 8520 * NOTE: if no normalization is needed, the routine will return pointers 8521 * directly from the data buffer. 8522 * 8523 * 3.3.3 Attribute-Value Normalization: 8524 * Before the value of an attribute is passed to the application or 8525 * checked for validity, the XML processor must normalize it as follows: 8526 * - a character reference is processed by appending the referenced 8527 * character to the attribute value 8528 * - an entity reference is processed by recursively processing the 8529 * replacement text of the entity 8530 * - a whitespace character (#x20, #xD, #xA, #x9) is processed by 8531 * appending #x20 to the normalized value, except that only a single 8532 * #x20 is appended for a "#xD#xA" sequence that is part of an external 8533 * parsed entity or the literal entity value of an internal parsed entity 8534 * - other characters are processed by appending them to the normalized value 8535 * If the declared value is not CDATA, then the XML processor must further 8536 * process the normalized attribute value by discarding any leading and 8537 * trailing space (#x20) characters, and by replacing sequences of space 8538 * (#x20) characters by a single space (#x20) character. 8539 * All attributes for which no declaration has been read should be treated 8540 * by a non-validating parser as if declared CDATA. 8541 * 8542 * Returns the AttValue parsed or NULL. The value has to be freed by the 8543 * caller if it was copied, this can be detected by val[*len] == 0. 8544 */ 8545 8546 static xmlChar * 8547 xmlParseAttValueInternal(xmlParserCtxtPtr ctxt, int *len, int *alloc, 8548 int normalize) 8549 { 8550 xmlChar limit = 0; 8551 const xmlChar *in = NULL, *start, *end, *last; 8552 xmlChar *ret = NULL; 8553 8554 GROW; 8555 in = (xmlChar *) CUR_PTR; 8556 if (*in != '"' && *in != '\'') { 8557 xmlFatalErr(ctxt, XML_ERR_ATTRIBUTE_NOT_STARTED, NULL); 8558 return (NULL); 8559 } 8560 ctxt->instate = XML_PARSER_ATTRIBUTE_VALUE; 8561 8562 /* 8563 * try to handle in this routine the most common case where no 8564 * allocation of a new string is required and where content is 8565 * pure ASCII. 8566 */ 8567 limit = *in++; 8568 end = ctxt->input->end; 8569 start = in; 8570 if (in >= end) { 8571 const xmlChar *oldbase = ctxt->input->base; 8572 GROW; 8573 if (oldbase != ctxt->input->base) { 8574 long delta = ctxt->input->base - oldbase; 8575 start = start + delta; 8576 in = in + delta; 8577 } 8578 end = ctxt->input->end; 8579 } 8580 if (normalize) { 8581 /* 8582 * Skip any leading spaces 8583 */ 8584 while ((in < end) && (*in != limit) && 8585 ((*in == 0x20) || (*in == 0x9) || 8586 (*in == 0xA) || (*in == 0xD))) { 8587 in++; 8588 start = in; 8589 if (in >= end) { 8590 const xmlChar *oldbase = ctxt->input->base; 8591 GROW; 8592 if (ctxt->instate == XML_PARSER_EOF) 8593 return(NULL); 8594 if (oldbase != ctxt->input->base) { 8595 long delta = ctxt->input->base - oldbase; 8596 start = start + delta; 8597 in = in + delta; 8598 } 8599 end = ctxt->input->end; 8600 } 8601 } 8602 while ((in < end) && (*in != limit) && (*in >= 0x20) && 8603 (*in <= 0x7f) && (*in != '&') && (*in != '<')) { 8604 if ((*in++ == 0x20) && (*in == 0x20)) break; 8605 if (in >= end) { 8606 const xmlChar *oldbase = ctxt->input->base; 8607 GROW; 8608 if (ctxt->instate == XML_PARSER_EOF) 8609 return(NULL); 8610 if (oldbase != ctxt->input->base) { 8611 long delta = ctxt->input->base - oldbase; 8612 start = start + delta; 8613 in = in + delta; 8614 } 8615 end = ctxt->input->end; 8616 } 8617 } 8618 last = in; 8619 /* 8620 * skip the trailing blanks 8621 */ 8622 while ((last[-1] == 0x20) && (last > start)) last--; 8623 while ((in < end) && (*in != limit) && 8624 ((*in == 0x20) || (*in == 0x9) || 8625 (*in == 0xA) || (*in == 0xD))) { 8626 in++; 8627 if (in >= end) { 8628 const xmlChar *oldbase = ctxt->input->base; 8629 GROW; 8630 if (ctxt->instate == XML_PARSER_EOF) 8631 return(NULL); 8632 if (oldbase != ctxt->input->base) { 8633 long delta = ctxt->input->base - oldbase; 8634 start = start + delta; 8635 in = in + delta; 8636 last = last + delta; 8637 } 8638 end = ctxt->input->end; 8639 } 8640 } 8641 if (*in != limit) goto need_complex; 8642 } else { 8643 while ((in < end) && (*in != limit) && (*in >= 0x20) && 8644 (*in <= 0x7f) && (*in != '&') && (*in != '<')) { 8645 in++; 8646 if (in >= end) { 8647 const xmlChar *oldbase = ctxt->input->base; 8648 GROW; 8649 if (ctxt->instate == XML_PARSER_EOF) 8650 return(NULL); 8651 if (oldbase != ctxt->input->base) { 8652 long delta = ctxt->input->base - oldbase; 8653 start = start + delta; 8654 in = in + delta; 8655 } 8656 end = ctxt->input->end; 8657 } 8658 } 8659 last = in; 8660 if (*in != limit) goto need_complex; 8661 } 8662 in++; 8663 if (len != NULL) { 8664 *len = last - start; 8665 ret = (xmlChar *) start; 8666 } else { 8667 if (alloc) *alloc = 1; 8668 ret = xmlStrndup(start, last - start); 8669 } 8670 CUR_PTR = in; 8671 if (alloc) *alloc = 0; 8672 return ret; 8673 need_complex: 8674 if (alloc) *alloc = 1; 8675 return xmlParseAttValueComplex(ctxt, len, normalize); 8676 } 8677 8678 /** 8679 * xmlParseAttribute2: 8680 * @ctxt: an XML parser context 8681 * @pref: the element prefix 8682 * @elem: the element name 8683 * @prefix: a xmlChar ** used to store the value of the attribute prefix 8684 * @value: a xmlChar ** used to store the value of the attribute 8685 * @len: an int * to save the length of the attribute 8686 * @alloc: an int * to indicate if the attribute was allocated 8687 * 8688 * parse an attribute in the new SAX2 framework. 8689 * 8690 * Returns the attribute name, and the value in *value, . 8691 */ 8692 8693 static const xmlChar * 8694 xmlParseAttribute2(xmlParserCtxtPtr ctxt, 8695 const xmlChar * pref, const xmlChar * elem, 8696 const xmlChar ** prefix, xmlChar ** value, 8697 int *len, int *alloc) 8698 { 8699 const xmlChar *name; 8700 xmlChar *val, *internal_val = NULL; 8701 int normalize = 0; 8702 8703 *value = NULL; 8704 GROW; 8705 name = xmlParseQName(ctxt, prefix); 8706 if (name == NULL) { 8707 xmlFatalErrMsg(ctxt, XML_ERR_NAME_REQUIRED, 8708 "error parsing attribute name\n"); 8709 return (NULL); 8710 } 8711 8712 /* 8713 * get the type if needed 8714 */ 8715 if (ctxt->attsSpecial != NULL) { 8716 int type; 8717 8718 type = (int) (long) xmlHashQLookup2(ctxt->attsSpecial, 8719 pref, elem, *prefix, name); 8720 if (type != 0) 8721 normalize = 1; 8722 } 8723 8724 /* 8725 * read the value 8726 */ 8727 SKIP_BLANKS; 8728 if (RAW == '=') { 8729 NEXT; 8730 SKIP_BLANKS; 8731 val = xmlParseAttValueInternal(ctxt, len, alloc, normalize); 8732 if (normalize) { 8733 /* 8734 * Sometimes a second normalisation pass for spaces is needed 8735 * but that only happens if charrefs or entities refernces 8736 * have been used in the attribute value, i.e. the attribute 8737 * value have been extracted in an allocated string already. 8738 */ 8739 if (*alloc) { 8740 const xmlChar *val2; 8741 8742 val2 = xmlAttrNormalizeSpace2(ctxt, val, len); 8743 if ((val2 != NULL) && (val2 != val)) { 8744 xmlFree(val); 8745 val = (xmlChar *) val2; 8746 } 8747 } 8748 } 8749 ctxt->instate = XML_PARSER_CONTENT; 8750 } else { 8751 xmlFatalErrMsgStr(ctxt, XML_ERR_ATTRIBUTE_WITHOUT_VALUE, 8752 "Specification mandate value for attribute %s\n", 8753 name); 8754 return (NULL); 8755 } 8756 8757 if (*prefix == ctxt->str_xml) { 8758 /* 8759 * Check that xml:lang conforms to the specification 8760 * No more registered as an error, just generate a warning now 8761 * since this was deprecated in XML second edition 8762 */ 8763 if ((ctxt->pedantic) && (xmlStrEqual(name, BAD_CAST "lang"))) { 8764 internal_val = xmlStrndup(val, *len); 8765 if (!xmlCheckLanguageID(internal_val)) { 8766 xmlWarningMsg(ctxt, XML_WAR_LANG_VALUE, 8767 "Malformed value for xml:lang : %s\n", 8768 internal_val, NULL); 8769 } 8770 } 8771 8772 /* 8773 * Check that xml:space conforms to the specification 8774 */ 8775 if (xmlStrEqual(name, BAD_CAST "space")) { 8776 internal_val = xmlStrndup(val, *len); 8777 if (xmlStrEqual(internal_val, BAD_CAST "default")) 8778 *(ctxt->space) = 0; 8779 else if (xmlStrEqual(internal_val, BAD_CAST "preserve")) 8780 *(ctxt->space) = 1; 8781 else { 8782 xmlWarningMsg(ctxt, XML_WAR_SPACE_VALUE, 8783 "Invalid value \"%s\" for xml:space : \"default\" or \"preserve\" expected\n", 8784 internal_val, NULL); 8785 } 8786 } 8787 if (internal_val) { 8788 xmlFree(internal_val); 8789 } 8790 } 8791 8792 *value = val; 8793 return (name); 8794 } 8795 /** 8796 * xmlParseStartTag2: 8797 * @ctxt: an XML parser context 8798 * 8799 * parse a start of tag either for rule element or 8800 * EmptyElement. In both case we don't parse the tag closing chars. 8801 * This routine is called when running SAX2 parsing 8802 * 8803 * [40] STag ::= '<' Name (S Attribute)* S? '>' 8804 * 8805 * [ WFC: Unique Att Spec ] 8806 * No attribute name may appear more than once in the same start-tag or 8807 * empty-element tag. 8808 * 8809 * [44] EmptyElemTag ::= '<' Name (S Attribute)* S? '/>' 8810 * 8811 * [ WFC: Unique Att Spec ] 8812 * No attribute name may appear more than once in the same start-tag or 8813 * empty-element tag. 8814 * 8815 * With namespace: 8816 * 8817 * [NS 8] STag ::= '<' QName (S Attribute)* S? '>' 8818 * 8819 * [NS 10] EmptyElement ::= '<' QName (S Attribute)* S? '/>' 8820 * 8821 * Returns the element name parsed 8822 */ 8823 8824 static const xmlChar * 8825 xmlParseStartTag2(xmlParserCtxtPtr ctxt, const xmlChar **pref, 8826 const xmlChar **URI, int *tlen) { 8827 const xmlChar *localname; 8828 const xmlChar *prefix; 8829 const xmlChar *attname; 8830 const xmlChar *aprefix; 8831 const xmlChar *nsname; 8832 xmlChar *attvalue; 8833 const xmlChar **atts = ctxt->atts; 8834 int maxatts = ctxt->maxatts; 8835 int nratts, nbatts, nbdef; 8836 int i, j, nbNs, attval, oldline, oldcol; 8837 const xmlChar *base; 8838 unsigned long cur; 8839 int nsNr = ctxt->nsNr; 8840 8841 if (RAW != '<') return(NULL); 8842 NEXT1; 8843 8844 /* 8845 * NOTE: it is crucial with the SAX2 API to never call SHRINK beyond that 8846 * point since the attribute values may be stored as pointers to 8847 * the buffer and calling SHRINK would destroy them ! 8848 * The Shrinking is only possible once the full set of attribute 8849 * callbacks have been done. 8850 */ 8851 reparse: 8852 SHRINK; 8853 base = ctxt->input->base; 8854 cur = ctxt->input->cur - ctxt->input->base; 8855 oldline = ctxt->input->line; 8856 oldcol = ctxt->input->col; 8857 nbatts = 0; 8858 nratts = 0; 8859 nbdef = 0; 8860 nbNs = 0; 8861 attval = 0; 8862 /* Forget any namespaces added during an earlier parse of this element. */ 8863 ctxt->nsNr = nsNr; 8864 8865 localname = xmlParseQName(ctxt, &prefix); 8866 if (localname == NULL) { 8867 xmlFatalErrMsg(ctxt, XML_ERR_NAME_REQUIRED, 8868 "StartTag: invalid element name\n"); 8869 return(NULL); 8870 } 8871 *tlen = ctxt->input->cur - ctxt->input->base - cur; 8872 8873 /* 8874 * Now parse the attributes, it ends up with the ending 8875 * 8876 * (S Attribute)* S? 8877 */ 8878 SKIP_BLANKS; 8879 GROW; 8880 if (ctxt->input->base != base) goto base_changed; 8881 8882 while (((RAW != '>') && 8883 ((RAW != '/') || (NXT(1) != '>')) && 8884 (IS_BYTE_CHAR(RAW))) && (ctxt->instate != XML_PARSER_EOF)) { 8885 const xmlChar *q = CUR_PTR; 8886 unsigned int cons = ctxt->input->consumed; 8887 int len = -1, alloc = 0; 8888 8889 attname = xmlParseAttribute2(ctxt, prefix, localname, 8890 &aprefix, &attvalue, &len, &alloc); 8891 if (ctxt->input->base != base) { 8892 if ((attvalue != NULL) && (alloc != 0)) 8893 xmlFree(attvalue); 8894 attvalue = NULL; 8895 goto base_changed; 8896 } 8897 if ((attname != NULL) && (attvalue != NULL)) { 8898 if (len < 0) len = xmlStrlen(attvalue); 8899 if ((attname == ctxt->str_xmlns) && (aprefix == NULL)) { 8900 const xmlChar *URL = xmlDictLookup(ctxt->dict, attvalue, len); 8901 xmlURIPtr uri; 8902 8903 if (*URL != 0) { 8904 uri = xmlParseURI((const char *) URL); 8905 if (uri == NULL) { 8906 xmlNsErr(ctxt, XML_WAR_NS_URI, 8907 "xmlns: '%s' is not a valid URI\n", 8908 URL, NULL, NULL); 8909 } else { 8910 if (uri->scheme == NULL) { 8911 xmlNsWarn(ctxt, XML_WAR_NS_URI_RELATIVE, 8912 "xmlns: URI %s is not absolute\n", 8913 URL, NULL, NULL); 8914 } 8915 xmlFreeURI(uri); 8916 } 8917 if (URL == ctxt->str_xml_ns) { 8918 if (attname != ctxt->str_xml) { 8919 xmlNsErr(ctxt, XML_NS_ERR_XML_NAMESPACE, 8920 "xml namespace URI cannot be the default namespace\n", 8921 NULL, NULL, NULL); 8922 } 8923 goto skip_default_ns; 8924 } 8925 if ((len == 29) && 8926 (xmlStrEqual(URL, 8927 BAD_CAST "http://www.w3.org/2000/xmlns/"))) { 8928 xmlNsErr(ctxt, XML_NS_ERR_XML_NAMESPACE, 8929 "reuse of the xmlns namespace name is forbidden\n", 8930 NULL, NULL, NULL); 8931 goto skip_default_ns; 8932 } 8933 } 8934 /* 8935 * check that it's not a defined namespace 8936 */ 8937 for (j = 1;j <= nbNs;j++) 8938 if (ctxt->nsTab[ctxt->nsNr - 2 * j] == NULL) 8939 break; 8940 if (j <= nbNs) 8941 xmlErrAttributeDup(ctxt, NULL, attname); 8942 else 8943 if (nsPush(ctxt, NULL, URL) > 0) nbNs++; 8944 skip_default_ns: 8945 if (alloc != 0) xmlFree(attvalue); 8946 SKIP_BLANKS; 8947 continue; 8948 } 8949 if (aprefix == ctxt->str_xmlns) { 8950 const xmlChar *URL = xmlDictLookup(ctxt->dict, attvalue, len); 8951 xmlURIPtr uri; 8952 8953 if (attname == ctxt->str_xml) { 8954 if (URL != ctxt->str_xml_ns) { 8955 xmlNsErr(ctxt, XML_NS_ERR_XML_NAMESPACE, 8956 "xml namespace prefix mapped to wrong URI\n", 8957 NULL, NULL, NULL); 8958 } 8959 /* 8960 * Do not keep a namespace definition node 8961 */ 8962 goto skip_ns; 8963 } 8964 if (URL == ctxt->str_xml_ns) { 8965 if (attname != ctxt->str_xml) { 8966 xmlNsErr(ctxt, XML_NS_ERR_XML_NAMESPACE, 8967 "xml namespace URI mapped to wrong prefix\n", 8968 NULL, NULL, NULL); 8969 } 8970 goto skip_ns; 8971 } 8972 if (attname == ctxt->str_xmlns) { 8973 xmlNsErr(ctxt, XML_NS_ERR_XML_NAMESPACE, 8974 "redefinition of the xmlns prefix is forbidden\n", 8975 NULL, NULL, NULL); 8976 goto skip_ns; 8977 } 8978 if ((len == 29) && 8979 (xmlStrEqual(URL, 8980 BAD_CAST "http://www.w3.org/2000/xmlns/"))) { 8981 xmlNsErr(ctxt, XML_NS_ERR_XML_NAMESPACE, 8982 "reuse of the xmlns namespace name is forbidden\n", 8983 NULL, NULL, NULL); 8984 goto skip_ns; 8985 } 8986 if ((URL == NULL) || (URL[0] == 0)) { 8987 xmlNsErr(ctxt, XML_NS_ERR_XML_NAMESPACE, 8988 "xmlns:%s: Empty XML namespace is not allowed\n", 8989 attname, NULL, NULL); 8990 goto skip_ns; 8991 } else { 8992 uri = xmlParseURI((const char *) URL); 8993 if (uri == NULL) { 8994 xmlNsErr(ctxt, XML_WAR_NS_URI, 8995 "xmlns:%s: '%s' is not a valid URI\n", 8996 attname, URL, NULL); 8997 } else { 8998 if ((ctxt->pedantic) && (uri->scheme == NULL)) { 8999 xmlNsWarn(ctxt, XML_WAR_NS_URI_RELATIVE, 9000 "xmlns:%s: URI %s is not absolute\n", 9001 attname, URL, NULL); 9002 } 9003 xmlFreeURI(uri); 9004 } 9005 } 9006 9007 /* 9008 * check that it's not a defined namespace 9009 */ 9010 for (j = 1;j <= nbNs;j++) 9011 if (ctxt->nsTab[ctxt->nsNr - 2 * j] == attname) 9012 break; 9013 if (j <= nbNs) 9014 xmlErrAttributeDup(ctxt, aprefix, attname); 9015 else 9016 if (nsPush(ctxt, attname, URL) > 0) nbNs++; 9017 skip_ns: 9018 if (alloc != 0) xmlFree(attvalue); 9019 SKIP_BLANKS; 9020 if (ctxt->input->base != base) goto base_changed; 9021 continue; 9022 } 9023 9024 /* 9025 * Add the pair to atts 9026 */ 9027 if ((atts == NULL) || (nbatts + 5 > maxatts)) { 9028 if (xmlCtxtGrowAttrs(ctxt, nbatts + 5) < 0) { 9029 if (attvalue[len] == 0) 9030 xmlFree(attvalue); 9031 goto failed; 9032 } 9033 maxatts = ctxt->maxatts; 9034 atts = ctxt->atts; 9035 } 9036 ctxt->attallocs[nratts++] = alloc; 9037 atts[nbatts++] = attname; 9038 atts[nbatts++] = aprefix; 9039 atts[nbatts++] = NULL; /* the URI will be fetched later */ 9040 atts[nbatts++] = attvalue; 9041 attvalue += len; 9042 atts[nbatts++] = attvalue; 9043 /* 9044 * tag if some deallocation is needed 9045 */ 9046 if (alloc != 0) attval = 1; 9047 } else { 9048 if ((attvalue != NULL) && (attvalue[len] == 0)) 9049 xmlFree(attvalue); 9050 } 9051 9052 failed: 9053 9054 GROW 9055 if (ctxt->instate == XML_PARSER_EOF) 9056 break; 9057 if (ctxt->input->base != base) goto base_changed; 9058 if ((RAW == '>') || (((RAW == '/') && (NXT(1) == '>')))) 9059 break; 9060 if (!IS_BLANK_CH(RAW)) { 9061 xmlFatalErrMsg(ctxt, XML_ERR_SPACE_REQUIRED, 9062 "attributes construct error\n"); 9063 break; 9064 } 9065 SKIP_BLANKS; 9066 if ((cons == ctxt->input->consumed) && (q == CUR_PTR) && 9067 (attname == NULL) && (attvalue == NULL)) { 9068 xmlFatalErr(ctxt, XML_ERR_INTERNAL_ERROR, 9069 "xmlParseStartTag: problem parsing attributes\n"); 9070 break; 9071 } 9072 GROW; 9073 if (ctxt->input->base != base) goto base_changed; 9074 } 9075 9076 /* 9077 * The attributes defaulting 9078 */ 9079 if (ctxt->attsDefault != NULL) { 9080 xmlDefAttrsPtr defaults; 9081 9082 defaults = xmlHashLookup2(ctxt->attsDefault, localname, prefix); 9083 if (defaults != NULL) { 9084 for (i = 0;i < defaults->nbAttrs;i++) { 9085 attname = defaults->values[5 * i]; 9086 aprefix = defaults->values[5 * i + 1]; 9087 9088 /* 9089 * special work for namespaces defaulted defs 9090 */ 9091 if ((attname == ctxt->str_xmlns) && (aprefix == NULL)) { 9092 /* 9093 * check that it's not a defined namespace 9094 */ 9095 for (j = 1;j <= nbNs;j++) 9096 if (ctxt->nsTab[ctxt->nsNr - 2 * j] == NULL) 9097 break; 9098 if (j <= nbNs) continue; 9099 9100 nsname = xmlGetNamespace(ctxt, NULL); 9101 if (nsname != defaults->values[5 * i + 2]) { 9102 if (nsPush(ctxt, NULL, 9103 defaults->values[5 * i + 2]) > 0) 9104 nbNs++; 9105 } 9106 } else if (aprefix == ctxt->str_xmlns) { 9107 /* 9108 * check that it's not a defined namespace 9109 */ 9110 for (j = 1;j <= nbNs;j++) 9111 if (ctxt->nsTab[ctxt->nsNr - 2 * j] == attname) 9112 break; 9113 if (j <= nbNs) continue; 9114 9115 nsname = xmlGetNamespace(ctxt, attname); 9116 if (nsname != defaults->values[2]) { 9117 if (nsPush(ctxt, attname, 9118 defaults->values[5 * i + 2]) > 0) 9119 nbNs++; 9120 } 9121 } else { 9122 /* 9123 * check that it's not a defined attribute 9124 */ 9125 for (j = 0;j < nbatts;j+=5) { 9126 if ((attname == atts[j]) && (aprefix == atts[j+1])) 9127 break; 9128 } 9129 if (j < nbatts) continue; 9130 9131 if ((atts == NULL) || (nbatts + 5 > maxatts)) { 9132 if (xmlCtxtGrowAttrs(ctxt, nbatts + 5) < 0) { 9133 return(NULL); 9134 } 9135 maxatts = ctxt->maxatts; 9136 atts = ctxt->atts; 9137 } 9138 atts[nbatts++] = attname; 9139 atts[nbatts++] = aprefix; 9140 if (aprefix == NULL) 9141 atts[nbatts++] = NULL; 9142 else 9143 atts[nbatts++] = xmlGetNamespace(ctxt, aprefix); 9144 atts[nbatts++] = defaults->values[5 * i + 2]; 9145 atts[nbatts++] = defaults->values[5 * i + 3]; 9146 if ((ctxt->standalone == 1) && 9147 (defaults->values[5 * i + 4] != NULL)) { 9148 xmlValidityError(ctxt, XML_DTD_STANDALONE_DEFAULTED, 9149 "standalone: attribute %s on %s defaulted from external subset\n", 9150 attname, localname); 9151 } 9152 nbdef++; 9153 } 9154 } 9155 } 9156 } 9157 9158 /* 9159 * The attributes checkings 9160 */ 9161 for (i = 0; i < nbatts;i += 5) { 9162 /* 9163 * The default namespace does not apply to attribute names. 9164 */ 9165 if (atts[i + 1] != NULL) { 9166 nsname = xmlGetNamespace(ctxt, atts[i + 1]); 9167 if (nsname == NULL) { 9168 xmlNsErr(ctxt, XML_NS_ERR_UNDEFINED_NAMESPACE, 9169 "Namespace prefix %s for %s on %s is not defined\n", 9170 atts[i + 1], atts[i], localname); 9171 } 9172 atts[i + 2] = nsname; 9173 } else 9174 nsname = NULL; 9175 /* 9176 * [ WFC: Unique Att Spec ] 9177 * No attribute name may appear more than once in the same 9178 * start-tag or empty-element tag. 9179 * As extended by the Namespace in XML REC. 9180 */ 9181 for (j = 0; j < i;j += 5) { 9182 if (atts[i] == atts[j]) { 9183 if (atts[i+1] == atts[j+1]) { 9184 xmlErrAttributeDup(ctxt, atts[i+1], atts[i]); 9185 break; 9186 } 9187 if ((nsname != NULL) && (atts[j + 2] == nsname)) { 9188 xmlNsErr(ctxt, XML_NS_ERR_ATTRIBUTE_REDEFINED, 9189 "Namespaced Attribute %s in '%s' redefined\n", 9190 atts[i], nsname, NULL); 9191 break; 9192 } 9193 } 9194 } 9195 } 9196 9197 nsname = xmlGetNamespace(ctxt, prefix); 9198 if ((prefix != NULL) && (nsname == NULL)) { 9199 xmlNsErr(ctxt, XML_NS_ERR_UNDEFINED_NAMESPACE, 9200 "Namespace prefix %s on %s is not defined\n", 9201 prefix, localname, NULL); 9202 } 9203 *pref = prefix; 9204 *URI = nsname; 9205 9206 /* 9207 * SAX: Start of Element ! 9208 */ 9209 if ((ctxt->sax != NULL) && (ctxt->sax->startElementNs != NULL) && 9210 (!ctxt->disableSAX)) { 9211 if (nbNs > 0) 9212 ctxt->sax->startElementNs(ctxt->userData, localname, prefix, 9213 nsname, nbNs, &ctxt->nsTab[ctxt->nsNr - 2 * nbNs], 9214 nbatts / 5, nbdef, atts); 9215 else 9216 ctxt->sax->startElementNs(ctxt->userData, localname, prefix, 9217 nsname, 0, NULL, nbatts / 5, nbdef, atts); 9218 } 9219 9220 /* 9221 * Free up attribute allocated strings if needed 9222 */ 9223 if (attval != 0) { 9224 for (i = 3,j = 0; j < nratts;i += 5,j++) 9225 if ((ctxt->attallocs[j] != 0) && (atts[i] != NULL)) 9226 xmlFree((xmlChar *) atts[i]); 9227 } 9228 9229 return(localname); 9230 9231 base_changed: 9232 /* 9233 * the attribute strings are valid iif the base didn't changed 9234 */ 9235 if (attval != 0) { 9236 for (i = 3,j = 0; j < nratts;i += 5,j++) 9237 if ((ctxt->attallocs[j] != 0) && (atts[i] != NULL)) 9238 xmlFree((xmlChar *) atts[i]); 9239 } 9240 ctxt->input->cur = ctxt->input->base + cur; 9241 ctxt->input->line = oldline; 9242 ctxt->input->col = oldcol; 9243 if (ctxt->wellFormed == 1) { 9244 goto reparse; 9245 } 9246 return(NULL); 9247 } 9248 9249 /** 9250 * xmlParseEndTag2: 9251 * @ctxt: an XML parser context 9252 * @line: line of the start tag 9253 * @nsNr: number of namespaces on the start tag 9254 * 9255 * parse an end of tag 9256 * 9257 * [42] ETag ::= '</' Name S? '>' 9258 * 9259 * With namespace 9260 * 9261 * [NS 9] ETag ::= '</' QName S? '>' 9262 */ 9263 9264 static void 9265 xmlParseEndTag2(xmlParserCtxtPtr ctxt, const xmlChar *prefix, 9266 const xmlChar *URI, int line, int nsNr, int tlen) { 9267 const xmlChar *name; 9268 9269 GROW; 9270 if ((RAW != '<') || (NXT(1) != '/')) { 9271 xmlFatalErr(ctxt, XML_ERR_LTSLASH_REQUIRED, NULL); 9272 return; 9273 } 9274 SKIP(2); 9275 9276 if ((tlen > 0) && (xmlStrncmp(ctxt->input->cur, ctxt->name, tlen) == 0)) { 9277 if (ctxt->input->cur[tlen] == '>') { 9278 ctxt->input->cur += tlen + 1; 9279 goto done; 9280 } 9281 ctxt->input->cur += tlen; 9282 name = (xmlChar*)1; 9283 } else { 9284 if (prefix == NULL) 9285 name = xmlParseNameAndCompare(ctxt, ctxt->name); 9286 else 9287 name = xmlParseQNameAndCompare(ctxt, ctxt->name, prefix); 9288 } 9289 9290 /* 9291 * We should definitely be at the ending "S? '>'" part 9292 */ 9293 GROW; 9294 if (ctxt->instate == XML_PARSER_EOF) 9295 return; 9296 SKIP_BLANKS; 9297 if ((!IS_BYTE_CHAR(RAW)) || (RAW != '>')) { 9298 xmlFatalErr(ctxt, XML_ERR_GT_REQUIRED, NULL); 9299 } else 9300 NEXT1; 9301 9302 /* 9303 * [ WFC: Element Type Match ] 9304 * The Name in an element's end-tag must match the element type in the 9305 * start-tag. 9306 * 9307 */ 9308 if (name != (xmlChar*)1) { 9309 if (name == NULL) name = BAD_CAST "unparseable"; 9310 if ((line == 0) && (ctxt->node != NULL)) 9311 line = ctxt->node->line; 9312 xmlFatalErrMsgStrIntStr(ctxt, XML_ERR_TAG_NAME_MISMATCH, 9313 "Opening and ending tag mismatch: %s line %d and %s\n", 9314 ctxt->name, line, name); 9315 } 9316 9317 /* 9318 * SAX: End of Tag 9319 */ 9320 done: 9321 if ((ctxt->sax != NULL) && (ctxt->sax->endElementNs != NULL) && 9322 (!ctxt->disableSAX)) 9323 ctxt->sax->endElementNs(ctxt->userData, ctxt->name, prefix, URI); 9324 9325 spacePop(ctxt); 9326 if (nsNr != 0) 9327 nsPop(ctxt, nsNr); 9328 return; 9329 } 9330 9331 /** 9332 * xmlParseCDSect: 9333 * @ctxt: an XML parser context 9334 * 9335 * Parse escaped pure raw content. 9336 * 9337 * [18] CDSect ::= CDStart CData CDEnd 9338 * 9339 * [19] CDStart ::= '<![CDATA[' 9340 * 9341 * [20] Data ::= (Char* - (Char* ']]>' Char*)) 9342 * 9343 * [21] CDEnd ::= ']]>' 9344 */ 9345 void 9346 xmlParseCDSect(xmlParserCtxtPtr ctxt) { 9347 xmlChar *buf = NULL; 9348 int len = 0; 9349 int size = XML_PARSER_BUFFER_SIZE; 9350 int r, rl; 9351 int s, sl; 9352 int cur, l; 9353 int count = 0; 9354 9355 /* Check 2.6.0 was NXT(0) not RAW */ 9356 if (CMP9(CUR_PTR, '<', '!', '[', 'C', 'D', 'A', 'T', 'A', '[')) { 9357 SKIP(9); 9358 } else 9359 return; 9360 9361 ctxt->instate = XML_PARSER_CDATA_SECTION; 9362 r = CUR_CHAR(rl); 9363 if (!IS_CHAR(r)) { 9364 xmlFatalErr(ctxt, XML_ERR_CDATA_NOT_FINISHED, NULL); 9365 ctxt->instate = XML_PARSER_CONTENT; 9366 return; 9367 } 9368 NEXTL(rl); 9369 s = CUR_CHAR(sl); 9370 if (!IS_CHAR(s)) { 9371 xmlFatalErr(ctxt, XML_ERR_CDATA_NOT_FINISHED, NULL); 9372 ctxt->instate = XML_PARSER_CONTENT; 9373 return; 9374 } 9375 NEXTL(sl); 9376 cur = CUR_CHAR(l); 9377 buf = (xmlChar *) xmlMallocAtomic(size * sizeof(xmlChar)); 9378 if (buf == NULL) { 9379 xmlErrMemory(ctxt, NULL); 9380 return; 9381 } 9382 while (IS_CHAR(cur) && 9383 ((r != ']') || (s != ']') || (cur != '>'))) { 9384 if (len + 5 >= size) { 9385 xmlChar *tmp; 9386 9387 size *= 2; 9388 tmp = (xmlChar *) xmlRealloc(buf, size * sizeof(xmlChar)); 9389 if (tmp == NULL) { 9390 xmlFree(buf); 9391 xmlErrMemory(ctxt, NULL); 9392 return; 9393 } 9394 buf = tmp; 9395 } 9396 COPY_BUF(rl,buf,len,r); 9397 r = s; 9398 rl = sl; 9399 s = cur; 9400 sl = l; 9401 count++; 9402 if (count > 50) { 9403 GROW; 9404 if (ctxt->instate == XML_PARSER_EOF) { 9405 xmlFree(buf); 9406 return; 9407 } 9408 count = 0; 9409 } 9410 NEXTL(l); 9411 cur = CUR_CHAR(l); 9412 } 9413 buf[len] = 0; 9414 ctxt->instate = XML_PARSER_CONTENT; 9415 if (cur != '>') { 9416 xmlFatalErrMsgStr(ctxt, XML_ERR_CDATA_NOT_FINISHED, 9417 "CData section not finished\n%.50s\n", buf); 9418 xmlFree(buf); 9419 return; 9420 } 9421 NEXTL(l); 9422 9423 /* 9424 * OK the buffer is to be consumed as cdata. 9425 */ 9426 if ((ctxt->sax != NULL) && (!ctxt->disableSAX)) { 9427 if (ctxt->sax->cdataBlock != NULL) 9428 ctxt->sax->cdataBlock(ctxt->userData, buf, len); 9429 else if (ctxt->sax->characters != NULL) 9430 ctxt->sax->characters(ctxt->userData, buf, len); 9431 } 9432 xmlFree(buf); 9433 } 9434 9435 /** 9436 * xmlParseContent: 9437 * @ctxt: an XML parser context 9438 * 9439 * Parse a content: 9440 * 9441 * [43] content ::= (element | CharData | Reference | CDSect | PI | Comment)* 9442 */ 9443 9444 void 9445 xmlParseContent(xmlParserCtxtPtr ctxt) { 9446 GROW; 9447 while ((RAW != 0) && 9448 ((RAW != '<') || (NXT(1) != '/')) && 9449 (ctxt->instate != XML_PARSER_EOF)) { 9450 const xmlChar *test = CUR_PTR; 9451 unsigned int cons = ctxt->input->consumed; 9452 const xmlChar *cur = ctxt->input->cur; 9453 9454 /* 9455 * First case : a Processing Instruction. 9456 */ 9457 if ((*cur == '<') && (cur[1] == '?')) { 9458 xmlParsePI(ctxt); 9459 } 9460 9461 /* 9462 * Second case : a CDSection 9463 */ 9464 /* 2.6.0 test was *cur not RAW */ 9465 else if (CMP9(CUR_PTR, '<', '!', '[', 'C', 'D', 'A', 'T', 'A', '[')) { 9466 xmlParseCDSect(ctxt); 9467 } 9468 9469 /* 9470 * Third case : a comment 9471 */ 9472 else if ((*cur == '<') && (NXT(1) == '!') && 9473 (NXT(2) == '-') && (NXT(3) == '-')) { 9474 xmlParseComment(ctxt); 9475 ctxt->instate = XML_PARSER_CONTENT; 9476 } 9477 9478 /* 9479 * Fourth case : a sub-element. 9480 */ 9481 else if (*cur == '<') { 9482 xmlParseElement(ctxt); 9483 } 9484 9485 /* 9486 * Fifth case : a reference. If if has not been resolved, 9487 * parsing returns it's Name, create the node 9488 */ 9489 9490 else if (*cur == '&') { 9491 xmlParseReference(ctxt); 9492 } 9493 9494 /* 9495 * Last case, text. Note that References are handled directly. 9496 */ 9497 else { 9498 xmlParseCharData(ctxt, 0); 9499 } 9500 9501 GROW; 9502 /* 9503 * Pop-up of finished entities. 9504 */ 9505 while ((RAW == 0) && (ctxt->inputNr > 1)) 9506 xmlPopInput(ctxt); 9507 SHRINK; 9508 9509 if ((cons == ctxt->input->consumed) && (test == CUR_PTR)) { 9510 xmlFatalErr(ctxt, XML_ERR_INTERNAL_ERROR, 9511 "detected an error in element content\n"); 9512 ctxt->instate = XML_PARSER_EOF; 9513 break; 9514 } 9515 } 9516 } 9517 9518 /** 9519 * xmlParseElement: 9520 * @ctxt: an XML parser context 9521 * 9522 * parse an XML element, this is highly recursive 9523 * 9524 * [39] element ::= EmptyElemTag | STag content ETag 9525 * 9526 * [ WFC: Element Type Match ] 9527 * The Name in an element's end-tag must match the element type in the 9528 * start-tag. 9529 * 9530 */ 9531 9532 void 9533 xmlParseElement(xmlParserCtxtPtr ctxt) { 9534 const xmlChar *name; 9535 const xmlChar *prefix = NULL; 9536 const xmlChar *URI = NULL; 9537 xmlParserNodeInfo node_info; 9538 int line, tlen; 9539 xmlNodePtr ret; 9540 int nsNr = ctxt->nsNr; 9541 9542 if (((unsigned int) ctxt->nameNr > xmlParserMaxDepth) && 9543 ((ctxt->options & XML_PARSE_HUGE) == 0)) { 9544 xmlFatalErrMsgInt(ctxt, XML_ERR_INTERNAL_ERROR, 9545 "Excessive depth in document: %d use XML_PARSE_HUGE option\n", 9546 xmlParserMaxDepth); 9547 ctxt->instate = XML_PARSER_EOF; 9548 return; 9549 } 9550 9551 /* Capture start position */ 9552 if (ctxt->record_info) { 9553 node_info.begin_pos = ctxt->input->consumed + 9554 (CUR_PTR - ctxt->input->base); 9555 node_info.begin_line = ctxt->input->line; 9556 } 9557 9558 if (ctxt->spaceNr == 0) 9559 spacePush(ctxt, -1); 9560 else if (*ctxt->space == -2) 9561 spacePush(ctxt, -1); 9562 else 9563 spacePush(ctxt, *ctxt->space); 9564 9565 line = ctxt->input->line; 9566 #ifdef LIBXML_SAX1_ENABLED 9567 if (ctxt->sax2) 9568 #endif /* LIBXML_SAX1_ENABLED */ 9569 name = xmlParseStartTag2(ctxt, &prefix, &URI, &tlen); 9570 #ifdef LIBXML_SAX1_ENABLED 9571 else 9572 name = xmlParseStartTag(ctxt); 9573 #endif /* LIBXML_SAX1_ENABLED */ 9574 if (ctxt->instate == XML_PARSER_EOF) 9575 return; 9576 if (name == NULL) { 9577 spacePop(ctxt); 9578 return; 9579 } 9580 namePush(ctxt, name); 9581 ret = ctxt->node; 9582 9583 #ifdef LIBXML_VALID_ENABLED 9584 /* 9585 * [ VC: Root Element Type ] 9586 * The Name in the document type declaration must match the element 9587 * type of the root element. 9588 */ 9589 if (ctxt->validate && ctxt->wellFormed && ctxt->myDoc && 9590 ctxt->node && (ctxt->node == ctxt->myDoc->children)) 9591 ctxt->valid &= xmlValidateRoot(&ctxt->vctxt, ctxt->myDoc); 9592 #endif /* LIBXML_VALID_ENABLED */ 9593 9594 /* 9595 * Check for an Empty Element. 9596 */ 9597 if ((RAW == '/') && (NXT(1) == '>')) { 9598 SKIP(2); 9599 if (ctxt->sax2) { 9600 if ((ctxt->sax != NULL) && (ctxt->sax->endElementNs != NULL) && 9601 (!ctxt->disableSAX)) 9602 ctxt->sax->endElementNs(ctxt->userData, name, prefix, URI); 9603 #ifdef LIBXML_SAX1_ENABLED 9604 } else { 9605 if ((ctxt->sax != NULL) && (ctxt->sax->endElement != NULL) && 9606 (!ctxt->disableSAX)) 9607 ctxt->sax->endElement(ctxt->userData, name); 9608 #endif /* LIBXML_SAX1_ENABLED */ 9609 } 9610 namePop(ctxt); 9611 spacePop(ctxt); 9612 if (nsNr != ctxt->nsNr) 9613 nsPop(ctxt, ctxt->nsNr - nsNr); 9614 if ( ret != NULL && ctxt->record_info ) { 9615 node_info.end_pos = ctxt->input->consumed + 9616 (CUR_PTR - ctxt->input->base); 9617 node_info.end_line = ctxt->input->line; 9618 node_info.node = ret; 9619 xmlParserAddNodeInfo(ctxt, &node_info); 9620 } 9621 return; 9622 } 9623 if (RAW == '>') { 9624 NEXT1; 9625 } else { 9626 xmlFatalErrMsgStrIntStr(ctxt, XML_ERR_GT_REQUIRED, 9627 "Couldn't find end of Start Tag %s line %d\n", 9628 name, line, NULL); 9629 9630 /* 9631 * end of parsing of this node. 9632 */ 9633 nodePop(ctxt); 9634 namePop(ctxt); 9635 spacePop(ctxt); 9636 if (nsNr != ctxt->nsNr) 9637 nsPop(ctxt, ctxt->nsNr - nsNr); 9638 9639 /* 9640 * Capture end position and add node 9641 */ 9642 if ( ret != NULL && ctxt->record_info ) { 9643 node_info.end_pos = ctxt->input->consumed + 9644 (CUR_PTR - ctxt->input->base); 9645 node_info.end_line = ctxt->input->line; 9646 node_info.node = ret; 9647 xmlParserAddNodeInfo(ctxt, &node_info); 9648 } 9649 return; 9650 } 9651 9652 /* 9653 * Parse the content of the element: 9654 */ 9655 xmlParseContent(ctxt); 9656 if (ctxt->instate == XML_PARSER_EOF) 9657 return; 9658 if (!IS_BYTE_CHAR(RAW)) { 9659 xmlFatalErrMsgStrIntStr(ctxt, XML_ERR_TAG_NOT_FINISHED, 9660 "Premature end of data in tag %s line %d\n", 9661 name, line, NULL); 9662 9663 /* 9664 * end of parsing of this node. 9665 */ 9666 nodePop(ctxt); 9667 namePop(ctxt); 9668 spacePop(ctxt); 9669 if (nsNr != ctxt->nsNr) 9670 nsPop(ctxt, ctxt->nsNr - nsNr); 9671 return; 9672 } 9673 9674 /* 9675 * parse the end of tag: '</' should be here. 9676 */ 9677 if (ctxt->sax2) { 9678 xmlParseEndTag2(ctxt, prefix, URI, line, ctxt->nsNr - nsNr, tlen); 9679 namePop(ctxt); 9680 } 9681 #ifdef LIBXML_SAX1_ENABLED 9682 else 9683 xmlParseEndTag1(ctxt, line); 9684 #endif /* LIBXML_SAX1_ENABLED */ 9685 9686 /* 9687 * Capture end position and add node 9688 */ 9689 if ( ret != NULL && ctxt->record_info ) { 9690 node_info.end_pos = ctxt->input->consumed + 9691 (CUR_PTR - ctxt->input->base); 9692 node_info.end_line = ctxt->input->line; 9693 node_info.node = ret; 9694 xmlParserAddNodeInfo(ctxt, &node_info); 9695 } 9696 } 9697 9698 /** 9699 * xmlParseVersionNum: 9700 * @ctxt: an XML parser context 9701 * 9702 * parse the XML version value. 9703 * 9704 * [26] VersionNum ::= '1.' [0-9]+ 9705 * 9706 * In practice allow [0-9].[0-9]+ at that level 9707 * 9708 * Returns the string giving the XML version number, or NULL 9709 */ 9710 xmlChar * 9711 xmlParseVersionNum(xmlParserCtxtPtr ctxt) { 9712 xmlChar *buf = NULL; 9713 int len = 0; 9714 int size = 10; 9715 xmlChar cur; 9716 9717 buf = (xmlChar *) xmlMallocAtomic(size * sizeof(xmlChar)); 9718 if (buf == NULL) { 9719 xmlErrMemory(ctxt, NULL); 9720 return(NULL); 9721 } 9722 cur = CUR; 9723 if (!((cur >= '0') && (cur <= '9'))) { 9724 xmlFree(buf); 9725 return(NULL); 9726 } 9727 buf[len++] = cur; 9728 NEXT; 9729 cur=CUR; 9730 if (cur != '.') { 9731 xmlFree(buf); 9732 return(NULL); 9733 } 9734 buf[len++] = cur; 9735 NEXT; 9736 cur=CUR; 9737 while ((cur >= '0') && (cur <= '9')) { 9738 if (len + 1 >= size) { 9739 xmlChar *tmp; 9740 9741 size *= 2; 9742 tmp = (xmlChar *) xmlRealloc(buf, size * sizeof(xmlChar)); 9743 if (tmp == NULL) { 9744 xmlFree(buf); 9745 xmlErrMemory(ctxt, NULL); 9746 return(NULL); 9747 } 9748 buf = tmp; 9749 } 9750 buf[len++] = cur; 9751 NEXT; 9752 cur=CUR; 9753 } 9754 buf[len] = 0; 9755 return(buf); 9756 } 9757 9758 /** 9759 * xmlParseVersionInfo: 9760 * @ctxt: an XML parser context 9761 * 9762 * parse the XML version. 9763 * 9764 * [24] VersionInfo ::= S 'version' Eq (' VersionNum ' | " VersionNum ") 9765 * 9766 * [25] Eq ::= S? '=' S? 9767 * 9768 * Returns the version string, e.g. "1.0" 9769 */ 9770 9771 xmlChar * 9772 xmlParseVersionInfo(xmlParserCtxtPtr ctxt) { 9773 xmlChar *version = NULL; 9774 9775 if (CMP7(CUR_PTR, 'v', 'e', 'r', 's', 'i', 'o', 'n')) { 9776 SKIP(7); 9777 SKIP_BLANKS; 9778 if (RAW != '=') { 9779 xmlFatalErr(ctxt, XML_ERR_EQUAL_REQUIRED, NULL); 9780 return(NULL); 9781 } 9782 NEXT; 9783 SKIP_BLANKS; 9784 if (RAW == '"') { 9785 NEXT; 9786 version = xmlParseVersionNum(ctxt); 9787 if (RAW != '"') { 9788 xmlFatalErr(ctxt, XML_ERR_STRING_NOT_CLOSED, NULL); 9789 } else 9790 NEXT; 9791 } else if (RAW == '\''){ 9792 NEXT; 9793 version = xmlParseVersionNum(ctxt); 9794 if (RAW != '\'') { 9795 xmlFatalErr(ctxt, XML_ERR_STRING_NOT_CLOSED, NULL); 9796 } else 9797 NEXT; 9798 } else { 9799 xmlFatalErr(ctxt, XML_ERR_STRING_NOT_STARTED, NULL); 9800 } 9801 } 9802 return(version); 9803 } 9804 9805 /** 9806 * xmlParseEncName: 9807 * @ctxt: an XML parser context 9808 * 9809 * parse the XML encoding name 9810 * 9811 * [81] EncName ::= [A-Za-z] ([A-Za-z0-9._] | '-')* 9812 * 9813 * Returns the encoding name value or NULL 9814 */ 9815 xmlChar * 9816 xmlParseEncName(xmlParserCtxtPtr ctxt) { 9817 xmlChar *buf = NULL; 9818 int len = 0; 9819 int size = 10; 9820 xmlChar cur; 9821 9822 cur = CUR; 9823 if (((cur >= 'a') && (cur <= 'z')) || 9824 ((cur >= 'A') && (cur <= 'Z'))) { 9825 buf = (xmlChar *) xmlMallocAtomic(size * sizeof(xmlChar)); 9826 if (buf == NULL) { 9827 xmlErrMemory(ctxt, NULL); 9828 return(NULL); 9829 } 9830 9831 buf[len++] = cur; 9832 NEXT; 9833 cur = CUR; 9834 while (((cur >= 'a') && (cur <= 'z')) || 9835 ((cur >= 'A') && (cur <= 'Z')) || 9836 ((cur >= '0') && (cur <= '9')) || 9837 (cur == '.') || (cur == '_') || 9838 (cur == '-')) { 9839 if (len + 1 >= size) { 9840 xmlChar *tmp; 9841 9842 size *= 2; 9843 tmp = (xmlChar *) xmlRealloc(buf, size * sizeof(xmlChar)); 9844 if (tmp == NULL) { 9845 xmlErrMemory(ctxt, NULL); 9846 xmlFree(buf); 9847 return(NULL); 9848 } 9849 buf = tmp; 9850 } 9851 buf[len++] = cur; 9852 NEXT; 9853 cur = CUR; 9854 if (cur == 0) { 9855 SHRINK; 9856 GROW; 9857 cur = CUR; 9858 } 9859 } 9860 buf[len] = 0; 9861 } else { 9862 xmlFatalErr(ctxt, XML_ERR_ENCODING_NAME, NULL); 9863 } 9864 return(buf); 9865 } 9866 9867 /** 9868 * xmlParseEncodingDecl: 9869 * @ctxt: an XML parser context 9870 * 9871 * parse the XML encoding declaration 9872 * 9873 * [80] EncodingDecl ::= S 'encoding' Eq ('"' EncName '"' | "'" EncName "'") 9874 * 9875 * this setups the conversion filters. 9876 * 9877 * Returns the encoding value or NULL 9878 */ 9879 9880 const xmlChar * 9881 xmlParseEncodingDecl(xmlParserCtxtPtr ctxt) { 9882 xmlChar *encoding = NULL; 9883 9884 SKIP_BLANKS; 9885 if (CMP8(CUR_PTR, 'e', 'n', 'c', 'o', 'd', 'i', 'n', 'g')) { 9886 SKIP(8); 9887 SKIP_BLANKS; 9888 if (RAW != '=') { 9889 xmlFatalErr(ctxt, XML_ERR_EQUAL_REQUIRED, NULL); 9890 return(NULL); 9891 } 9892 NEXT; 9893 SKIP_BLANKS; 9894 if (RAW == '"') { 9895 NEXT; 9896 encoding = xmlParseEncName(ctxt); 9897 if (RAW != '"') { 9898 xmlFatalErr(ctxt, XML_ERR_STRING_NOT_CLOSED, NULL); 9899 } else 9900 NEXT; 9901 } else if (RAW == '\''){ 9902 NEXT; 9903 encoding = xmlParseEncName(ctxt); 9904 if (RAW != '\'') { 9905 xmlFatalErr(ctxt, XML_ERR_STRING_NOT_CLOSED, NULL); 9906 } else 9907 NEXT; 9908 } else { 9909 xmlFatalErr(ctxt, XML_ERR_STRING_NOT_STARTED, NULL); 9910 } 9911 /* 9912 * UTF-16 encoding stwich has already taken place at this stage, 9913 * more over the little-endian/big-endian selection is already done 9914 */ 9915 if ((encoding != NULL) && 9916 ((!xmlStrcasecmp(encoding, BAD_CAST "UTF-16")) || 9917 (!xmlStrcasecmp(encoding, BAD_CAST "UTF16")))) { 9918 /* 9919 * If no encoding was passed to the parser, that we are 9920 * using UTF-16 and no decoder is present i.e. the 9921 * document is apparently UTF-8 compatible, then raise an 9922 * encoding mismatch fatal error 9923 */ 9924 if ((ctxt->encoding == NULL) && 9925 (ctxt->input->buf != NULL) && 9926 (ctxt->input->buf->encoder == NULL)) { 9927 xmlFatalErrMsg(ctxt, XML_ERR_INVALID_ENCODING, 9928 "Document labelled UTF-16 but has UTF-8 content\n"); 9929 } 9930 if (ctxt->encoding != NULL) 9931 xmlFree((xmlChar *) ctxt->encoding); 9932 ctxt->encoding = encoding; 9933 } 9934 /* 9935 * UTF-8 encoding is handled natively 9936 */ 9937 else if ((encoding != NULL) && 9938 ((!xmlStrcasecmp(encoding, BAD_CAST "UTF-8")) || 9939 (!xmlStrcasecmp(encoding, BAD_CAST "UTF8")))) { 9940 if (ctxt->encoding != NULL) 9941 xmlFree((xmlChar *) ctxt->encoding); 9942 ctxt->encoding = encoding; 9943 } 9944 else if (encoding != NULL) { 9945 xmlCharEncodingHandlerPtr handler; 9946 9947 if (ctxt->input->encoding != NULL) 9948 xmlFree((xmlChar *) ctxt->input->encoding); 9949 ctxt->input->encoding = encoding; 9950 9951 handler = xmlFindCharEncodingHandler((const char *) encoding); 9952 if (handler != NULL) { 9953 xmlSwitchToEncoding(ctxt, handler); 9954 } else { 9955 xmlFatalErrMsgStr(ctxt, XML_ERR_UNSUPPORTED_ENCODING, 9956 "Unsupported encoding %s\n", encoding); 9957 return(NULL); 9958 } 9959 } 9960 } 9961 return(encoding); 9962 } 9963 9964 /** 9965 * xmlParseSDDecl: 9966 * @ctxt: an XML parser context 9967 * 9968 * parse the XML standalone declaration 9969 * 9970 * [32] SDDecl ::= S 'standalone' Eq 9971 * (("'" ('yes' | 'no') "'") | ('"' ('yes' | 'no')'"')) 9972 * 9973 * [ VC: Standalone Document Declaration ] 9974 * TODO The standalone document declaration must have the value "no" 9975 * if any external markup declarations contain declarations of: 9976 * - attributes with default values, if elements to which these 9977 * attributes apply appear in the document without specifications 9978 * of values for these attributes, or 9979 * - entities (other than amp, lt, gt, apos, quot), if references 9980 * to those entities appear in the document, or 9981 * - attributes with values subject to normalization, where the 9982 * attribute appears in the document with a value which will change 9983 * as a result of normalization, or 9984 * - element types with element content, if white space occurs directly 9985 * within any instance of those types. 9986 * 9987 * Returns: 9988 * 1 if standalone="yes" 9989 * 0 if standalone="no" 9990 * -2 if standalone attribute is missing or invalid 9991 * (A standalone value of -2 means that the XML declaration was found, 9992 * but no value was specified for the standalone attribute). 9993 */ 9994 9995 int 9996 xmlParseSDDecl(xmlParserCtxtPtr ctxt) { 9997 int standalone = -2; 9998 9999 SKIP_BLANKS; 10000 if (CMP10(CUR_PTR, 's', 't', 'a', 'n', 'd', 'a', 'l', 'o', 'n', 'e')) { 10001 SKIP(10); 10002 SKIP_BLANKS; 10003 if (RAW != '=') { 10004 xmlFatalErr(ctxt, XML_ERR_EQUAL_REQUIRED, NULL); 10005 return(standalone); 10006 } 10007 NEXT; 10008 SKIP_BLANKS; 10009 if (RAW == '\''){ 10010 NEXT; 10011 if ((RAW == 'n') && (NXT(1) == 'o')) { 10012 standalone = 0; 10013 SKIP(2); 10014 } else if ((RAW == 'y') && (NXT(1) == 'e') && 10015 (NXT(2) == 's')) { 10016 standalone = 1; 10017 SKIP(3); 10018 } else { 10019 xmlFatalErr(ctxt, XML_ERR_STANDALONE_VALUE, NULL); 10020 } 10021 if (RAW != '\'') { 10022 xmlFatalErr(ctxt, XML_ERR_STRING_NOT_CLOSED, NULL); 10023 } else 10024 NEXT; 10025 } else if (RAW == '"'){ 10026 NEXT; 10027 if ((RAW == 'n') && (NXT(1) == 'o')) { 10028 standalone = 0; 10029 SKIP(2); 10030 } else if ((RAW == 'y') && (NXT(1) == 'e') && 10031 (NXT(2) == 's')) { 10032 standalone = 1; 10033 SKIP(3); 10034 } else { 10035 xmlFatalErr(ctxt, XML_ERR_STANDALONE_VALUE, NULL); 10036 } 10037 if (RAW != '"') { 10038 xmlFatalErr(ctxt, XML_ERR_STRING_NOT_CLOSED, NULL); 10039 } else 10040 NEXT; 10041 } else { 10042 xmlFatalErr(ctxt, XML_ERR_STRING_NOT_STARTED, NULL); 10043 } 10044 } 10045 return(standalone); 10046 } 10047 10048 /** 10049 * xmlParseXMLDecl: 10050 * @ctxt: an XML parser context 10051 * 10052 * parse an XML declaration header 10053 * 10054 * [23] XMLDecl ::= '<?xml' VersionInfo EncodingDecl? SDDecl? S? '?>' 10055 */ 10056 10057 void 10058 xmlParseXMLDecl(xmlParserCtxtPtr ctxt) { 10059 xmlChar *version; 10060 10061 /* 10062 * This value for standalone indicates that the document has an 10063 * XML declaration but it does not have a standalone attribute. 10064 * It will be overwritten later if a standalone attribute is found. 10065 */ 10066 ctxt->input->standalone = -2; 10067 10068 /* 10069 * We know that '<?xml' is here. 10070 */ 10071 SKIP(5); 10072 10073 if (!IS_BLANK_CH(RAW)) { 10074 xmlFatalErrMsg(ctxt, XML_ERR_SPACE_REQUIRED, 10075 "Blank needed after '<?xml'\n"); 10076 } 10077 SKIP_BLANKS; 10078 10079 /* 10080 * We must have the VersionInfo here. 10081 */ 10082 version = xmlParseVersionInfo(ctxt); 10083 if (version == NULL) { 10084 xmlFatalErr(ctxt, XML_ERR_VERSION_MISSING, NULL); 10085 } else { 10086 if (!xmlStrEqual(version, (const xmlChar *) XML_DEFAULT_VERSION)) { 10087 /* 10088 * Changed here for XML-1.0 5th edition 10089 */ 10090 if (ctxt->options & XML_PARSE_OLD10) { 10091 xmlFatalErrMsgStr(ctxt, XML_ERR_UNKNOWN_VERSION, 10092 "Unsupported version '%s'\n", 10093 version); 10094 } else { 10095 if ((version[0] == '1') && ((version[1] == '.'))) { 10096 xmlWarningMsg(ctxt, XML_WAR_UNKNOWN_VERSION, 10097 "Unsupported version '%s'\n", 10098 version, NULL); 10099 } else { 10100 xmlFatalErrMsgStr(ctxt, XML_ERR_UNKNOWN_VERSION, 10101 "Unsupported version '%s'\n", 10102 version); 10103 } 10104 } 10105 } 10106 if (ctxt->version != NULL) 10107 xmlFree((void *) ctxt->version); 10108 ctxt->version = version; 10109 } 10110 10111 /* 10112 * We may have the encoding declaration 10113 */ 10114 if (!IS_BLANK_CH(RAW)) { 10115 if ((RAW == '?') && (NXT(1) == '>')) { 10116 SKIP(2); 10117 return; 10118 } 10119 xmlFatalErrMsg(ctxt, XML_ERR_SPACE_REQUIRED, "Blank needed here\n"); 10120 } 10121 xmlParseEncodingDecl(ctxt); 10122 if (ctxt->errNo == XML_ERR_UNSUPPORTED_ENCODING) { 10123 /* 10124 * The XML REC instructs us to stop parsing right here 10125 */ 10126 return; 10127 } 10128 10129 /* 10130 * We may have the standalone status. 10131 */ 10132 if ((ctxt->input->encoding != NULL) && (!IS_BLANK_CH(RAW))) { 10133 if ((RAW == '?') && (NXT(1) == '>')) { 10134 SKIP(2); 10135 return; 10136 } 10137 xmlFatalErrMsg(ctxt, XML_ERR_SPACE_REQUIRED, "Blank needed here\n"); 10138 } 10139 10140 /* 10141 * We can grow the input buffer freely at that point 10142 */ 10143 GROW; 10144 10145 SKIP_BLANKS; 10146 ctxt->input->standalone = xmlParseSDDecl(ctxt); 10147 10148 SKIP_BLANKS; 10149 if ((RAW == '?') && (NXT(1) == '>')) { 10150 SKIP(2); 10151 } else if (RAW == '>') { 10152 /* Deprecated old WD ... */ 10153 xmlFatalErr(ctxt, XML_ERR_XMLDECL_NOT_FINISHED, NULL); 10154 NEXT; 10155 } else { 10156 xmlFatalErr(ctxt, XML_ERR_XMLDECL_NOT_FINISHED, NULL); 10157 MOVETO_ENDTAG(CUR_PTR); 10158 NEXT; 10159 } 10160 } 10161 10162 /** 10163 * xmlParseMisc: 10164 * @ctxt: an XML parser context 10165 * 10166 * parse an XML Misc* optional field. 10167 * 10168 * [27] Misc ::= Comment | PI | S 10169 */ 10170 10171 void 10172 xmlParseMisc(xmlParserCtxtPtr ctxt) { 10173 while ((ctxt->instate != XML_PARSER_EOF) && 10174 (((RAW == '<') && (NXT(1) == '?')) || 10175 (CMP4(CUR_PTR, '<', '!', '-', '-')) || 10176 IS_BLANK_CH(CUR))) { 10177 if ((RAW == '<') && (NXT(1) == '?')) { 10178 xmlParsePI(ctxt); 10179 } else if (IS_BLANK_CH(CUR)) { 10180 NEXT; 10181 } else 10182 xmlParseComment(ctxt); 10183 } 10184 } 10185 10186 /** 10187 * xmlParseDocument: 10188 * @ctxt: an XML parser context 10189 * 10190 * parse an XML document (and build a tree if using the standard SAX 10191 * interface). 10192 * 10193 * [1] document ::= prolog element Misc* 10194 * 10195 * [22] prolog ::= XMLDecl? Misc* (doctypedecl Misc*)? 10196 * 10197 * Returns 0, -1 in case of error. the parser context is augmented 10198 * as a result of the parsing. 10199 */ 10200 10201 int 10202 xmlParseDocument(xmlParserCtxtPtr ctxt) { 10203 xmlChar start[4]; 10204 xmlCharEncoding enc; 10205 10206 xmlInitParser(); 10207 10208 if ((ctxt == NULL) || (ctxt->input == NULL)) 10209 return(-1); 10210 10211 GROW; 10212 10213 /* 10214 * SAX: detecting the level. 10215 */ 10216 xmlDetectSAX2(ctxt); 10217 10218 /* 10219 * SAX: beginning of the document processing. 10220 */ 10221 if ((ctxt->sax) && (ctxt->sax->setDocumentLocator)) 10222 ctxt->sax->setDocumentLocator(ctxt->userData, &xmlDefaultSAXLocator); 10223 if (ctxt->instate == XML_PARSER_EOF) 10224 return(-1); 10225 10226 if ((ctxt->encoding == (const xmlChar *)XML_CHAR_ENCODING_NONE) && 10227 ((ctxt->input->end - ctxt->input->cur) >= 4)) { 10228 /* 10229 * Get the 4 first bytes and decode the charset 10230 * if enc != XML_CHAR_ENCODING_NONE 10231 * plug some encoding conversion routines. 10232 */ 10233 start[0] = RAW; 10234 start[1] = NXT(1); 10235 start[2] = NXT(2); 10236 start[3] = NXT(3); 10237 enc = xmlDetectCharEncoding(&start[0], 4); 10238 if (enc != XML_CHAR_ENCODING_NONE) { 10239 xmlSwitchEncoding(ctxt, enc); 10240 } 10241 } 10242 10243 10244 if (CUR == 0) { 10245 xmlFatalErr(ctxt, XML_ERR_DOCUMENT_EMPTY, NULL); 10246 } 10247 10248 /* 10249 * Check for the XMLDecl in the Prolog. 10250 * do not GROW here to avoid the detected encoder to decode more 10251 * than just the first line, unless the amount of data is really 10252 * too small to hold "<?xml version="1.0" encoding="foo" 10253 */ 10254 if ((ctxt->input->end - ctxt->input->cur) < 35) { 10255 GROW; 10256 } 10257 if ((CMP5(CUR_PTR, '<', '?', 'x', 'm', 'l')) && (IS_BLANK_CH(NXT(5)))) { 10258 10259 /* 10260 * Note that we will switch encoding on the fly. 10261 */ 10262 xmlParseXMLDecl(ctxt); 10263 if (ctxt->errNo == XML_ERR_UNSUPPORTED_ENCODING) { 10264 /* 10265 * The XML REC instructs us to stop parsing right here 10266 */ 10267 return(-1); 10268 } 10269 ctxt->standalone = ctxt->input->standalone; 10270 SKIP_BLANKS; 10271 } else { 10272 ctxt->version = xmlCharStrdup(XML_DEFAULT_VERSION); 10273 } 10274 if ((ctxt->sax) && (ctxt->sax->startDocument) && (!ctxt->disableSAX)) 10275 ctxt->sax->startDocument(ctxt->userData); 10276 if (ctxt->instate == XML_PARSER_EOF) 10277 return(-1); 10278 10279 /* 10280 * The Misc part of the Prolog 10281 */ 10282 GROW; 10283 xmlParseMisc(ctxt); 10284 10285 /* 10286 * Then possibly doc type declaration(s) and more Misc 10287 * (doctypedecl Misc*)? 10288 */ 10289 GROW; 10290 if (CMP9(CUR_PTR, '<', '!', 'D', 'O', 'C', 'T', 'Y', 'P', 'E')) { 10291 10292 ctxt->inSubset = 1; 10293 xmlParseDocTypeDecl(ctxt); 10294 if (RAW == '[') { 10295 ctxt->instate = XML_PARSER_DTD; 10296 xmlParseInternalSubset(ctxt); 10297 if (ctxt->instate == XML_PARSER_EOF) 10298 return(-1); 10299 } 10300 10301 /* 10302 * Create and update the external subset. 10303 */ 10304 ctxt->inSubset = 2; 10305 if ((ctxt->sax != NULL) && (ctxt->sax->externalSubset != NULL) && 10306 (!ctxt->disableSAX)) 10307 ctxt->sax->externalSubset(ctxt->userData, ctxt->intSubName, 10308 ctxt->extSubSystem, ctxt->extSubURI); 10309 if (ctxt->instate == XML_PARSER_EOF) 10310 return(-1); 10311 ctxt->inSubset = 0; 10312 10313 xmlCleanSpecialAttr(ctxt); 10314 10315 ctxt->instate = XML_PARSER_PROLOG; 10316 xmlParseMisc(ctxt); 10317 } 10318 10319 /* 10320 * Time to start parsing the tree itself 10321 */ 10322 GROW; 10323 if (RAW != '<') { 10324 xmlFatalErrMsg(ctxt, XML_ERR_DOCUMENT_EMPTY, 10325 "Start tag expected, '<' not found\n"); 10326 } else { 10327 ctxt->instate = XML_PARSER_CONTENT; 10328 xmlParseElement(ctxt); 10329 ctxt->instate = XML_PARSER_EPILOG; 10330 10331 10332 /* 10333 * The Misc part at the end 10334 */ 10335 xmlParseMisc(ctxt); 10336 10337 if (RAW != 0) { 10338 xmlFatalErr(ctxt, XML_ERR_DOCUMENT_END, NULL); 10339 } 10340 ctxt->instate = XML_PARSER_EOF; 10341 } 10342 10343 /* 10344 * SAX: end of the document processing. 10345 */ 10346 if ((ctxt->sax) && (ctxt->sax->endDocument != NULL)) 10347 ctxt->sax->endDocument(ctxt->userData); 10348 10349 /* 10350 * Remove locally kept entity definitions if the tree was not built 10351 */ 10352 if ((ctxt->myDoc != NULL) && 10353 (xmlStrEqual(ctxt->myDoc->version, SAX_COMPAT_MODE))) { 10354 xmlFreeDoc(ctxt->myDoc); 10355 ctxt->myDoc = NULL; 10356 } 10357 10358 if ((ctxt->wellFormed) && (ctxt->myDoc != NULL)) { 10359 ctxt->myDoc->properties |= XML_DOC_WELLFORMED; 10360 if (ctxt->valid) 10361 ctxt->myDoc->properties |= XML_DOC_DTDVALID; 10362 if (ctxt->nsWellFormed) 10363 ctxt->myDoc->properties |= XML_DOC_NSVALID; 10364 if (ctxt->options & XML_PARSE_OLD10) 10365 ctxt->myDoc->properties |= XML_DOC_OLD10; 10366 } 10367 if (! ctxt->wellFormed) { 10368 ctxt->valid = 0; 10369 return(-1); 10370 } 10371 return(0); 10372 } 10373 10374 /** 10375 * xmlParseExtParsedEnt: 10376 * @ctxt: an XML parser context 10377 * 10378 * parse a general parsed entity 10379 * An external general parsed entity is well-formed if it matches the 10380 * production labeled extParsedEnt. 10381 * 10382 * [78] extParsedEnt ::= TextDecl? content 10383 * 10384 * Returns 0, -1 in case of error. the parser context is augmented 10385 * as a result of the parsing. 10386 */ 10387 10388 int 10389 xmlParseExtParsedEnt(xmlParserCtxtPtr ctxt) { 10390 xmlChar start[4]; 10391 xmlCharEncoding enc; 10392 10393 if ((ctxt == NULL) || (ctxt->input == NULL)) 10394 return(-1); 10395 10396 xmlDefaultSAXHandlerInit(); 10397 10398 xmlDetectSAX2(ctxt); 10399 10400 GROW; 10401 10402 /* 10403 * SAX: beginning of the document processing. 10404 */ 10405 if ((ctxt->sax) && (ctxt->sax->setDocumentLocator)) 10406 ctxt->sax->setDocumentLocator(ctxt->userData, &xmlDefaultSAXLocator); 10407 10408 /* 10409 * Get the 4 first bytes and decode the charset 10410 * if enc != XML_CHAR_ENCODING_NONE 10411 * plug some encoding conversion routines. 10412 */ 10413 if ((ctxt->input->end - ctxt->input->cur) >= 4) { 10414 start[0] = RAW; 10415 start[1] = NXT(1); 10416 start[2] = NXT(2); 10417 start[3] = NXT(3); 10418 enc = xmlDetectCharEncoding(start, 4); 10419 if (enc != XML_CHAR_ENCODING_NONE) { 10420 xmlSwitchEncoding(ctxt, enc); 10421 } 10422 } 10423 10424 10425 if (CUR == 0) { 10426 xmlFatalErr(ctxt, XML_ERR_DOCUMENT_EMPTY, NULL); 10427 } 10428 10429 /* 10430 * Check for the XMLDecl in the Prolog. 10431 */ 10432 GROW; 10433 if ((CMP5(CUR_PTR, '<', '?', 'x', 'm', 'l')) && (IS_BLANK_CH(NXT(5)))) { 10434 10435 /* 10436 * Note that we will switch encoding on the fly. 10437 */ 10438 xmlParseXMLDecl(ctxt); 10439 if (ctxt->errNo == XML_ERR_UNSUPPORTED_ENCODING) { 10440 /* 10441 * The XML REC instructs us to stop parsing right here 10442 */ 10443 return(-1); 10444 } 10445 SKIP_BLANKS; 10446 } else { 10447 ctxt->version = xmlCharStrdup(XML_DEFAULT_VERSION); 10448 } 10449 if ((ctxt->sax) && (ctxt->sax->startDocument) && (!ctxt->disableSAX)) 10450 ctxt->sax->startDocument(ctxt->userData); 10451 if (ctxt->instate == XML_PARSER_EOF) 10452 return(-1); 10453 10454 /* 10455 * Doing validity checking on chunk doesn't make sense 10456 */ 10457 ctxt->instate = XML_PARSER_CONTENT; 10458 ctxt->validate = 0; 10459 ctxt->loadsubset = 0; 10460 ctxt->depth = 0; 10461 10462 xmlParseContent(ctxt); 10463 if (ctxt->instate == XML_PARSER_EOF) 10464 return(-1); 10465 10466 if ((RAW == '<') && (NXT(1) == '/')) { 10467 xmlFatalErr(ctxt, XML_ERR_NOT_WELL_BALANCED, NULL); 10468 } else if (RAW != 0) { 10469 xmlFatalErr(ctxt, XML_ERR_EXTRA_CONTENT, NULL); 10470 } 10471 10472 /* 10473 * SAX: end of the document processing. 10474 */ 10475 if ((ctxt->sax) && (ctxt->sax->endDocument != NULL)) 10476 ctxt->sax->endDocument(ctxt->userData); 10477 10478 if (! ctxt->wellFormed) return(-1); 10479 return(0); 10480 } 10481 10482 #ifdef LIBXML_PUSH_ENABLED 10483 /************************************************************************ 10484 * * 10485 * Progressive parsing interfaces * 10486 * * 10487 ************************************************************************/ 10488 10489 /** 10490 * xmlParseLookupSequence: 10491 * @ctxt: an XML parser context 10492 * @first: the first char to lookup 10493 * @next: the next char to lookup or zero 10494 * @third: the next char to lookup or zero 10495 * 10496 * Try to find if a sequence (first, next, third) or just (first next) or 10497 * (first) is available in the input stream. 10498 * This function has a side effect of (possibly) incrementing ctxt->checkIndex 10499 * to avoid rescanning sequences of bytes, it DOES change the state of the 10500 * parser, do not use liberally. 10501 * 10502 * Returns the index to the current parsing point if the full sequence 10503 * is available, -1 otherwise. 10504 */ 10505 static int 10506 xmlParseLookupSequence(xmlParserCtxtPtr ctxt, xmlChar first, 10507 xmlChar next, xmlChar third) { 10508 int base, len; 10509 xmlParserInputPtr in; 10510 const xmlChar *buf; 10511 10512 in = ctxt->input; 10513 if (in == NULL) return(-1); 10514 base = in->cur - in->base; 10515 if (base < 0) return(-1); 10516 if (ctxt->checkIndex > base) 10517 base = ctxt->checkIndex; 10518 if (in->buf == NULL) { 10519 buf = in->base; 10520 len = in->length; 10521 } else { 10522 buf = in->buf->buffer->content; 10523 len = in->buf->buffer->use; 10524 } 10525 /* take into account the sequence length */ 10526 if (third) len -= 2; 10527 else if (next) len --; 10528 for (;base < len;base++) { 10529 if (buf[base] == first) { 10530 if (third != 0) { 10531 if ((buf[base + 1] != next) || 10532 (buf[base + 2] != third)) continue; 10533 } else if (next != 0) { 10534 if (buf[base + 1] != next) continue; 10535 } 10536 ctxt->checkIndex = 0; 10537 #ifdef DEBUG_PUSH 10538 if (next == 0) 10539 xmlGenericError(xmlGenericErrorContext, 10540 "PP: lookup '%c' found at %d\n", 10541 first, base); 10542 else if (third == 0) 10543 xmlGenericError(xmlGenericErrorContext, 10544 "PP: lookup '%c%c' found at %d\n", 10545 first, next, base); 10546 else 10547 xmlGenericError(xmlGenericErrorContext, 10548 "PP: lookup '%c%c%c' found at %d\n", 10549 first, next, third, base); 10550 #endif 10551 return(base - (in->cur - in->base)); 10552 } 10553 } 10554 ctxt->checkIndex = base; 10555 #ifdef DEBUG_PUSH 10556 if (next == 0) 10557 xmlGenericError(xmlGenericErrorContext, 10558 "PP: lookup '%c' failed\n", first); 10559 else if (third == 0) 10560 xmlGenericError(xmlGenericErrorContext, 10561 "PP: lookup '%c%c' failed\n", first, next); 10562 else 10563 xmlGenericError(xmlGenericErrorContext, 10564 "PP: lookup '%c%c%c' failed\n", first, next, third); 10565 #endif 10566 return(-1); 10567 } 10568 10569 /** 10570 * xmlParseGetLasts: 10571 * @ctxt: an XML parser context 10572 * @lastlt: pointer to store the last '<' from the input 10573 * @lastgt: pointer to store the last '>' from the input 10574 * 10575 * Lookup the last < and > in the current chunk 10576 */ 10577 static void 10578 xmlParseGetLasts(xmlParserCtxtPtr ctxt, const xmlChar **lastlt, 10579 const xmlChar **lastgt) { 10580 const xmlChar *tmp; 10581 10582 if ((ctxt == NULL) || (lastlt == NULL) || (lastgt == NULL)) { 10583 xmlGenericError(xmlGenericErrorContext, 10584 "Internal error: xmlParseGetLasts\n"); 10585 return; 10586 } 10587 if ((ctxt->progressive != 0) && (ctxt->inputNr == 1)) { 10588 tmp = ctxt->input->end; 10589 tmp--; 10590 while ((tmp >= ctxt->input->base) && (*tmp != '<')) tmp--; 10591 if (tmp < ctxt->input->base) { 10592 *lastlt = NULL; 10593 *lastgt = NULL; 10594 } else { 10595 *lastlt = tmp; 10596 tmp++; 10597 while ((tmp < ctxt->input->end) && (*tmp != '>')) { 10598 if (*tmp == '\'') { 10599 tmp++; 10600 while ((tmp < ctxt->input->end) && (*tmp != '\'')) tmp++; 10601 if (tmp < ctxt->input->end) tmp++; 10602 } else if (*tmp == '"') { 10603 tmp++; 10604 while ((tmp < ctxt->input->end) && (*tmp != '"')) tmp++; 10605 if (tmp < ctxt->input->end) tmp++; 10606 } else 10607 tmp++; 10608 } 10609 if (tmp < ctxt->input->end) 10610 *lastgt = tmp; 10611 else { 10612 tmp = *lastlt; 10613 tmp--; 10614 while ((tmp >= ctxt->input->base) && (*tmp != '>')) tmp--; 10615 if (tmp >= ctxt->input->base) 10616 *lastgt = tmp; 10617 else 10618 *lastgt = NULL; 10619 } 10620 } 10621 } else { 10622 *lastlt = NULL; 10623 *lastgt = NULL; 10624 } 10625 } 10626 /** 10627 * xmlCheckCdataPush: 10628 * @cur: pointer to the bock of characters 10629 * @len: length of the block in bytes 10630 * 10631 * Check that the block of characters is okay as SCdata content [20] 10632 * 10633 * Returns the number of bytes to pass if okay, a negative index where an 10634 * UTF-8 error occured otherwise 10635 */ 10636 static int 10637 xmlCheckCdataPush(const xmlChar *utf, int len) { 10638 int ix; 10639 unsigned char c; 10640 int codepoint; 10641 10642 if ((utf == NULL) || (len <= 0)) 10643 return(0); 10644 10645 for (ix = 0; ix < len;) { /* string is 0-terminated */ 10646 c = utf[ix]; 10647 if ((c & 0x80) == 0x00) { /* 1-byte code, starts with 10 */ 10648 if (c >= 0x20) 10649 ix++; 10650 else if ((c == 0xA) || (c == 0xD) || (c == 0x9)) 10651 ix++; 10652 else 10653 return(-ix); 10654 } else if ((c & 0xe0) == 0xc0) {/* 2-byte code, starts with 110 */ 10655 if (ix + 2 > len) return(ix); 10656 if ((utf[ix+1] & 0xc0 ) != 0x80) 10657 return(-ix); 10658 codepoint = (utf[ix] & 0x1f) << 6; 10659 codepoint |= utf[ix+1] & 0x3f; 10660 if (!xmlIsCharQ(codepoint)) 10661 return(-ix); 10662 ix += 2; 10663 } else if ((c & 0xf0) == 0xe0) {/* 3-byte code, starts with 1110 */ 10664 if (ix + 3 > len) return(ix); 10665 if (((utf[ix+1] & 0xc0) != 0x80) || 10666 ((utf[ix+2] & 0xc0) != 0x80)) 10667 return(-ix); 10668 codepoint = (utf[ix] & 0xf) << 12; 10669 codepoint |= (utf[ix+1] & 0x3f) << 6; 10670 codepoint |= utf[ix+2] & 0x3f; 10671 if (!xmlIsCharQ(codepoint)) 10672 return(-ix); 10673 ix += 3; 10674 } else if ((c & 0xf8) == 0xf0) {/* 4-byte code, starts with 11110 */ 10675 if (ix + 4 > len) return(ix); 10676 if (((utf[ix+1] & 0xc0) != 0x80) || 10677 ((utf[ix+2] & 0xc0) != 0x80) || 10678 ((utf[ix+3] & 0xc0) != 0x80)) 10679 return(-ix); 10680 codepoint = (utf[ix] & 0x7) << 18; 10681 codepoint |= (utf[ix+1] & 0x3f) << 12; 10682 codepoint |= (utf[ix+2] & 0x3f) << 6; 10683 codepoint |= utf[ix+3] & 0x3f; 10684 if (!xmlIsCharQ(codepoint)) 10685 return(-ix); 10686 ix += 4; 10687 } else /* unknown encoding */ 10688 return(-ix); 10689 } 10690 return(ix); 10691 } 10692 10693 /** 10694 * xmlParseTryOrFinish: 10695 * @ctxt: an XML parser context 10696 * @terminate: last chunk indicator 10697 * 10698 * Try to progress on parsing 10699 * 10700 * Returns zero if no parsing was possible 10701 */ 10702 static int 10703 xmlParseTryOrFinish(xmlParserCtxtPtr ctxt, int terminate) { 10704 int ret = 0; 10705 int avail, tlen; 10706 xmlChar cur, next; 10707 const xmlChar *lastlt, *lastgt; 10708 10709 if (ctxt->input == NULL) 10710 return(0); 10711 10712 #ifdef DEBUG_PUSH 10713 switch (ctxt->instate) { 10714 case XML_PARSER_EOF: 10715 xmlGenericError(xmlGenericErrorContext, 10716 "PP: try EOF\n"); break; 10717 case XML_PARSER_START: 10718 xmlGenericError(xmlGenericErrorContext, 10719 "PP: try START\n"); break; 10720 case XML_PARSER_MISC: 10721 xmlGenericError(xmlGenericErrorContext, 10722 "PP: try MISC\n");break; 10723 case XML_PARSER_COMMENT: 10724 xmlGenericError(xmlGenericErrorContext, 10725 "PP: try COMMENT\n");break; 10726 case XML_PARSER_PROLOG: 10727 xmlGenericError(xmlGenericErrorContext, 10728 "PP: try PROLOG\n");break; 10729 case XML_PARSER_START_TAG: 10730 xmlGenericError(xmlGenericErrorContext, 10731 "PP: try START_TAG\n");break; 10732 case XML_PARSER_CONTENT: 10733 xmlGenericError(xmlGenericErrorContext, 10734 "PP: try CONTENT\n");break; 10735 case XML_PARSER_CDATA_SECTION: 10736 xmlGenericError(xmlGenericErrorContext, 10737 "PP: try CDATA_SECTION\n");break; 10738 case XML_PARSER_END_TAG: 10739 xmlGenericError(xmlGenericErrorContext, 10740 "PP: try END_TAG\n");break; 10741 case XML_PARSER_ENTITY_DECL: 10742 xmlGenericError(xmlGenericErrorContext, 10743 "PP: try ENTITY_DECL\n");break; 10744 case XML_PARSER_ENTITY_VALUE: 10745 xmlGenericError(xmlGenericErrorContext, 10746 "PP: try ENTITY_VALUE\n");break; 10747 case XML_PARSER_ATTRIBUTE_VALUE: 10748 xmlGenericError(xmlGenericErrorContext, 10749 "PP: try ATTRIBUTE_VALUE\n");break; 10750 case XML_PARSER_DTD: 10751 xmlGenericError(xmlGenericErrorContext, 10752 "PP: try DTD\n");break; 10753 case XML_PARSER_EPILOG: 10754 xmlGenericError(xmlGenericErrorContext, 10755 "PP: try EPILOG\n");break; 10756 case XML_PARSER_PI: 10757 xmlGenericError(xmlGenericErrorContext, 10758 "PP: try PI\n");break; 10759 case XML_PARSER_IGNORE: 10760 xmlGenericError(xmlGenericErrorContext, 10761 "PP: try IGNORE\n");break; 10762 } 10763 #endif 10764 10765 if ((ctxt->input != NULL) && 10766 (ctxt->input->cur - ctxt->input->base > 4096)) { 10767 xmlSHRINK(ctxt); 10768 ctxt->checkIndex = 0; 10769 } 10770 xmlParseGetLasts(ctxt, &lastlt, &lastgt); 10771 10772 while (ctxt->instate != XML_PARSER_EOF) { 10773 if ((ctxt->errNo != XML_ERR_OK) && (ctxt->disableSAX == 1)) 10774 return(0); 10775 10776 10777 /* 10778 * Pop-up of finished entities. 10779 */ 10780 while ((RAW == 0) && (ctxt->inputNr > 1)) 10781 xmlPopInput(ctxt); 10782 10783 if (ctxt->input == NULL) break; 10784 if (ctxt->input->buf == NULL) 10785 avail = ctxt->input->length - 10786 (ctxt->input->cur - ctxt->input->base); 10787 else { 10788 /* 10789 * If we are operating on converted input, try to flush 10790 * remainng chars to avoid them stalling in the non-converted 10791 * buffer. 10792 */ 10793 if ((ctxt->input->buf->raw != NULL) && 10794 (ctxt->input->buf->raw->use > 0)) { 10795 int base = ctxt->input->base - 10796 ctxt->input->buf->buffer->content; 10797 int current = ctxt->input->cur - ctxt->input->base; 10798 10799 xmlParserInputBufferPush(ctxt->input->buf, 0, ""); 10800 ctxt->input->base = ctxt->input->buf->buffer->content + base; 10801 ctxt->input->cur = ctxt->input->base + current; 10802 ctxt->input->end = 10803 &ctxt->input->buf->buffer->content[ 10804 ctxt->input->buf->buffer->use]; 10805 } 10806 avail = ctxt->input->buf->buffer->use - 10807 (ctxt->input->cur - ctxt->input->base); 10808 } 10809 if (avail < 1) 10810 goto done; 10811 switch (ctxt->instate) { 10812 case XML_PARSER_EOF: 10813 /* 10814 * Document parsing is done ! 10815 */ 10816 goto done; 10817 case XML_PARSER_START: 10818 if (ctxt->charset == XML_CHAR_ENCODING_NONE) { 10819 xmlChar start[4]; 10820 xmlCharEncoding enc; 10821 10822 /* 10823 * Very first chars read from the document flow. 10824 */ 10825 if (avail < 4) 10826 goto done; 10827 10828 /* 10829 * Get the 4 first bytes and decode the charset 10830 * if enc != XML_CHAR_ENCODING_NONE 10831 * plug some encoding conversion routines, 10832 * else xmlSwitchEncoding will set to (default) 10833 * UTF8. 10834 */ 10835 start[0] = RAW; 10836 start[1] = NXT(1); 10837 start[2] = NXT(2); 10838 start[3] = NXT(3); 10839 enc = xmlDetectCharEncoding(start, 4); 10840 xmlSwitchEncoding(ctxt, enc); 10841 break; 10842 } 10843 10844 if (avail < 2) 10845 goto done; 10846 cur = ctxt->input->cur[0]; 10847 next = ctxt->input->cur[1]; 10848 if (cur == 0) { 10849 if ((ctxt->sax) && (ctxt->sax->setDocumentLocator)) 10850 ctxt->sax->setDocumentLocator(ctxt->userData, 10851 &xmlDefaultSAXLocator); 10852 xmlFatalErr(ctxt, XML_ERR_DOCUMENT_EMPTY, NULL); 10853 ctxt->instate = XML_PARSER_EOF; 10854 #ifdef DEBUG_PUSH 10855 xmlGenericError(xmlGenericErrorContext, 10856 "PP: entering EOF\n"); 10857 #endif 10858 if ((ctxt->sax) && (ctxt->sax->endDocument != NULL)) 10859 ctxt->sax->endDocument(ctxt->userData); 10860 goto done; 10861 } 10862 if ((cur == '<') && (next == '?')) { 10863 /* PI or XML decl */ 10864 if (avail < 5) return(ret); 10865 if ((!terminate) && 10866 (xmlParseLookupSequence(ctxt, '?', '>', 0) < 0)) 10867 return(ret); 10868 if ((ctxt->sax) && (ctxt->sax->setDocumentLocator)) 10869 ctxt->sax->setDocumentLocator(ctxt->userData, 10870 &xmlDefaultSAXLocator); 10871 if ((ctxt->input->cur[2] == 'x') && 10872 (ctxt->input->cur[3] == 'm') && 10873 (ctxt->input->cur[4] == 'l') && 10874 (IS_BLANK_CH(ctxt->input->cur[5]))) { 10875 ret += 5; 10876 #ifdef DEBUG_PUSH 10877 xmlGenericError(xmlGenericErrorContext, 10878 "PP: Parsing XML Decl\n"); 10879 #endif 10880 xmlParseXMLDecl(ctxt); 10881 if (ctxt->errNo == XML_ERR_UNSUPPORTED_ENCODING) { 10882 /* 10883 * The XML REC instructs us to stop parsing right 10884 * here 10885 */ 10886 ctxt->instate = XML_PARSER_EOF; 10887 return(0); 10888 } 10889 ctxt->standalone = ctxt->input->standalone; 10890 if ((ctxt->encoding == NULL) && 10891 (ctxt->input->encoding != NULL)) 10892 ctxt->encoding = xmlStrdup(ctxt->input->encoding); 10893 if ((ctxt->sax) && (ctxt->sax->startDocument) && 10894 (!ctxt->disableSAX)) 10895 ctxt->sax->startDocument(ctxt->userData); 10896 ctxt->instate = XML_PARSER_MISC; 10897 #ifdef DEBUG_PUSH 10898 xmlGenericError(xmlGenericErrorContext, 10899 "PP: entering MISC\n"); 10900 #endif 10901 } else { 10902 ctxt->version = xmlCharStrdup(XML_DEFAULT_VERSION); 10903 if ((ctxt->sax) && (ctxt->sax->startDocument) && 10904 (!ctxt->disableSAX)) 10905 ctxt->sax->startDocument(ctxt->userData); 10906 ctxt->instate = XML_PARSER_MISC; 10907 #ifdef DEBUG_PUSH 10908 xmlGenericError(xmlGenericErrorContext, 10909 "PP: entering MISC\n"); 10910 #endif 10911 } 10912 } else { 10913 if ((ctxt->sax) && (ctxt->sax->setDocumentLocator)) 10914 ctxt->sax->setDocumentLocator(ctxt->userData, 10915 &xmlDefaultSAXLocator); 10916 ctxt->version = xmlCharStrdup(XML_DEFAULT_VERSION); 10917 if (ctxt->version == NULL) { 10918 xmlErrMemory(ctxt, NULL); 10919 break; 10920 } 10921 if ((ctxt->sax) && (ctxt->sax->startDocument) && 10922 (!ctxt->disableSAX)) 10923 ctxt->sax->startDocument(ctxt->userData); 10924 ctxt->instate = XML_PARSER_MISC; 10925 #ifdef DEBUG_PUSH 10926 xmlGenericError(xmlGenericErrorContext, 10927 "PP: entering MISC\n"); 10928 #endif 10929 } 10930 break; 10931 case XML_PARSER_START_TAG: { 10932 const xmlChar *name; 10933 const xmlChar *prefix = NULL; 10934 const xmlChar *URI = NULL; 10935 int nsNr = ctxt->nsNr; 10936 10937 if ((avail < 2) && (ctxt->inputNr == 1)) 10938 goto done; 10939 cur = ctxt->input->cur[0]; 10940 if (cur != '<') { 10941 xmlFatalErr(ctxt, XML_ERR_DOCUMENT_EMPTY, NULL); 10942 ctxt->instate = XML_PARSER_EOF; 10943 if ((ctxt->sax) && (ctxt->sax->endDocument != NULL)) 10944 ctxt->sax->endDocument(ctxt->userData); 10945 goto done; 10946 } 10947 if (!terminate) { 10948 if (ctxt->progressive) { 10949 /* > can be found unescaped in attribute values */ 10950 if ((lastgt == NULL) || (ctxt->input->cur >= lastgt)) 10951 goto done; 10952 } else if (xmlParseLookupSequence(ctxt, '>', 0, 0) < 0) { 10953 goto done; 10954 } 10955 } 10956 if (ctxt->spaceNr == 0) 10957 spacePush(ctxt, -1); 10958 else if (*ctxt->space == -2) 10959 spacePush(ctxt, -1); 10960 else 10961 spacePush(ctxt, *ctxt->space); 10962 #ifdef LIBXML_SAX1_ENABLED 10963 if (ctxt->sax2) 10964 #endif /* LIBXML_SAX1_ENABLED */ 10965 name = xmlParseStartTag2(ctxt, &prefix, &URI, &tlen); 10966 #ifdef LIBXML_SAX1_ENABLED 10967 else 10968 name = xmlParseStartTag(ctxt); 10969 #endif /* LIBXML_SAX1_ENABLED */ 10970 if (ctxt->instate == XML_PARSER_EOF) 10971 goto done; 10972 if (name == NULL) { 10973 spacePop(ctxt); 10974 ctxt->instate = XML_PARSER_EOF; 10975 if ((ctxt->sax) && (ctxt->sax->endDocument != NULL)) 10976 ctxt->sax->endDocument(ctxt->userData); 10977 goto done; 10978 } 10979 #ifdef LIBXML_VALID_ENABLED 10980 /* 10981 * [ VC: Root Element Type ] 10982 * The Name in the document type declaration must match 10983 * the element type of the root element. 10984 */ 10985 if (ctxt->validate && ctxt->wellFormed && ctxt->myDoc && 10986 ctxt->node && (ctxt->node == ctxt->myDoc->children)) 10987 ctxt->valid &= xmlValidateRoot(&ctxt->vctxt, ctxt->myDoc); 10988 #endif /* LIBXML_VALID_ENABLED */ 10989 10990 /* 10991 * Check for an Empty Element. 10992 */ 10993 if ((RAW == '/') && (NXT(1) == '>')) { 10994 SKIP(2); 10995 10996 if (ctxt->sax2) { 10997 if ((ctxt->sax != NULL) && 10998 (ctxt->sax->endElementNs != NULL) && 10999 (!ctxt->disableSAX)) 11000 ctxt->sax->endElementNs(ctxt->userData, name, 11001 prefix, URI); 11002 if (ctxt->nsNr - nsNr > 0) 11003 nsPop(ctxt, ctxt->nsNr - nsNr); 11004 #ifdef LIBXML_SAX1_ENABLED 11005 } else { 11006 if ((ctxt->sax != NULL) && 11007 (ctxt->sax->endElement != NULL) && 11008 (!ctxt->disableSAX)) 11009 ctxt->sax->endElement(ctxt->userData, name); 11010 #endif /* LIBXML_SAX1_ENABLED */ 11011 } 11012 if (ctxt->instate == XML_PARSER_EOF) 11013 goto done; 11014 spacePop(ctxt); 11015 if (ctxt->nameNr == 0) { 11016 ctxt->instate = XML_PARSER_EPILOG; 11017 } else { 11018 ctxt->instate = XML_PARSER_CONTENT; 11019 } 11020 break; 11021 } 11022 if (RAW == '>') { 11023 NEXT; 11024 } else { 11025 xmlFatalErrMsgStr(ctxt, XML_ERR_GT_REQUIRED, 11026 "Couldn't find end of Start Tag %s\n", 11027 name); 11028 nodePop(ctxt); 11029 spacePop(ctxt); 11030 } 11031 if (ctxt->sax2) 11032 nameNsPush(ctxt, name, prefix, URI, ctxt->nsNr - nsNr); 11033 #ifdef LIBXML_SAX1_ENABLED 11034 else 11035 namePush(ctxt, name); 11036 #endif /* LIBXML_SAX1_ENABLED */ 11037 11038 ctxt->instate = XML_PARSER_CONTENT; 11039 break; 11040 } 11041 case XML_PARSER_CONTENT: { 11042 const xmlChar *test; 11043 unsigned int cons; 11044 if ((avail < 2) && (ctxt->inputNr == 1)) 11045 goto done; 11046 cur = ctxt->input->cur[0]; 11047 next = ctxt->input->cur[1]; 11048 11049 test = CUR_PTR; 11050 cons = ctxt->input->consumed; 11051 if ((cur == '<') && (next == '/')) { 11052 ctxt->instate = XML_PARSER_END_TAG; 11053 break; 11054 } else if ((cur == '<') && (next == '?')) { 11055 if ((!terminate) && 11056 (xmlParseLookupSequence(ctxt, '?', '>', 0) < 0)) 11057 goto done; 11058 xmlParsePI(ctxt); 11059 } else if ((cur == '<') && (next != '!')) { 11060 ctxt->instate = XML_PARSER_START_TAG; 11061 break; 11062 } else if ((cur == '<') && (next == '!') && 11063 (ctxt->input->cur[2] == '-') && 11064 (ctxt->input->cur[3] == '-')) { 11065 int term; 11066 11067 if (avail < 4) 11068 goto done; 11069 ctxt->input->cur += 4; 11070 term = xmlParseLookupSequence(ctxt, '-', '-', '>'); 11071 ctxt->input->cur -= 4; 11072 if ((!terminate) && (term < 0)) 11073 goto done; 11074 xmlParseComment(ctxt); 11075 ctxt->instate = XML_PARSER_CONTENT; 11076 } else if ((cur == '<') && (ctxt->input->cur[1] == '!') && 11077 (ctxt->input->cur[2] == '[') && 11078 (ctxt->input->cur[3] == 'C') && 11079 (ctxt->input->cur[4] == 'D') && 11080 (ctxt->input->cur[5] == 'A') && 11081 (ctxt->input->cur[6] == 'T') && 11082 (ctxt->input->cur[7] == 'A') && 11083 (ctxt->input->cur[8] == '[')) { 11084 SKIP(9); 11085 ctxt->instate = XML_PARSER_CDATA_SECTION; 11086 break; 11087 } else if ((cur == '<') && (next == '!') && 11088 (avail < 9)) { 11089 goto done; 11090 } else if (cur == '&') { 11091 if ((!terminate) && 11092 (xmlParseLookupSequence(ctxt, ';', 0, 0) < 0)) 11093 goto done; 11094 xmlParseReference(ctxt); 11095 } else { 11096 /* TODO Avoid the extra copy, handle directly !!! */ 11097 /* 11098 * Goal of the following test is: 11099 * - minimize calls to the SAX 'character' callback 11100 * when they are mergeable 11101 * - handle an problem for isBlank when we only parse 11102 * a sequence of blank chars and the next one is 11103 * not available to check against '<' presence. 11104 * - tries to homogenize the differences in SAX 11105 * callbacks between the push and pull versions 11106 * of the parser. 11107 */ 11108 if ((ctxt->inputNr == 1) && 11109 (avail < XML_PARSER_BIG_BUFFER_SIZE)) { 11110 if (!terminate) { 11111 if (ctxt->progressive) { 11112 if ((lastlt == NULL) || 11113 (ctxt->input->cur > lastlt)) 11114 goto done; 11115 } else if (xmlParseLookupSequence(ctxt, 11116 '<', 0, 0) < 0) { 11117 goto done; 11118 } 11119 } 11120 } 11121 ctxt->checkIndex = 0; 11122 xmlParseCharData(ctxt, 0); 11123 } 11124 /* 11125 * Pop-up of finished entities. 11126 */ 11127 while ((RAW == 0) && (ctxt->inputNr > 1)) 11128 xmlPopInput(ctxt); 11129 if ((cons == ctxt->input->consumed) && (test == CUR_PTR)) { 11130 xmlFatalErr(ctxt, XML_ERR_INTERNAL_ERROR, 11131 "detected an error in element content\n"); 11132 ctxt->instate = XML_PARSER_EOF; 11133 break; 11134 } 11135 break; 11136 } 11137 case XML_PARSER_END_TAG: 11138 if (avail < 2) 11139 goto done; 11140 if (!terminate) { 11141 if (ctxt->progressive) { 11142 /* > can be found unescaped in attribute values */ 11143 if ((lastgt == NULL) || (ctxt->input->cur >= lastgt)) 11144 goto done; 11145 } else if (xmlParseLookupSequence(ctxt, '>', 0, 0) < 0) { 11146 goto done; 11147 } 11148 } 11149 if (ctxt->sax2) { 11150 xmlParseEndTag2(ctxt, 11151 (void *) ctxt->pushTab[ctxt->nameNr * 3 - 3], 11152 (void *) ctxt->pushTab[ctxt->nameNr * 3 - 2], 0, 11153 (int) (long) ctxt->pushTab[ctxt->nameNr * 3 - 1], 0); 11154 nameNsPop(ctxt); 11155 } 11156 #ifdef LIBXML_SAX1_ENABLED 11157 else 11158 xmlParseEndTag1(ctxt, 0); 11159 #endif /* LIBXML_SAX1_ENABLED */ 11160 if (ctxt->instate == XML_PARSER_EOF) { 11161 /* Nothing */ 11162 } else if (ctxt->nameNr == 0) { 11163 ctxt->instate = XML_PARSER_EPILOG; 11164 } else { 11165 ctxt->instate = XML_PARSER_CONTENT; 11166 } 11167 break; 11168 case XML_PARSER_CDATA_SECTION: { 11169 /* 11170 * The Push mode need to have the SAX callback for 11171 * cdataBlock merge back contiguous callbacks. 11172 */ 11173 int base; 11174 11175 base = xmlParseLookupSequence(ctxt, ']', ']', '>'); 11176 if (base < 0) { 11177 if (avail >= XML_PARSER_BIG_BUFFER_SIZE + 2) { 11178 int tmp; 11179 11180 tmp = xmlCheckCdataPush(ctxt->input->cur, 11181 XML_PARSER_BIG_BUFFER_SIZE); 11182 if (tmp < 0) { 11183 tmp = -tmp; 11184 ctxt->input->cur += tmp; 11185 goto encoding_error; 11186 } 11187 if ((ctxt->sax != NULL) && (!ctxt->disableSAX)) { 11188 if (ctxt->sax->cdataBlock != NULL) 11189 ctxt->sax->cdataBlock(ctxt->userData, 11190 ctxt->input->cur, tmp); 11191 else if (ctxt->sax->characters != NULL) 11192 ctxt->sax->characters(ctxt->userData, 11193 ctxt->input->cur, tmp); 11194 } 11195 if (ctxt->instate == XML_PARSER_EOF) 11196 goto done; 11197 SKIPL(tmp); 11198 ctxt->checkIndex = 0; 11199 } 11200 goto done; 11201 } else { 11202 int tmp; 11203 11204 tmp = xmlCheckCdataPush(ctxt->input->cur, base); 11205 if ((tmp < 0) || (tmp != base)) { 11206 tmp = -tmp; 11207 ctxt->input->cur += tmp; 11208 goto encoding_error; 11209 } 11210 if ((ctxt->sax != NULL) && (base == 0) && 11211 (ctxt->sax->cdataBlock != NULL) && 11212 (!ctxt->disableSAX)) { 11213 /* 11214 * Special case to provide identical behaviour 11215 * between pull and push parsers on enpty CDATA 11216 * sections 11217 */ 11218 if ((ctxt->input->cur - ctxt->input->base >= 9) && 11219 (!strncmp((const char *)&ctxt->input->cur[-9], 11220 "<![CDATA[", 9))) 11221 ctxt->sax->cdataBlock(ctxt->userData, 11222 BAD_CAST "", 0); 11223 } else if ((ctxt->sax != NULL) && (base > 0) && 11224 (!ctxt->disableSAX)) { 11225 if (ctxt->sax->cdataBlock != NULL) 11226 ctxt->sax->cdataBlock(ctxt->userData, 11227 ctxt->input->cur, base); 11228 else if (ctxt->sax->characters != NULL) 11229 ctxt->sax->characters(ctxt->userData, 11230 ctxt->input->cur, base); 11231 } 11232 if (ctxt->instate == XML_PARSER_EOF) 11233 goto done; 11234 SKIPL(base + 3); 11235 ctxt->checkIndex = 0; 11236 ctxt->instate = XML_PARSER_CONTENT; 11237 #ifdef DEBUG_PUSH 11238 xmlGenericError(xmlGenericErrorContext, 11239 "PP: entering CONTENT\n"); 11240 #endif 11241 } 11242 break; 11243 } 11244 case XML_PARSER_MISC: 11245 SKIP_BLANKS; 11246 if (ctxt->input->buf == NULL) 11247 avail = ctxt->input->length - 11248 (ctxt->input->cur - ctxt->input->base); 11249 else 11250 avail = ctxt->input->buf->buffer->use - 11251 (ctxt->input->cur - ctxt->input->base); 11252 if (avail < 2) 11253 goto done; 11254 cur = ctxt->input->cur[0]; 11255 next = ctxt->input->cur[1]; 11256 if ((cur == '<') && (next == '?')) { 11257 if ((!terminate) && 11258 (xmlParseLookupSequence(ctxt, '?', '>', 0) < 0)) 11259 goto done; 11260 #ifdef DEBUG_PUSH 11261 xmlGenericError(xmlGenericErrorContext, 11262 "PP: Parsing PI\n"); 11263 #endif 11264 xmlParsePI(ctxt); 11265 if (ctxt->instate == XML_PARSER_EOF) 11266 goto done; 11267 ctxt->checkIndex = 0; 11268 } else if ((cur == '<') && (next == '!') && 11269 (ctxt->input->cur[2] == '-') && 11270 (ctxt->input->cur[3] == '-')) { 11271 if ((!terminate) && 11272 (xmlParseLookupSequence(ctxt, '-', '-', '>') < 0)) 11273 goto done; 11274 #ifdef DEBUG_PUSH 11275 xmlGenericError(xmlGenericErrorContext, 11276 "PP: Parsing Comment\n"); 11277 #endif 11278 xmlParseComment(ctxt); 11279 if (ctxt->instate == XML_PARSER_EOF) 11280 goto done; 11281 ctxt->instate = XML_PARSER_MISC; 11282 ctxt->checkIndex = 0; 11283 } else if ((cur == '<') && (next == '!') && 11284 (ctxt->input->cur[2] == 'D') && 11285 (ctxt->input->cur[3] == 'O') && 11286 (ctxt->input->cur[4] == 'C') && 11287 (ctxt->input->cur[5] == 'T') && 11288 (ctxt->input->cur[6] == 'Y') && 11289 (ctxt->input->cur[7] == 'P') && 11290 (ctxt->input->cur[8] == 'E')) { 11291 if ((!terminate) && 11292 (xmlParseLookupSequence(ctxt, '>', 0, 0) < 0)) 11293 goto done; 11294 #ifdef DEBUG_PUSH 11295 xmlGenericError(xmlGenericErrorContext, 11296 "PP: Parsing internal subset\n"); 11297 #endif 11298 ctxt->inSubset = 1; 11299 xmlParseDocTypeDecl(ctxt); 11300 if (ctxt->instate == XML_PARSER_EOF) 11301 goto done; 11302 if (RAW == '[') { 11303 ctxt->instate = XML_PARSER_DTD; 11304 #ifdef DEBUG_PUSH 11305 xmlGenericError(xmlGenericErrorContext, 11306 "PP: entering DTD\n"); 11307 #endif 11308 } else { 11309 /* 11310 * Create and update the external subset. 11311 */ 11312 ctxt->inSubset = 2; 11313 if ((ctxt->sax != NULL) && (!ctxt->disableSAX) && 11314 (ctxt->sax->externalSubset != NULL)) 11315 ctxt->sax->externalSubset(ctxt->userData, 11316 ctxt->intSubName, ctxt->extSubSystem, 11317 ctxt->extSubURI); 11318 ctxt->inSubset = 0; 11319 xmlCleanSpecialAttr(ctxt); 11320 ctxt->instate = XML_PARSER_PROLOG; 11321 #ifdef DEBUG_PUSH 11322 xmlGenericError(xmlGenericErrorContext, 11323 "PP: entering PROLOG\n"); 11324 #endif 11325 } 11326 } else if ((cur == '<') && (next == '!') && 11327 (avail < 9)) { 11328 goto done; 11329 } else { 11330 ctxt->instate = XML_PARSER_START_TAG; 11331 ctxt->progressive = 1; 11332 xmlParseGetLasts(ctxt, &lastlt, &lastgt); 11333 #ifdef DEBUG_PUSH 11334 xmlGenericError(xmlGenericErrorContext, 11335 "PP: entering START_TAG\n"); 11336 #endif 11337 } 11338 break; 11339 case XML_PARSER_PROLOG: 11340 SKIP_BLANKS; 11341 if (ctxt->input->buf == NULL) 11342 avail = ctxt->input->length - (ctxt->input->cur - ctxt->input->base); 11343 else 11344 avail = ctxt->input->buf->buffer->use - (ctxt->input->cur - ctxt->input->base); 11345 if (avail < 2) 11346 goto done; 11347 cur = ctxt->input->cur[0]; 11348 next = ctxt->input->cur[1]; 11349 if ((cur == '<') && (next == '?')) { 11350 if ((!terminate) && 11351 (xmlParseLookupSequence(ctxt, '?', '>', 0) < 0)) 11352 goto done; 11353 #ifdef DEBUG_PUSH 11354 xmlGenericError(xmlGenericErrorContext, 11355 "PP: Parsing PI\n"); 11356 #endif 11357 xmlParsePI(ctxt); 11358 if (ctxt->instate == XML_PARSER_EOF) 11359 goto done; 11360 } else if ((cur == '<') && (next == '!') && 11361 (ctxt->input->cur[2] == '-') && (ctxt->input->cur[3] == '-')) { 11362 if ((!terminate) && 11363 (xmlParseLookupSequence(ctxt, '-', '-', '>') < 0)) 11364 goto done; 11365 #ifdef DEBUG_PUSH 11366 xmlGenericError(xmlGenericErrorContext, 11367 "PP: Parsing Comment\n"); 11368 #endif 11369 xmlParseComment(ctxt); 11370 if (ctxt->instate == XML_PARSER_EOF) 11371 goto done; 11372 ctxt->instate = XML_PARSER_PROLOG; 11373 } else if ((cur == '<') && (next == '!') && 11374 (avail < 4)) { 11375 goto done; 11376 } else { 11377 ctxt->instate = XML_PARSER_START_TAG; 11378 if (ctxt->progressive == 0) 11379 ctxt->progressive = 1; 11380 xmlParseGetLasts(ctxt, &lastlt, &lastgt); 11381 #ifdef DEBUG_PUSH 11382 xmlGenericError(xmlGenericErrorContext, 11383 "PP: entering START_TAG\n"); 11384 #endif 11385 } 11386 break; 11387 case XML_PARSER_EPILOG: 11388 SKIP_BLANKS; 11389 if (ctxt->input->buf == NULL) 11390 avail = ctxt->input->length - (ctxt->input->cur - ctxt->input->base); 11391 else 11392 avail = ctxt->input->buf->buffer->use - (ctxt->input->cur - ctxt->input->base); 11393 if (avail < 2) 11394 goto done; 11395 cur = ctxt->input->cur[0]; 11396 next = ctxt->input->cur[1]; 11397 if ((cur == '<') && (next == '?')) { 11398 if ((!terminate) && 11399 (xmlParseLookupSequence(ctxt, '?', '>', 0) < 0)) 11400 goto done; 11401 #ifdef DEBUG_PUSH 11402 xmlGenericError(xmlGenericErrorContext, 11403 "PP: Parsing PI\n"); 11404 #endif 11405 xmlParsePI(ctxt); 11406 if (ctxt->instate == XML_PARSER_EOF) 11407 goto done; 11408 ctxt->instate = XML_PARSER_EPILOG; 11409 } else if ((cur == '<') && (next == '!') && 11410 (ctxt->input->cur[2] == '-') && (ctxt->input->cur[3] == '-')) { 11411 if ((!terminate) && 11412 (xmlParseLookupSequence(ctxt, '-', '-', '>') < 0)) 11413 goto done; 11414 #ifdef DEBUG_PUSH 11415 xmlGenericError(xmlGenericErrorContext, 11416 "PP: Parsing Comment\n"); 11417 #endif 11418 xmlParseComment(ctxt); 11419 if (ctxt->instate == XML_PARSER_EOF) 11420 goto done; 11421 ctxt->instate = XML_PARSER_EPILOG; 11422 } else if ((cur == '<') && (next == '!') && 11423 (avail < 4)) { 11424 goto done; 11425 } else { 11426 xmlFatalErr(ctxt, XML_ERR_DOCUMENT_END, NULL); 11427 ctxt->instate = XML_PARSER_EOF; 11428 #ifdef DEBUG_PUSH 11429 xmlGenericError(xmlGenericErrorContext, 11430 "PP: entering EOF\n"); 11431 #endif 11432 if ((ctxt->sax) && (ctxt->sax->endDocument != NULL)) 11433 ctxt->sax->endDocument(ctxt->userData); 11434 goto done; 11435 } 11436 break; 11437 case XML_PARSER_DTD: { 11438 /* 11439 * Sorry but progressive parsing of the internal subset 11440 * is not expected to be supported. We first check that 11441 * the full content of the internal subset is available and 11442 * the parsing is launched only at that point. 11443 * Internal subset ends up with "']' S? '>'" in an unescaped 11444 * section and not in a ']]>' sequence which are conditional 11445 * sections (whoever argued to keep that crap in XML deserve 11446 * a place in hell !). 11447 */ 11448 int base, i; 11449 xmlChar *buf; 11450 xmlChar quote = 0; 11451 11452 base = ctxt->input->cur - ctxt->input->base; 11453 if (base < 0) return(0); 11454 if (ctxt->checkIndex > base) 11455 base = ctxt->checkIndex; 11456 buf = ctxt->input->buf->buffer->content; 11457 for (;(unsigned int) base < ctxt->input->buf->buffer->use; 11458 base++) { 11459 if (quote != 0) { 11460 if (buf[base] == quote) 11461 quote = 0; 11462 continue; 11463 } 11464 if ((quote == 0) && (buf[base] == '<')) { 11465 int found = 0; 11466 /* special handling of comments */ 11467 if (((unsigned int) base + 4 < 11468 ctxt->input->buf->buffer->use) && 11469 (buf[base + 1] == '!') && 11470 (buf[base + 2] == '-') && 11471 (buf[base + 3] == '-')) { 11472 for (;(unsigned int) base + 3 < 11473 ctxt->input->buf->buffer->use; base++) { 11474 if ((buf[base] == '-') && 11475 (buf[base + 1] == '-') && 11476 (buf[base + 2] == '>')) { 11477 found = 1; 11478 base += 2; 11479 break; 11480 } 11481 } 11482 if (!found) { 11483 #if 0 11484 fprintf(stderr, "unfinished comment\n"); 11485 #endif 11486 break; /* for */ 11487 } 11488 continue; 11489 } 11490 } 11491 if (buf[base] == '"') { 11492 quote = '"'; 11493 continue; 11494 } 11495 if (buf[base] == '\'') { 11496 quote = '\''; 11497 continue; 11498 } 11499 if (buf[base] == ']') { 11500 #if 0 11501 fprintf(stderr, "%c%c%c%c: ", buf[base], 11502 buf[base + 1], buf[base + 2], buf[base + 3]); 11503 #endif 11504 if ((unsigned int) base +1 >= 11505 ctxt->input->buf->buffer->use) 11506 break; 11507 if (buf[base + 1] == ']') { 11508 /* conditional crap, skip both ']' ! */ 11509 base++; 11510 continue; 11511 } 11512 for (i = 1; 11513 (unsigned int) base + i < ctxt->input->buf->buffer->use; 11514 i++) { 11515 if (buf[base + i] == '>') { 11516 #if 0 11517 fprintf(stderr, "found\n"); 11518 #endif 11519 goto found_end_int_subset; 11520 } 11521 if (!IS_BLANK_CH(buf[base + i])) { 11522 #if 0 11523 fprintf(stderr, "not found\n"); 11524 #endif 11525 goto not_end_of_int_subset; 11526 } 11527 } 11528 #if 0 11529 fprintf(stderr, "end of stream\n"); 11530 #endif 11531 break; 11532 11533 } 11534 not_end_of_int_subset: 11535 continue; /* for */ 11536 } 11537 /* 11538 * We didn't found the end of the Internal subset 11539 */ 11540 #ifdef DEBUG_PUSH 11541 if (next == 0) 11542 xmlGenericError(xmlGenericErrorContext, 11543 "PP: lookup of int subset end filed\n"); 11544 #endif 11545 goto done; 11546 11547 found_end_int_subset: 11548 xmlParseInternalSubset(ctxt); 11549 if (ctxt->instate == XML_PARSER_EOF) 11550 goto done; 11551 ctxt->inSubset = 2; 11552 if ((ctxt->sax != NULL) && (!ctxt->disableSAX) && 11553 (ctxt->sax->externalSubset != NULL)) 11554 ctxt->sax->externalSubset(ctxt->userData, ctxt->intSubName, 11555 ctxt->extSubSystem, ctxt->extSubURI); 11556 ctxt->inSubset = 0; 11557 xmlCleanSpecialAttr(ctxt); 11558 if (ctxt->instate == XML_PARSER_EOF) 11559 goto done; 11560 ctxt->instate = XML_PARSER_PROLOG; 11561 ctxt->checkIndex = 0; 11562 #ifdef DEBUG_PUSH 11563 xmlGenericError(xmlGenericErrorContext, 11564 "PP: entering PROLOG\n"); 11565 #endif 11566 break; 11567 } 11568 case XML_PARSER_COMMENT: 11569 xmlGenericError(xmlGenericErrorContext, 11570 "PP: internal error, state == COMMENT\n"); 11571 ctxt->instate = XML_PARSER_CONTENT; 11572 #ifdef DEBUG_PUSH 11573 xmlGenericError(xmlGenericErrorContext, 11574 "PP: entering CONTENT\n"); 11575 #endif 11576 break; 11577 case XML_PARSER_IGNORE: 11578 xmlGenericError(xmlGenericErrorContext, 11579 "PP: internal error, state == IGNORE"); 11580 ctxt->instate = XML_PARSER_DTD; 11581 #ifdef DEBUG_PUSH 11582 xmlGenericError(xmlGenericErrorContext, 11583 "PP: entering DTD\n"); 11584 #endif 11585 break; 11586 case XML_PARSER_PI: 11587 xmlGenericError(xmlGenericErrorContext, 11588 "PP: internal error, state == PI\n"); 11589 ctxt->instate = XML_PARSER_CONTENT; 11590 #ifdef DEBUG_PUSH 11591 xmlGenericError(xmlGenericErrorContext, 11592 "PP: entering CONTENT\n"); 11593 #endif 11594 break; 11595 case XML_PARSER_ENTITY_DECL: 11596 xmlGenericError(xmlGenericErrorContext, 11597 "PP: internal error, state == ENTITY_DECL\n"); 11598 ctxt->instate = XML_PARSER_DTD; 11599 #ifdef DEBUG_PUSH 11600 xmlGenericError(xmlGenericErrorContext, 11601 "PP: entering DTD\n"); 11602 #endif 11603 break; 11604 case XML_PARSER_ENTITY_VALUE: 11605 xmlGenericError(xmlGenericErrorContext, 11606 "PP: internal error, state == ENTITY_VALUE\n"); 11607 ctxt->instate = XML_PARSER_CONTENT; 11608 #ifdef DEBUG_PUSH 11609 xmlGenericError(xmlGenericErrorContext, 11610 "PP: entering DTD\n"); 11611 #endif 11612 break; 11613 case XML_PARSER_ATTRIBUTE_VALUE: 11614 xmlGenericError(xmlGenericErrorContext, 11615 "PP: internal error, state == ATTRIBUTE_VALUE\n"); 11616 ctxt->instate = XML_PARSER_START_TAG; 11617 #ifdef DEBUG_PUSH 11618 xmlGenericError(xmlGenericErrorContext, 11619 "PP: entering START_TAG\n"); 11620 #endif 11621 break; 11622 case XML_PARSER_SYSTEM_LITERAL: 11623 xmlGenericError(xmlGenericErrorContext, 11624 "PP: internal error, state == SYSTEM_LITERAL\n"); 11625 ctxt->instate = XML_PARSER_START_TAG; 11626 #ifdef DEBUG_PUSH 11627 xmlGenericError(xmlGenericErrorContext, 11628 "PP: entering START_TAG\n"); 11629 #endif 11630 break; 11631 case XML_PARSER_PUBLIC_LITERAL: 11632 xmlGenericError(xmlGenericErrorContext, 11633 "PP: internal error, state == PUBLIC_LITERAL\n"); 11634 ctxt->instate = XML_PARSER_START_TAG; 11635 #ifdef DEBUG_PUSH 11636 xmlGenericError(xmlGenericErrorContext, 11637 "PP: entering START_TAG\n"); 11638 #endif 11639 break; 11640 } 11641 } 11642 done: 11643 #ifdef DEBUG_PUSH 11644 xmlGenericError(xmlGenericErrorContext, "PP: done %d\n", ret); 11645 #endif 11646 return(ret); 11647 encoding_error: 11648 { 11649 char buffer[150]; 11650 11651 snprintf(buffer, 149, "Bytes: 0x%02X 0x%02X 0x%02X 0x%02X\n", 11652 ctxt->input->cur[0], ctxt->input->cur[1], 11653 ctxt->input->cur[2], ctxt->input->cur[3]); 11654 __xmlErrEncoding(ctxt, XML_ERR_INVALID_CHAR, 11655 "Input is not proper UTF-8, indicate encoding !\n%s", 11656 BAD_CAST buffer, NULL); 11657 } 11658 return(0); 11659 } 11660 11661 /** 11662 * xmlParseChunk: 11663 * @ctxt: an XML parser context 11664 * @chunk: an char array 11665 * @size: the size in byte of the chunk 11666 * @terminate: last chunk indicator 11667 * 11668 * Parse a Chunk of memory 11669 * 11670 * Returns zero if no error, the xmlParserErrors otherwise. 11671 */ 11672 int 11673 xmlParseChunk(xmlParserCtxtPtr ctxt, const char *chunk, int size, 11674 int terminate) { 11675 int end_in_lf = 0; 11676 int remain = 0; 11677 11678 if (ctxt == NULL) 11679 return(XML_ERR_INTERNAL_ERROR); 11680 if ((ctxt->errNo != XML_ERR_OK) && (ctxt->disableSAX == 1)) 11681 return(ctxt->errNo); 11682 if (ctxt->instate == XML_PARSER_EOF) 11683 return(-1); 11684 if (ctxt->instate == XML_PARSER_START) 11685 xmlDetectSAX2(ctxt); 11686 if ((size > 0) && (chunk != NULL) && (!terminate) && 11687 (chunk[size - 1] == '\r')) { 11688 end_in_lf = 1; 11689 size--; 11690 } 11691 11692 xmldecl_done: 11693 11694 if ((size > 0) && (chunk != NULL) && (ctxt->input != NULL) && 11695 (ctxt->input->buf != NULL) && (ctxt->instate != XML_PARSER_EOF)) { 11696 int base = ctxt->input->base - ctxt->input->buf->buffer->content; 11697 int cur = ctxt->input->cur - ctxt->input->base; 11698 int res; 11699 11700 /* 11701 * Specific handling if we autodetected an encoding, we should not 11702 * push more than the first line ... which depend on the encoding 11703 * And only push the rest once the final encoding was detected 11704 */ 11705 if ((ctxt->instate == XML_PARSER_START) && (ctxt->input != NULL) && 11706 (ctxt->input->buf != NULL) && (ctxt->input->buf->encoder != NULL)) { 11707 unsigned int len = 45; 11708 11709 if ((xmlStrcasestr(BAD_CAST ctxt->input->buf->encoder->name, 11710 BAD_CAST "UTF-16")) || 11711 (xmlStrcasestr(BAD_CAST ctxt->input->buf->encoder->name, 11712 BAD_CAST "UTF16"))) 11713 len = 90; 11714 else if ((xmlStrcasestr(BAD_CAST ctxt->input->buf->encoder->name, 11715 BAD_CAST "UCS-4")) || 11716 (xmlStrcasestr(BAD_CAST ctxt->input->buf->encoder->name, 11717 BAD_CAST "UCS4"))) 11718 len = 180; 11719 11720 if (ctxt->input->buf->rawconsumed < len) 11721 len -= ctxt->input->buf->rawconsumed; 11722 11723 /* 11724 * Change size for reading the initial declaration only 11725 * if size is greater than len. Otherwise, memmove in xmlBufferAdd 11726 * will blindly copy extra bytes from memory. 11727 */ 11728 if (size > len) { 11729 remain = size - len; 11730 size = len; 11731 } else { 11732 remain = 0; 11733 } 11734 } 11735 res =xmlParserInputBufferPush(ctxt->input->buf, size, chunk); 11736 if (res < 0) { 11737 ctxt->errNo = XML_PARSER_EOF; 11738 ctxt->disableSAX = 1; 11739 return (XML_PARSER_EOF); 11740 } 11741 ctxt->input->base = ctxt->input->buf->buffer->content + base; 11742 ctxt->input->cur = ctxt->input->base + cur; 11743 ctxt->input->end = 11744 &ctxt->input->buf->buffer->content[ctxt->input->buf->buffer->use]; 11745 #ifdef DEBUG_PUSH 11746 xmlGenericError(xmlGenericErrorContext, "PP: pushed %d\n", size); 11747 #endif 11748 11749 } else if (ctxt->instate != XML_PARSER_EOF) { 11750 if ((ctxt->input != NULL) && ctxt->input->buf != NULL) { 11751 xmlParserInputBufferPtr in = ctxt->input->buf; 11752 if ((in->encoder != NULL) && (in->buffer != NULL) && 11753 (in->raw != NULL)) { 11754 int nbchars; 11755 11756 nbchars = xmlCharEncInFunc(in->encoder, in->buffer, in->raw); 11757 if (nbchars < 0) { 11758 /* TODO 2.6.0 */ 11759 xmlGenericError(xmlGenericErrorContext, 11760 "xmlParseChunk: encoder error\n"); 11761 return(XML_ERR_INVALID_ENCODING); 11762 } 11763 } 11764 } 11765 } 11766 if (remain != 0) 11767 xmlParseTryOrFinish(ctxt, 0); 11768 else 11769 xmlParseTryOrFinish(ctxt, terminate); 11770 if (ctxt->instate == XML_PARSER_EOF) 11771 return(ctxt->errNo); 11772 if ((ctxt->errNo != XML_ERR_OK) && (ctxt->disableSAX == 1)) 11773 return(ctxt->errNo); 11774 11775 if (remain != 0) { 11776 chunk += size; 11777 size = remain; 11778 remain = 0; 11779 goto xmldecl_done; 11780 } 11781 if ((end_in_lf == 1) && (ctxt->input != NULL) && 11782 (ctxt->input->buf != NULL)) { 11783 xmlParserInputBufferPush(ctxt->input->buf, 1, "\r"); 11784 } 11785 if (terminate) { 11786 /* 11787 * Check for termination 11788 */ 11789 int avail = 0; 11790 11791 if (ctxt->input != NULL) { 11792 if (ctxt->input->buf == NULL) 11793 avail = ctxt->input->length - 11794 (ctxt->input->cur - ctxt->input->base); 11795 else 11796 avail = ctxt->input->buf->buffer->use - 11797 (ctxt->input->cur - ctxt->input->base); 11798 } 11799 11800 if ((ctxt->instate != XML_PARSER_EOF) && 11801 (ctxt->instate != XML_PARSER_EPILOG)) { 11802 xmlFatalErr(ctxt, XML_ERR_DOCUMENT_END, NULL); 11803 } 11804 if ((ctxt->instate == XML_PARSER_EPILOG) && (avail > 0)) { 11805 xmlFatalErr(ctxt, XML_ERR_DOCUMENT_END, NULL); 11806 } 11807 if (ctxt->instate != XML_PARSER_EOF) { 11808 if ((ctxt->sax) && (ctxt->sax->endDocument != NULL)) 11809 ctxt->sax->endDocument(ctxt->userData); 11810 } 11811 ctxt->instate = XML_PARSER_EOF; 11812 } 11813 return((xmlParserErrors) ctxt->errNo); 11814 } 11815 11816 /************************************************************************ 11817 * * 11818 * I/O front end functions to the parser * 11819 * * 11820 ************************************************************************/ 11821 11822 /** 11823 * xmlCreatePushParserCtxt: 11824 * @sax: a SAX handler 11825 * @user_data: The user data returned on SAX callbacks 11826 * @chunk: a pointer to an array of chars 11827 * @size: number of chars in the array 11828 * @filename: an optional file name or URI 11829 * 11830 * Create a parser context for using the XML parser in push mode. 11831 * If @buffer and @size are non-NULL, the data is used to detect 11832 * the encoding. The remaining characters will be parsed so they 11833 * don't need to be fed in again through xmlParseChunk. 11834 * To allow content encoding detection, @size should be >= 4 11835 * The value of @filename is used for fetching external entities 11836 * and error/warning reports. 11837 * 11838 * Returns the new parser context or NULL 11839 */ 11840 11841 xmlParserCtxtPtr 11842 xmlCreatePushParserCtxt(xmlSAXHandlerPtr sax, void *user_data, 11843 const char *chunk, int size, const char *filename) { 11844 xmlParserCtxtPtr ctxt; 11845 xmlParserInputPtr inputStream; 11846 xmlParserInputBufferPtr buf; 11847 xmlCharEncoding enc = XML_CHAR_ENCODING_NONE; 11848 11849 /* 11850 * plug some encoding conversion routines 11851 */ 11852 if ((chunk != NULL) && (size >= 4)) 11853 enc = xmlDetectCharEncoding((const xmlChar *) chunk, size); 11854 11855 buf = xmlAllocParserInputBuffer(enc); 11856 if (buf == NULL) return(NULL); 11857 11858 ctxt = xmlNewParserCtxt(); 11859 if (ctxt == NULL) { 11860 xmlErrMemory(NULL, "creating parser: out of memory\n"); 11861 xmlFreeParserInputBuffer(buf); 11862 return(NULL); 11863 } 11864 ctxt->dictNames = 1; 11865 ctxt->pushTab = (void **) xmlMalloc(ctxt->nameMax * 3 * sizeof(xmlChar *)); 11866 if (ctxt->pushTab == NULL) { 11867 xmlErrMemory(ctxt, NULL); 11868 xmlFreeParserInputBuffer(buf); 11869 xmlFreeParserCtxt(ctxt); 11870 return(NULL); 11871 } 11872 if (sax != NULL) { 11873 #ifdef LIBXML_SAX1_ENABLED 11874 if (ctxt->sax != (xmlSAXHandlerPtr) &xmlDefaultSAXHandler) 11875 #endif /* LIBXML_SAX1_ENABLED */ 11876 xmlFree(ctxt->sax); 11877 ctxt->sax = (xmlSAXHandlerPtr) xmlMalloc(sizeof(xmlSAXHandler)); 11878 if (ctxt->sax == NULL) { 11879 xmlErrMemory(ctxt, NULL); 11880 xmlFreeParserInputBuffer(buf); 11881 xmlFreeParserCtxt(ctxt); 11882 return(NULL); 11883 } 11884 memset(ctxt->sax, 0, sizeof(xmlSAXHandler)); 11885 if (sax->initialized == XML_SAX2_MAGIC) 11886 memcpy(ctxt->sax, sax, sizeof(xmlSAXHandler)); 11887 else 11888 memcpy(ctxt->sax, sax, sizeof(xmlSAXHandlerV1)); 11889 if (user_data != NULL) 11890 ctxt->userData = user_data; 11891 } 11892 if (filename == NULL) { 11893 ctxt->directory = NULL; 11894 } else { 11895 ctxt->directory = xmlParserGetDirectory(filename); 11896 } 11897 11898 inputStream = xmlNewInputStream(ctxt); 11899 if (inputStream == NULL) { 11900 xmlFreeParserCtxt(ctxt); 11901 xmlFreeParserInputBuffer(buf); 11902 return(NULL); 11903 } 11904 11905 if (filename == NULL) 11906 inputStream->filename = NULL; 11907 else { 11908 inputStream->filename = (char *) 11909 xmlCanonicPath((const xmlChar *) filename); 11910 if (inputStream->filename == NULL) { 11911 xmlFreeParserCtxt(ctxt); 11912 xmlFreeParserInputBuffer(buf); 11913 return(NULL); 11914 } 11915 } 11916 inputStream->buf = buf; 11917 inputStream->base = inputStream->buf->buffer->content; 11918 inputStream->cur = inputStream->buf->buffer->content; 11919 inputStream->end = 11920 &inputStream->buf->buffer->content[inputStream->buf->buffer->use]; 11921 11922 inputPush(ctxt, inputStream); 11923 11924 /* 11925 * If the caller didn't provide an initial 'chunk' for determining 11926 * the encoding, we set the context to XML_CHAR_ENCODING_NONE so 11927 * that it can be automatically determined later 11928 */ 11929 if ((size == 0) || (chunk == NULL)) { 11930 ctxt->charset = XML_CHAR_ENCODING_NONE; 11931 } else if ((ctxt->input != NULL) && (ctxt->input->buf != NULL)) { 11932 int base = ctxt->input->base - ctxt->input->buf->buffer->content; 11933 int cur = ctxt->input->cur - ctxt->input->base; 11934 11935 xmlParserInputBufferPush(ctxt->input->buf, size, chunk); 11936 11937 ctxt->input->base = ctxt->input->buf->buffer->content + base; 11938 ctxt->input->cur = ctxt->input->base + cur; 11939 ctxt->input->end = 11940 &ctxt->input->buf->buffer->content[ctxt->input->buf->buffer->use]; 11941 #ifdef DEBUG_PUSH 11942 xmlGenericError(xmlGenericErrorContext, "PP: pushed %d\n", size); 11943 #endif 11944 } 11945 11946 if (enc != XML_CHAR_ENCODING_NONE) { 11947 xmlSwitchEncoding(ctxt, enc); 11948 } 11949 11950 return(ctxt); 11951 } 11952 #endif /* LIBXML_PUSH_ENABLED */ 11953 11954 /** 11955 * xmlStopParser: 11956 * @ctxt: an XML parser context 11957 * 11958 * Blocks further parser processing 11959 */ 11960 void 11961 xmlStopParser(xmlParserCtxtPtr ctxt) { 11962 if (ctxt == NULL) 11963 return; 11964 ctxt->instate = XML_PARSER_EOF; 11965 ctxt->errNo = XML_ERR_USER_STOP; 11966 ctxt->disableSAX = 1; 11967 if (ctxt->input != NULL) { 11968 ctxt->input->cur = BAD_CAST""; 11969 ctxt->input->base = ctxt->input->cur; 11970 } 11971 } 11972 11973 /** 11974 * xmlCreateIOParserCtxt: 11975 * @sax: a SAX handler 11976 * @user_data: The user data returned on SAX callbacks 11977 * @ioread: an I/O read function 11978 * @ioclose: an I/O close function 11979 * @ioctx: an I/O handler 11980 * @enc: the charset encoding if known 11981 * 11982 * Create a parser context for using the XML parser with an existing 11983 * I/O stream 11984 * 11985 * Returns the new parser context or NULL 11986 */ 11987 xmlParserCtxtPtr 11988 xmlCreateIOParserCtxt(xmlSAXHandlerPtr sax, void *user_data, 11989 xmlInputReadCallback ioread, xmlInputCloseCallback ioclose, 11990 void *ioctx, xmlCharEncoding enc) { 11991 xmlParserCtxtPtr ctxt; 11992 xmlParserInputPtr inputStream; 11993 xmlParserInputBufferPtr buf; 11994 11995 if (ioread == NULL) return(NULL); 11996 11997 buf = xmlParserInputBufferCreateIO(ioread, ioclose, ioctx, enc); 11998 if (buf == NULL) return(NULL); 11999 12000 ctxt = xmlNewParserCtxt(); 12001 if (ctxt == NULL) { 12002 xmlFreeParserInputBuffer(buf); 12003 return(NULL); 12004 } 12005 if (sax != NULL) { 12006 #ifdef LIBXML_SAX1_ENABLED 12007 if (ctxt->sax != (xmlSAXHandlerPtr) &xmlDefaultSAXHandler) 12008 #endif /* LIBXML_SAX1_ENABLED */ 12009 xmlFree(ctxt->sax); 12010 ctxt->sax = (xmlSAXHandlerPtr) xmlMalloc(sizeof(xmlSAXHandler)); 12011 if (ctxt->sax == NULL) { 12012 xmlErrMemory(ctxt, NULL); 12013 xmlFreeParserCtxt(ctxt); 12014 return(NULL); 12015 } 12016 memset(ctxt->sax, 0, sizeof(xmlSAXHandler)); 12017 if (sax->initialized == XML_SAX2_MAGIC) 12018 memcpy(ctxt->sax, sax, sizeof(xmlSAXHandler)); 12019 else 12020 memcpy(ctxt->sax, sax, sizeof(xmlSAXHandlerV1)); 12021 if (user_data != NULL) 12022 ctxt->userData = user_data; 12023 } 12024 12025 inputStream = xmlNewIOInputStream(ctxt, buf, enc); 12026 if (inputStream == NULL) { 12027 xmlFreeParserCtxt(ctxt); 12028 return(NULL); 12029 } 12030 inputPush(ctxt, inputStream); 12031 12032 return(ctxt); 12033 } 12034 12035 #ifdef LIBXML_VALID_ENABLED 12036 /************************************************************************ 12037 * * 12038 * Front ends when parsing a DTD * 12039 * * 12040 ************************************************************************/ 12041 12042 /** 12043 * xmlIOParseDTD: 12044 * @sax: the SAX handler block or NULL 12045 * @input: an Input Buffer 12046 * @enc: the charset encoding if known 12047 * 12048 * Load and parse a DTD 12049 * 12050 * Returns the resulting xmlDtdPtr or NULL in case of error. 12051 * @input will be freed by the function in any case. 12052 */ 12053 12054 xmlDtdPtr 12055 xmlIOParseDTD(xmlSAXHandlerPtr sax, xmlParserInputBufferPtr input, 12056 xmlCharEncoding enc) { 12057 xmlDtdPtr ret = NULL; 12058 xmlParserCtxtPtr ctxt; 12059 xmlParserInputPtr pinput = NULL; 12060 xmlChar start[4]; 12061 12062 if (input == NULL) 12063 return(NULL); 12064 12065 ctxt = xmlNewParserCtxt(); 12066 if (ctxt == NULL) { 12067 xmlFreeParserInputBuffer(input); 12068 return(NULL); 12069 } 12070 12071 /* 12072 * Set-up the SAX context 12073 */ 12074 if (sax != NULL) { 12075 if (ctxt->sax != NULL) 12076 xmlFree(ctxt->sax); 12077 ctxt->sax = sax; 12078 ctxt->userData = ctxt; 12079 } 12080 xmlDetectSAX2(ctxt); 12081 12082 /* 12083 * generate a parser input from the I/O handler 12084 */ 12085 12086 pinput = xmlNewIOInputStream(ctxt, input, XML_CHAR_ENCODING_NONE); 12087 if (pinput == NULL) { 12088 if (sax != NULL) ctxt->sax = NULL; 12089 xmlFreeParserInputBuffer(input); 12090 xmlFreeParserCtxt(ctxt); 12091 return(NULL); 12092 } 12093 12094 /* 12095 * plug some encoding conversion routines here. 12096 */ 12097 if (xmlPushInput(ctxt, pinput) < 0) { 12098 if (sax != NULL) ctxt->sax = NULL; 12099 xmlFreeParserCtxt(ctxt); 12100 return(NULL); 12101 } 12102 if (enc != XML_CHAR_ENCODING_NONE) { 12103 xmlSwitchEncoding(ctxt, enc); 12104 } 12105 12106 pinput->filename = NULL; 12107 pinput->line = 1; 12108 pinput->col = 1; 12109 pinput->base = ctxt->input->cur; 12110 pinput->cur = ctxt->input->cur; 12111 pinput->free = NULL; 12112 12113 /* 12114 * let's parse that entity knowing it's an external subset. 12115 */ 12116 ctxt->inSubset = 2; 12117 ctxt->myDoc = xmlNewDoc(BAD_CAST "1.0"); 12118 if (ctxt->myDoc == NULL) { 12119 xmlErrMemory(ctxt, "New Doc failed"); 12120 return(NULL); 12121 } 12122 ctxt->myDoc->properties = XML_DOC_INTERNAL; 12123 ctxt->myDoc->extSubset = xmlNewDtd(ctxt->myDoc, BAD_CAST "none", 12124 BAD_CAST "none", BAD_CAST "none"); 12125 12126 if ((enc == XML_CHAR_ENCODING_NONE) && 12127 ((ctxt->input->end - ctxt->input->cur) >= 4)) { 12128 /* 12129 * Get the 4 first bytes and decode the charset 12130 * if enc != XML_CHAR_ENCODING_NONE 12131 * plug some encoding conversion routines. 12132 */ 12133 start[0] = RAW; 12134 start[1] = NXT(1); 12135 start[2] = NXT(2); 12136 start[3] = NXT(3); 12137 enc = xmlDetectCharEncoding(start, 4); 12138 if (enc != XML_CHAR_ENCODING_NONE) { 12139 xmlSwitchEncoding(ctxt, enc); 12140 } 12141 } 12142 12143 xmlParseExternalSubset(ctxt, BAD_CAST "none", BAD_CAST "none"); 12144 12145 if (ctxt->myDoc != NULL) { 12146 if (ctxt->wellFormed) { 12147 ret = ctxt->myDoc->extSubset; 12148 ctxt->myDoc->extSubset = NULL; 12149 if (ret != NULL) { 12150 xmlNodePtr tmp; 12151 12152 ret->doc = NULL; 12153 tmp = ret->children; 12154 while (tmp != NULL) { 12155 tmp->doc = NULL; 12156 tmp = tmp->next; 12157 } 12158 } 12159 } else { 12160 ret = NULL; 12161 } 12162 xmlFreeDoc(ctxt->myDoc); 12163 ctxt->myDoc = NULL; 12164 } 12165 if (sax != NULL) ctxt->sax = NULL; 12166 xmlFreeParserCtxt(ctxt); 12167 12168 return(ret); 12169 } 12170 12171 /** 12172 * xmlSAXParseDTD: 12173 * @sax: the SAX handler block 12174 * @ExternalID: a NAME* containing the External ID of the DTD 12175 * @SystemID: a NAME* containing the URL to the DTD 12176 * 12177 * Load and parse an external subset. 12178 * 12179 * Returns the resulting xmlDtdPtr or NULL in case of error. 12180 */ 12181 12182 xmlDtdPtr 12183 xmlSAXParseDTD(xmlSAXHandlerPtr sax, const xmlChar *ExternalID, 12184 const xmlChar *SystemID) { 12185 xmlDtdPtr ret = NULL; 12186 xmlParserCtxtPtr ctxt; 12187 xmlParserInputPtr input = NULL; 12188 xmlCharEncoding enc; 12189 xmlChar* systemIdCanonic; 12190 12191 if ((ExternalID == NULL) && (SystemID == NULL)) return(NULL); 12192 12193 ctxt = xmlNewParserCtxt(); 12194 if (ctxt == NULL) { 12195 return(NULL); 12196 } 12197 12198 /* 12199 * Set-up the SAX context 12200 */ 12201 if (sax != NULL) { 12202 if (ctxt->sax != NULL) 12203 xmlFree(ctxt->sax); 12204 ctxt->sax = sax; 12205 ctxt->userData = ctxt; 12206 } 12207 12208 /* 12209 * Canonicalise the system ID 12210 */ 12211 systemIdCanonic = xmlCanonicPath(SystemID); 12212 if ((SystemID != NULL) && (systemIdCanonic == NULL)) { 12213 xmlFreeParserCtxt(ctxt); 12214 return(NULL); 12215 } 12216 12217 /* 12218 * Ask the Entity resolver to load the damn thing 12219 */ 12220 12221 if ((ctxt->sax != NULL) && (ctxt->sax->resolveEntity != NULL)) 12222 input = ctxt->sax->resolveEntity(ctxt->userData, ExternalID, 12223 systemIdCanonic); 12224 if (input == NULL) { 12225 if (sax != NULL) ctxt->sax = NULL; 12226 xmlFreeParserCtxt(ctxt); 12227 if (systemIdCanonic != NULL) 12228 xmlFree(systemIdCanonic); 12229 return(NULL); 12230 } 12231 12232 /* 12233 * plug some encoding conversion routines here. 12234 */ 12235 if (xmlPushInput(ctxt, input) < 0) { 12236 if (sax != NULL) ctxt->sax = NULL; 12237 xmlFreeParserCtxt(ctxt); 12238 if (systemIdCanonic != NULL) 12239 xmlFree(systemIdCanonic); 12240 return(NULL); 12241 } 12242 if ((ctxt->input->end - ctxt->input->cur) >= 4) { 12243 enc = xmlDetectCharEncoding(ctxt->input->cur, 4); 12244 xmlSwitchEncoding(ctxt, enc); 12245 } 12246 12247 if (input->filename == NULL) 12248 input->filename = (char *) systemIdCanonic; 12249 else 12250 xmlFree(systemIdCanonic); 12251 input->line = 1; 12252 input->col = 1; 12253 input->base = ctxt->input->cur; 12254 input->cur = ctxt->input->cur; 12255 input->free = NULL; 12256 12257 /* 12258 * let's parse that entity knowing it's an external subset. 12259 */ 12260 ctxt->inSubset = 2; 12261 ctxt->myDoc = xmlNewDoc(BAD_CAST "1.0"); 12262 if (ctxt->myDoc == NULL) { 12263 xmlErrMemory(ctxt, "New Doc failed"); 12264 if (sax != NULL) ctxt->sax = NULL; 12265 xmlFreeParserCtxt(ctxt); 12266 return(NULL); 12267 } 12268 ctxt->myDoc->properties = XML_DOC_INTERNAL; 12269 ctxt->myDoc->extSubset = xmlNewDtd(ctxt->myDoc, BAD_CAST "none", 12270 ExternalID, SystemID); 12271 xmlParseExternalSubset(ctxt, ExternalID, SystemID); 12272 12273 if (ctxt->myDoc != NULL) { 12274 if (ctxt->wellFormed) { 12275 ret = ctxt->myDoc->extSubset; 12276 ctxt->myDoc->extSubset = NULL; 12277 if (ret != NULL) { 12278 xmlNodePtr tmp; 12279 12280 ret->doc = NULL; 12281 tmp = ret->children; 12282 while (tmp != NULL) { 12283 tmp->doc = NULL; 12284 tmp = tmp->next; 12285 } 12286 } 12287 } else { 12288 ret = NULL; 12289 } 12290 xmlFreeDoc(ctxt->myDoc); 12291 ctxt->myDoc = NULL; 12292 } 12293 if (sax != NULL) ctxt->sax = NULL; 12294 xmlFreeParserCtxt(ctxt); 12295 12296 return(ret); 12297 } 12298 12299 12300 /** 12301 * xmlParseDTD: 12302 * @ExternalID: a NAME* containing the External ID of the DTD 12303 * @SystemID: a NAME* containing the URL to the DTD 12304 * 12305 * Load and parse an external subset. 12306 * 12307 * Returns the resulting xmlDtdPtr or NULL in case of error. 12308 */ 12309 12310 xmlDtdPtr 12311 xmlParseDTD(const xmlChar *ExternalID, const xmlChar *SystemID) { 12312 return(xmlSAXParseDTD(NULL, ExternalID, SystemID)); 12313 } 12314 #endif /* LIBXML_VALID_ENABLED */ 12315 12316 /************************************************************************ 12317 * * 12318 * Front ends when parsing an Entity * 12319 * * 12320 ************************************************************************/ 12321 12322 /** 12323 * xmlParseCtxtExternalEntity: 12324 * @ctx: the existing parsing context 12325 * @URL: the URL for the entity to load 12326 * @ID: the System ID for the entity to load 12327 * @lst: the return value for the set of parsed nodes 12328 * 12329 * Parse an external general entity within an existing parsing context 12330 * An external general parsed entity is well-formed if it matches the 12331 * production labeled extParsedEnt. 12332 * 12333 * [78] extParsedEnt ::= TextDecl? content 12334 * 12335 * Returns 0 if the entity is well formed, -1 in case of args problem and 12336 * the parser error code otherwise 12337 */ 12338 12339 int 12340 xmlParseCtxtExternalEntity(xmlParserCtxtPtr ctx, const xmlChar *URL, 12341 const xmlChar *ID, xmlNodePtr *lst) { 12342 xmlParserCtxtPtr ctxt; 12343 xmlDocPtr newDoc; 12344 xmlNodePtr newRoot; 12345 xmlSAXHandlerPtr oldsax = NULL; 12346 int ret = 0; 12347 xmlChar start[4]; 12348 xmlCharEncoding enc; 12349 12350 if (ctx == NULL) return(-1); 12351 12352 if (((ctx->depth > 40) && ((ctx->options & XML_PARSE_HUGE) == 0)) || 12353 (ctx->depth > 1024)) { 12354 return(XML_ERR_ENTITY_LOOP); 12355 } 12356 12357 if (lst != NULL) 12358 *lst = NULL; 12359 if ((URL == NULL) && (ID == NULL)) 12360 return(-1); 12361 if (ctx->myDoc == NULL) /* @@ relax but check for dereferences */ 12362 return(-1); 12363 12364 ctxt = xmlCreateEntityParserCtxtInternal(URL, ID, NULL, ctx); 12365 if (ctxt == NULL) { 12366 return(-1); 12367 } 12368 12369 oldsax = ctxt->sax; 12370 ctxt->sax = ctx->sax; 12371 xmlDetectSAX2(ctxt); 12372 newDoc = xmlNewDoc(BAD_CAST "1.0"); 12373 if (newDoc == NULL) { 12374 xmlFreeParserCtxt(ctxt); 12375 return(-1); 12376 } 12377 newDoc->properties = XML_DOC_INTERNAL; 12378 if (ctx->myDoc->dict) { 12379 newDoc->dict = ctx->myDoc->dict; 12380 xmlDictReference(newDoc->dict); 12381 } 12382 if (ctx->myDoc != NULL) { 12383 newDoc->intSubset = ctx->myDoc->intSubset; 12384 newDoc->extSubset = ctx->myDoc->extSubset; 12385 } 12386 if (ctx->myDoc->URL != NULL) { 12387 newDoc->URL = xmlStrdup(ctx->myDoc->URL); 12388 } 12389 newRoot = xmlNewDocNode(newDoc, NULL, BAD_CAST "pseudoroot", NULL); 12390 if (newRoot == NULL) { 12391 ctxt->sax = oldsax; 12392 xmlFreeParserCtxt(ctxt); 12393 newDoc->intSubset = NULL; 12394 newDoc->extSubset = NULL; 12395 xmlFreeDoc(newDoc); 12396 return(-1); 12397 } 12398 xmlAddChild((xmlNodePtr) newDoc, newRoot); 12399 nodePush(ctxt, newDoc->children); 12400 if (ctx->myDoc == NULL) { 12401 ctxt->myDoc = newDoc; 12402 } else { 12403 ctxt->myDoc = ctx->myDoc; 12404 newDoc->children->doc = ctx->myDoc; 12405 } 12406 12407 /* 12408 * Get the 4 first bytes and decode the charset 12409 * if enc != XML_CHAR_ENCODING_NONE 12410 * plug some encoding conversion routines. 12411 */ 12412 GROW 12413 if ((ctxt->input->end - ctxt->input->cur) >= 4) { 12414 start[0] = RAW; 12415 start[1] = NXT(1); 12416 start[2] = NXT(2); 12417 start[3] = NXT(3); 12418 enc = xmlDetectCharEncoding(start, 4); 12419 if (enc != XML_CHAR_ENCODING_NONE) { 12420 xmlSwitchEncoding(ctxt, enc); 12421 } 12422 } 12423 12424 /* 12425 * Parse a possible text declaration first 12426 */ 12427 if ((CMP5(CUR_PTR, '<', '?', 'x', 'm', 'l')) && (IS_BLANK_CH(NXT(5)))) { 12428 xmlParseTextDecl(ctxt); 12429 /* 12430 * An XML-1.0 document can't reference an entity not XML-1.0 12431 */ 12432 if ((xmlStrEqual(ctx->version, BAD_CAST "1.0")) && 12433 (!xmlStrEqual(ctxt->input->version, BAD_CAST "1.0"))) { 12434 xmlFatalErrMsg(ctxt, XML_ERR_VERSION_MISMATCH, 12435 "Version mismatch between document and entity\n"); 12436 } 12437 } 12438 12439 /* 12440 * Doing validity checking on chunk doesn't make sense 12441 */ 12442 ctxt->instate = XML_PARSER_CONTENT; 12443 ctxt->validate = ctx->validate; 12444 ctxt->valid = ctx->valid; 12445 ctxt->loadsubset = ctx->loadsubset; 12446 ctxt->depth = ctx->depth + 1; 12447 ctxt->replaceEntities = ctx->replaceEntities; 12448 if (ctxt->validate) { 12449 ctxt->vctxt.error = ctx->vctxt.error; 12450 ctxt->vctxt.warning = ctx->vctxt.warning; 12451 } else { 12452 ctxt->vctxt.error = NULL; 12453 ctxt->vctxt.warning = NULL; 12454 } 12455 ctxt->vctxt.nodeTab = NULL; 12456 ctxt->vctxt.nodeNr = 0; 12457 ctxt->vctxt.nodeMax = 0; 12458 ctxt->vctxt.node = NULL; 12459 if (ctxt->dict != NULL) xmlDictFree(ctxt->dict); 12460 ctxt->dict = ctx->dict; 12461 ctxt->str_xml = xmlDictLookup(ctxt->dict, BAD_CAST "xml", 3); 12462 ctxt->str_xmlns = xmlDictLookup(ctxt->dict, BAD_CAST "xmlns", 5); 12463 ctxt->str_xml_ns = xmlDictLookup(ctxt->dict, XML_XML_NAMESPACE, 36); 12464 ctxt->dictNames = ctx->dictNames; 12465 ctxt->attsDefault = ctx->attsDefault; 12466 ctxt->attsSpecial = ctx->attsSpecial; 12467 ctxt->linenumbers = ctx->linenumbers; 12468 12469 xmlParseContent(ctxt); 12470 12471 ctx->validate = ctxt->validate; 12472 ctx->valid = ctxt->valid; 12473 if ((RAW == '<') && (NXT(1) == '/')) { 12474 xmlFatalErr(ctxt, XML_ERR_NOT_WELL_BALANCED, NULL); 12475 } else if (RAW != 0) { 12476 xmlFatalErr(ctxt, XML_ERR_EXTRA_CONTENT, NULL); 12477 } 12478 if (ctxt->node != newDoc->children) { 12479 xmlFatalErr(ctxt, XML_ERR_NOT_WELL_BALANCED, NULL); 12480 } 12481 12482 if (!ctxt->wellFormed) { 12483 if (ctxt->errNo == 0) 12484 ret = 1; 12485 else 12486 ret = ctxt->errNo; 12487 } else { 12488 if (lst != NULL) { 12489 xmlNodePtr cur; 12490 12491 /* 12492 * Return the newly created nodeset after unlinking it from 12493 * they pseudo parent. 12494 */ 12495 cur = newDoc->children->children; 12496 *lst = cur; 12497 while (cur != NULL) { 12498 cur->parent = NULL; 12499 cur = cur->next; 12500 } 12501 newDoc->children->children = NULL; 12502 } 12503 ret = 0; 12504 } 12505 ctxt->sax = oldsax; 12506 ctxt->dict = NULL; 12507 ctxt->attsDefault = NULL; 12508 ctxt->attsSpecial = NULL; 12509 xmlFreeParserCtxt(ctxt); 12510 newDoc->intSubset = NULL; 12511 newDoc->extSubset = NULL; 12512 xmlFreeDoc(newDoc); 12513 12514 return(ret); 12515 } 12516 12517 /** 12518 * xmlParseExternalEntityPrivate: 12519 * @doc: the document the chunk pertains to 12520 * @oldctxt: the previous parser context if available 12521 * @sax: the SAX handler bloc (possibly NULL) 12522 * @user_data: The user data returned on SAX callbacks (possibly NULL) 12523 * @depth: Used for loop detection, use 0 12524 * @URL: the URL for the entity to load 12525 * @ID: the System ID for the entity to load 12526 * @list: the return value for the set of parsed nodes 12527 * 12528 * Private version of xmlParseExternalEntity() 12529 * 12530 * Returns 0 if the entity is well formed, -1 in case of args problem and 12531 * the parser error code otherwise 12532 */ 12533 12534 static xmlParserErrors 12535 xmlParseExternalEntityPrivate(xmlDocPtr doc, xmlParserCtxtPtr oldctxt, 12536 xmlSAXHandlerPtr sax, 12537 void *user_data, int depth, const xmlChar *URL, 12538 const xmlChar *ID, xmlNodePtr *list) { 12539 xmlParserCtxtPtr ctxt; 12540 xmlDocPtr newDoc; 12541 xmlNodePtr newRoot; 12542 xmlSAXHandlerPtr oldsax = NULL; 12543 xmlParserErrors ret = XML_ERR_OK; 12544 xmlChar start[4]; 12545 xmlCharEncoding enc; 12546 12547 if (((depth > 40) && 12548 ((oldctxt == NULL) || (oldctxt->options & XML_PARSE_HUGE) == 0)) || 12549 (depth > 1024)) { 12550 return(XML_ERR_ENTITY_LOOP); 12551 } 12552 12553 if (list != NULL) 12554 *list = NULL; 12555 if ((URL == NULL) && (ID == NULL)) 12556 return(XML_ERR_INTERNAL_ERROR); 12557 if (doc == NULL) 12558 return(XML_ERR_INTERNAL_ERROR); 12559 12560 12561 ctxt = xmlCreateEntityParserCtxtInternal(URL, ID, NULL, oldctxt); 12562 if (ctxt == NULL) return(XML_WAR_UNDECLARED_ENTITY); 12563 ctxt->userData = ctxt; 12564 if (oldctxt != NULL) { 12565 ctxt->_private = oldctxt->_private; 12566 ctxt->loadsubset = oldctxt->loadsubset; 12567 ctxt->validate = oldctxt->validate; 12568 ctxt->external = oldctxt->external; 12569 ctxt->record_info = oldctxt->record_info; 12570 ctxt->node_seq.maximum = oldctxt->node_seq.maximum; 12571 ctxt->node_seq.length = oldctxt->node_seq.length; 12572 ctxt->node_seq.buffer = oldctxt->node_seq.buffer; 12573 } else { 12574 /* 12575 * Doing validity checking on chunk without context 12576 * doesn't make sense 12577 */ 12578 ctxt->_private = NULL; 12579 ctxt->validate = 0; 12580 ctxt->external = 2; 12581 ctxt->loadsubset = 0; 12582 } 12583 if (sax != NULL) { 12584 oldsax = ctxt->sax; 12585 ctxt->sax = sax; 12586 if (user_data != NULL) 12587 ctxt->userData = user_data; 12588 } 12589 xmlDetectSAX2(ctxt); 12590 newDoc = xmlNewDoc(BAD_CAST "1.0"); 12591 if (newDoc == NULL) { 12592 ctxt->node_seq.maximum = 0; 12593 ctxt->node_seq.length = 0; 12594 ctxt->node_seq.buffer = NULL; 12595 xmlFreeParserCtxt(ctxt); 12596 return(XML_ERR_INTERNAL_ERROR); 12597 } 12598 newDoc->properties = XML_DOC_INTERNAL; 12599 newDoc->intSubset = doc->intSubset; 12600 newDoc->extSubset = doc->extSubset; 12601 newDoc->dict = doc->dict; 12602 xmlDictReference(newDoc->dict); 12603 12604 if (doc->URL != NULL) { 12605 newDoc->URL = xmlStrdup(doc->URL); 12606 } 12607 newRoot = xmlNewDocNode(newDoc, NULL, BAD_CAST "pseudoroot", NULL); 12608 if (newRoot == NULL) { 12609 if (sax != NULL) 12610 ctxt->sax = oldsax; 12611 ctxt->node_seq.maximum = 0; 12612 ctxt->node_seq.length = 0; 12613 ctxt->node_seq.buffer = NULL; 12614 xmlFreeParserCtxt(ctxt); 12615 newDoc->intSubset = NULL; 12616 newDoc->extSubset = NULL; 12617 xmlFreeDoc(newDoc); 12618 return(XML_ERR_INTERNAL_ERROR); 12619 } 12620 xmlAddChild((xmlNodePtr) newDoc, newRoot); 12621 nodePush(ctxt, newDoc->children); 12622 ctxt->myDoc = doc; 12623 newRoot->doc = doc; 12624 12625 /* 12626 * Get the 4 first bytes and decode the charset 12627 * if enc != XML_CHAR_ENCODING_NONE 12628 * plug some encoding conversion routines. 12629 */ 12630 GROW; 12631 if ((ctxt->input->end - ctxt->input->cur) >= 4) { 12632 start[0] = RAW; 12633 start[1] = NXT(1); 12634 start[2] = NXT(2); 12635 start[3] = NXT(3); 12636 enc = xmlDetectCharEncoding(start, 4); 12637 if (enc != XML_CHAR_ENCODING_NONE) { 12638 xmlSwitchEncoding(ctxt, enc); 12639 } 12640 } 12641 12642 /* 12643 * Parse a possible text declaration first 12644 */ 12645 if ((CMP5(CUR_PTR, '<', '?', 'x', 'm', 'l')) && (IS_BLANK_CH(NXT(5)))) { 12646 xmlParseTextDecl(ctxt); 12647 } 12648 12649 ctxt->instate = XML_PARSER_CONTENT; 12650 ctxt->depth = depth; 12651 12652 xmlParseContent(ctxt); 12653 12654 if ((RAW == '<') && (NXT(1) == '/')) { 12655 xmlFatalErr(ctxt, XML_ERR_NOT_WELL_BALANCED, NULL); 12656 } else if (RAW != 0) { 12657 xmlFatalErr(ctxt, XML_ERR_EXTRA_CONTENT, NULL); 12658 } 12659 if (ctxt->node != newDoc->children) { 12660 xmlFatalErr(ctxt, XML_ERR_NOT_WELL_BALANCED, NULL); 12661 } 12662 12663 if (!ctxt->wellFormed) { 12664 if (ctxt->errNo == 0) 12665 ret = XML_ERR_INTERNAL_ERROR; 12666 else 12667 ret = (xmlParserErrors)ctxt->errNo; 12668 } else { 12669 if (list != NULL) { 12670 xmlNodePtr cur; 12671 12672 /* 12673 * Return the newly created nodeset after unlinking it from 12674 * they pseudo parent. 12675 */ 12676 cur = newDoc->children->children; 12677 *list = cur; 12678 while (cur != NULL) { 12679 cur->parent = NULL; 12680 cur = cur->next; 12681 } 12682 newDoc->children->children = NULL; 12683 } 12684 ret = XML_ERR_OK; 12685 } 12686 12687 /* 12688 * Record in the parent context the number of entities replacement 12689 * done when parsing that reference. 12690 */ 12691 if (oldctxt != NULL) 12692 oldctxt->nbentities += ctxt->nbentities; 12693 12694 /* 12695 * Also record the size of the entity parsed 12696 */ 12697 if (ctxt->input != NULL) { 12698 oldctxt->sizeentities += ctxt->input->consumed; 12699 oldctxt->sizeentities += (ctxt->input->cur - ctxt->input->base); 12700 } 12701 /* 12702 * And record the last error if any 12703 */ 12704 if (ctxt->lastError.code != XML_ERR_OK) 12705 xmlCopyError(&ctxt->lastError, &oldctxt->lastError); 12706 12707 if (sax != NULL) 12708 ctxt->sax = oldsax; 12709 oldctxt->node_seq.maximum = ctxt->node_seq.maximum; 12710 oldctxt->node_seq.length = ctxt->node_seq.length; 12711 oldctxt->node_seq.buffer = ctxt->node_seq.buffer; 12712 ctxt->node_seq.maximum = 0; 12713 ctxt->node_seq.length = 0; 12714 ctxt->node_seq.buffer = NULL; 12715 xmlFreeParserCtxt(ctxt); 12716 newDoc->intSubset = NULL; 12717 newDoc->extSubset = NULL; 12718 xmlFreeDoc(newDoc); 12719 12720 return(ret); 12721 } 12722 12723 #ifdef LIBXML_SAX1_ENABLED 12724 /** 12725 * xmlParseExternalEntity: 12726 * @doc: the document the chunk pertains to 12727 * @sax: the SAX handler bloc (possibly NULL) 12728 * @user_data: The user data returned on SAX callbacks (possibly NULL) 12729 * @depth: Used for loop detection, use 0 12730 * @URL: the URL for the entity to load 12731 * @ID: the System ID for the entity to load 12732 * @lst: the return value for the set of parsed nodes 12733 * 12734 * Parse an external general entity 12735 * An external general parsed entity is well-formed if it matches the 12736 * production labeled extParsedEnt. 12737 * 12738 * [78] extParsedEnt ::= TextDecl? content 12739 * 12740 * Returns 0 if the entity is well formed, -1 in case of args problem and 12741 * the parser error code otherwise 12742 */ 12743 12744 int 12745 xmlParseExternalEntity(xmlDocPtr doc, xmlSAXHandlerPtr sax, void *user_data, 12746 int depth, const xmlChar *URL, const xmlChar *ID, xmlNodePtr *lst) { 12747 return(xmlParseExternalEntityPrivate(doc, NULL, sax, user_data, depth, URL, 12748 ID, lst)); 12749 } 12750 12751 /** 12752 * xmlParseBalancedChunkMemory: 12753 * @doc: the document the chunk pertains to 12754 * @sax: the SAX handler bloc (possibly NULL) 12755 * @user_data: The user data returned on SAX callbacks (possibly NULL) 12756 * @depth: Used for loop detection, use 0 12757 * @string: the input string in UTF8 or ISO-Latin (zero terminated) 12758 * @lst: the return value for the set of parsed nodes 12759 * 12760 * Parse a well-balanced chunk of an XML document 12761 * called by the parser 12762 * The allowed sequence for the Well Balanced Chunk is the one defined by 12763 * the content production in the XML grammar: 12764 * 12765 * [43] content ::= (element | CharData | Reference | CDSect | PI | Comment)* 12766 * 12767 * Returns 0 if the chunk is well balanced, -1 in case of args problem and 12768 * the parser error code otherwise 12769 */ 12770 12771 int 12772 xmlParseBalancedChunkMemory(xmlDocPtr doc, xmlSAXHandlerPtr sax, 12773 void *user_data, int depth, const xmlChar *string, xmlNodePtr *lst) { 12774 return xmlParseBalancedChunkMemoryRecover( doc, sax, user_data, 12775 depth, string, lst, 0 ); 12776 } 12777 #endif /* LIBXML_SAX1_ENABLED */ 12778 12779 /** 12780 * xmlParseBalancedChunkMemoryInternal: 12781 * @oldctxt: the existing parsing context 12782 * @string: the input string in UTF8 or ISO-Latin (zero terminated) 12783 * @user_data: the user data field for the parser context 12784 * @lst: the return value for the set of parsed nodes 12785 * 12786 * 12787 * Parse a well-balanced chunk of an XML document 12788 * called by the parser 12789 * The allowed sequence for the Well Balanced Chunk is the one defined by 12790 * the content production in the XML grammar: 12791 * 12792 * [43] content ::= (element | CharData | Reference | CDSect | PI | Comment)* 12793 * 12794 * Returns XML_ERR_OK if the chunk is well balanced, and the parser 12795 * error code otherwise 12796 * 12797 * In case recover is set to 1, the nodelist will not be empty even if 12798 * the parsed chunk is not well balanced. 12799 */ 12800 static xmlParserErrors 12801 xmlParseBalancedChunkMemoryInternal(xmlParserCtxtPtr oldctxt, 12802 const xmlChar *string, void *user_data, xmlNodePtr *lst) { 12803 xmlParserCtxtPtr ctxt; 12804 xmlDocPtr newDoc = NULL; 12805 xmlNodePtr newRoot; 12806 xmlSAXHandlerPtr oldsax = NULL; 12807 xmlNodePtr content = NULL; 12808 xmlNodePtr last = NULL; 12809 int size; 12810 xmlParserErrors ret = XML_ERR_OK; 12811 #ifdef SAX2 12812 int i; 12813 #endif 12814 12815 if (((oldctxt->depth > 40) && ((oldctxt->options & XML_PARSE_HUGE) == 0)) || 12816 (oldctxt->depth > 1024)) { 12817 return(XML_ERR_ENTITY_LOOP); 12818 } 12819 12820 12821 if (lst != NULL) 12822 *lst = NULL; 12823 if (string == NULL) 12824 return(XML_ERR_INTERNAL_ERROR); 12825 12826 size = xmlStrlen(string); 12827 12828 ctxt = xmlCreateMemoryParserCtxt((char *) string, size); 12829 if (ctxt == NULL) return(XML_WAR_UNDECLARED_ENTITY); 12830 if (user_data != NULL) 12831 ctxt->userData = user_data; 12832 else 12833 ctxt->userData = ctxt; 12834 if (ctxt->dict != NULL) xmlDictFree(ctxt->dict); 12835 ctxt->dict = oldctxt->dict; 12836 ctxt->str_xml = xmlDictLookup(ctxt->dict, BAD_CAST "xml", 3); 12837 ctxt->str_xmlns = xmlDictLookup(ctxt->dict, BAD_CAST "xmlns", 5); 12838 ctxt->str_xml_ns = xmlDictLookup(ctxt->dict, XML_XML_NAMESPACE, 36); 12839 12840 #ifdef SAX2 12841 /* propagate namespaces down the entity */ 12842 for (i = 0;i < oldctxt->nsNr;i += 2) { 12843 nsPush(ctxt, oldctxt->nsTab[i], oldctxt->nsTab[i+1]); 12844 } 12845 #endif 12846 12847 oldsax = ctxt->sax; 12848 ctxt->sax = oldctxt->sax; 12849 xmlDetectSAX2(ctxt); 12850 ctxt->replaceEntities = oldctxt->replaceEntities; 12851 ctxt->options = oldctxt->options; 12852 12853 ctxt->_private = oldctxt->_private; 12854 if (oldctxt->myDoc == NULL) { 12855 newDoc = xmlNewDoc(BAD_CAST "1.0"); 12856 if (newDoc == NULL) { 12857 ctxt->sax = oldsax; 12858 ctxt->dict = NULL; 12859 xmlFreeParserCtxt(ctxt); 12860 return(XML_ERR_INTERNAL_ERROR); 12861 } 12862 newDoc->properties = XML_DOC_INTERNAL; 12863 newDoc->dict = ctxt->dict; 12864 xmlDictReference(newDoc->dict); 12865 ctxt->myDoc = newDoc; 12866 } else { 12867 ctxt->myDoc = oldctxt->myDoc; 12868 content = ctxt->myDoc->children; 12869 last = ctxt->myDoc->last; 12870 } 12871 newRoot = xmlNewDocNode(ctxt->myDoc, NULL, BAD_CAST "pseudoroot", NULL); 12872 if (newRoot == NULL) { 12873 ctxt->sax = oldsax; 12874 ctxt->dict = NULL; 12875 xmlFreeParserCtxt(ctxt); 12876 if (newDoc != NULL) { 12877 xmlFreeDoc(newDoc); 12878 } 12879 return(XML_ERR_INTERNAL_ERROR); 12880 } 12881 ctxt->myDoc->children = NULL; 12882 ctxt->myDoc->last = NULL; 12883 xmlAddChild((xmlNodePtr) ctxt->myDoc, newRoot); 12884 nodePush(ctxt, ctxt->myDoc->children); 12885 ctxt->instate = XML_PARSER_CONTENT; 12886 ctxt->depth = oldctxt->depth + 1; 12887 12888 ctxt->validate = 0; 12889 ctxt->loadsubset = oldctxt->loadsubset; 12890 if ((oldctxt->validate) || (oldctxt->replaceEntities != 0)) { 12891 /* 12892 * ID/IDREF registration will be done in xmlValidateElement below 12893 */ 12894 ctxt->loadsubset |= XML_SKIP_IDS; 12895 } 12896 ctxt->dictNames = oldctxt->dictNames; 12897 ctxt->attsDefault = oldctxt->attsDefault; 12898 ctxt->attsSpecial = oldctxt->attsSpecial; 12899 12900 xmlParseContent(ctxt); 12901 if ((RAW == '<') && (NXT(1) == '/')) { 12902 xmlFatalErr(ctxt, XML_ERR_NOT_WELL_BALANCED, NULL); 12903 } else if (RAW != 0) { 12904 xmlFatalErr(ctxt, XML_ERR_EXTRA_CONTENT, NULL); 12905 } 12906 if (ctxt->node != ctxt->myDoc->children) { 12907 xmlFatalErr(ctxt, XML_ERR_NOT_WELL_BALANCED, NULL); 12908 } 12909 12910 if (!ctxt->wellFormed) { 12911 if (ctxt->errNo == 0) 12912 ret = XML_ERR_INTERNAL_ERROR; 12913 else 12914 ret = (xmlParserErrors)ctxt->errNo; 12915 } else { 12916 ret = XML_ERR_OK; 12917 } 12918 12919 if ((lst != NULL) && (ret == XML_ERR_OK)) { 12920 xmlNodePtr cur; 12921 12922 /* 12923 * Return the newly created nodeset after unlinking it from 12924 * they pseudo parent. 12925 */ 12926 cur = ctxt->myDoc->children->children; 12927 *lst = cur; 12928 while (cur != NULL) { 12929 #ifdef LIBXML_VALID_ENABLED 12930 if ((oldctxt->validate) && (oldctxt->wellFormed) && 12931 (oldctxt->myDoc) && (oldctxt->myDoc->intSubset) && 12932 (cur->type == XML_ELEMENT_NODE)) { 12933 oldctxt->valid &= xmlValidateElement(&oldctxt->vctxt, 12934 oldctxt->myDoc, cur); 12935 } 12936 #endif /* LIBXML_VALID_ENABLED */ 12937 cur->parent = NULL; 12938 cur = cur->next; 12939 } 12940 ctxt->myDoc->children->children = NULL; 12941 } 12942 if (ctxt->myDoc != NULL) { 12943 xmlFreeNode(ctxt->myDoc->children); 12944 ctxt->myDoc->children = content; 12945 ctxt->myDoc->last = last; 12946 } 12947 12948 /* 12949 * Record in the parent context the number of entities replacement 12950 * done when parsing that reference. 12951 */ 12952 if (oldctxt != NULL) 12953 oldctxt->nbentities += ctxt->nbentities; 12954 12955 /* 12956 * Also record the last error if any 12957 */ 12958 if (ctxt->lastError.code != XML_ERR_OK) 12959 xmlCopyError(&ctxt->lastError, &oldctxt->lastError); 12960 12961 ctxt->sax = oldsax; 12962 ctxt->dict = NULL; 12963 ctxt->attsDefault = NULL; 12964 ctxt->attsSpecial = NULL; 12965 xmlFreeParserCtxt(ctxt); 12966 if (newDoc != NULL) { 12967 xmlFreeDoc(newDoc); 12968 } 12969 12970 return(ret); 12971 } 12972 12973 /** 12974 * xmlParseInNodeContext: 12975 * @node: the context node 12976 * @data: the input string 12977 * @datalen: the input string length in bytes 12978 * @options: a combination of xmlParserOption 12979 * @lst: the return value for the set of parsed nodes 12980 * 12981 * Parse a well-balanced chunk of an XML document 12982 * within the context (DTD, namespaces, etc ...) of the given node. 12983 * 12984 * The allowed sequence for the data is a Well Balanced Chunk defined by 12985 * the content production in the XML grammar: 12986 * 12987 * [43] content ::= (element | CharData | Reference | CDSect | PI | Comment)* 12988 * 12989 * Returns XML_ERR_OK if the chunk is well balanced, and the parser 12990 * error code otherwise 12991 */ 12992 xmlParserErrors 12993 xmlParseInNodeContext(xmlNodePtr node, const char *data, int datalen, 12994 int options, xmlNodePtr *lst) { 12995 #ifdef SAX2 12996 xmlParserCtxtPtr ctxt; 12997 xmlDocPtr doc = NULL; 12998 xmlNodePtr fake, cur; 12999 int nsnr = 0; 13000 13001 xmlParserErrors ret = XML_ERR_OK; 13002 13003 /* 13004 * check all input parameters, grab the document 13005 */ 13006 if ((lst == NULL) || (node == NULL) || (data == NULL) || (datalen < 0)) 13007 return(XML_ERR_INTERNAL_ERROR); 13008 switch (node->type) { 13009 case XML_ELEMENT_NODE: 13010 case XML_ATTRIBUTE_NODE: 13011 case XML_TEXT_NODE: 13012 case XML_CDATA_SECTION_NODE: 13013 case XML_ENTITY_REF_NODE: 13014 case XML_PI_NODE: 13015 case XML_COMMENT_NODE: 13016 case XML_DOCUMENT_NODE: 13017 case XML_HTML_DOCUMENT_NODE: 13018 break; 13019 default: 13020 return(XML_ERR_INTERNAL_ERROR); 13021 13022 } 13023 while ((node != NULL) && (node->type != XML_ELEMENT_NODE) && 13024 (node->type != XML_DOCUMENT_NODE) && 13025 (node->type != XML_HTML_DOCUMENT_NODE)) 13026 node = node->parent; 13027 if (node == NULL) 13028 return(XML_ERR_INTERNAL_ERROR); 13029 if (node->type == XML_ELEMENT_NODE) 13030 doc = node->doc; 13031 else 13032 doc = (xmlDocPtr) node; 13033 if (doc == NULL) 13034 return(XML_ERR_INTERNAL_ERROR); 13035 13036 /* 13037 * allocate a context and set-up everything not related to the 13038 * node position in the tree 13039 */ 13040 if (doc->type == XML_DOCUMENT_NODE) 13041 ctxt = xmlCreateMemoryParserCtxt((char *) data, datalen); 13042 #ifdef LIBXML_HTML_ENABLED 13043 else if (doc->type == XML_HTML_DOCUMENT_NODE) { 13044 ctxt = htmlCreateMemoryParserCtxt((char *) data, datalen); 13045 /* 13046 * When parsing in context, it makes no sense to add implied 13047 * elements like html/body/etc... 13048 */ 13049 options |= HTML_PARSE_NOIMPLIED; 13050 } 13051 #endif 13052 else 13053 return(XML_ERR_INTERNAL_ERROR); 13054 13055 if (ctxt == NULL) 13056 return(XML_ERR_NO_MEMORY); 13057 13058 /* 13059 * Use input doc's dict if present, else assure XML_PARSE_NODICT is set. 13060 * We need a dictionary for xmlDetectSAX2, so if there's no doc dict 13061 * we must wait until the last moment to free the original one. 13062 */ 13063 if (doc->dict != NULL) { 13064 if (ctxt->dict != NULL) 13065 xmlDictFree(ctxt->dict); 13066 ctxt->dict = doc->dict; 13067 } else 13068 options |= XML_PARSE_NODICT; 13069 13070 if (doc->encoding != NULL) { 13071 xmlCharEncodingHandlerPtr hdlr; 13072 13073 if (ctxt->encoding != NULL) 13074 xmlFree((xmlChar *) ctxt->encoding); 13075 ctxt->encoding = xmlStrdup((const xmlChar *) doc->encoding); 13076 13077 hdlr = xmlFindCharEncodingHandler(doc->encoding); 13078 if (hdlr != NULL) { 13079 xmlSwitchToEncoding(ctxt, hdlr); 13080 } else { 13081 return(XML_ERR_UNSUPPORTED_ENCODING); 13082 } 13083 } 13084 13085 xmlCtxtUseOptionsInternal(ctxt, options, NULL); 13086 xmlDetectSAX2(ctxt); 13087 ctxt->myDoc = doc; 13088 13089 fake = xmlNewComment(NULL); 13090 if (fake == NULL) { 13091 xmlFreeParserCtxt(ctxt); 13092 return(XML_ERR_NO_MEMORY); 13093 } 13094 xmlAddChild(node, fake); 13095 13096 if (node->type == XML_ELEMENT_NODE) { 13097 nodePush(ctxt, node); 13098 /* 13099 * initialize the SAX2 namespaces stack 13100 */ 13101 cur = node; 13102 while ((cur != NULL) && (cur->type == XML_ELEMENT_NODE)) { 13103 xmlNsPtr ns = cur->nsDef; 13104 const xmlChar *iprefix, *ihref; 13105 13106 while (ns != NULL) { 13107 if (ctxt->dict) { 13108 iprefix = xmlDictLookup(ctxt->dict, ns->prefix, -1); 13109 ihref = xmlDictLookup(ctxt->dict, ns->href, -1); 13110 } else { 13111 iprefix = ns->prefix; 13112 ihref = ns->href; 13113 } 13114 13115 if (xmlGetNamespace(ctxt, iprefix) == NULL) { 13116 nsPush(ctxt, iprefix, ihref); 13117 nsnr++; 13118 } 13119 ns = ns->next; 13120 } 13121 cur = cur->parent; 13122 } 13123 ctxt->instate = XML_PARSER_CONTENT; 13124 } 13125 13126 if ((ctxt->validate) || (ctxt->replaceEntities != 0)) { 13127 /* 13128 * ID/IDREF registration will be done in xmlValidateElement below 13129 */ 13130 ctxt->loadsubset |= XML_SKIP_IDS; 13131 } 13132 13133 #ifdef LIBXML_HTML_ENABLED 13134 if (doc->type == XML_HTML_DOCUMENT_NODE) 13135 __htmlParseContent(ctxt); 13136 else 13137 #endif 13138 xmlParseContent(ctxt); 13139 13140 nsPop(ctxt, nsnr); 13141 if ((RAW == '<') && (NXT(1) == '/')) { 13142 xmlFatalErr(ctxt, XML_ERR_NOT_WELL_BALANCED, NULL); 13143 } else if (RAW != 0) { 13144 xmlFatalErr(ctxt, XML_ERR_EXTRA_CONTENT, NULL); 13145 } 13146 if ((ctxt->node != NULL) && (ctxt->node != node)) { 13147 xmlFatalErr(ctxt, XML_ERR_NOT_WELL_BALANCED, NULL); 13148 ctxt->wellFormed = 0; 13149 } 13150 13151 if (!ctxt->wellFormed) { 13152 if (ctxt->errNo == 0) 13153 ret = XML_ERR_INTERNAL_ERROR; 13154 else 13155 ret = (xmlParserErrors)ctxt->errNo; 13156 } else { 13157 ret = XML_ERR_OK; 13158 } 13159 13160 /* 13161 * Return the newly created nodeset after unlinking it from 13162 * the pseudo sibling. 13163 */ 13164 13165 cur = fake->next; 13166 fake->next = NULL; 13167 node->last = fake; 13168 13169 if (cur != NULL) { 13170 cur->prev = NULL; 13171 } 13172 13173 *lst = cur; 13174 13175 while (cur != NULL) { 13176 cur->parent = NULL; 13177 cur = cur->next; 13178 } 13179 13180 xmlUnlinkNode(fake); 13181 xmlFreeNode(fake); 13182 13183 13184 if (ret != XML_ERR_OK) { 13185 xmlFreeNodeList(*lst); 13186 *lst = NULL; 13187 } 13188 13189 if (doc->dict != NULL) 13190 ctxt->dict = NULL; 13191 xmlFreeParserCtxt(ctxt); 13192 13193 return(ret); 13194 #else /* !SAX2 */ 13195 return(XML_ERR_INTERNAL_ERROR); 13196 #endif 13197 } 13198 13199 #ifdef LIBXML_SAX1_ENABLED 13200 /** 13201 * xmlParseBalancedChunkMemoryRecover: 13202 * @doc: the document the chunk pertains to 13203 * @sax: the SAX handler bloc (possibly NULL) 13204 * @user_data: The user data returned on SAX callbacks (possibly NULL) 13205 * @depth: Used for loop detection, use 0 13206 * @string: the input string in UTF8 or ISO-Latin (zero terminated) 13207 * @lst: the return value for the set of parsed nodes 13208 * @recover: return nodes even if the data is broken (use 0) 13209 * 13210 * 13211 * Parse a well-balanced chunk of an XML document 13212 * called by the parser 13213 * The allowed sequence for the Well Balanced Chunk is the one defined by 13214 * the content production in the XML grammar: 13215 * 13216 * [43] content ::= (element | CharData | Reference | CDSect | PI | Comment)* 13217 * 13218 * Returns 0 if the chunk is well balanced, -1 in case of args problem and 13219 * the parser error code otherwise 13220 * 13221 * In case recover is set to 1, the nodelist will not be empty even if 13222 * the parsed chunk is not well balanced, assuming the parsing succeeded to 13223 * some extent. 13224 */ 13225 int 13226 xmlParseBalancedChunkMemoryRecover(xmlDocPtr doc, xmlSAXHandlerPtr sax, 13227 void *user_data, int depth, const xmlChar *string, xmlNodePtr *lst, 13228 int recover) { 13229 xmlParserCtxtPtr ctxt; 13230 xmlDocPtr newDoc; 13231 xmlSAXHandlerPtr oldsax = NULL; 13232 xmlNodePtr content, newRoot; 13233 int size; 13234 int ret = 0; 13235 13236 if (depth > 40) { 13237 return(XML_ERR_ENTITY_LOOP); 13238 } 13239 13240 13241 if (lst != NULL) 13242 *lst = NULL; 13243 if (string == NULL) 13244 return(-1); 13245 13246 size = xmlStrlen(string); 13247 13248 ctxt = xmlCreateMemoryParserCtxt((char *) string, size); 13249 if (ctxt == NULL) return(-1); 13250 ctxt->userData = ctxt; 13251 if (sax != NULL) { 13252 oldsax = ctxt->sax; 13253 ctxt->sax = sax; 13254 if (user_data != NULL) 13255 ctxt->userData = user_data; 13256 } 13257 newDoc = xmlNewDoc(BAD_CAST "1.0"); 13258 if (newDoc == NULL) { 13259 xmlFreeParserCtxt(ctxt); 13260 return(-1); 13261 } 13262 newDoc->properties = XML_DOC_INTERNAL; 13263 if ((doc != NULL) && (doc->dict != NULL)) { 13264 xmlDictFree(ctxt->dict); 13265 ctxt->dict = doc->dict; 13266 xmlDictReference(ctxt->dict); 13267 ctxt->str_xml = xmlDictLookup(ctxt->dict, BAD_CAST "xml", 3); 13268 ctxt->str_xmlns = xmlDictLookup(ctxt->dict, BAD_CAST "xmlns", 5); 13269 ctxt->str_xml_ns = xmlDictLookup(ctxt->dict, XML_XML_NAMESPACE, 36); 13270 ctxt->dictNames = 1; 13271 } else { 13272 xmlCtxtUseOptionsInternal(ctxt, XML_PARSE_NODICT, NULL); 13273 } 13274 if (doc != NULL) { 13275 newDoc->intSubset = doc->intSubset; 13276 newDoc->extSubset = doc->extSubset; 13277 } 13278 newRoot = xmlNewDocNode(newDoc, NULL, BAD_CAST "pseudoroot", NULL); 13279 if (newRoot == NULL) { 13280 if (sax != NULL) 13281 ctxt->sax = oldsax; 13282 xmlFreeParserCtxt(ctxt); 13283 newDoc->intSubset = NULL; 13284 newDoc->extSubset = NULL; 13285 xmlFreeDoc(newDoc); 13286 return(-1); 13287 } 13288 xmlAddChild((xmlNodePtr) newDoc, newRoot); 13289 nodePush(ctxt, newRoot); 13290 if (doc == NULL) { 13291 ctxt->myDoc = newDoc; 13292 } else { 13293 ctxt->myDoc = newDoc; 13294 newDoc->children->doc = doc; 13295 /* Ensure that doc has XML spec namespace */ 13296 xmlSearchNsByHref(doc, (xmlNodePtr)doc, XML_XML_NAMESPACE); 13297 newDoc->oldNs = doc->oldNs; 13298 } 13299 ctxt->instate = XML_PARSER_CONTENT; 13300 ctxt->depth = depth; 13301 13302 /* 13303 * Doing validity checking on chunk doesn't make sense 13304 */ 13305 ctxt->validate = 0; 13306 ctxt->loadsubset = 0; 13307 xmlDetectSAX2(ctxt); 13308 13309 if ( doc != NULL ){ 13310 content = doc->children; 13311 doc->children = NULL; 13312 xmlParseContent(ctxt); 13313 doc->children = content; 13314 } 13315 else { 13316 xmlParseContent(ctxt); 13317 } 13318 if ((RAW == '<') && (NXT(1) == '/')) { 13319 xmlFatalErr(ctxt, XML_ERR_NOT_WELL_BALANCED, NULL); 13320 } else if (RAW != 0) { 13321 xmlFatalErr(ctxt, XML_ERR_EXTRA_CONTENT, NULL); 13322 } 13323 if (ctxt->node != newDoc->children) { 13324 xmlFatalErr(ctxt, XML_ERR_NOT_WELL_BALANCED, NULL); 13325 } 13326 13327 if (!ctxt->wellFormed) { 13328 if (ctxt->errNo == 0) 13329 ret = 1; 13330 else 13331 ret = ctxt->errNo; 13332 } else { 13333 ret = 0; 13334 } 13335 13336 if ((lst != NULL) && ((ret == 0) || (recover == 1))) { 13337 xmlNodePtr cur; 13338 13339 /* 13340 * Return the newly created nodeset after unlinking it from 13341 * they pseudo parent. 13342 */ 13343 cur = newDoc->children->children; 13344 *lst = cur; 13345 while (cur != NULL) { 13346 xmlSetTreeDoc(cur, doc); 13347 cur->parent = NULL; 13348 cur = cur->next; 13349 } 13350 newDoc->children->children = NULL; 13351 } 13352 13353 if (sax != NULL) 13354 ctxt->sax = oldsax; 13355 xmlFreeParserCtxt(ctxt); 13356 newDoc->intSubset = NULL; 13357 newDoc->extSubset = NULL; 13358 newDoc->oldNs = NULL; 13359 xmlFreeDoc(newDoc); 13360 13361 return(ret); 13362 } 13363 13364 /** 13365 * xmlSAXParseEntity: 13366 * @sax: the SAX handler block 13367 * @filename: the filename 13368 * 13369 * parse an XML external entity out of context and build a tree. 13370 * It use the given SAX function block to handle the parsing callback. 13371 * If sax is NULL, fallback to the default DOM tree building routines. 13372 * 13373 * [78] extParsedEnt ::= TextDecl? content 13374 * 13375 * This correspond to a "Well Balanced" chunk 13376 * 13377 * Returns the resulting document tree 13378 */ 13379 13380 xmlDocPtr 13381 xmlSAXParseEntity(xmlSAXHandlerPtr sax, const char *filename) { 13382 xmlDocPtr ret; 13383 xmlParserCtxtPtr ctxt; 13384 13385 ctxt = xmlCreateFileParserCtxt(filename); 13386 if (ctxt == NULL) { 13387 return(NULL); 13388 } 13389 if (sax != NULL) { 13390 if (ctxt->sax != NULL) 13391 xmlFree(ctxt->sax); 13392 ctxt->sax = sax; 13393 ctxt->userData = NULL; 13394 } 13395 13396 xmlParseExtParsedEnt(ctxt); 13397 13398 if (ctxt->wellFormed) 13399 ret = ctxt->myDoc; 13400 else { 13401 ret = NULL; 13402 xmlFreeDoc(ctxt->myDoc); 13403 ctxt->myDoc = NULL; 13404 } 13405 if (sax != NULL) 13406 ctxt->sax = NULL; 13407 xmlFreeParserCtxt(ctxt); 13408 13409 return(ret); 13410 } 13411 13412 /** 13413 * xmlParseEntity: 13414 * @filename: the filename 13415 * 13416 * parse an XML external entity out of context and build a tree. 13417 * 13418 * [78] extParsedEnt ::= TextDecl? content 13419 * 13420 * This correspond to a "Well Balanced" chunk 13421 * 13422 * Returns the resulting document tree 13423 */ 13424 13425 xmlDocPtr 13426 xmlParseEntity(const char *filename) { 13427 return(xmlSAXParseEntity(NULL, filename)); 13428 } 13429 #endif /* LIBXML_SAX1_ENABLED */ 13430 13431 /** 13432 * xmlCreateEntityParserCtxtInternal: 13433 * @URL: the entity URL 13434 * @ID: the entity PUBLIC ID 13435 * @base: a possible base for the target URI 13436 * @pctx: parser context used to set options on new context 13437 * 13438 * Create a parser context for an external entity 13439 * Automatic support for ZLIB/Compress compressed document is provided 13440 * by default if found at compile-time. 13441 * 13442 * Returns the new parser context or NULL 13443 */ 13444 static xmlParserCtxtPtr 13445 xmlCreateEntityParserCtxtInternal(const xmlChar *URL, const xmlChar *ID, 13446 const xmlChar *base, xmlParserCtxtPtr pctx) { 13447 xmlParserCtxtPtr ctxt; 13448 xmlParserInputPtr inputStream; 13449 char *directory = NULL; 13450 xmlChar *uri; 13451 13452 ctxt = xmlNewParserCtxt(); 13453 if (ctxt == NULL) { 13454 return(NULL); 13455 } 13456 13457 if (pctx != NULL) { 13458 ctxt->options = pctx->options; 13459 ctxt->_private = pctx->_private; 13460 } 13461 13462 uri = xmlBuildURI(URL, base); 13463 13464 if (uri == NULL) { 13465 inputStream = xmlLoadExternalEntity((char *)URL, (char *)ID, ctxt); 13466 if (inputStream == NULL) { 13467 xmlFreeParserCtxt(ctxt); 13468 return(NULL); 13469 } 13470 13471 inputPush(ctxt, inputStream); 13472 13473 if ((ctxt->directory == NULL) && (directory == NULL)) 13474 directory = xmlParserGetDirectory((char *)URL); 13475 if ((ctxt->directory == NULL) && (directory != NULL)) 13476 ctxt->directory = directory; 13477 } else { 13478 inputStream = xmlLoadExternalEntity((char *)uri, (char *)ID, ctxt); 13479 if (inputStream == NULL) { 13480 xmlFree(uri); 13481 xmlFreeParserCtxt(ctxt); 13482 return(NULL); 13483 } 13484 13485 inputPush(ctxt, inputStream); 13486 13487 if ((ctxt->directory == NULL) && (directory == NULL)) 13488 directory = xmlParserGetDirectory((char *)uri); 13489 if ((ctxt->directory == NULL) && (directory != NULL)) 13490 ctxt->directory = directory; 13491 xmlFree(uri); 13492 } 13493 return(ctxt); 13494 } 13495 13496 /** 13497 * xmlCreateEntityParserCtxt: 13498 * @URL: the entity URL 13499 * @ID: the entity PUBLIC ID 13500 * @base: a possible base for the target URI 13501 * 13502 * Create a parser context for an external entity 13503 * Automatic support for ZLIB/Compress compressed document is provided 13504 * by default if found at compile-time. 13505 * 13506 * Returns the new parser context or NULL 13507 */ 13508 xmlParserCtxtPtr 13509 xmlCreateEntityParserCtxt(const xmlChar *URL, const xmlChar *ID, 13510 const xmlChar *base) { 13511 return xmlCreateEntityParserCtxtInternal(URL, ID, base, NULL); 13512 13513 } 13514 13515 /************************************************************************ 13516 * * 13517 * Front ends when parsing from a file * 13518 * * 13519 ************************************************************************/ 13520 13521 /** 13522 * xmlCreateURLParserCtxt: 13523 * @filename: the filename or URL 13524 * @options: a combination of xmlParserOption 13525 * 13526 * Create a parser context for a file or URL content. 13527 * Automatic support for ZLIB/Compress compressed document is provided 13528 * by default if found at compile-time and for file accesses 13529 * 13530 * Returns the new parser context or NULL 13531 */ 13532 xmlParserCtxtPtr 13533 xmlCreateURLParserCtxt(const char *filename, int options) 13534 { 13535 xmlParserCtxtPtr ctxt; 13536 xmlParserInputPtr inputStream; 13537 char *directory = NULL; 13538 13539 ctxt = xmlNewParserCtxt(); 13540 if (ctxt == NULL) { 13541 xmlErrMemory(NULL, "cannot allocate parser context"); 13542 return(NULL); 13543 } 13544 13545 if (options) 13546 xmlCtxtUseOptionsInternal(ctxt, options, NULL); 13547 ctxt->linenumbers = 1; 13548 13549 inputStream = xmlLoadExternalEntity(filename, NULL, ctxt); 13550 if (inputStream == NULL) { 13551 xmlFreeParserCtxt(ctxt); 13552 return(NULL); 13553 } 13554 13555 inputPush(ctxt, inputStream); 13556 if ((ctxt->directory == NULL) && (directory == NULL)) 13557 directory = xmlParserGetDirectory(filename); 13558 if ((ctxt->directory == NULL) && (directory != NULL)) 13559 ctxt->directory = directory; 13560 13561 return(ctxt); 13562 } 13563 13564 /** 13565 * xmlCreateFileParserCtxt: 13566 * @filename: the filename 13567 * 13568 * Create a parser context for a file content. 13569 * Automatic support for ZLIB/Compress compressed document is provided 13570 * by default if found at compile-time. 13571 * 13572 * Returns the new parser context or NULL 13573 */ 13574 xmlParserCtxtPtr 13575 xmlCreateFileParserCtxt(const char *filename) 13576 { 13577 return(xmlCreateURLParserCtxt(filename, 0)); 13578 } 13579 13580 #ifdef LIBXML_SAX1_ENABLED 13581 /** 13582 * xmlSAXParseFileWithData: 13583 * @sax: the SAX handler block 13584 * @filename: the filename 13585 * @recovery: work in recovery mode, i.e. tries to read no Well Formed 13586 * documents 13587 * @data: the userdata 13588 * 13589 * parse an XML file and build a tree. Automatic support for ZLIB/Compress 13590 * compressed document is provided by default if found at compile-time. 13591 * It use the given SAX function block to handle the parsing callback. 13592 * If sax is NULL, fallback to the default DOM tree building routines. 13593 * 13594 * User data (void *) is stored within the parser context in the 13595 * context's _private member, so it is available nearly everywhere in libxml 13596 * 13597 * Returns the resulting document tree 13598 */ 13599 13600 xmlDocPtr 13601 xmlSAXParseFileWithData(xmlSAXHandlerPtr sax, const char *filename, 13602 int recovery, void *data) { 13603 xmlDocPtr ret; 13604 xmlParserCtxtPtr ctxt; 13605 13606 xmlInitParser(); 13607 13608 ctxt = xmlCreateFileParserCtxt(filename); 13609 if (ctxt == NULL) { 13610 return(NULL); 13611 } 13612 if (sax != NULL) { 13613 if (ctxt->sax != NULL) 13614 xmlFree(ctxt->sax); 13615 ctxt->sax = sax; 13616 } 13617 xmlDetectSAX2(ctxt); 13618 if (data!=NULL) { 13619 ctxt->_private = data; 13620 } 13621 13622 if (ctxt->directory == NULL) 13623 ctxt->directory = xmlParserGetDirectory(filename); 13624 13625 ctxt->recovery = recovery; 13626 13627 xmlParseDocument(ctxt); 13628 13629 if ((ctxt->wellFormed) || recovery) { 13630 ret = ctxt->myDoc; 13631 if (ret != NULL) { 13632 if (ctxt->input->buf->compressed > 0) 13633 ret->compression = 9; 13634 else 13635 ret->compression = ctxt->input->buf->compressed; 13636 } 13637 } 13638 else { 13639 ret = NULL; 13640 xmlFreeDoc(ctxt->myDoc); 13641 ctxt->myDoc = NULL; 13642 } 13643 if (sax != NULL) 13644 ctxt->sax = NULL; 13645 xmlFreeParserCtxt(ctxt); 13646 13647 return(ret); 13648 } 13649 13650 /** 13651 * xmlSAXParseFile: 13652 * @sax: the SAX handler block 13653 * @filename: the filename 13654 * @recovery: work in recovery mode, i.e. tries to read no Well Formed 13655 * documents 13656 * 13657 * parse an XML file and build a tree. Automatic support for ZLIB/Compress 13658 * compressed document is provided by default if found at compile-time. 13659 * It use the given SAX function block to handle the parsing callback. 13660 * If sax is NULL, fallback to the default DOM tree building routines. 13661 * 13662 * Returns the resulting document tree 13663 */ 13664 13665 xmlDocPtr 13666 xmlSAXParseFile(xmlSAXHandlerPtr sax, const char *filename, 13667 int recovery) { 13668 return(xmlSAXParseFileWithData(sax,filename,recovery,NULL)); 13669 } 13670 13671 /** 13672 * xmlRecoverDoc: 13673 * @cur: a pointer to an array of xmlChar 13674 * 13675 * parse an XML in-memory document and build a tree. 13676 * In the case the document is not Well Formed, a attempt to build a 13677 * tree is tried anyway 13678 * 13679 * Returns the resulting document tree or NULL in case of failure 13680 */ 13681 13682 xmlDocPtr 13683 xmlRecoverDoc(const xmlChar *cur) { 13684 return(xmlSAXParseDoc(NULL, cur, 1)); 13685 } 13686 13687 /** 13688 * xmlParseFile: 13689 * @filename: the filename 13690 * 13691 * parse an XML file and build a tree. Automatic support for ZLIB/Compress 13692 * compressed document is provided by default if found at compile-time. 13693 * 13694 * Returns the resulting document tree if the file was wellformed, 13695 * NULL otherwise. 13696 */ 13697 13698 xmlDocPtr 13699 xmlParseFile(const char *filename) { 13700 return(xmlSAXParseFile(NULL, filename, 0)); 13701 } 13702 13703 /** 13704 * xmlRecoverFile: 13705 * @filename: the filename 13706 * 13707 * parse an XML file and build a tree. Automatic support for ZLIB/Compress 13708 * compressed document is provided by default if found at compile-time. 13709 * In the case the document is not Well Formed, it attempts to build 13710 * a tree anyway 13711 * 13712 * Returns the resulting document tree or NULL in case of failure 13713 */ 13714 13715 xmlDocPtr 13716 xmlRecoverFile(const char *filename) { 13717 return(xmlSAXParseFile(NULL, filename, 1)); 13718 } 13719 13720 13721 /** 13722 * xmlSetupParserForBuffer: 13723 * @ctxt: an XML parser context 13724 * @buffer: a xmlChar * buffer 13725 * @filename: a file name 13726 * 13727 * Setup the parser context to parse a new buffer; Clears any prior 13728 * contents from the parser context. The buffer parameter must not be 13729 * NULL, but the filename parameter can be 13730 */ 13731 void 13732 xmlSetupParserForBuffer(xmlParserCtxtPtr ctxt, const xmlChar* buffer, 13733 const char* filename) 13734 { 13735 xmlParserInputPtr input; 13736 13737 if ((ctxt == NULL) || (buffer == NULL)) 13738 return; 13739 13740 input = xmlNewInputStream(ctxt); 13741 if (input == NULL) { 13742 xmlErrMemory(NULL, "parsing new buffer: out of memory\n"); 13743 xmlClearParserCtxt(ctxt); 13744 return; 13745 } 13746 13747 xmlClearParserCtxt(ctxt); 13748 if (filename != NULL) 13749 input->filename = (char *) xmlCanonicPath((const xmlChar *)filename); 13750 input->base = buffer; 13751 input->cur = buffer; 13752 input->end = &buffer[xmlStrlen(buffer)]; 13753 inputPush(ctxt, input); 13754 } 13755 13756 /** 13757 * xmlSAXUserParseFile: 13758 * @sax: a SAX handler 13759 * @user_data: The user data returned on SAX callbacks 13760 * @filename: a file name 13761 * 13762 * parse an XML file and call the given SAX handler routines. 13763 * Automatic support for ZLIB/Compress compressed document is provided 13764 * 13765 * Returns 0 in case of success or a error number otherwise 13766 */ 13767 int 13768 xmlSAXUserParseFile(xmlSAXHandlerPtr sax, void *user_data, 13769 const char *filename) { 13770 int ret = 0; 13771 xmlParserCtxtPtr ctxt; 13772 13773 ctxt = xmlCreateFileParserCtxt(filename); 13774 if (ctxt == NULL) return -1; 13775 if (ctxt->sax != (xmlSAXHandlerPtr) &xmlDefaultSAXHandler) 13776 xmlFree(ctxt->sax); 13777 ctxt->sax = sax; 13778 xmlDetectSAX2(ctxt); 13779 13780 if (user_data != NULL) 13781 ctxt->userData = user_data; 13782 13783 xmlParseDocument(ctxt); 13784 13785 if (ctxt->wellFormed) 13786 ret = 0; 13787 else { 13788 if (ctxt->errNo != 0) 13789 ret = ctxt->errNo; 13790 else 13791 ret = -1; 13792 } 13793 if (sax != NULL) 13794 ctxt->sax = NULL; 13795 if (ctxt->myDoc != NULL) { 13796 xmlFreeDoc(ctxt->myDoc); 13797 ctxt->myDoc = NULL; 13798 } 13799 xmlFreeParserCtxt(ctxt); 13800 13801 return ret; 13802 } 13803 #endif /* LIBXML_SAX1_ENABLED */ 13804 13805 /************************************************************************ 13806 * * 13807 * Front ends when parsing from memory * 13808 * * 13809 ************************************************************************/ 13810 13811 /** 13812 * xmlCreateMemoryParserCtxt: 13813 * @buffer: a pointer to a char array 13814 * @size: the size of the array 13815 * 13816 * Create a parser context for an XML in-memory document. 13817 * 13818 * Returns the new parser context or NULL 13819 */ 13820 xmlParserCtxtPtr 13821 xmlCreateMemoryParserCtxt(const char *buffer, int size) { 13822 xmlParserCtxtPtr ctxt; 13823 xmlParserInputPtr input; 13824 xmlParserInputBufferPtr buf; 13825 13826 if (buffer == NULL) 13827 return(NULL); 13828 if (size <= 0) 13829 return(NULL); 13830 13831 ctxt = xmlNewParserCtxt(); 13832 if (ctxt == NULL) 13833 return(NULL); 13834 13835 /* TODO: xmlParserInputBufferCreateStatic, requires some serious changes */ 13836 buf = xmlParserInputBufferCreateMem(buffer, size, XML_CHAR_ENCODING_NONE); 13837 if (buf == NULL) { 13838 xmlFreeParserCtxt(ctxt); 13839 return(NULL); 13840 } 13841 13842 input = xmlNewInputStream(ctxt); 13843 if (input == NULL) { 13844 xmlFreeParserInputBuffer(buf); 13845 xmlFreeParserCtxt(ctxt); 13846 return(NULL); 13847 } 13848 13849 input->filename = NULL; 13850 input->buf = buf; 13851 input->base = input->buf->buffer->content; 13852 input->cur = input->buf->buffer->content; 13853 input->end = &input->buf->buffer->content[input->buf->buffer->use]; 13854 13855 inputPush(ctxt, input); 13856 return(ctxt); 13857 } 13858 13859 #ifdef LIBXML_SAX1_ENABLED 13860 /** 13861 * xmlSAXParseMemoryWithData: 13862 * @sax: the SAX handler block 13863 * @buffer: an pointer to a char array 13864 * @size: the size of the array 13865 * @recovery: work in recovery mode, i.e. tries to read no Well Formed 13866 * documents 13867 * @data: the userdata 13868 * 13869 * parse an XML in-memory block and use the given SAX function block 13870 * to handle the parsing callback. If sax is NULL, fallback to the default 13871 * DOM tree building routines. 13872 * 13873 * User data (void *) is stored within the parser context in the 13874 * context's _private member, so it is available nearly everywhere in libxml 13875 * 13876 * Returns the resulting document tree 13877 */ 13878 13879 xmlDocPtr 13880 xmlSAXParseMemoryWithData(xmlSAXHandlerPtr sax, const char *buffer, 13881 int size, int recovery, void *data) { 13882 xmlDocPtr ret; 13883 xmlParserCtxtPtr ctxt; 13884 13885 xmlInitParser(); 13886 13887 ctxt = xmlCreateMemoryParserCtxt(buffer, size); 13888 if (ctxt == NULL) return(NULL); 13889 if (sax != NULL) { 13890 if (ctxt->sax != NULL) 13891 xmlFree(ctxt->sax); 13892 ctxt->sax = sax; 13893 } 13894 xmlDetectSAX2(ctxt); 13895 if (data!=NULL) { 13896 ctxt->_private=data; 13897 } 13898 13899 ctxt->recovery = recovery; 13900 13901 xmlParseDocument(ctxt); 13902 13903 if ((ctxt->wellFormed) || recovery) ret = ctxt->myDoc; 13904 else { 13905 ret = NULL; 13906 xmlFreeDoc(ctxt->myDoc); 13907 ctxt->myDoc = NULL; 13908 } 13909 if (sax != NULL) 13910 ctxt->sax = NULL; 13911 xmlFreeParserCtxt(ctxt); 13912 13913 return(ret); 13914 } 13915 13916 /** 13917 * xmlSAXParseMemory: 13918 * @sax: the SAX handler block 13919 * @buffer: an pointer to a char array 13920 * @size: the size of the array 13921 * @recovery: work in recovery mode, i.e. tries to read not Well Formed 13922 * documents 13923 * 13924 * parse an XML in-memory block and use the given SAX function block 13925 * to handle the parsing callback. If sax is NULL, fallback to the default 13926 * DOM tree building routines. 13927 * 13928 * Returns the resulting document tree 13929 */ 13930 xmlDocPtr 13931 xmlSAXParseMemory(xmlSAXHandlerPtr sax, const char *buffer, 13932 int size, int recovery) { 13933 return xmlSAXParseMemoryWithData(sax, buffer, size, recovery, NULL); 13934 } 13935 13936 /** 13937 * xmlParseMemory: 13938 * @buffer: an pointer to a char array 13939 * @size: the size of the array 13940 * 13941 * parse an XML in-memory block and build a tree. 13942 * 13943 * Returns the resulting document tree 13944 */ 13945 13946 xmlDocPtr xmlParseMemory(const char *buffer, int size) { 13947 return(xmlSAXParseMemory(NULL, buffer, size, 0)); 13948 } 13949 13950 /** 13951 * xmlRecoverMemory: 13952 * @buffer: an pointer to a char array 13953 * @size: the size of the array 13954 * 13955 * parse an XML in-memory block and build a tree. 13956 * In the case the document is not Well Formed, an attempt to 13957 * build a tree is tried anyway 13958 * 13959 * Returns the resulting document tree or NULL in case of error 13960 */ 13961 13962 xmlDocPtr xmlRecoverMemory(const char *buffer, int size) { 13963 return(xmlSAXParseMemory(NULL, buffer, size, 1)); 13964 } 13965 13966 /** 13967 * xmlSAXUserParseMemory: 13968 * @sax: a SAX handler 13969 * @user_data: The user data returned on SAX callbacks 13970 * @buffer: an in-memory XML document input 13971 * @size: the length of the XML document in bytes 13972 * 13973 * A better SAX parsing routine. 13974 * parse an XML in-memory buffer and call the given SAX handler routines. 13975 * 13976 * Returns 0 in case of success or a error number otherwise 13977 */ 13978 int xmlSAXUserParseMemory(xmlSAXHandlerPtr sax, void *user_data, 13979 const char *buffer, int size) { 13980 int ret = 0; 13981 xmlParserCtxtPtr ctxt; 13982 13983 xmlInitParser(); 13984 13985 ctxt = xmlCreateMemoryParserCtxt(buffer, size); 13986 if (ctxt == NULL) return -1; 13987 if (ctxt->sax != (xmlSAXHandlerPtr) &xmlDefaultSAXHandler) 13988 xmlFree(ctxt->sax); 13989 ctxt->sax = sax; 13990 xmlDetectSAX2(ctxt); 13991 13992 if (user_data != NULL) 13993 ctxt->userData = user_data; 13994 13995 xmlParseDocument(ctxt); 13996 13997 if (ctxt->wellFormed) 13998 ret = 0; 13999 else { 14000 if (ctxt->errNo != 0) 14001 ret = ctxt->errNo; 14002 else 14003 ret = -1; 14004 } 14005 if (sax != NULL) 14006 ctxt->sax = NULL; 14007 if (ctxt->myDoc != NULL) { 14008 xmlFreeDoc(ctxt->myDoc); 14009 ctxt->myDoc = NULL; 14010 } 14011 xmlFreeParserCtxt(ctxt); 14012 14013 return ret; 14014 } 14015 #endif /* LIBXML_SAX1_ENABLED */ 14016 14017 /** 14018 * xmlCreateDocParserCtxt: 14019 * @cur: a pointer to an array of xmlChar 14020 * 14021 * Creates a parser context for an XML in-memory document. 14022 * 14023 * Returns the new parser context or NULL 14024 */ 14025 xmlParserCtxtPtr 14026 xmlCreateDocParserCtxt(const xmlChar *cur) { 14027 int len; 14028 14029 if (cur == NULL) 14030 return(NULL); 14031 len = xmlStrlen(cur); 14032 return(xmlCreateMemoryParserCtxt((const char *)cur, len)); 14033 } 14034 14035 #ifdef LIBXML_SAX1_ENABLED 14036 /** 14037 * xmlSAXParseDoc: 14038 * @sax: the SAX handler block 14039 * @cur: a pointer to an array of xmlChar 14040 * @recovery: work in recovery mode, i.e. tries to read no Well Formed 14041 * documents 14042 * 14043 * parse an XML in-memory document and build a tree. 14044 * It use the given SAX function block to handle the parsing callback. 14045 * If sax is NULL, fallback to the default DOM tree building routines. 14046 * 14047 * Returns the resulting document tree 14048 */ 14049 14050 xmlDocPtr 14051 xmlSAXParseDoc(xmlSAXHandlerPtr sax, const xmlChar *cur, int recovery) { 14052 xmlDocPtr ret; 14053 xmlParserCtxtPtr ctxt; 14054 xmlSAXHandlerPtr oldsax = NULL; 14055 14056 if (cur == NULL) return(NULL); 14057 14058 14059 ctxt = xmlCreateDocParserCtxt(cur); 14060 if (ctxt == NULL) return(NULL); 14061 if (sax != NULL) { 14062 oldsax = ctxt->sax; 14063 ctxt->sax = sax; 14064 ctxt->userData = NULL; 14065 } 14066 xmlDetectSAX2(ctxt); 14067 14068 xmlParseDocument(ctxt); 14069 if ((ctxt->wellFormed) || recovery) ret = ctxt->myDoc; 14070 else { 14071 ret = NULL; 14072 xmlFreeDoc(ctxt->myDoc); 14073 ctxt->myDoc = NULL; 14074 } 14075 if (sax != NULL) 14076 ctxt->sax = oldsax; 14077 xmlFreeParserCtxt(ctxt); 14078 14079 return(ret); 14080 } 14081 14082 /** 14083 * xmlParseDoc: 14084 * @cur: a pointer to an array of xmlChar 14085 * 14086 * parse an XML in-memory document and build a tree. 14087 * 14088 * Returns the resulting document tree 14089 */ 14090 14091 xmlDocPtr 14092 xmlParseDoc(const xmlChar *cur) { 14093 return(xmlSAXParseDoc(NULL, cur, 0)); 14094 } 14095 #endif /* LIBXML_SAX1_ENABLED */ 14096 14097 #ifdef LIBXML_LEGACY_ENABLED 14098 /************************************************************************ 14099 * * 14100 * Specific function to keep track of entities references * 14101 * and used by the XSLT debugger * 14102 * * 14103 ************************************************************************/ 14104 14105 static xmlEntityReferenceFunc xmlEntityRefFunc = NULL; 14106 14107 /** 14108 * xmlAddEntityReference: 14109 * @ent : A valid entity 14110 * @firstNode : A valid first node for children of entity 14111 * @lastNode : A valid last node of children entity 14112 * 14113 * Notify of a reference to an entity of type XML_EXTERNAL_GENERAL_PARSED_ENTITY 14114 */ 14115 static void 14116 xmlAddEntityReference(xmlEntityPtr ent, xmlNodePtr firstNode, 14117 xmlNodePtr lastNode) 14118 { 14119 if (xmlEntityRefFunc != NULL) { 14120 (*xmlEntityRefFunc) (ent, firstNode, lastNode); 14121 } 14122 } 14123 14124 14125 /** 14126 * xmlSetEntityReferenceFunc: 14127 * @func: A valid function 14128 * 14129 * Set the function to call call back when a xml reference has been made 14130 */ 14131 void 14132 xmlSetEntityReferenceFunc(xmlEntityReferenceFunc func) 14133 { 14134 xmlEntityRefFunc = func; 14135 } 14136 #endif /* LIBXML_LEGACY_ENABLED */ 14137 14138 /************************************************************************ 14139 * * 14140 * Miscellaneous * 14141 * * 14142 ************************************************************************/ 14143 14144 #ifdef LIBXML_XPATH_ENABLED 14145 #include <libxml/xpath.h> 14146 #endif 14147 14148 extern void XMLCDECL xmlGenericErrorDefaultFunc(void *ctx, const char *msg, ...); 14149 static int xmlParserInitialized = 0; 14150 14151 /** 14152 * xmlInitParser: 14153 * 14154 * Initialization function for the XML parser. 14155 * This is not reentrant. Call once before processing in case of 14156 * use in multithreaded programs. 14157 */ 14158 14159 void 14160 xmlInitParser(void) { 14161 if (xmlParserInitialized != 0) 14162 return; 14163 14164 #ifdef LIBXML_THREAD_ENABLED 14165 __xmlGlobalInitMutexLock(); 14166 if (xmlParserInitialized == 0) { 14167 #endif 14168 xmlInitGlobals(); 14169 xmlInitThreads(); 14170 if ((xmlGenericError == xmlGenericErrorDefaultFunc) || 14171 (xmlGenericError == NULL)) 14172 initGenericErrorDefaultFunc(NULL); 14173 xmlInitMemory(); 14174 xmlInitCharEncodingHandlers(); 14175 xmlDefaultSAXHandlerInit(); 14176 xmlRegisterDefaultInputCallbacks(); 14177 #ifdef LIBXML_OUTPUT_ENABLED 14178 xmlRegisterDefaultOutputCallbacks(); 14179 #endif /* LIBXML_OUTPUT_ENABLED */ 14180 #ifdef LIBXML_HTML_ENABLED 14181 htmlInitAutoClose(); 14182 htmlDefaultSAXHandlerInit(); 14183 #endif 14184 #ifdef LIBXML_XPATH_ENABLED 14185 xmlXPathInit(); 14186 #endif 14187 xmlParserInitialized = 1; 14188 #ifdef LIBXML_THREAD_ENABLED 14189 } 14190 __xmlGlobalInitMutexUnlock(); 14191 #endif 14192 } 14193 14194 /** 14195 * xmlCleanupParser: 14196 * 14197 * This function name is somewhat misleading. It does not clean up 14198 * parser state, it cleans up memory allocated by the library itself. 14199 * It is a cleanup function for the XML library. It tries to reclaim all 14200 * related global memory allocated for the library processing. 14201 * It doesn't deallocate any document related memory. One should 14202 * call xmlCleanupParser() only when the process has finished using 14203 * the library and all XML/HTML documents built with it. 14204 * See also xmlInitParser() which has the opposite function of preparing 14205 * the library for operations. 14206 * 14207 * WARNING: if your application is multithreaded or has plugin support 14208 * calling this may crash the application if another thread or 14209 * a plugin is still using libxml2. It's sometimes very hard to 14210 * guess if libxml2 is in use in the application, some libraries 14211 * or plugins may use it without notice. In case of doubt abstain 14212 * from calling this function or do it just before calling exit() 14213 * to avoid leak reports from valgrind ! 14214 */ 14215 14216 void 14217 xmlCleanupParser(void) { 14218 if (!xmlParserInitialized) 14219 return; 14220 14221 xmlCleanupCharEncodingHandlers(); 14222 #ifdef LIBXML_CATALOG_ENABLED 14223 xmlCatalogCleanup(); 14224 #endif 14225 xmlDictCleanup(); 14226 xmlCleanupInputCallbacks(); 14227 #ifdef LIBXML_OUTPUT_ENABLED 14228 xmlCleanupOutputCallbacks(); 14229 #endif 14230 #ifdef LIBXML_SCHEMAS_ENABLED 14231 xmlSchemaCleanupTypes(); 14232 xmlRelaxNGCleanupTypes(); 14233 #endif 14234 xmlCleanupGlobals(); 14235 xmlResetLastError(); 14236 xmlCleanupThreads(); /* must be last if called not from the main thread */ 14237 xmlCleanupMemory(); 14238 xmlParserInitialized = 0; 14239 } 14240 14241 /************************************************************************ 14242 * * 14243 * New set (2.6.0) of simpler and more flexible APIs * 14244 * * 14245 ************************************************************************/ 14246 14247 /** 14248 * DICT_FREE: 14249 * @str: a string 14250 * 14251 * Free a string if it is not owned by the "dict" dictionnary in the 14252 * current scope 14253 */ 14254 #define DICT_FREE(str) \ 14255 if ((str) && ((!dict) || \ 14256 (xmlDictOwns(dict, (const xmlChar *)(str)) == 0))) \ 14257 xmlFree((char *)(str)); 14258 14259 /** 14260 * xmlCtxtReset: 14261 * @ctxt: an XML parser context 14262 * 14263 * Reset a parser context 14264 */ 14265 void 14266 xmlCtxtReset(xmlParserCtxtPtr ctxt) 14267 { 14268 xmlParserInputPtr input; 14269 xmlDictPtr dict; 14270 14271 if (ctxt == NULL) 14272 return; 14273 14274 dict = ctxt->dict; 14275 14276 while ((input = inputPop(ctxt)) != NULL) { /* Non consuming */ 14277 xmlFreeInputStream(input); 14278 } 14279 ctxt->inputNr = 0; 14280 ctxt->input = NULL; 14281 14282 ctxt->spaceNr = 0; 14283 if (ctxt->spaceTab != NULL) { 14284 ctxt->spaceTab[0] = -1; 14285 ctxt->space = &ctxt->spaceTab[0]; 14286 } else { 14287 ctxt->space = NULL; 14288 } 14289 14290 14291 ctxt->nodeNr = 0; 14292 ctxt->node = NULL; 14293 14294 ctxt->nameNr = 0; 14295 ctxt->name = NULL; 14296 14297 DICT_FREE(ctxt->version); 14298 ctxt->version = NULL; 14299 DICT_FREE(ctxt->encoding); 14300 ctxt->encoding = NULL; 14301 DICT_FREE(ctxt->directory); 14302 ctxt->directory = NULL; 14303 DICT_FREE(ctxt->extSubURI); 14304 ctxt->extSubURI = NULL; 14305 DICT_FREE(ctxt->extSubSystem); 14306 ctxt->extSubSystem = NULL; 14307 if (ctxt->myDoc != NULL) 14308 xmlFreeDoc(ctxt->myDoc); 14309 ctxt->myDoc = NULL; 14310 14311 ctxt->standalone = -1; 14312 ctxt->hasExternalSubset = 0; 14313 ctxt->hasPErefs = 0; 14314 ctxt->html = 0; 14315 ctxt->external = 0; 14316 ctxt->instate = XML_PARSER_START; 14317 ctxt->token = 0; 14318 14319 ctxt->wellFormed = 1; 14320 ctxt->nsWellFormed = 1; 14321 ctxt->disableSAX = 0; 14322 ctxt->valid = 1; 14323 #if 0 14324 ctxt->vctxt.userData = ctxt; 14325 ctxt->vctxt.error = xmlParserValidityError; 14326 ctxt->vctxt.warning = xmlParserValidityWarning; 14327 #endif 14328 ctxt->record_info = 0; 14329 ctxt->nbChars = 0; 14330 ctxt->checkIndex = 0; 14331 ctxt->inSubset = 0; 14332 ctxt->errNo = XML_ERR_OK; 14333 ctxt->depth = 0; 14334 ctxt->charset = XML_CHAR_ENCODING_UTF8; 14335 ctxt->catalogs = NULL; 14336 ctxt->nbentities = 0; 14337 ctxt->sizeentities = 0; 14338 xmlInitNodeInfoSeq(&ctxt->node_seq); 14339 14340 if (ctxt->attsDefault != NULL) { 14341 xmlHashFree(ctxt->attsDefault, (xmlHashDeallocator) xmlFree); 14342 ctxt->attsDefault = NULL; 14343 } 14344 if (ctxt->attsSpecial != NULL) { 14345 xmlHashFree(ctxt->attsSpecial, NULL); 14346 ctxt->attsSpecial = NULL; 14347 } 14348 14349 #ifdef LIBXML_CATALOG_ENABLED 14350 if (ctxt->catalogs != NULL) 14351 xmlCatalogFreeLocal(ctxt->catalogs); 14352 #endif 14353 if (ctxt->lastError.code != XML_ERR_OK) 14354 xmlResetError(&ctxt->lastError); 14355 } 14356 14357 /** 14358 * xmlCtxtResetPush: 14359 * @ctxt: an XML parser context 14360 * @chunk: a pointer to an array of chars 14361 * @size: number of chars in the array 14362 * @filename: an optional file name or URI 14363 * @encoding: the document encoding, or NULL 14364 * 14365 * Reset a push parser context 14366 * 14367 * Returns 0 in case of success and 1 in case of error 14368 */ 14369 int 14370 xmlCtxtResetPush(xmlParserCtxtPtr ctxt, const char *chunk, 14371 int size, const char *filename, const char *encoding) 14372 { 14373 xmlParserInputPtr inputStream; 14374 xmlParserInputBufferPtr buf; 14375 xmlCharEncoding enc = XML_CHAR_ENCODING_NONE; 14376 14377 if (ctxt == NULL) 14378 return(1); 14379 14380 if ((encoding == NULL) && (chunk != NULL) && (size >= 4)) 14381 enc = xmlDetectCharEncoding((const xmlChar *) chunk, size); 14382 14383 buf = xmlAllocParserInputBuffer(enc); 14384 if (buf == NULL) 14385 return(1); 14386 14387 if (ctxt == NULL) { 14388 xmlFreeParserInputBuffer(buf); 14389 return(1); 14390 } 14391 14392 xmlCtxtReset(ctxt); 14393 14394 if (ctxt->pushTab == NULL) { 14395 ctxt->pushTab = (void **) xmlMalloc(ctxt->nameMax * 3 * 14396 sizeof(xmlChar *)); 14397 if (ctxt->pushTab == NULL) { 14398 xmlErrMemory(ctxt, NULL); 14399 xmlFreeParserInputBuffer(buf); 14400 return(1); 14401 } 14402 } 14403 14404 if (filename == NULL) { 14405 ctxt->directory = NULL; 14406 } else { 14407 ctxt->directory = xmlParserGetDirectory(filename); 14408 } 14409 14410 inputStream = xmlNewInputStream(ctxt); 14411 if (inputStream == NULL) { 14412 xmlFreeParserInputBuffer(buf); 14413 return(1); 14414 } 14415 14416 if (filename == NULL) 14417 inputStream->filename = NULL; 14418 else 14419 inputStream->filename = (char *) 14420 xmlCanonicPath((const xmlChar *) filename); 14421 inputStream->buf = buf; 14422 inputStream->base = inputStream->buf->buffer->content; 14423 inputStream->cur = inputStream->buf->buffer->content; 14424 inputStream->end = 14425 &inputStream->buf->buffer->content[inputStream->buf->buffer->use]; 14426 14427 inputPush(ctxt, inputStream); 14428 14429 if ((size > 0) && (chunk != NULL) && (ctxt->input != NULL) && 14430 (ctxt->input->buf != NULL)) { 14431 int base = ctxt->input->base - ctxt->input->buf->buffer->content; 14432 int cur = ctxt->input->cur - ctxt->input->base; 14433 14434 xmlParserInputBufferPush(ctxt->input->buf, size, chunk); 14435 14436 ctxt->input->base = ctxt->input->buf->buffer->content + base; 14437 ctxt->input->cur = ctxt->input->base + cur; 14438 ctxt->input->end = 14439 &ctxt->input->buf->buffer->content[ctxt->input->buf->buffer-> 14440 use]; 14441 #ifdef DEBUG_PUSH 14442 xmlGenericError(xmlGenericErrorContext, "PP: pushed %d\n", size); 14443 #endif 14444 } 14445 14446 if (encoding != NULL) { 14447 xmlCharEncodingHandlerPtr hdlr; 14448 14449 if (ctxt->encoding != NULL) 14450 xmlFree((xmlChar *) ctxt->encoding); 14451 ctxt->encoding = xmlStrdup((const xmlChar *) encoding); 14452 14453 hdlr = xmlFindCharEncodingHandler(encoding); 14454 if (hdlr != NULL) { 14455 xmlSwitchToEncoding(ctxt, hdlr); 14456 } else { 14457 xmlFatalErrMsgStr(ctxt, XML_ERR_UNSUPPORTED_ENCODING, 14458 "Unsupported encoding %s\n", BAD_CAST encoding); 14459 } 14460 } else if (enc != XML_CHAR_ENCODING_NONE) { 14461 xmlSwitchEncoding(ctxt, enc); 14462 } 14463 14464 return(0); 14465 } 14466 14467 14468 /** 14469 * xmlCtxtUseOptionsInternal: 14470 * @ctxt: an XML parser context 14471 * @options: a combination of xmlParserOption 14472 * @encoding: the user provided encoding to use 14473 * 14474 * Applies the options to the parser context 14475 * 14476 * Returns 0 in case of success, the set of unknown or unimplemented options 14477 * in case of error. 14478 */ 14479 static int 14480 xmlCtxtUseOptionsInternal(xmlParserCtxtPtr ctxt, int options, const char *encoding) 14481 { 14482 if (ctxt == NULL) 14483 return(-1); 14484 if (encoding != NULL) { 14485 if (ctxt->encoding != NULL) 14486 xmlFree((xmlChar *) ctxt->encoding); 14487 ctxt->encoding = xmlStrdup((const xmlChar *) encoding); 14488 } 14489 if (options & XML_PARSE_RECOVER) { 14490 ctxt->recovery = 1; 14491 options -= XML_PARSE_RECOVER; 14492 ctxt->options |= XML_PARSE_RECOVER; 14493 } else 14494 ctxt->recovery = 0; 14495 if (options & XML_PARSE_DTDLOAD) { 14496 ctxt->loadsubset = XML_DETECT_IDS; 14497 options -= XML_PARSE_DTDLOAD; 14498 ctxt->options |= XML_PARSE_DTDLOAD; 14499 } else 14500 ctxt->loadsubset = 0; 14501 if (options & XML_PARSE_DTDATTR) { 14502 ctxt->loadsubset |= XML_COMPLETE_ATTRS; 14503 options -= XML_PARSE_DTDATTR; 14504 ctxt->options |= XML_PARSE_DTDATTR; 14505 } 14506 if (options & XML_PARSE_NOENT) { 14507 ctxt->replaceEntities = 1; 14508 /* ctxt->loadsubset |= XML_DETECT_IDS; */ 14509 options -= XML_PARSE_NOENT; 14510 ctxt->options |= XML_PARSE_NOENT; 14511 } else 14512 ctxt->replaceEntities = 0; 14513 if (options & XML_PARSE_PEDANTIC) { 14514 ctxt->pedantic = 1; 14515 options -= XML_PARSE_PEDANTIC; 14516 ctxt->options |= XML_PARSE_PEDANTIC; 14517 } else 14518 ctxt->pedantic = 0; 14519 if (options & XML_PARSE_NOBLANKS) { 14520 ctxt->keepBlanks = 0; 14521 ctxt->sax->ignorableWhitespace = xmlSAX2IgnorableWhitespace; 14522 options -= XML_PARSE_NOBLANKS; 14523 ctxt->options |= XML_PARSE_NOBLANKS; 14524 } else 14525 ctxt->keepBlanks = 1; 14526 if (options & XML_PARSE_DTDVALID) { 14527 ctxt->validate = 1; 14528 if (options & XML_PARSE_NOWARNING) 14529 ctxt->vctxt.warning = NULL; 14530 if (options & XML_PARSE_NOERROR) 14531 ctxt->vctxt.error = NULL; 14532 options -= XML_PARSE_DTDVALID; 14533 ctxt->options |= XML_PARSE_DTDVALID; 14534 } else 14535 ctxt->validate = 0; 14536 if (options & XML_PARSE_NOWARNING) { 14537 ctxt->sax->warning = NULL; 14538 options -= XML_PARSE_NOWARNING; 14539 } 14540 if (options & XML_PARSE_NOERROR) { 14541 ctxt->sax->error = NULL; 14542 ctxt->sax->fatalError = NULL; 14543 options -= XML_PARSE_NOERROR; 14544 } 14545 #ifdef LIBXML_SAX1_ENABLED 14546 if (options & XML_PARSE_SAX1) { 14547 ctxt->sax->startElement = xmlSAX2StartElement; 14548 ctxt->sax->endElement = xmlSAX2EndElement; 14549 ctxt->sax->startElementNs = NULL; 14550 ctxt->sax->endElementNs = NULL; 14551 ctxt->sax->initialized = 1; 14552 options -= XML_PARSE_SAX1; 14553 ctxt->options |= XML_PARSE_SAX1; 14554 } 14555 #endif /* LIBXML_SAX1_ENABLED */ 14556 if (options & XML_PARSE_NODICT) { 14557 ctxt->dictNames = 0; 14558 options -= XML_PARSE_NODICT; 14559 ctxt->options |= XML_PARSE_NODICT; 14560 } else { 14561 ctxt->dictNames = 1; 14562 } 14563 if (options & XML_PARSE_NOCDATA) { 14564 ctxt->sax->cdataBlock = NULL; 14565 options -= XML_PARSE_NOCDATA; 14566 ctxt->options |= XML_PARSE_NOCDATA; 14567 } 14568 if (options & XML_PARSE_NSCLEAN) { 14569 ctxt->options |= XML_PARSE_NSCLEAN; 14570 options -= XML_PARSE_NSCLEAN; 14571 } 14572 if (options & XML_PARSE_NONET) { 14573 ctxt->options |= XML_PARSE_NONET; 14574 options -= XML_PARSE_NONET; 14575 } 14576 if (options & XML_PARSE_COMPACT) { 14577 ctxt->options |= XML_PARSE_COMPACT; 14578 options -= XML_PARSE_COMPACT; 14579 } 14580 if (options & XML_PARSE_OLD10) { 14581 ctxt->options |= XML_PARSE_OLD10; 14582 options -= XML_PARSE_OLD10; 14583 } 14584 if (options & XML_PARSE_NOBASEFIX) { 14585 ctxt->options |= XML_PARSE_NOBASEFIX; 14586 options -= XML_PARSE_NOBASEFIX; 14587 } 14588 if (options & XML_PARSE_HUGE) { 14589 ctxt->options |= XML_PARSE_HUGE; 14590 options -= XML_PARSE_HUGE; 14591 } 14592 if (options & XML_PARSE_OLDSAX) { 14593 ctxt->options |= XML_PARSE_OLDSAX; 14594 options -= XML_PARSE_OLDSAX; 14595 } 14596 ctxt->linenumbers = 1; 14597 return (options); 14598 } 14599 14600 /** 14601 * xmlCtxtUseOptions: 14602 * @ctxt: an XML parser context 14603 * @options: a combination of xmlParserOption 14604 * 14605 * Applies the options to the parser context 14606 * 14607 * Returns 0 in case of success, the set of unknown or unimplemented options 14608 * in case of error. 14609 */ 14610 int 14611 xmlCtxtUseOptions(xmlParserCtxtPtr ctxt, int options) 14612 { 14613 return(xmlCtxtUseOptionsInternal(ctxt, options, NULL)); 14614 } 14615 14616 /** 14617 * xmlDoRead: 14618 * @ctxt: an XML parser context 14619 * @URL: the base URL to use for the document 14620 * @encoding: the document encoding, or NULL 14621 * @options: a combination of xmlParserOption 14622 * @reuse: keep the context for reuse 14623 * 14624 * Common front-end for the xmlRead functions 14625 * 14626 * Returns the resulting document tree or NULL 14627 */ 14628 static xmlDocPtr 14629 xmlDoRead(xmlParserCtxtPtr ctxt, const char *URL, const char *encoding, 14630 int options, int reuse) 14631 { 14632 xmlDocPtr ret; 14633 14634 xmlCtxtUseOptionsInternal(ctxt, options, encoding); 14635 if (encoding != NULL) { 14636 xmlCharEncodingHandlerPtr hdlr; 14637 14638 hdlr = xmlFindCharEncodingHandler(encoding); 14639 if (hdlr != NULL) 14640 xmlSwitchToEncoding(ctxt, hdlr); 14641 } 14642 if ((URL != NULL) && (ctxt->input != NULL) && 14643 (ctxt->input->filename == NULL)) 14644 ctxt->input->filename = (char *) xmlStrdup((const xmlChar *) URL); 14645 xmlParseDocument(ctxt); 14646 if ((ctxt->wellFormed) || ctxt->recovery) 14647 ret = ctxt->myDoc; 14648 else { 14649 ret = NULL; 14650 if (ctxt->myDoc != NULL) { 14651 xmlFreeDoc(ctxt->myDoc); 14652 } 14653 } 14654 ctxt->myDoc = NULL; 14655 if (!reuse) { 14656 xmlFreeParserCtxt(ctxt); 14657 } 14658 14659 return (ret); 14660 } 14661 14662 /** 14663 * xmlReadDoc: 14664 * @cur: a pointer to a zero terminated string 14665 * @URL: the base URL to use for the document 14666 * @encoding: the document encoding, or NULL 14667 * @options: a combination of xmlParserOption 14668 * 14669 * parse an XML in-memory document and build a tree. 14670 * 14671 * Returns the resulting document tree 14672 */ 14673 xmlDocPtr 14674 xmlReadDoc(const xmlChar * cur, const char *URL, const char *encoding, int options) 14675 { 14676 xmlParserCtxtPtr ctxt; 14677 14678 if (cur == NULL) 14679 return (NULL); 14680 14681 ctxt = xmlCreateDocParserCtxt(cur); 14682 if (ctxt == NULL) 14683 return (NULL); 14684 return (xmlDoRead(ctxt, URL, encoding, options, 0)); 14685 } 14686 14687 /** 14688 * xmlReadFile: 14689 * @filename: a file or URL 14690 * @encoding: the document encoding, or NULL 14691 * @options: a combination of xmlParserOption 14692 * 14693 * parse an XML file from the filesystem or the network. 14694 * 14695 * Returns the resulting document tree 14696 */ 14697 xmlDocPtr 14698 xmlReadFile(const char *filename, const char *encoding, int options) 14699 { 14700 xmlParserCtxtPtr ctxt; 14701 14702 ctxt = xmlCreateURLParserCtxt(filename, options); 14703 if (ctxt == NULL) 14704 return (NULL); 14705 return (xmlDoRead(ctxt, NULL, encoding, options, 0)); 14706 } 14707 14708 /** 14709 * xmlReadMemory: 14710 * @buffer: a pointer to a char array 14711 * @size: the size of the array 14712 * @URL: the base URL to use for the document 14713 * @encoding: the document encoding, or NULL 14714 * @options: a combination of xmlParserOption 14715 * 14716 * parse an XML in-memory document and build a tree. 14717 * 14718 * Returns the resulting document tree 14719 */ 14720 xmlDocPtr 14721 xmlReadMemory(const char *buffer, int size, const char *URL, const char *encoding, int options) 14722 { 14723 xmlParserCtxtPtr ctxt; 14724 14725 ctxt = xmlCreateMemoryParserCtxt(buffer, size); 14726 if (ctxt == NULL) 14727 return (NULL); 14728 return (xmlDoRead(ctxt, URL, encoding, options, 0)); 14729 } 14730 14731 /** 14732 * xmlReadFd: 14733 * @fd: an open file descriptor 14734 * @URL: the base URL to use for the document 14735 * @encoding: the document encoding, or NULL 14736 * @options: a combination of xmlParserOption 14737 * 14738 * parse an XML from a file descriptor and build a tree. 14739 * NOTE that the file descriptor will not be closed when the 14740 * reader is closed or reset. 14741 * 14742 * Returns the resulting document tree 14743 */ 14744 xmlDocPtr 14745 xmlReadFd(int fd, const char *URL, const char *encoding, int options) 14746 { 14747 xmlParserCtxtPtr ctxt; 14748 xmlParserInputBufferPtr input; 14749 xmlParserInputPtr stream; 14750 14751 if (fd < 0) 14752 return (NULL); 14753 14754 input = xmlParserInputBufferCreateFd(fd, XML_CHAR_ENCODING_NONE); 14755 if (input == NULL) 14756 return (NULL); 14757 input->closecallback = NULL; 14758 ctxt = xmlNewParserCtxt(); 14759 if (ctxt == NULL) { 14760 xmlFreeParserInputBuffer(input); 14761 return (NULL); 14762 } 14763 stream = xmlNewIOInputStream(ctxt, input, XML_CHAR_ENCODING_NONE); 14764 if (stream == NULL) { 14765 xmlFreeParserInputBuffer(input); 14766 xmlFreeParserCtxt(ctxt); 14767 return (NULL); 14768 } 14769 inputPush(ctxt, stream); 14770 return (xmlDoRead(ctxt, URL, encoding, options, 0)); 14771 } 14772 14773 /** 14774 * xmlReadIO: 14775 * @ioread: an I/O read function 14776 * @ioclose: an I/O close function 14777 * @ioctx: an I/O handler 14778 * @URL: the base URL to use for the document 14779 * @encoding: the document encoding, or NULL 14780 * @options: a combination of xmlParserOption 14781 * 14782 * parse an XML document from I/O functions and source and build a tree. 14783 * 14784 * Returns the resulting document tree 14785 */ 14786 xmlDocPtr 14787 xmlReadIO(xmlInputReadCallback ioread, xmlInputCloseCallback ioclose, 14788 void *ioctx, const char *URL, const char *encoding, int options) 14789 { 14790 xmlParserCtxtPtr ctxt; 14791 xmlParserInputBufferPtr input; 14792 xmlParserInputPtr stream; 14793 14794 if (ioread == NULL) 14795 return (NULL); 14796 14797 input = xmlParserInputBufferCreateIO(ioread, ioclose, ioctx, 14798 XML_CHAR_ENCODING_NONE); 14799 if (input == NULL) 14800 return (NULL); 14801 ctxt = xmlNewParserCtxt(); 14802 if (ctxt == NULL) { 14803 xmlFreeParserInputBuffer(input); 14804 return (NULL); 14805 } 14806 stream = xmlNewIOInputStream(ctxt, input, XML_CHAR_ENCODING_NONE); 14807 if (stream == NULL) { 14808 xmlFreeParserInputBuffer(input); 14809 xmlFreeParserCtxt(ctxt); 14810 return (NULL); 14811 } 14812 inputPush(ctxt, stream); 14813 return (xmlDoRead(ctxt, URL, encoding, options, 0)); 14814 } 14815 14816 /** 14817 * xmlCtxtReadDoc: 14818 * @ctxt: an XML parser context 14819 * @cur: a pointer to a zero terminated string 14820 * @URL: the base URL to use for the document 14821 * @encoding: the document encoding, or NULL 14822 * @options: a combination of xmlParserOption 14823 * 14824 * parse an XML in-memory document and build a tree. 14825 * This reuses the existing @ctxt parser context 14826 * 14827 * Returns the resulting document tree 14828 */ 14829 xmlDocPtr 14830 xmlCtxtReadDoc(xmlParserCtxtPtr ctxt, const xmlChar * cur, 14831 const char *URL, const char *encoding, int options) 14832 { 14833 xmlParserInputPtr stream; 14834 14835 if (cur == NULL) 14836 return (NULL); 14837 if (ctxt == NULL) 14838 return (NULL); 14839 14840 xmlCtxtReset(ctxt); 14841 14842 stream = xmlNewStringInputStream(ctxt, cur); 14843 if (stream == NULL) { 14844 return (NULL); 14845 } 14846 inputPush(ctxt, stream); 14847 return (xmlDoRead(ctxt, URL, encoding, options, 1)); 14848 } 14849 14850 /** 14851 * xmlCtxtReadFile: 14852 * @ctxt: an XML parser context 14853 * @filename: a file or URL 14854 * @encoding: the document encoding, or NULL 14855 * @options: a combination of xmlParserOption 14856 * 14857 * parse an XML file from the filesystem or the network. 14858 * This reuses the existing @ctxt parser context 14859 * 14860 * Returns the resulting document tree 14861 */ 14862 xmlDocPtr 14863 xmlCtxtReadFile(xmlParserCtxtPtr ctxt, const char *filename, 14864 const char *encoding, int options) 14865 { 14866 xmlParserInputPtr stream; 14867 14868 if (filename == NULL) 14869 return (NULL); 14870 if (ctxt == NULL) 14871 return (NULL); 14872 14873 xmlCtxtReset(ctxt); 14874 14875 stream = xmlLoadExternalEntity(filename, NULL, ctxt); 14876 if (stream == NULL) { 14877 return (NULL); 14878 } 14879 inputPush(ctxt, stream); 14880 return (xmlDoRead(ctxt, NULL, encoding, options, 1)); 14881 } 14882 14883 /** 14884 * xmlCtxtReadMemory: 14885 * @ctxt: an XML parser context 14886 * @buffer: a pointer to a char array 14887 * @size: the size of the array 14888 * @URL: the base URL to use for the document 14889 * @encoding: the document encoding, or NULL 14890 * @options: a combination of xmlParserOption 14891 * 14892 * parse an XML in-memory document and build a tree. 14893 * This reuses the existing @ctxt parser context 14894 * 14895 * Returns the resulting document tree 14896 */ 14897 xmlDocPtr 14898 xmlCtxtReadMemory(xmlParserCtxtPtr ctxt, const char *buffer, int size, 14899 const char *URL, const char *encoding, int options) 14900 { 14901 xmlParserInputBufferPtr input; 14902 xmlParserInputPtr stream; 14903 14904 if (ctxt == NULL) 14905 return (NULL); 14906 if (buffer == NULL) 14907 return (NULL); 14908 14909 xmlCtxtReset(ctxt); 14910 14911 input = xmlParserInputBufferCreateMem(buffer, size, XML_CHAR_ENCODING_NONE); 14912 if (input == NULL) { 14913 return(NULL); 14914 } 14915 14916 stream = xmlNewIOInputStream(ctxt, input, XML_CHAR_ENCODING_NONE); 14917 if (stream == NULL) { 14918 xmlFreeParserInputBuffer(input); 14919 return(NULL); 14920 } 14921 14922 inputPush(ctxt, stream); 14923 return (xmlDoRead(ctxt, URL, encoding, options, 1)); 14924 } 14925 14926 /** 14927 * xmlCtxtReadFd: 14928 * @ctxt: an XML parser context 14929 * @fd: an open file descriptor 14930 * @URL: the base URL to use for the document 14931 * @encoding: the document encoding, or NULL 14932 * @options: a combination of xmlParserOption 14933 * 14934 * parse an XML from a file descriptor and build a tree. 14935 * This reuses the existing @ctxt parser context 14936 * NOTE that the file descriptor will not be closed when the 14937 * reader is closed or reset. 14938 * 14939 * Returns the resulting document tree 14940 */ 14941 xmlDocPtr 14942 xmlCtxtReadFd(xmlParserCtxtPtr ctxt, int fd, 14943 const char *URL, const char *encoding, int options) 14944 { 14945 xmlParserInputBufferPtr input; 14946 xmlParserInputPtr stream; 14947 14948 if (fd < 0) 14949 return (NULL); 14950 if (ctxt == NULL) 14951 return (NULL); 14952 14953 xmlCtxtReset(ctxt); 14954 14955 14956 input = xmlParserInputBufferCreateFd(fd, XML_CHAR_ENCODING_NONE); 14957 if (input == NULL) 14958 return (NULL); 14959 input->closecallback = NULL; 14960 stream = xmlNewIOInputStream(ctxt, input, XML_CHAR_ENCODING_NONE); 14961 if (stream == NULL) { 14962 xmlFreeParserInputBuffer(input); 14963 return (NULL); 14964 } 14965 inputPush(ctxt, stream); 14966 return (xmlDoRead(ctxt, URL, encoding, options, 1)); 14967 } 14968 14969 /** 14970 * xmlCtxtReadIO: 14971 * @ctxt: an XML parser context 14972 * @ioread: an I/O read function 14973 * @ioclose: an I/O close function 14974 * @ioctx: an I/O handler 14975 * @URL: the base URL to use for the document 14976 * @encoding: the document encoding, or NULL 14977 * @options: a combination of xmlParserOption 14978 * 14979 * parse an XML document from I/O functions and source and build a tree. 14980 * This reuses the existing @ctxt parser context 14981 * 14982 * Returns the resulting document tree 14983 */ 14984 xmlDocPtr 14985 xmlCtxtReadIO(xmlParserCtxtPtr ctxt, xmlInputReadCallback ioread, 14986 xmlInputCloseCallback ioclose, void *ioctx, 14987 const char *URL, 14988 const char *encoding, int options) 14989 { 14990 xmlParserInputBufferPtr input; 14991 xmlParserInputPtr stream; 14992 14993 if (ioread == NULL) 14994 return (NULL); 14995 if (ctxt == NULL) 14996 return (NULL); 14997 14998 xmlCtxtReset(ctxt); 14999 15000 input = xmlParserInputBufferCreateIO(ioread, ioclose, ioctx, 15001 XML_CHAR_ENCODING_NONE); 15002 if (input == NULL) 15003 return (NULL); 15004 stream = xmlNewIOInputStream(ctxt, input, XML_CHAR_ENCODING_NONE); 15005 if (stream == NULL) { 15006 xmlFreeParserInputBuffer(input); 15007 return (NULL); 15008 } 15009 inputPush(ctxt, stream); 15010 return (xmlDoRead(ctxt, URL, encoding, options, 1)); 15011 } 15012 15013 #define bottom_parser 15014 #include "elfgcchack.h" 15015
