parser.c

   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@veillard.com
  31  */
  32
  33 #define IN_LIBXML
  34 #include "libxml.h"
  35
  36 #if defined(WIN32) && !defined (__CYGWIN__)
  37 #define XML_DIR_SEP '\\'
  38 #else
  39 #define XML_DIR_SEP '/'
  40 #endif
  41
  42 #include <stdlib.h>
  43 #include <limits.h>
  44 #include <string.h>
  45 #include <stdarg.h>
  46 #include <libxml/xmlmemory.h>
  47 #include <libxml/threads.h>
  48 #include <libxml/globals.h>
  49 #include <libxml/tree.h>
  50 #include <libxml/parser.h>
  51 #include <libxml/parserInternals.h>
  52 #include <libxml/valid.h>
  53 #include <libxml/entities.h>
  54 #include <libxml/xmlerror.h>
  55 #include <libxml/encoding.h>
  56 #include <libxml/xmlIO.h>
  57 #include <libxml/uri.h>
  58 #ifdef LIBXML_CATALOG_ENABLED
  59 #include <libxml/catalog.h>
  60 #endif
  61 #ifdef LIBXML_SCHEMAS_ENABLED
  62 #include <libxml/xmlschemastypes.h>
  63 #include <libxml/relaxng.h>
  64 #endif
  65 #ifdef HAVE_CTYPE_H
  66 #include <ctype.h>
  67 #endif
  68 #ifdef HAVE_STDLIB_H
  69 #include <stdlib.h>
  70 #endif
  71 #ifdef HAVE_SYS_STAT_H
  72 #include <sys/stat.h>
  73 #endif
  74 #ifdef HAVE_FCNTL_H
  75 #include <fcntl.h>
  76 #endif
  77 #ifdef HAVE_UNISTD_H
  78 #include <unistd.h>
  79 #endif
  80 #ifdef HAVE_ZLIB_H
  81 #include <zlib.h>
  82 #endif
  83 #ifdef HAVE_LZMA_H
  84 #include <lzma.h>
  85 #endif
  86
  87 #include "buf.h"
  88 #include "enc.h"
  89
  90 static void
  91 xmlFatalErr(xmlParserCtxtPtr ctxt, xmlParserErrors error, const char *info);
  92
  93 static xmlParserCtxtPtr
  94 xmlCreateEntityParserCtxtInternal(const xmlChar *URL, const xmlChar *ID,
  95                           const xmlChar *base, xmlParserCtxtPtr pctx);
  96
  97 /************************************************************************
  98  *                                                                      *
  99  *      Arbitrary limits set in the parser. See XML_PARSE_HUGE          *
 100  *                                                                      *
 101  ************************************************************************/
 102
 103 #define XML_PARSER_BIG_ENTITY 1000
 104 #define XML_PARSER_LOT_ENTITY 5000
 105
 106 /*
 107  * XML_PARSER_NON_LINEAR is the threshold where the ratio of parsed entity
 108  *    replacement over the size in byte of the input indicates that you have
 109  *    and eponential behaviour. A value of 10 correspond to at least 3 entity
 110  *    replacement per byte of input.
 111  */
 112 #define XML_PARSER_NON_LINEAR 10
 113
 114 /*
 115  * xmlParserEntityCheck
 116  *
 117  * Function to check non-linear entity expansion behaviour
 118  * This is here to detect and stop exponential linear entity expansion
 119  * This is not a limitation of the parser but a safety
 120  * boundary feature. It can be disabled with the XML_PARSE_HUGE
 121  * parser option.
 122  */
 123 static int
 124 xmlParserEntityCheck(xmlParserCtxtPtr ctxt, size_t size,
 125                      xmlEntityPtr ent, size_t replacement)
 126 {
 127     size_t consumed = 0;
 128
 129     if ((ctxt == NULL) || (ctxt->options & XML_PARSE_HUGE))
 130         return (0);
 131     if (ctxt->lastError.code == XML_ERR_ENTITY_LOOP)
 132         return (1);
 133     if (replacement != 0) {
 134         if (replacement < XML_MAX_TEXT_LENGTH)
 135             return(0);
 136
 137         /*
 138          * If the volume of entity copy reaches 10 times the
 139          * amount of parsed data and over the large text threshold
 140          * then that's very likely to be an abuse.
 141          */
 142         if (ctxt->input != NULL) {
 143             consumed = ctxt->input->consumed +
 144                        (ctxt->input->cur - ctxt->input->base);
 145         }
 146         consumed += ctxt->sizeentities;
 147
 148         if (replacement < XML_PARSER_NON_LINEAR * consumed)
 149             return(0);
 150     } else if (size != 0) {
 151         /*
 152          * Do the check based on the replacement size of the entity
 153          */
 154         if (size < XML_PARSER_BIG_ENTITY)
 155             return(0);
 156
 157         /*
 158          * A limit on the amount of text data reasonably used
 159          */
 160         if (ctxt->input != NULL) {
 161             consumed = ctxt->input->consumed +
 162                 (ctxt->input->cur - ctxt->input->base);
 163         }
 164         consumed += ctxt->sizeentities;
 165
 166         if ((size < XML_PARSER_NON_LINEAR * consumed) &&
 167             (ctxt->nbentities * 3 < XML_PARSER_NON_LINEAR * consumed))
 168             return (0);
 169     } else if (ent != NULL) {
 170         /*
 171          * use the number of parsed entities in the replacement
 172          */
 173         size = ent->checked / 2;
 174
 175         /*
 176          * The amount of data parsed counting entities size only once
 177          */
 178         if (ctxt->input != NULL) {
 179             consumed = ctxt->input->consumed +
 180                 (ctxt->input->cur - ctxt->input->base);
 181         }
 182         consumed += ctxt->sizeentities;
 183
 184         /*
 185          * Check the density of entities for the amount of data
 186          * knowing an entity reference will take at least 3 bytes
 187          */
 188         if (size * 3 < consumed * XML_PARSER_NON_LINEAR)
 189             return (0);
 190     } else {
 191         /*
 192          * strange we got no data for checking just return
 193          */
 194         return (0);
 195     }
 196     xmlFatalErr(ctxt, XML_ERR_ENTITY_LOOP, NULL);
 197     return (1);
 198 }
 199
 200 /**
 201  * xmlParserMaxDepth:
 202  *
 203  * arbitrary depth limit for the XML documents that we allow to
 204  * process. This is not a limitation of the parser but a safety
 205  * boundary feature. It can be disabled with the XML_PARSE_HUGE
 206  * parser option.
 207  */
 208 unsigned int xmlParserMaxDepth = 256;
 209
 210
 211
 212 #define SAX2 1
 213 #define XML_PARSER_BIG_BUFFER_SIZE 300
 214 #define XML_PARSER_BUFFER_SIZE 100
 215 #define SAX_COMPAT_MODE BAD_CAST "SAX compatibility mode document"
 216
 217 /**
 218  * XML_PARSER_CHUNK_SIZE
 219  *
 220  * When calling GROW that's the minimal amount of data
 221  * the parser expected to have received. It is not a hard
 222  * limit but an optimization when reading strings like Names
 223  * It is not strictly needed as long as inputs available characters
 224  * are followed by 0, which should be provided by the I/O level
 225  */
 226 #define XML_PARSER_CHUNK_SIZE 100
 227
 228 /*
 229  * List of XML prefixed PI allowed by W3C specs
 230  */
 231
 232 static const char *xmlW3CPIs[] = {
 233     "xml-stylesheet",
 234     "xml-model",
 235     NULL
 236 };
 237
 238
 239 /* DEPR void xmlParserHandleReference(xmlParserCtxtPtr ctxt); */
 240 static xmlEntityPtr xmlParseStringPEReference(xmlParserCtxtPtr ctxt,
 241                                               const xmlChar **str);
 242
 243 static xmlParserErrors
 244 xmlParseExternalEntityPrivate(xmlDocPtr doc, xmlParserCtxtPtr oldctxt,
 245                       xmlSAXHandlerPtr sax,
 246                       void *user_data, int depth, const xmlChar *URL,
 247                       const xmlChar *ID, xmlNodePtr *list);
 248
 249 static int
 250 xmlCtxtUseOptionsInternal(xmlParserCtxtPtr ctxt, int options,
 251                           const char *encoding);
 252 #ifdef LIBXML_LEGACY_ENABLED
 253 static void
 254 xmlAddEntityReference(xmlEntityPtr ent, xmlNodePtr firstNode,
 255                       xmlNodePtr lastNode);
 256 #endif /* LIBXML_LEGACY_ENABLED */
 257
 258 static xmlParserErrors
 259 xmlParseBalancedChunkMemoryInternal(xmlParserCtxtPtr oldctxt,
 260                       const xmlChar *string, void *user_data, xmlNodePtr *lst);
 261
 262 static int
 263 xmlLoadEntityContent(xmlParserCtxtPtr ctxt, xmlEntityPtr entity);
 264
 265 /************************************************************************
 266  *                                                                      *
 267  *              Some factorized error routines                          *
 268  *                                                                      *
 269  ************************************************************************/
 270
 271 /**
 272  * xmlErrAttributeDup:
 273  * @ctxt:  an XML parser context
 274  * @prefix:  the attribute prefix
 275  * @localname:  the attribute localname
 276  *
 277  * Handle a redefinition of attribute error
 278  */
 279 static void
 280 xmlErrAttributeDup(xmlParserCtxtPtr ctxt, const xmlChar * prefix,
 281                    const xmlChar * localname)
 282 {
 283     if ((ctxt != NULL) && (ctxt->disableSAX != 0) &&
 284         (ctxt->instate == XML_PARSER_EOF))
 285         return;
 286     if (ctxt != NULL)
 287         ctxt->errNo = XML_ERR_ATTRIBUTE_REDEFINED;
 288
 289     if (prefix == NULL)
 290         __xmlRaiseError(NULL, NULL, NULL, ctxt, NULL, XML_FROM_PARSER,
 291                         XML_ERR_ATTRIBUTE_REDEFINED, XML_ERR_FATAL, NULL, 0,
 292                         (const char *) localname, NULL, NULL, 0, 0,
 293                         "Attribute %s redefined\n", localname);
 294     else
 295         __xmlRaiseError(NULL, NULL, NULL, ctxt, NULL, XML_FROM_PARSER,
 296                         XML_ERR_ATTRIBUTE_REDEFINED, XML_ERR_FATAL, NULL, 0,
 297                         (const char *) prefix, (const char *) localname,
 298                         NULL, 0, 0, "Attribute %s:%s redefined\n", prefix,
 299                         localname);
 300     if (ctxt != NULL) {
 301         ctxt->wellFormed = 0;
 302         if (ctxt->recovery == 0)
 303             ctxt->disableSAX = 1;
 304     }
 305 }
 306
 307 /**
 308  * xmlFatalErr:
 309  * @ctxt:  an XML parser context
 310  * @error:  the error number
 311  * @extra:  extra information string
 312  *
 313  * Handle a fatal parser error, i.e. violating Well-Formedness constraints
 314  */
 315 static void
 316 xmlFatalErr(xmlParserCtxtPtr ctxt, xmlParserErrors error, const char *info)
 317 {
 318     const char *errmsg;
 319     char errstr[129] = "";
 320
 321     if ((ctxt != NULL) && (ctxt->disableSAX != 0) &&
 322         (ctxt->instate == XML_PARSER_EOF))
 323         return;
 324     switch (error) {
 325         case XML_ERR_INVALID_HEX_CHARREF:
 326             errmsg = "CharRef: invalid hexadecimal value";
 327             break;
 328         case XML_ERR_INVALID_DEC_CHARREF:
 329             errmsg = "CharRef: invalid decimal value";
 330             break;
 331         case XML_ERR_INVALID_CHARREF:
 332             errmsg = "CharRef: invalid value";
 333             break;
 334         case XML_ERR_INTERNAL_ERROR:
 335             errmsg = "internal error";
 336             break;
 337         case XML_ERR_PEREF_AT_EOF:
 338             errmsg = "PEReference at end of document";
 339             break;
 340         case XML_ERR_PEREF_IN_PROLOG:
 341             errmsg = "PEReference in prolog";
 342             break;
 343         case XML_ERR_PEREF_IN_EPILOG:
 344             errmsg = "PEReference in epilog";
 345             break;
 346         case XML_ERR_PEREF_NO_NAME:
 347             errmsg = "PEReference: no name";
 348             break;
 349         case XML_ERR_PEREF_SEMICOL_MISSING:
 350             errmsg = "PEReference: expecting ';'";
 351             break;
 352         case XML_ERR_ENTITY_LOOP:
 353             errmsg = "Detected an entity reference loop";
 354             break;
 355         case XML_ERR_ENTITY_NOT_STARTED:
 356             errmsg = "EntityValue: \" or ' expected";
 357             break;
 358         case XML_ERR_ENTITY_PE_INTERNAL:
 359             errmsg = "PEReferences forbidden in internal subset";
 360             break;
 361         case XML_ERR_ENTITY_NOT_FINISHED:
 362             errmsg = "EntityValue: \" or ' expected";
 363             break;
 364         case XML_ERR_ATTRIBUTE_NOT_STARTED:
 365             errmsg = "AttValue: \" or ' expected";
 366             break;
 367         case XML_ERR_LT_IN_ATTRIBUTE:
 368             errmsg = "Unescaped '<' not allowed in attributes values";
 369             break;
 370         case XML_ERR_LITERAL_NOT_STARTED:
 371             errmsg = "SystemLiteral \" or ' expected";
 372             break;
 373         case XML_ERR_LITERAL_NOT_FINISHED:
 374             errmsg = "Unfinished System or Public ID \" or ' expected";
 375             break;
 376         case XML_ERR_MISPLACED_CDATA_END:
 377             errmsg = "Sequence ']]>' not allowed in content";
 378             break;
 379         case XML_ERR_URI_REQUIRED:
 380             errmsg = "SYSTEM or PUBLIC, the URI is missing";
 381             break;
 382         case XML_ERR_PUBID_REQUIRED:
 383             errmsg = "PUBLIC, the Public Identifier is missing";
 384             break;
 385         case XML_ERR_HYPHEN_IN_COMMENT:
 386             errmsg = "Comment must not contain '--' (double-hyphen)";
 387             break;
 388         case XML_ERR_PI_NOT_STARTED:
 389             errmsg = "xmlParsePI : no target name";
 390             break;
 391         case XML_ERR_RESERVED_XML_NAME:
 392             errmsg = "Invalid PI name";
 393             break;
 394         case XML_ERR_NOTATION_NOT_STARTED:
 395             errmsg = "NOTATION: Name expected here";
 396             break;
 397         case XML_ERR_NOTATION_NOT_FINISHED:
 398             errmsg = "'>' required to close NOTATION declaration";
 399             break;
 400         case XML_ERR_VALUE_REQUIRED:
 401             errmsg = "Entity value required";
 402             break;
 403         case XML_ERR_URI_FRAGMENT:
 404             errmsg = "Fragment not allowed";
 405             break;
 406         case XML_ERR_ATTLIST_NOT_STARTED:
 407             errmsg = "'(' required to start ATTLIST enumeration";
 408             break;
 409         case XML_ERR_NMTOKEN_REQUIRED:
 410             errmsg = "NmToken expected in ATTLIST enumeration";
 411             break;
 412         case XML_ERR_ATTLIST_NOT_FINISHED:
 413             errmsg = "')' required to finish ATTLIST enumeration";
 414             break;
 415         case XML_ERR_MIXED_NOT_STARTED:
 416             errmsg = "MixedContentDecl : '|' or ')*' expected";
 417             break;
 418         case XML_ERR_PCDATA_REQUIRED:
 419             errmsg = "MixedContentDecl : '#PCDATA' expected";
 420             break;
 421         case XML_ERR_ELEMCONTENT_NOT_STARTED:
 422             errmsg = "ContentDecl : Name or '(' expected";
 423             break;
 424         case XML_ERR_ELEMCONTENT_NOT_FINISHED:
 425             errmsg = "ContentDecl : ',' '|' or ')' expected";
 426             break;
 427         case XML_ERR_PEREF_IN_INT_SUBSET:
 428             errmsg =
 429                 "PEReference: forbidden within markup decl in internal subset";
 430             break;
 431         case XML_ERR_GT_REQUIRED:
 432             errmsg = "expected '>'";
 433             break;
 434         case XML_ERR_CONDSEC_INVALID:
 435             errmsg = "XML conditional section '[' expected";
 436             break;
 437         case XML_ERR_EXT_SUBSET_NOT_FINISHED:
 438             errmsg = "Content error in the external subset";
 439             break;
 440         case XML_ERR_CONDSEC_INVALID_KEYWORD:
 441             errmsg =
 442                 "conditional section INCLUDE or IGNORE keyword expected";
 443             break;
 444         case XML_ERR_CONDSEC_NOT_FINISHED:
 445             errmsg = "XML conditional section not closed";
 446             break;
 447         case XML_ERR_XMLDECL_NOT_STARTED:
 448             errmsg = "Text declaration '<?xml' required";
 449             break;
 450         case XML_ERR_XMLDECL_NOT_FINISHED:
 451             errmsg = "parsing XML declaration: '?>' expected";
 452             break;
 453         case XML_ERR_EXT_ENTITY_STANDALONE:
 454             errmsg = "external parsed entities cannot be standalone";
 455             break;
 456         case XML_ERR_ENTITYREF_SEMICOL_MISSING:
 457             errmsg = "EntityRef: expecting ';'";
 458             break;
 459         case XML_ERR_DOCTYPE_NOT_FINISHED:
 460             errmsg = "DOCTYPE improperly terminated";
 461             break;
 462         case XML_ERR_LTSLASH_REQUIRED:
 463             errmsg = "EndTag: '</' not found";
 464             break;
 465         case XML_ERR_EQUAL_REQUIRED:
 466             errmsg = "expected '='";
 467             break;
 468         case XML_ERR_STRING_NOT_CLOSED:
 469             errmsg = "String not closed expecting \" or '";
 470             break;
 471         case XML_ERR_STRING_NOT_STARTED:
 472             errmsg = "String not started expecting ' or \"";
 473             break;
 474         case XML_ERR_ENCODING_NAME:
 475             errmsg = "Invalid XML encoding name";
 476             break;
 477         case XML_ERR_STANDALONE_VALUE:
 478             errmsg = "standalone accepts only 'yes' or 'no'";
 479             break;
 480         case XML_ERR_DOCUMENT_EMPTY:
 481             errmsg = "Document is empty";
 482             break;
 483         case XML_ERR_DOCUMENT_END:
 484             errmsg = "Extra content at the end of the document";
 485             break;
 486         case XML_ERR_NOT_WELL_BALANCED:
 487             errmsg = "chunk is not well balanced";
 488             break;
 489         case XML_ERR_EXTRA_CONTENT:
 490             errmsg = "extra content at the end of well balanced chunk";
 491             break;
 492         case XML_ERR_VERSION_MISSING:
 493             errmsg = "Malformed declaration expecting version";
 494             break;
 495         case XML_ERR_NAME_TOO_LONG:
 496             errmsg = "Name too long use XML_PARSE_HUGE option";
 497             break;
 498 #if 0
 499         case:
 500             errmsg = "";
 501             break;
 502 #endif
 503         default:
 504             errmsg = "Unregistered error message";
 505     }
 506     if (info == NULL)
 507         snprintf(errstr, 128, "%s\n", errmsg);
 508     else
 509         snprintf(errstr, 128, "%s: %%s\n", errmsg);
 510     if (ctxt != NULL)
 511         ctxt->errNo = error;
 512     __xmlRaiseError(NULL, NULL, NULL, ctxt, NULL, XML_FROM_PARSER, error,
 513                     XML_ERR_FATAL, NULL, 0, info, NULL, NULL, 0, 0, &errstr[0],
 514                     info);
 515     if (ctxt != NULL) {
 516         ctxt->wellFormed = 0;
 517         if (ctxt->recovery == 0)
 518             ctxt->disableSAX = 1;
 519     }
 520 }
 521
 522 /**
 523  * xmlFatalErrMsg:
 524  * @ctxt:  an XML parser context
 525  * @error:  the error number
 526  * @msg:  the error message
 527  *
 528  * Handle a fatal parser error, i.e. violating Well-Formedness constraints
 529  */
 530 static void
 531 xmlFatalErrMsg(xmlParserCtxtPtr ctxt, xmlParserErrors error,
 532                const char *msg)
 533 {
 534     if ((ctxt != NULL) && (ctxt->disableSAX != 0) &&
 535         (ctxt->instate == XML_PARSER_EOF))
 536         return;
 537     if (ctxt != NULL)
 538         ctxt->errNo = error;
 539     __xmlRaiseError(NULL, NULL, NULL, ctxt, NULL, XML_FROM_PARSER, error,
 540                     XML_ERR_FATAL, NULL, 0, NULL, NULL, NULL, 0, 0, "%s", msg);
 541     if (ctxt != NULL) {
 542         ctxt->wellFormed = 0;
 543         if (ctxt->recovery == 0)
 544             ctxt->disableSAX = 1;
 545     }
 546 }
 547
 548 /**
 549  * xmlWarningMsg:
 550  * @ctxt:  an XML parser context
 551  * @error:  the error number
 552  * @msg:  the error message
 553  * @str1:  extra data
 554  * @str2:  extra data
 555  *
 556  * Handle a warning.
 557  */
 558 static void
 559 xmlWarningMsg(xmlParserCtxtPtr ctxt, xmlParserErrors error,
 560               const char *msg, const xmlChar *str1, const xmlChar *str2)
 561 {
 562     xmlStructuredErrorFunc schannel = NULL;
 563
 564     if ((ctxt != NULL) && (ctxt->disableSAX != 0) &&
 565         (ctxt->instate == XML_PARSER_EOF))
 566         return;
 567     if ((ctxt != NULL) && (ctxt->sax != NULL) &&
 568         (ctxt->sax->initialized == XML_SAX2_MAGIC))
 569         schannel = ctxt->sax->serror;
 570     if (ctxt != NULL) {
 571         __xmlRaiseError(schannel,
 572                     (ctxt->sax) ? ctxt->sax->warning : NULL,
 573                     ctxt->userData,
 574                     ctxt, NULL, XML_FROM_PARSER, error,
 575                     XML_ERR_WARNING, NULL, 0,
 576                     (const char *) str1, (const char *) str2, NULL, 0, 0,
 577                     msg, (const char *) str1, (const char *) str2);
 578     } else {
 579         __xmlRaiseError(schannel, NULL, NULL,
 580                     ctxt, NULL, XML_FROM_PARSER, error,
 581                     XML_ERR_WARNING, NULL, 0,
 582                     (const char *) str1, (const char *) str2, NULL, 0, 0,
 583                     msg, (const char *) str1, (const char *) str2);
 584     }
 585 }
 586
 587 /**
 588  * xmlValidityError:
 589  * @ctxt:  an XML parser context
 590  * @error:  the error number
 591  * @msg:  the error message
 592  * @str1:  extra data
 593  *
 594  * Handle a validity error.
 595  */
 596 static void
 597 xmlValidityError(xmlParserCtxtPtr ctxt, xmlParserErrors error,
 598               const char *msg, const xmlChar *str1, const xmlChar *str2)
 599 {
 600     xmlStructuredErrorFunc schannel = NULL;
 601
 602     if ((ctxt != NULL) && (ctxt->disableSAX != 0) &&
 603         (ctxt->instate == XML_PARSER_EOF))
 604         return;
 605     if (ctxt != NULL) {
 606         ctxt->errNo = error;
 607         if ((ctxt->sax != NULL) && (ctxt->sax->initialized == XML_SAX2_MAGIC))
 608             schannel = ctxt->sax->serror;
 609     }
 610     if (ctxt != NULL) {
 611         __xmlRaiseError(schannel,
 612                     ctxt->vctxt.error, ctxt->vctxt.userData,
 613                     ctxt, NULL, XML_FROM_DTD, error,
 614                     XML_ERR_ERROR, NULL, 0, (const char *) str1,
 615                     (const char *) str2, NULL, 0, 0,
 616                     msg, (const char *) str1, (const char *) str2);
 617         ctxt->valid = 0;
 618     } else {
 619         __xmlRaiseError(schannel, NULL, NULL,
 620                     ctxt, NULL, XML_FROM_DTD, error,
 621                     XML_ERR_ERROR, NULL, 0, (const char *) str1,
 622                     (const char *) str2, NULL, 0, 0,
 623                     msg, (const char *) str1, (const char *) str2);
 624     }
 625 }
 626
 627 /**
 628  * xmlFatalErrMsgInt:
 629  * @ctxt:  an XML parser context
 630  * @error:  the error number
 631  * @msg:  the error message
 632  * @val:  an integer value
 633  *
 634  * Handle a fatal parser error, i.e. violating Well-Formedness constraints
 635  */
 636 static void
 637 xmlFatalErrMsgInt(xmlParserCtxtPtr ctxt, xmlParserErrors error,
 638                   const char *msg, int val)
 639 {
 640     if ((ctxt != NULL) && (ctxt->disableSAX != 0) &&
 641         (ctxt->instate == XML_PARSER_EOF))
 642         return;
 643     if (ctxt != NULL)
 644         ctxt->errNo = error;
 645     __xmlRaiseError(NULL, NULL, NULL,
 646                     ctxt, NULL, XML_FROM_PARSER, error, XML_ERR_FATAL,
 647                     NULL, 0, NULL, NULL, NULL, val, 0, msg, val);
 648     if (ctxt != NULL) {
 649         ctxt->wellFormed = 0;
 650         if (ctxt->recovery == 0)
 651             ctxt->disableSAX = 1;
 652     }
 653 }
 654
 655 /**
 656  * xmlFatalErrMsgStrIntStr:
 657  * @ctxt:  an XML parser context
 658  * @error:  the error number
 659  * @msg:  the error message
 660  * @str1:  an string info
 661  * @val:  an integer value
 662  * @str2:  an string info
 663  *
 664  * Handle a fatal parser error, i.e. violating Well-Formedness constraints
 665  */
 666 static void
 667 xmlFatalErrMsgStrIntStr(xmlParserCtxtPtr ctxt, xmlParserErrors error,
 668                   const char *msg, const xmlChar *str1, int val,
 669                   const xmlChar *str2)
 670 {
 671     if ((ctxt != NULL) && (ctxt->disableSAX != 0) &&
 672         (ctxt->instate == XML_PARSER_EOF))
 673         return;
 674     if (ctxt != NULL)
 675         ctxt->errNo = error;
 676     __xmlRaiseError(NULL, NULL, NULL,
 677                     ctxt, NULL, XML_FROM_PARSER, error, XML_ERR_FATAL,
 678                     NULL, 0, (const char *) str1, (const char *) str2,
 679                     NULL, val, 0, msg, str1, val, str2);
 680     if (ctxt != NULL) {
 681         ctxt->wellFormed = 0;
 682         if (ctxt->recovery == 0)
 683             ctxt->disableSAX = 1;
 684     }
 685 }
 686
 687 /**
 688  * xmlFatalErrMsgStr:
 689  * @ctxt:  an XML parser context
 690  * @error:  the error number
 691  * @msg:  the error message
 692  * @val:  a string value
 693  *
 694  * Handle a fatal parser error, i.e. violating Well-Formedness constraints
 695  */
 696 static void
 697 xmlFatalErrMsgStr(xmlParserCtxtPtr ctxt, xmlParserErrors error,
 698                   const char *msg, const xmlChar * val)
 699 {
 700     if ((ctxt != NULL) && (ctxt->disableSAX != 0) &&
 701         (ctxt->instate == XML_PARSER_EOF))
 702         return;
 703     if (ctxt != NULL)
 704         ctxt->errNo = error;
 705     __xmlRaiseError(NULL, NULL, NULL, ctxt, NULL,
 706                     XML_FROM_PARSER, error, XML_ERR_FATAL,
 707                     NULL, 0, (const char *) val, NULL, NULL, 0, 0, msg,
 708                     val);
 709     if (ctxt != NULL) {
 710         ctxt->wellFormed = 0;
 711         if (ctxt->recovery == 0)
 712             ctxt->disableSAX = 1;
 713     }
 714 }
 715
 716 /**
 717  * xmlErrMsgStr:
 718  * @ctxt:  an XML parser context
 719  * @error:  the error number
 720  * @msg:  the error message
 721  * @val:  a string value
 722  *
 723  * Handle a non fatal parser error
 724  */
 725 static void
 726 xmlErrMsgStr(xmlParserCtxtPtr ctxt, xmlParserErrors error,
 727                   const char *msg, const xmlChar * val)
 728 {
 729     if ((ctxt != NULL) && (ctxt->disableSAX != 0) &&
 730         (ctxt->instate == XML_PARSER_EOF))
 731         return;
 732     if (ctxt != NULL)
 733         ctxt->errNo = error;
 734     __xmlRaiseError(NULL, NULL, NULL, ctxt, NULL,
 735                     XML_FROM_PARSER, error, XML_ERR_ERROR,
 736                     NULL, 0, (const char *) val, NULL, NULL, 0, 0, msg,
 737                     val);
 738 }
 739
 740 /**
 741  * xmlNsErr:
 742  * @ctxt:  an XML parser context
 743  * @error:  the error number
 744  * @msg:  the message
 745  * @info1:  extra information string
 746  * @info2:  extra information string
 747  *
 748  * Handle a fatal parser error, i.e. violating Well-Formedness constraints
 749  */
 750 static void
 751 xmlNsErr(xmlParserCtxtPtr ctxt, xmlParserErrors error,
 752          const char *msg,
 753          const xmlChar * info1, const xmlChar * info2,
 754          const xmlChar * info3)
 755 {
 756     if ((ctxt != NULL) && (ctxt->disableSAX != 0) &&
 757         (ctxt->instate == XML_PARSER_EOF))
 758         return;
 759     if (ctxt != NULL)
 760         ctxt->errNo = error;
 761     __xmlRaiseError(NULL, NULL, NULL, ctxt, NULL, XML_FROM_NAMESPACE, error,
 762                     XML_ERR_ERROR, NULL, 0, (const char *) info1,
 763                     (const char *) info2, (const char *) info3, 0, 0, msg,
 764                     info1, info2, info3);
 765     if (ctxt != NULL)
 766         ctxt->nsWellFormed = 0;
 767 }
 768
 769 /**
 770  * xmlNsWarn
 771  * @ctxt:  an XML parser context
 772  * @error:  the error number
 773  * @msg:  the message
 774  * @info1:  extra information string
 775  * @info2:  extra information string
 776  *
 777  * Handle a namespace warning error
 778  */
 779 static void
 780 xmlNsWarn(xmlParserCtxtPtr ctxt, xmlParserErrors error,
 781          const char *msg,
 782          const xmlChar * info1, const xmlChar * info2,
 783          const xmlChar * info3)
 784 {
 785     if ((ctxt != NULL) && (ctxt->disableSAX != 0) &&
 786         (ctxt->instate == XML_PARSER_EOF))
 787         return;
 788     __xmlRaiseError(NULL, NULL, NULL, ctxt, NULL, XML_FROM_NAMESPACE, error,
 789                     XML_ERR_WARNING, NULL, 0, (const char *) info1,
 790                     (const char *) info2, (const char *) info3, 0, 0, msg,
 791                     info1, info2, info3);
 792 }
 793
 794 /************************************************************************
 795  *                                                                      *
 796  *              Library wide options                                    *
 797  *                                                                      *
 798  ************************************************************************/
 799
 800 /**
 801   * xmlHasFeature:
 802   * @feature: the feature to be examined
 803   *
 804   * Examines if the library has been compiled with a given feature.
 805   *
 806   * Returns a non-zero value if the feature exist, otherwise zero.
 807   * Returns zero (0) if the feature does not exist or an unknown
 808   * unknown feature is requested, non-zero otherwise.
 809   */
 810 int
 811 xmlHasFeature(xmlFeature feature)
 812 {
 813     switch (feature) {
 814         case XML_WITH_THREAD:
 815 #ifdef LIBXML_THREAD_ENABLED
 816             return(1);
 817 #else
 818             return(0);
 819 #endif
 820         case XML_WITH_TREE:
 821 #ifdef LIBXML_TREE_ENABLED
 822             return(1);
 823 #else
 824             return(0);
 825 #endif
 826         case XML_WITH_OUTPUT:
 827 #ifdef LIBXML_OUTPUT_ENABLED
 828             return(1);
 829 #else
 830             return(0);
 831 #endif
 832         case XML_WITH_PUSH:
 833 #ifdef LIBXML_PUSH_ENABLED
 834             return(1);
 835 #else
 836             return(0);
 837 #endif
 838         case XML_WITH_READER:
 839 #ifdef LIBXML_READER_ENABLED
 840             return(1);
 841 #else
 842             return(0);
 843 #endif
 844         case XML_WITH_PATTERN:
 845 #ifdef LIBXML_PATTERN_ENABLED
 846             return(1);
 847 #else
 848             return(0);
 849 #endif
 850         case XML_WITH_WRITER:
 851 #ifdef LIBXML_WRITER_ENABLED
 852             return(1);
 853 #else
 854             return(0);
 855 #endif
 856         case XML_WITH_SAX1:
 857 #ifdef LIBXML_SAX1_ENABLED
 858             return(1);
 859 #else
 860             return(0);
 861 #endif
 862         case XML_WITH_FTP:
 863 #ifdef LIBXML_FTP_ENABLED
 864             return(1);
 865 #else
 866             return(0);
 867 #endif
 868         case XML_WITH_HTTP:
 869 #ifdef LIBXML_HTTP_ENABLED
 870             return(1);
 871 #else
 872             return(0);
 873 #endif
 874         case XML_WITH_VALID:
 875 #ifdef LIBXML_VALID_ENABLED
 876             return(1);
 877 #else
 878             return(0);
 879 #endif
 880         case XML_WITH_HTML:
 881 #ifdef LIBXML_HTML_ENABLED
 882             return(1);
 883 #else
 884             return(0);
 885 #endif
 886         case XML_WITH_LEGACY:
 887 #ifdef LIBXML_LEGACY_ENABLED
 888             return(1);
 889 #else
 890             return(0);
 891 #endif
 892         case XML_WITH_C14N:
 893 #ifdef LIBXML_C14N_ENABLED
 894             return(1);
 895 #else
 896             return(0);
 897 #endif
 898         case XML_WITH_CATALOG:
 899 #ifdef LIBXML_CATALOG_ENABLED
 900             return(1);
 901 #else
 902             return(0);
 903 #endif
 904         case XML_WITH_XPATH:
 905 #ifdef LIBXML_XPATH_ENABLED
 906             return(1);
 907 #else
 908             return(0);
 909 #endif
 910         case XML_WITH_XPTR:
 911 #ifdef LIBXML_XPTR_ENABLED
 912             return(1);
 913 #else
 914             return(0);
 915 #endif
 916         case XML_WITH_XINCLUDE:
 917 #ifdef LIBXML_XINCLUDE_ENABLED
 918             return(1);
 919 #else
 920             return(0);
 921 #endif
 922         case XML_WITH_ICONV:
 923 #ifdef LIBXML_ICONV_ENABLED
 924             return(1);
 925 #else
 926             return(0);
 927 #endif
 928         case XML_WITH_ISO8859X:
 929 #ifdef LIBXML_ISO8859X_ENABLED
 930             return(1);
 931 #else
 932             return(0);
 933 #endif
 934         case XML_WITH_UNICODE:
 935 #ifdef LIBXML_UNICODE_ENABLED
 936             return(1);
 937 #else
 938             return(0);
 939 #endif
 940         case XML_WITH_REGEXP:
 941 #ifdef LIBXML_REGEXP_ENABLED
 942             return(1);
 943 #else
 944             return(0);
 945 #endif
 946         case XML_WITH_AUTOMATA:
 947 #ifdef LIBXML_AUTOMATA_ENABLED
 948             return(1);
 949 #else
 950             return(0);
 951 #endif
 952         case XML_WITH_EXPR:
 953 #ifdef LIBXML_EXPR_ENABLED
 954             return(1);
 955 #else
 956             return(0);
 957 #endif
 958         case XML_WITH_SCHEMAS:
 959 #ifdef LIBXML_SCHEMAS_ENABLED
 960             return(1);
 961 #else
 962             return(0);
 963 #endif
 964         case XML_WITH_SCHEMATRON:
 965 #ifdef LIBXML_SCHEMATRON_ENABLED
 966             return(1);
 967 #else
 968             return(0);
 969 #endif
 970         case XML_WITH_MODULES:
 971 #ifdef LIBXML_MODULES_ENABLED
 972             return(1);
 973 #else
 974             return(0);
 975 #endif
 976         case XML_WITH_DEBUG:
 977 #ifdef LIBXML_DEBUG_ENABLED
 978             return(1);
 979 #else
 980             return(0);
 981 #endif
 982         case XML_WITH_DEBUG_MEM:
 983 #ifdef DEBUG_MEMORY_LOCATION
 984             return(1);
 985 #else
 986             return(0);
 987 #endif
 988         case XML_WITH_DEBUG_RUN:
 989 #ifdef LIBXML_DEBUG_RUNTIME
 990             return(1);
 991 #else
 992             return(0);
 993 #endif
 994         case XML_WITH_ZLIB:
 995 #ifdef LIBXML_ZLIB_ENABLED
 996             return(1);
 997 #else
 998             return(0);
 999 #endif
1000         case XML_WITH_LZMA:
1001 #ifdef LIBXML_LZMA_ENABLED
1002             return(1);
1003 #else
1004             return(0);
1005 #endif
1006         case XML_WITH_ICU:
1007 #ifdef LIBXML_ICU_ENABLED
1008             return(1);
1009 #else
1010             return(0);
1011 #endif
1012         default:
1013             break;
1014      }
1015      return(0);
1016 }
1017
1018 /************************************************************************
1019  *                                                                      *
1020  *              SAX2 defaulted attributes handling                      *
1021  *                                                                      *
1022  ************************************************************************/
1023
1024 /**
1025  * xmlDetectSAX2:
1026  * @ctxt:  an XML parser context
1027  *
1028  * Do the SAX2 detection and specific intialization
1029  */
1030 static void
1031 xmlDetectSAX2(xmlParserCtxtPtr ctxt) {
1032     if (ctxt == NULL) return;
1033 #ifdef LIBXML_SAX1_ENABLED
1034     if ((ctxt->sax) &&  (ctxt->sax->initialized == XML_SAX2_MAGIC) &&
1035         ((ctxt->sax->startElementNs != NULL) ||
1036          (ctxt->sax->endElementNs != NULL))) ctxt->sax2 = 1;
1037 #else
1038     ctxt->sax2 = 1;
1039 #endif /* LIBXML_SAX1_ENABLED */
1040
1041     ctxt->str_xml = xmlDictLookup(ctxt->dict, BAD_CAST "xml", 3);
1042     ctxt->str_xmlns = xmlDictLookup(ctxt->dict, BAD_CAST "xmlns", 5);
1043     ctxt->str_xml_ns = xmlDictLookup(ctxt->dict, XML_XML_NAMESPACE, 36);
1044     if ((ctxt->str_xml==NULL) || (ctxt->str_xmlns==NULL) ||
1045                 (ctxt->str_xml_ns == NULL)) {
1046         xmlErrMemory(ctxt, NULL);
1047     }
1048 }
1049
1050 typedef struct _xmlDefAttrs xmlDefAttrs;
1051 typedef xmlDefAttrs *xmlDefAttrsPtr;
1052 struct _xmlDefAttrs {
1053     int nbAttrs;        /* number of defaulted attributes on that element */
1054     int maxAttrs;       /* the size of the array */
1055     const xmlChar *values[5]; /* array of localname/prefix/values/external */
1056 };
1057
1058 /**
1059  * xmlAttrNormalizeSpace:
1060  * @src: the source string
1061  * @dst: the target string
1062  *
1063  * Normalize the space in non CDATA attribute values:
1064  * If the attribute type is not CDATA, then the XML processor MUST further
1065  * process the normalized attribute value by discarding any leading and
1066  * trailing space (#x20) characters, and by replacing sequences of space
1067  * (#x20) characters by a single space (#x20) character.
1068  * Note that the size of dst need to be at least src, and if one doesn't need
1069  * to preserve dst (and it doesn't come from a dictionary or read-only) then
1070  * passing src as dst is just fine.
1071  *
1072  * Returns a pointer to the normalized value (dst) or NULL if no conversion
1073  *         is needed.
1074  */
1075 static xmlChar *
1076 xmlAttrNormalizeSpace(const xmlChar *src, xmlChar *dst)
1077 {
1078     if ((src == NULL) || (dst == NULL))
1079         return(NULL);
1080
1081     while (*src == 0x20) src++;
1082     while (*src != 0) {
1083         if (*src == 0x20) {
1084             while (*src == 0x20) src++;
1085             if (*src != 0)
1086                 *dst++ = 0x20;
1087         } else {
1088             *dst++ = *src++;
1089         }
1090     }
1091     *dst = 0;
1092     if (dst == src)
1093        return(NULL);
1094     return(dst);
1095 }
1096
1097 /**
1098  * xmlAttrNormalizeSpace2:
1099  * @src: the source string
1100  *
1101  * Normalize the space in non CDATA attribute values, a slightly more complex
1102  * front end to avoid allocation problems when running on attribute values
1103  * coming from the input.
1104  *
1105  * Returns a pointer to the normalized value (dst) or NULL if no conversion
1106  *         is needed.
1107  */
1108 static const xmlChar *
1109 xmlAttrNormalizeSpace2(xmlParserCtxtPtr ctxt, xmlChar *src, int *len)
1110 {
1111     int i;
1112     int remove_head = 0;
1113     int need_realloc = 0;
1114     const xmlChar *cur;
1115
1116     if ((ctxt == NULL) || (src == NULL) || (len == NULL))
1117         return(NULL);
1118     i = *len;
1119     if (i <= 0)
1120         return(NULL);
1121
1122     cur = src;
1123     while (*cur == 0x20) {
1124         cur++;
1125         remove_head++;
1126     }
1127     while (*cur != 0) {
1128         if (*cur == 0x20) {
1129             cur++;
1130             if ((*cur == 0x20) || (*cur == 0)) {
1131                 need_realloc = 1;
1132                 break;
1133             }
1134         } else
1135             cur++;
1136     }
1137     if (need_realloc) {
1138         xmlChar *ret;
1139
1140         ret = xmlStrndup(src + remove_head, i - remove_head + 1);
1141         if (ret == NULL) {
1142             xmlErrMemory(ctxt, NULL);
1143             return(NULL);
1144         }
1145         xmlAttrNormalizeSpace(ret, ret);
1146         *len = (int) strlen((const char *)ret);
1147         return(ret);
1148     } else if (remove_head) {
1149         *len -= remove_head;
1150         memmove(src, src + remove_head, 1 + *len);
1151         return(src);
1152     }
1153     return(NULL);
1154 }
1155
1156 /**
1157  * xmlAddDefAttrs:
1158  * @ctxt:  an XML parser context
1159  * @fullname:  the element fullname
1160  * @fullattr:  the attribute fullname
1161  * @value:  the attribute value
1162  *
1163  * Add a defaulted attribute for an element
1164  */
1165 static void
1166 xmlAddDefAttrs(xmlParserCtxtPtr ctxt,
1167                const xmlChar *fullname,
1168                const xmlChar *fullattr,
1169                const xmlChar *value) {
1170     xmlDefAttrsPtr defaults;
1171     int len;
1172     const xmlChar *name;
1173     const xmlChar *prefix;
1174
1175     /*
1176      * Allows to detect attribute redefinitions
1177      */
1178     if (ctxt->attsSpecial != NULL) {
1179         if (xmlHashLookup2(ctxt->attsSpecial, fullname, fullattr) != NULL)
1180             return;
1181     }
1182
1183     if (ctxt->attsDefault == NULL) {
1184         ctxt->attsDefault = xmlHashCreateDict(10, ctxt->dict);
1185         if (ctxt->attsDefault == NULL)
1186             goto mem_error;
1187     }
1188
1189     /*
1190      * split the element name into prefix:localname , the string found
1191      * are within the DTD and then not associated to namespace names.
1192      */
1193     name = xmlSplitQName3(fullname, &len);
1194     if (name == NULL) {
1195         name = xmlDictLookup(ctxt->dict, fullname, -1);
1196         prefix = NULL;
1197     } else {
1198         name = xmlDictLookup(ctxt->dict, name, -1);
1199         prefix = xmlDictLookup(ctxt->dict, fullname, len);
1200     }
1201
1202     /*
1203      * make sure there is some storage
1204      */
1205     defaults = xmlHashLookup2(ctxt->attsDefault, name, prefix);
1206     if (defaults == NULL) {
1207         defaults = (xmlDefAttrsPtr) xmlMalloc(sizeof(xmlDefAttrs) +
1208                            (4 * 5) * sizeof(const xmlChar *));
1209         if (defaults == NULL)
1210             goto mem_error;
1211         defaults->nbAttrs = 0;
1212         defaults->maxAttrs = 4;
1213         if (xmlHashUpdateEntry2(ctxt->attsDefault, name, prefix,
1214                                 defaults, NULL) < 0) {
1215             xmlFree(defaults);
1216             goto mem_error;
1217         }
1218     } else if (defaults->nbAttrs >= defaults->maxAttrs) {
1219         xmlDefAttrsPtr temp;
1220
1221         temp = (xmlDefAttrsPtr) xmlRealloc(defaults, sizeof(xmlDefAttrs) +
1222                        (2 * defaults->maxAttrs * 5) * sizeof(const xmlChar *));
1223         if (temp == NULL)
1224             goto mem_error;
1225         defaults = temp;
1226         defaults->maxAttrs *= 2;
1227         if (xmlHashUpdateEntry2(ctxt->attsDefault, name, prefix,
1228                                 defaults, NULL) < 0) {
1229             xmlFree(defaults);
1230             goto mem_error;
1231         }
1232     }
1233
1234     /*
1235      * Split the element name into prefix:localname , the string found
1236      * are within the DTD and hen not associated to namespace names.
1237      */
1238     name = xmlSplitQName3(fullattr, &len);
1239     if (name == NULL) {
1240         name = xmlDictLookup(ctxt->dict, fullattr, -1);
1241         prefix = NULL;
1242     } else {
1243         name = xmlDictLookup(ctxt->dict, name, -1);
1244         prefix = xmlDictLookup(ctxt->dict, fullattr, len);
1245     }
1246
1247     defaults->values[5 * defaults->nbAttrs] = name;
1248     defaults->values[5 * defaults->nbAttrs + 1] = prefix;
1249     /* intern the string and precompute the end */
1250     len = xmlStrlen(value);
1251     value = xmlDictLookup(ctxt->dict, value, len);
1252     defaults->values[5 * defaults->nbAttrs + 2] = value;
1253     defaults->values[5 * defaults->nbAttrs + 3] = value + len;
1254     if (ctxt->external)
1255         defaults->values[5 * defaults->nbAttrs + 4] = BAD_CAST "external";
1256     else
1257         defaults->values[5 * defaults->nbAttrs + 4] = NULL;
1258     defaults->nbAttrs++;
1259
1260     return;
1261
1262 mem_error:
1263     xmlErrMemory(ctxt, NULL);
1264     return;
1265 }
1266
1267 /**
1268  * xmlAddSpecialAttr:
1269  * @ctxt:  an XML parser context
1270  * @fullname:  the element fullname
1271  * @fullattr:  the attribute fullname
1272  * @type:  the attribute type
1273  *
1274  * Register this attribute type
1275  */
1276 static void
1277 xmlAddSpecialAttr(xmlParserCtxtPtr ctxt,
1278                   const xmlChar *fullname,
1279                   const xmlChar *fullattr,
1280                   int type)
1281 {
1282     if (ctxt->attsSpecial == NULL) {
1283         ctxt->attsSpecial = xmlHashCreateDict(10, ctxt->dict);
1284         if (ctxt->attsSpecial == NULL)
1285             goto mem_error;
1286     }
1287
1288     if (xmlHashLookup2(ctxt->attsSpecial, fullname, fullattr) != NULL)
1289         return;
1290
1291     xmlHashAddEntry2(ctxt->attsSpecial, fullname, fullattr,
1292                      (void *) (long) type);
1293     return;
1294
1295 mem_error:
1296     xmlErrMemory(ctxt, NULL);
1297     return;
1298 }
1299
1300 /**
1301  * xmlCleanSpecialAttrCallback:
1302  *
1303  * Removes CDATA attributes from the special attribute table
1304  */
1305 static void
1306 xmlCleanSpecialAttrCallback(void *payload, void *data,
1307                             const xmlChar *fullname, const xmlChar *fullattr,
1308                             const xmlChar *unused ATTRIBUTE_UNUSED) {
1309     xmlParserCtxtPtr ctxt = (xmlParserCtxtPtr) data;
1310
1311     if (((long) payload) == XML_ATTRIBUTE_CDATA) {
1312         xmlHashRemoveEntry2(ctxt->attsSpecial, fullname, fullattr, NULL);
1313     }
1314 }
1315
1316 /**
1317  * xmlCleanSpecialAttr:
1318  * @ctxt:  an XML parser context
1319  *
1320  * Trim the list of attributes defined to remove all those of type
1321  * CDATA as they are not special. This call should be done when finishing
1322  * to parse the DTD and before starting to parse the document root.
1323  */
1324 static void
1325 xmlCleanSpecialAttr(xmlParserCtxtPtr ctxt)
1326 {
1327     if (ctxt->attsSpecial == NULL)
1328         return;
1329
1330     xmlHashScanFull(ctxt->attsSpecial, xmlCleanSpecialAttrCallback, ctxt);
1331
1332     if (xmlHashSize(ctxt->attsSpecial) == 0) {
1333         xmlHashFree(ctxt->attsSpecial, NULL);
1334         ctxt->attsSpecial = NULL;
1335     }
1336     return;
1337 }
1338
1339 /**
1340  * xmlCheckLanguageID:
1341  * @lang:  pointer to the string value
1342  *
1343  * Checks that the value conforms to the LanguageID production:
1344  *
1345  * NOTE: this is somewhat deprecated, those productions were removed from
1346  *       the XML Second edition.
1347  *
1348  * [33] LanguageID ::= Langcode ('-' Subcode)*
1349  * [34] Langcode ::= ISO639Code |  IanaCode |  UserCode
1350  * [35] ISO639Code ::= ([a-z] | [A-Z]) ([a-z] | [A-Z])
1351  * [36] IanaCode ::= ('i' | 'I') '-' ([a-z] | [A-Z])+
1352  * [37] UserCode ::= ('x' | 'X') '-' ([a-z] | [A-Z])+
1353  * [38] Subcode ::= ([a-z] | [A-Z])+
1354  *
1355  * The current REC reference the sucessors of RFC 1766, currently 5646
1356  *
1357  * http://www.rfc-editor.org/rfc/rfc5646.txt
1358  * langtag       = language
1359  *                 ["-" script]
1360  *                 ["-" region]
1361  *                 *("-" variant)
1362  *                 *("-" extension)
1363  *                 ["-" privateuse]
1364  * language      = 2*3ALPHA            ; shortest ISO 639 code
1365  *                 ["-" extlang]       ; sometimes followed by
1366  *                                     ; extended language subtags
1367  *               / 4ALPHA              ; or reserved for future use
1368  *               / 5*8ALPHA            ; or registered language subtag
1369  *
1370  * extlang       = 3ALPHA              ; selected ISO 639 codes
1371  *                 *2("-" 3ALPHA)      ; permanently reserved
1372  *
1373  * script        = 4ALPHA              ; ISO 15924 code
1374  *
1375  * region        = 2ALPHA              ; ISO 3166-1 code
1376  *               / 3DIGIT              ; UN M.49 code
1377  *
1378  * variant       = 5*8alphanum         ; registered variants
1379  *               / (DIGIT 3alphanum)
1380  *
1381  * extension     = singleton 1*("-" (2*8alphanum))
1382  *
1383  *                                     ; Single alphanumerics
1384  *                                     ; "x" reserved for private use
1385  * singleton     = DIGIT               ; 0 - 9
1386  *               / %x41-57             ; A - W
1387  *               / %x59-5A             ; Y - Z
1388  *               / %x61-77             ; a - w
1389  *               / %x79-7A             ; y - z
1390  *
1391  * it sounds right to still allow Irregular i-xxx IANA and user codes too
1392  * The parser below doesn't try to cope with extension or privateuse
1393  * that could be added but that's not interoperable anyway
1394  *
1395  * Returns 1 if correct 0 otherwise
1396  **/
1397 int
1398 xmlCheckLanguageID(const xmlChar * lang)
1399 {
1400     const xmlChar *cur = lang, *nxt;
1401
1402     if (cur == NULL)
1403         return (0);
1404     if (((cur[0] == 'i') && (cur[1] == '-')) ||
1405         ((cur[0] == 'I') && (cur[1] == '-')) ||
1406         ((cur[0] == 'x') && (cur[1] == '-')) ||
1407         ((cur[0] == 'X') && (cur[1] == '-'))) {
1408         /*
1409          * Still allow IANA code and user code which were coming
1410          * from the previous version of the XML-1.0 specification
1411          * it's deprecated but we should not fail
1412          */
1413         cur += 2;
1414         while (((cur[0] >= 'A') && (cur[0] <= 'Z')) ||
1415                ((cur[0] >= 'a') && (cur[0] <= 'z')))
1416             cur++;
1417         return(cur[0] == 0);
1418     }
1419     nxt = cur;
1420     while (((nxt[0] >= 'A') && (nxt[0] <= 'Z')) ||
1421            ((nxt[0] >= 'a') && (nxt[0] <= 'z')))
1422            nxt++;
1423     if (nxt - cur >= 4) {
1424         /*
1425          * Reserved
1426          */
1427         if ((nxt - cur > 8) || (nxt[0] != 0))
1428             return(0);
1429         return(1);
1430     }
1431     if (nxt - cur < 2)
1432         return(0);
1433     /* we got an ISO 639 code */
1434     if (nxt[0] == 0)
1435         return(1);
1436     if (nxt[0] != '-')
1437         return(0);
1438
1439     nxt++;
1440     cur = nxt;
1441     /* now we can have extlang or script or region or variant */
1442     if ((nxt[0] >= '0') && (nxt[0] <= '9'))
1443         goto region_m49;
1444
1445     while (((nxt[0] >= 'A') && (nxt[0] <= 'Z')) ||
1446            ((nxt[0] >= 'a') && (nxt[0] <= 'z')))
1447            nxt++;
1448     if (nxt - cur == 4)
1449         goto script;
1450     if (nxt - cur == 2)
1451         goto region;
1452     if ((nxt - cur >= 5) && (nxt - cur <= 8))
1453         goto variant;
1454     if (nxt - cur != 3)
1455         return(0);
1456     /* we parsed an extlang */
1457     if (nxt[0] == 0)
1458         return(1);
1459     if (nxt[0] != '-')
1460         return(0);
1461
1462     nxt++;
1463     cur = nxt;
1464     /* now we can have script or region or variant */
1465     if ((nxt[0] >= '0') && (nxt[0] <= '9'))
1466         goto region_m49;
1467
1468     while (((nxt[0] >= 'A') && (nxt[0] <= 'Z')) ||
1469            ((nxt[0] >= 'a') && (nxt[0] <= 'z')))
1470            nxt++;
1471     if (nxt - cur == 2)
1472         goto region;
1473     if ((nxt - cur >= 5) && (nxt - cur <= 8))
1474         goto variant;
1475     if (nxt - cur != 4)
1476         return(0);
1477     /* we parsed a script */
1478 script:
1479     if (nxt[0] == 0)
1480         return(1);
1481     if (nxt[0] != '-')
1482         return(0);
1483
1484     nxt++;
1485     cur = nxt;
1486     /* now we can have region or variant */
1487     if ((nxt[0] >= '0') && (nxt[0] <= '9'))
1488         goto region_m49;
1489
1490     while (((nxt[0] >= 'A') && (nxt[0] <= 'Z')) ||
1491            ((nxt[0] >= 'a') && (nxt[0] <= 'z')))
1492            nxt++;
1493
1494     if ((nxt - cur >= 5) && (nxt - cur <= 8))
1495         goto variant;
1496     if (nxt - cur != 2)
1497         return(0);
1498     /* we parsed a region */
1499 region:
1500     if (nxt[0] == 0)
1501         return(1);
1502     if (nxt[0] != '-')
1503         return(0);
1504
1505     nxt++;
1506     cur = nxt;
1507     /* now we can just have a variant */
1508     while (((nxt[0] >= 'A') && (nxt[0] <= 'Z')) ||
1509            ((nxt[0] >= 'a') && (nxt[0] <= 'z')))
1510            nxt++;
1511
1512     if ((nxt - cur < 5) || (nxt - cur > 8))
1513         return(0);
1514
1515     /* we parsed a variant */
1516 variant:
1517     if (nxt[0] == 0)
1518         return(1);
1519     if (nxt[0] != '-')
1520         return(0);
1521     /* extensions and private use subtags not checked */
1522     return (1);
1523
1524 region_m49:
1525     if (((nxt[1] >= '0') && (nxt[1] <= '9')) &&
1526         ((nxt[2] >= '0') && (nxt[2] <= '9'))) {
1527         nxt += 3;
1528         goto region;
1529     }
1530     return(0);
1531 }
1532
1533 /************************************************************************
1534  *                                                                      *
1535  *              Parser stacks related functions and macros              *
1536  *                                                                      *
1537  ************************************************************************/
1538
1539 static xmlEntityPtr xmlParseStringEntityRef(xmlParserCtxtPtr ctxt,
1540                                             const xmlChar ** str);
1541
1542 #ifdef SAX2
1543 /**
1544  * nsPush:
1545  * @ctxt:  an XML parser context
1546  * @prefix:  the namespace prefix or NULL
1547  * @URL:  the namespace name
1548  *
1549  * Pushes a new parser namespace on top of the ns stack
1550  *
1551  * Returns -1 in case of error, -2 if the namespace should be discarded
1552  *         and the index in the stack otherwise.
1553  */
1554 static int
1555 nsPush(xmlParserCtxtPtr ctxt, const xmlChar *prefix, const xmlChar *URL)
1556 {
1557     if (ctxt->options & XML_PARSE_NSCLEAN) {
1558         int i;
1559         for (i = ctxt->nsNr - 2;i >= 0;i -= 2) {
1560             if (ctxt->nsTab[i] == prefix) {
1561                 /* in scope */
1562                 if (ctxt->nsTab[i + 1] == URL)
1563                     return(-2);
1564                 /* out of scope keep it */
1565                 break;
1566             }
1567         }
1568     }
1569     if ((ctxt->nsMax == 0) || (ctxt->nsTab == NULL)) {
1570         ctxt->nsMax = 10;
1571         ctxt->nsNr = 0;
1572         ctxt->nsTab = (const xmlChar **)
1573                       xmlMalloc(ctxt->nsMax * sizeof(xmlChar *));
1574         if (ctxt->nsTab == NULL) {
1575             xmlErrMemory(ctxt, NULL);
1576             ctxt->nsMax = 0;
1577             return (-1);
1578         }
1579     } else if (ctxt->nsNr >= ctxt->nsMax) {
1580         const xmlChar ** tmp;
1581         ctxt->nsMax *= 2;
1582         tmp = (const xmlChar **) xmlRealloc((char *) ctxt->nsTab,
1583                                     ctxt->nsMax * sizeof(ctxt->nsTab[0]));
1584         if (tmp == NULL) {
1585             xmlErrMemory(ctxt, NULL);
1586             ctxt->nsMax /= 2;
1587             return (-1);
1588         }
1589         ctxt->nsTab = tmp;
1590     }
1591     ctxt->nsTab[ctxt->nsNr++] = prefix;
1592     ctxt->nsTab[ctxt->nsNr++] = URL;
1593     return (ctxt->nsNr);
1594 }
1595 /**
1596  * nsPop:
1597  * @ctxt: an XML parser context
1598  * @nr:  the number to pop
1599  *
1600  * Pops the top @nr parser prefix/namespace from the ns stack
1601  *
1602  * Returns the number of namespaces removed
1603  */
1604 static int
1605 nsPop(xmlParserCtxtPtr ctxt, int nr)
1606 {
1607     int i;
1608
1609     if (ctxt->nsTab == NULL) return(0);
1610     if (ctxt->nsNr < nr) {
1611         xmlGenericError(xmlGenericErrorContext, "Pbm popping %d NS\n", nr);
1612         nr = ctxt->nsNr;
1613     }
1614     if (ctxt->nsNr <= 0)
1615         return (0);
1616
1617     for (i = 0;i < nr;i++) {
1618          ctxt->nsNr--;
1619          ctxt->nsTab[ctxt->nsNr] = NULL;
1620     }
1621     return(nr);
1622 }
1623 #endif
1624
1625 static int
1626 xmlCtxtGrowAttrs(xmlParserCtxtPtr ctxt, int nr) {
1627     const xmlChar **atts;
1628     int *attallocs;
1629     int maxatts;
1630
1631     if (ctxt->atts == NULL) {
1632         maxatts = 55; /* allow for 10 attrs by default */
1633         atts = (const xmlChar **)
1634                xmlMalloc(maxatts * sizeof(xmlChar *));
1635         if (atts == NULL) goto mem_error;
1636         ctxt->atts = atts;
1637         attallocs = (int *) xmlMalloc((maxatts / 5) * sizeof(int));
1638         if (attallocs == NULL) goto mem_error;
1639         ctxt->attallocs = attallocs;
1640         ctxt->maxatts = maxatts;
1641     } else if (nr + 5 > ctxt->maxatts) {
1642         maxatts = (nr + 5) * 2;
1643         atts = (const xmlChar **) xmlRealloc((void *) ctxt->atts,
1644                                      maxatts * sizeof(const xmlChar *));
1645         if (atts == NULL) goto mem_error;
1646         ctxt->atts = atts;
1647         attallocs = (int *) xmlRealloc((void *) ctxt->attallocs,
1648                                      (maxatts / 5) * sizeof(int));
1649         if (attallocs == NULL) goto mem_error;
1650         ctxt->attallocs = attallocs;
1651         ctxt->maxatts = maxatts;
1652     }
1653     return(ctxt->maxatts);
1654 mem_error:
1655     xmlErrMemory(ctxt, NULL);
1656     return(-1);
1657 }
1658
1659 /**
1660  * inputPush:
1661  * @ctxt:  an XML parser context
1662  * @value:  the parser input
1663  *
1664  * Pushes a new parser input on top of the input stack
1665  *
1666  * Returns -1 in case of error, the index in the stack otherwise
1667  */
1668 int
1669 inputPush(xmlParserCtxtPtr ctxt, xmlParserInputPtr value)
1670 {
1671     if ((ctxt == NULL) || (value == NULL))
1672         return(-1);
1673     if (ctxt->inputNr >= ctxt->inputMax) {
1674         ctxt->inputMax *= 2;
1675         ctxt->inputTab =
1676             (xmlParserInputPtr *) xmlRealloc(ctxt->inputTab,
1677                                              ctxt->inputMax *
1678                                              sizeof(ctxt->inputTab[0]));
1679         if (ctxt->inputTab == NULL) {
1680             xmlErrMemory(ctxt, NULL);
1681             xmlFreeInputStream(value);
1682             ctxt->inputMax /= 2;
1683             value = NULL;
1684             return (-1);
1685         }
1686     }
1687     ctxt->inputTab[ctxt->inputNr] = value;
1688     ctxt->input = value;
1689     return (ctxt->inputNr++);
1690 }
1691 /**
1692  * inputPop:
1693  * @ctxt: an XML parser context
1694  *
1695  * Pops the top parser input from the input stack
1696  *
1697  * Returns the input just removed
1698  */
1699 xmlParserInputPtr
1700 inputPop(xmlParserCtxtPtr ctxt)
1701 {
1702     xmlParserInputPtr ret;
1703
1704     if (ctxt == NULL)
1705         return(NULL);
1706     if (ctxt->inputNr <= 0)
1707         return (NULL);
1708     ctxt->inputNr--;
1709     if (ctxt->inputNr > 0)
1710         ctxt->input = ctxt->inputTab[ctxt->inputNr - 1];
1711     else
1712         ctxt->input = NULL;
1713     ret = ctxt->inputTab[ctxt->inputNr];
1714     ctxt->inputTab[ctxt->inputNr] = NULL;
1715     return (ret);
1716 }
1717 /**
1718  * nodePush:
1719  * @ctxt:  an XML parser context
1720  * @value:  the element node
1721  *
1722  * Pushes a new element node on top of the node stack
1723  *
1724  * Returns -1 in case of error, the index in the stack otherwise
1725  */
1726 int
1727 nodePush(xmlParserCtxtPtr ctxt, xmlNodePtr value)
1728 {
1729     if (ctxt == NULL) return(0);
1730     if (ctxt->nodeNr >= ctxt->nodeMax) {
1731         xmlNodePtr *tmp;
1732
1733         tmp = (xmlNodePtr *) xmlRealloc(ctxt->nodeTab,
1734                                       ctxt->nodeMax * 2 *
1735                                       sizeof(ctxt->nodeTab[0]));
1736         if (tmp == NULL) {
1737             xmlErrMemory(ctxt, NULL);
1738             return (-1);
1739         }
1740         ctxt->nodeTab = tmp;
1741         ctxt->nodeMax *= 2;
1742     }
1743     if ((((unsigned int) ctxt->nodeNr) > xmlParserMaxDepth) &&
1744         ((ctxt->options & XML_PARSE_HUGE) == 0)) {
1745         xmlFatalErrMsgInt(ctxt, XML_ERR_INTERNAL_ERROR,
1746                  "Excessive depth in document: %d use XML_PARSE_HUGE option\n",
1747                           xmlParserMaxDepth);
1748         ctxt->instate = XML_PARSER_EOF;
1749         return(-1);
1750     }
1751     ctxt->nodeTab[ctxt->nodeNr] = value;
1752     ctxt->node = value;
1753     return (ctxt->nodeNr++);
1754 }
1755
1756 /**
1757  * nodePop:
1758  * @ctxt: an XML parser context
1759  *
1760  * Pops the top element node from the node stack
1761  *
1762  * Returns the node just removed
1763  */
1764 xmlNodePtr
1765 nodePop(xmlParserCtxtPtr ctxt)
1766 {
1767     xmlNodePtr ret;
1768
1769     if (ctxt == NULL) return(NULL);
1770     if (ctxt->nodeNr <= 0)
1771         return (NULL);
1772     ctxt->nodeNr--;
1773     if (ctxt->nodeNr > 0)
1774         ctxt->node = ctxt->nodeTab[ctxt->nodeNr - 1];
1775     else
1776         ctxt->node = NULL;
1777     ret = ctxt->nodeTab[ctxt->nodeNr];
1778     ctxt->nodeTab[ctxt->nodeNr] = NULL;
1779     return (ret);
1780 }
1781
1782 #ifdef LIBXML_PUSH_ENABLED
1783 /**
1784  * nameNsPush:
1785  * @ctxt:  an XML parser context
1786  * @value:  the element name
1787  * @prefix:  the element prefix
1788  * @URI:  the element namespace name
1789  *
1790  * Pushes a new element name/prefix/URL on top of the name stack
1791  *
1792  * Returns -1 in case of error, the index in the stack otherwise
1793  */
1794 static int
1795 nameNsPush(xmlParserCtxtPtr ctxt, const xmlChar * value,
1796            const xmlChar *prefix, const xmlChar *URI, int nsNr)
1797 {
1798     if (ctxt->nameNr >= ctxt->nameMax) {
1799         const xmlChar * *tmp;
1800         void **tmp2;
1801         ctxt->nameMax *= 2;
1802         tmp = (const xmlChar * *) xmlRealloc((xmlChar * *)ctxt->nameTab,
1803                                     ctxt->nameMax *
1804                                     sizeof(ctxt->nameTab[0]));
1805         if (tmp == NULL) {
1806             ctxt->nameMax /= 2;
1807             goto mem_error;
1808         }
1809         ctxt->nameTab = tmp;
1810         tmp2 = (void **) xmlRealloc((void * *)ctxt->pushTab,
1811                                     ctxt->nameMax * 3 *
1812                                     sizeof(ctxt->pushTab[0]));
1813         if (tmp2 == NULL) {
1814             ctxt->nameMax /= 2;
1815             goto mem_error;
1816         }
1817         ctxt->pushTab = tmp2;
1818     }
1819     ctxt->nameTab[ctxt->nameNr] = value;
1820     ctxt->name = value;
1821     ctxt->pushTab[ctxt->nameNr * 3] = (void *) prefix;
1822     ctxt->pushTab[ctxt->nameNr * 3 + 1] = (void *) URI;
1823     ctxt->pushTab[ctxt->nameNr * 3 + 2] = (void *) (long) nsNr;
1824     return (ctxt->nameNr++);
1825 mem_error:
1826     xmlErrMemory(ctxt, NULL);
1827     return (-1);
1828 }
1829 /**
1830  * nameNsPop:
1831  * @ctxt: an XML parser context
1832  *
1833  * Pops the top element/prefix/URI name from the name stack
1834  *
1835  * Returns the name just removed
1836  */
1837 static const xmlChar *
1838 nameNsPop(xmlParserCtxtPtr ctxt)
1839 {
1840     const xmlChar *ret;
1841
1842     if (ctxt->nameNr <= 0)
1843         return (NULL);
1844     ctxt->nameNr--;
1845     if (ctxt->nameNr > 0)
1846         ctxt->name = ctxt->nameTab[ctxt->nameNr - 1];
1847     else
1848         ctxt->name = NULL;
1849     ret = ctxt->nameTab[ctxt->nameNr];
1850     ctxt->nameTab[ctxt->nameNr] = NULL;
1851     return (ret);
1852 }
1853 #endif /* LIBXML_PUSH_ENABLED */
1854
1855 /**
1856  * namePush:
1857  * @ctxt:  an XML parser context
1858  * @value:  the element name
1859  *
1860  * Pushes a new element name on top of the name stack
1861  *
1862  * Returns -1 in case of error, the index in the stack otherwise
1863  */
1864 int
1865 namePush(xmlParserCtxtPtr ctxt, const xmlChar * value)
1866 {
1867     if (ctxt == NULL) return (-1);
1868
1869     if (ctxt->nameNr >= ctxt->nameMax) {
1870         const xmlChar * *tmp;
1871         tmp = (const xmlChar * *) xmlRealloc((xmlChar * *)ctxt->nameTab,
1872                                     ctxt->nameMax * 2 *
1873                                     sizeof(ctxt->nameTab[0]));
1874         if (tmp == NULL) {
1875             goto mem_error;
1876         }
1877         ctxt->nameTab = tmp;
1878         ctxt->nameMax *= 2;
1879     }
1880     ctxt->nameTab[ctxt->nameNr] = value;
1881     ctxt->name = value;
1882     return (ctxt->nameNr++);
1883 mem_error:
1884     xmlErrMemory(ctxt, NULL);
1885     return (-1);
1886 }
1887 /**
1888  * namePop:
1889  * @ctxt: an XML parser context
1890  *
1891  * Pops the top element name from the name stack
1892  *
1893  * Returns the name just removed
1894  */
1895 const xmlChar *
1896 namePop(xmlParserCtxtPtr ctxt)
1897 {
1898     const xmlChar *ret;
1899
1900     if ((ctxt == NULL) || (ctxt->nameNr <= 0))
1901         return (NULL);
1902     ctxt->nameNr--;
1903     if (ctxt->nameNr > 0)
1904         ctxt->name = ctxt->nameTab[ctxt->nameNr - 1];
1905     else
1906         ctxt->name = NULL;
1907     ret = ctxt->nameTab[ctxt->nameNr];
1908     ctxt->nameTab[ctxt->nameNr] = NULL;
1909     return (ret);
1910 }
1911
1912 static int spacePush(xmlParserCtxtPtr ctxt, int val) {
1913     if (ctxt->spaceNr >= ctxt->spaceMax) {
1914         int *tmp;
1915
1916         ctxt->spaceMax *= 2;
1917         tmp = (int *) xmlRealloc(ctxt->spaceTab,
1918                                  ctxt->spaceMax * sizeof(ctxt->spaceTab[0]));
1919         if (tmp == NULL) {
1920             xmlErrMemory(ctxt, NULL);
1921             ctxt->spaceMax /=2;
1922             return(-1);
1923         }
1924         ctxt->spaceTab = tmp;
1925     }
1926     ctxt->spaceTab[ctxt->spaceNr] = val;
1927     ctxt->space = &ctxt->spaceTab[ctxt->spaceNr];
1928     return(ctxt->spaceNr++);
1929 }
1930
1931 static int spacePop(xmlParserCtxtPtr ctxt) {
1932     int ret;
1933     if (ctxt->spaceNr <= 0) return(0);
1934     ctxt->spaceNr--;
1935     if (ctxt->spaceNr > 0)
1936         ctxt->space = &ctxt->spaceTab[ctxt->spaceNr - 1];
1937     else
1938         ctxt->space = &ctxt->spaceTab[0];
1939     ret = ctxt->spaceTab[ctxt->spaceNr];
1940     ctxt->spaceTab[ctxt->spaceNr] = -1;
1941     return(ret);
1942 }
1943
1944 /*
1945  * Macros for accessing the content. Those should be used only by the parser,
1946  * and not exported.
1947  *
1948  * Dirty macros, i.e. one often need to make assumption on the context to
1949  * use them
1950  *
1951  *   CUR_PTR return the current pointer to the xmlChar to be parsed.
1952  *           To be used with extreme caution since operations consuming
1953  *           characters may move the input buffer to a different location !
1954  *   CUR     returns the current xmlChar value, i.e. a 8 bit value if compiled
1955  *           This should be used internally by the parser
1956  *           only to compare to ASCII values otherwise it would break when
1957  *           running with UTF-8 encoding.
1958  *   RAW     same as CUR but in the input buffer, bypass any token
1959  *           extraction that may have been done
1960  *   NXT(n)  returns the n'th next xmlChar. Same as CUR is should be used only
1961  *           to compare on ASCII based substring.
1962  *   SKIP(n) Skip n xmlChar, and must also be used only to skip ASCII defined
1963  *           strings without newlines within the parser.
1964  *   NEXT1(l) Skip 1 xmlChar, and must also be used only to skip 1 non-newline ASCII
1965  *           defined char within the parser.
1966  * Clean macros, not dependent of an ASCII context, expect UTF-8 encoding
1967  *
1968  *   NEXT    Skip to the next character, this does the proper decoding
1969  *           in UTF-8 mode. It also pop-up unfinished entities on the fly.
1970  *   NEXTL(l) Skip the current unicode character of l xmlChars long.
1971  *   CUR_CHAR(l) returns the current unicode character (int), set l
1972  *           to the number of xmlChars used for the encoding [0-5].
1973  *   CUR_SCHAR  same but operate on a string instead of the context
1974  *   COPY_BUF  copy the current unicode char to the target buffer, increment
1975  *            the index
1976  *   GROW, SHRINK  handling of input buffers
1977  */
1978
1979 #define RAW (*ctxt->input->cur)
1980 #define CUR (*ctxt->input->cur)
1981 #define NXT(val) ctxt->input->cur[(val)]
1982 #define CUR_PTR ctxt->input->cur
1983
1984 #define CMP4( s, c1, c2, c3, c4 ) \
1985   ( ((unsigned char *) s)[ 0 ] == c1 && ((unsigned char *) s)[ 1 ] == c2 && \
1986     ((unsigned char *) s)[ 2 ] == c3 && ((unsigned char *) s)[ 3 ] == c4 )
1987 #define CMP5( s, c1, c2, c3, c4, c5 ) \
1988   ( CMP4( s, c1, c2, c3, c4 ) && ((unsigned char *) s)[ 4 ] == c5 )
1989 #define CMP6( s, c1, c2, c3, c4, c5, c6 ) \
1990   ( CMP5( s, c1, c2, c3, c4, c5 ) && ((unsigned char *) s)[ 5 ] == c6 )
1991 #define CMP7( s, c1, c2, c3, c4, c5, c6, c7 ) \
1992   ( CMP6( s, c1, c2, c3, c4, c5, c6 ) && ((unsigned char *) s)[ 6 ] == c7 )
1993 #define CMP8( s, c1, c2, c3, c4, c5, c6, c7, c8 ) \
1994   ( CMP7( s, c1, c2, c3, c4, c5, c6, c7 ) && ((unsigned char *) s)[ 7 ] == c8 )
1995 #define CMP9( s, c1, c2, c3, c4, c5, c6, c7, c8, c9 ) \
1996   ( CMP8( s, c1, c2, c3, c4, c5, c6, c7, c8 ) && \
1997     ((unsigned char *) s)[ 8 ] == c9 )
1998 #define CMP10( s, c1, c2, c3, c4, c5, c6, c7, c8, c9, c10 ) \
1999   ( CMP9( s, c1, c2, c3, c4, c5, c6, c7, c8, c9 ) && \
2000     ((unsigned char *) s)[ 9 ] == c10 )
2001
2002 #define SKIP(val) do {                                                  \
2003     ctxt->nbChars += (val),ctxt->input->cur += (val),ctxt->input->col+=(val);                   \
2004     if (*ctxt->input->cur == '%') xmlParserHandlePEReference(ctxt);     \
2005     if ((*ctxt->input->cur == 0) &&                                     \
2006         (xmlParserInputGrow(ctxt->input, INPUT_CHUNK) <= 0))            \
2007             xmlPopInput(ctxt);                                          \
2008   } while (0)
2009
2010 #define SKIPL(val) do {                                                 \
2011     int skipl;                                                          \
2012     for(skipl=0; skipl<val; skipl++) {                                  \
2013         if (*(ctxt->input->cur) == '\n') {                              \
2014         ctxt->input->line++; ctxt->input->col = 1;                      \
2015         } else ctxt->input->col++;                                      \
2016         ctxt->nbChars++;                                                \
2017         ctxt->input->cur++;                                             \
2018     }                                                                   \
2019     if (*ctxt->input->cur == '%') xmlParserHandlePEReference(ctxt);     \
2020     if ((*ctxt->input->cur == 0) &&                                     \
2021         (xmlParserInputGrow(ctxt->input, INPUT_CHUNK) <= 0))            \
2022             xmlPopInput(ctxt);                                          \
2023   } while (0)
2024
2025 #define SHRINK if ((ctxt->progressive == 0) &&                          \
2026                    (ctxt->input->cur - ctxt->input->base > 2 * INPUT_CHUNK) && \
2027                    (ctxt->input->end - ctxt->input->cur < 2 * INPUT_CHUNK)) \
2028         xmlSHRINK (ctxt);
2029
2030 static void xmlSHRINK (xmlParserCtxtPtr ctxt) {
2031     xmlParserInputShrink(ctxt->input);
2032     if ((*ctxt->input->cur == 0) &&
2033         (xmlParserInputGrow(ctxt->input, INPUT_CHUNK) <= 0))
2034             xmlPopInput(ctxt);
2035   }
2036
2037 #define GROW if ((ctxt->progressive == 0) &&                            \
2038                  (ctxt->input->end - ctxt->input->cur < INPUT_CHUNK))   \
2039         xmlGROW (ctxt);
2040
2041 static void xmlGROW (xmlParserCtxtPtr ctxt) {
2042     if ((((ctxt->input->end - ctxt->input->cur) > XML_MAX_LOOKUP_LIMIT) ||
2043          ((ctxt->input->cur - ctxt->input->base) > XML_MAX_LOOKUP_LIMIT)) &&
2044          ((ctxt->input->buf) && (ctxt->input->buf->readcallback != (xmlInputReadCallback) xmlNop)) &&
2045         ((ctxt->options & XML_PARSE_HUGE) == 0)) {
2046         xmlFatalErr(ctxt, XML_ERR_INTERNAL_ERROR, "Huge input lookup");
2047         ctxt->instate = XML_PARSER_EOF;
2048     }
2049     xmlParserInputGrow(ctxt->input, INPUT_CHUNK);
2050     if ((ctxt->input->cur != NULL) && (*ctxt->input->cur == 0) &&
2051         (xmlParserInputGrow(ctxt->input, INPUT_CHUNK) <= 0))
2052             xmlPopInput(ctxt);
2053 }
2054
2055 #define SKIP_BLANKS xmlSkipBlankChars(ctxt)
2056
2057 #define NEXT xmlNextChar(ctxt)
2058
2059 #define NEXT1 {                                                         \
2060         ctxt->input->col++;                                             \
2061         ctxt->input->cur++;                                             \
2062         ctxt->nbChars++;                                                \
2063         if (*ctxt->input->cur == 0)                                     \
2064             xmlParserInputGrow(ctxt->input, INPUT_CHUNK);               \
2065     }
2066
2067 #define NEXTL(l) do {                                                   \
2068     if (*(ctxt->input->cur) == '\n') {                                  \
2069         ctxt->input->line++; ctxt->input->col = 1;                      \
2070     } else ctxt->input->col++;                                          \
2071     ctxt->input->cur += l;                              \
2072     if (*ctxt->input->cur == '%') xmlParserHandlePEReference(ctxt);     \
2073   } while (0)
2074
2075 #define CUR_CHAR(l) xmlCurrentChar(ctxt, &l)
2076 #define CUR_SCHAR(s, l) xmlStringCurrentChar(ctxt, s, &l)
2077
2078 #define COPY_BUF(l,b,i,v)                                               \
2079     if (l == 1) b[i++] = (xmlChar) v;                                   \
2080     else i += xmlCopyCharMultiByte(&b[i],v)
2081
2082 /**
2083  * xmlSkipBlankChars:
2084  * @ctxt:  the XML parser context
2085  *
2086  * skip all blanks character found at that point in the input streams.
2087  * It pops up finished entities in the process if allowable at that point.
2088  *
2089  * Returns the number of space chars skipped
2090  */
2091
2092 int
2093 xmlSkipBlankChars(xmlParserCtxtPtr ctxt) {
2094     int res = 0;
2095
2096     /*
2097      * It's Okay to use CUR/NEXT here since all the blanks are on
2098      * the ASCII range.
2099      */
2100     if ((ctxt->inputNr == 1) && (ctxt->instate != XML_PARSER_DTD)) {
2101         const xmlChar *cur;
2102         /*
2103          * if we are in the document content, go really fast
2104          */
2105         cur = ctxt->input->cur;
2106         while (IS_BLANK_CH(*cur)) {
2107             if (*cur == '\n') {
2108                 ctxt->input->line++; ctxt->input->col = 1;
2109             }
2110             cur++;
2111             res++;
2112             if (*cur == 0) {
2113                 ctxt->input->cur = cur;
2114                 xmlParserInputGrow(ctxt->input, INPUT_CHUNK);
2115                 cur = ctxt->input->cur;
2116             }
2117         }
2118         ctxt->input->cur = cur;
2119     } else {
2120         int cur;
2121         do {
2122             cur = CUR;
2123             while (IS_BLANK_CH(cur)) { /* CHECKED tstblanks.xml */
2124                 NEXT;
2125                 cur = CUR;
2126                 res++;
2127             }
2128             while ((cur == 0) && (ctxt->inputNr > 1) &&
2129                    (ctxt->instate != XML_PARSER_COMMENT)) {
2130                 xmlPopInput(ctxt);
2131                 cur = CUR;
2132             }
2133             /*
2134              * Need to handle support of entities branching here
2135              */
2136             if (*ctxt->input->cur == '%') xmlParserHandlePEReference(ctxt);
2137         } while (IS_BLANK(cur)); /* CHECKED tstblanks.xml */
2138     }
2139     return(res);
2140 }
2141
2142 /************************************************************************
2143  *                                                                      *
2144  *              Commodity functions to handle entities                  *
2145  *                                                                      *
2146  ************************************************************************/
2147
2148 /**
2149  * xmlPopInput:
2150  * @ctxt:  an XML parser context
2151  *
2152  * xmlPopInput: the current input pointed by ctxt->input came to an end
2153  *          pop it and return the next char.
2154  *
2155  * Returns the current xmlChar in the parser context
2156  */
2157 xmlChar
2158 xmlPopInput(xmlParserCtxtPtr ctxt) {
2159     if ((ctxt == NULL) || (ctxt->inputNr <= 1)) return(0);
2160     if (xmlParserDebugEntities)
2161         xmlGenericError(xmlGenericErrorContext,
2162                 "Popping input %d\n", ctxt->inputNr);
2163     xmlFreeInputStream(inputPop(ctxt));
2164     if ((*ctxt->input->cur == 0) &&
2165         (xmlParserInputGrow(ctxt->input, INPUT_CHUNK) <= 0))
2166             return(xmlPopInput(ctxt));
2167     return(CUR);
2168 }
2169
2170 /**
2171  * xmlPushInput:
2172  * @ctxt:  an XML parser context
2173  * @input:  an XML parser input fragment (entity, XML fragment ...).
2174  *
2175  * xmlPushInput: switch to a new input stream which is stacked on top
2176  *               of the previous one(s).
2177  * Returns -1 in case of error or the index in the input stack
2178  */
2179 int
2180 xmlPushInput(xmlParserCtxtPtr ctxt, xmlParserInputPtr input) {
2181     int ret;
2182     if (input == NULL) return(-1);
2183
2184     if (xmlParserDebugEntities) {
2185         if ((ctxt->input != NULL) && (ctxt->input->filename))
2186             xmlGenericError(xmlGenericErrorContext,
2187                     "%s(%d): ", ctxt->input->filename,
2188                     ctxt->input->line);
2189         xmlGenericError(xmlGenericErrorContext,
2190                 "Pushing input %d : %.30s\n", ctxt->inputNr+1, input->cur);
2191     }
2192     ret = inputPush(ctxt, input);
2193     if (ctxt->instate == XML_PARSER_EOF)
2194         return(-1);
2195     GROW;
2196     return(ret);
2197 }
2198
2199 /**
2200  * xmlParseCharRef:
2201  * @ctxt:  an XML parser context
2202  *
2203  * parse Reference declarations
2204  *
2205  * [66] CharRef ::= '&#' [0-9]+ ';' |
2206  *                  '&#x' [0-9a-fA-F]+ ';'
2207  *
2208  * [ WFC: Legal Character ]
2209  * Characters referred to using character references must match the
2210  * production for Char.
2211  *
2212  * Returns the value parsed (as an int), 0 in case of error
2213  */
2214 int
2215 xmlParseCharRef(xmlParserCtxtPtr ctxt) {
2216     unsigned int val = 0;
2217     int count = 0;
2218     unsigned int outofrange = 0;
2219
2220     /*
2221      * Using RAW/CUR/NEXT is okay since we are working on ASCII range here
2222      */
2223     if ((RAW == '&') && (NXT(1) == '#') &&
2224         (NXT(2) == 'x')) {
2225         SKIP(3);
2226         GROW;
2227         while (RAW != ';') { /* loop blocked by count */
2228             if (count++ > 20) {
2229                 count = 0;
2230                 GROW;
2231                 if (ctxt->instate == XML_PARSER_EOF)
2232                     return(0);
2233             }
2234             if ((RAW >= '0') && (RAW <= '9'))
2235                 val = val * 16 + (CUR - '0');
2236             else if ((RAW >= 'a') && (RAW <= 'f') && (count < 20))
2237                 val = val * 16 + (CUR - 'a') + 10;
2238             else if ((RAW >= 'A') && (RAW <= 'F') && (count < 20))
2239                 val = val * 16 + (CUR - 'A') + 10;
2240             else {
2241                 xmlFatalErr(ctxt, XML_ERR_INVALID_HEX_CHARREF, NULL);
2242                 val = 0;
2243                 break;
2244             }
2245             if (val > 0x10FFFF)
2246                 outofrange = val;
2247
2248             NEXT;
2249             count++;
2250         }
2251         if (RAW == ';') {
2252             /* on purpose to avoid reentrancy problems with NEXT and SKIP */
2253             ctxt->input->col++;
2254             ctxt->nbChars ++;
2255             ctxt->input->cur++;
2256         }
2257     } else if  ((RAW == '&') && (NXT(1) == '#')) {
2258         SKIP(2);
2259         GROW;
2260         while (RAW != ';') { /* loop blocked by count */
2261             if (count++ > 20) {
2262                 count = 0;
2263                 GROW;
2264                 if (ctxt->instate == XML_PARSER_EOF)
2265                     return(0);
2266             }
2267             if ((RAW >= '0') && (RAW <= '9'))
2268                 val = val * 10 + (CUR - '0');
2269             else {
2270                 xmlFatalErr(ctxt, XML_ERR_INVALID_DEC_CHARREF, NULL);
2271                 val = 0;
2272                 break;
2273             }
2274             if (val > 0x10FFFF)
2275                 outofrange = val;
2276
2277             NEXT;
2278             count++;
2279         }
2280         if (RAW == ';') {
2281             /* on purpose to avoid reentrancy problems with NEXT and SKIP */
2282             ctxt->input->col++;
2283             ctxt->nbChars ++;
2284             ctxt->input->cur++;
2285         }
2286     } else {
2287         xmlFatalErr(ctxt, XML_ERR_INVALID_CHARREF, NULL);
2288     }
2289
2290     /*
2291      * [ WFC: Legal Character ]
2292      * Characters referred to using character references must match the
2293      * production for Char.
2294      */
2295     if ((IS_CHAR(val) && (outofrange == 0))) {
2296         return(val);
2297     } else {
2298         xmlFatalErrMsgInt(ctxt, XML_ERR_INVALID_CHAR,
2299                           "xmlParseCharRef: invalid xmlChar value %d\n",
2300                           val);
2301     }
2302     return(0);
2303 }
2304
2305 /**
2306  * xmlParseStringCharRef:
2307  * @ctxt:  an XML parser context
2308  * @str:  a pointer to an index in the string
2309  *
2310  * parse Reference declarations, variant parsing from a string rather
2311  * than an an input flow.
2312  *
2313  * [66] CharRef ::= '&#' [0-9]+ ';' |
2314  *                  '&#x' [0-9a-fA-F]+ ';'
2315  *
2316  * [ WFC: Legal Character ]
2317  * Characters referred to using character references must match the
2318  * production for Char.
2319  *
2320  * Returns the value parsed (as an int), 0 in case of error, str will be
2321  *         updated to the current value of the index
2322  */
2323 static int
2324 xmlParseStringCharRef(xmlParserCtxtPtr ctxt, const xmlChar **str) {
2325     const xmlChar *ptr;
2326     xmlChar cur;
2327     unsigned int val = 0;
2328     unsigned int outofrange = 0;
2329
2330     if ((str == NULL) || (*str == NULL)) return(0);
2331     ptr = *str;
2332     cur = *ptr;
2333     if ((cur == '&') && (ptr[1] == '#') && (ptr[2] == 'x')) {
2334         ptr += 3;
2335         cur = *ptr;
2336         while (cur != ';') { /* Non input consuming loop */
2337             if ((cur >= '0') && (cur <= '9'))
2338                 val = val * 16 + (cur - '0');
2339             else if ((cur >= 'a') && (cur <= 'f'))
2340                 val = val * 16 + (cur - 'a') + 10;
2341             else if ((cur >= 'A') && (cur <= 'F'))
2342                 val = val * 16 + (cur - 'A') + 10;
2343             else {
2344                 xmlFatalErr(ctxt, XML_ERR_INVALID_HEX_CHARREF, NULL);
2345                 val = 0;
2346                 break;
2347             }
2348             if (val > 0x10FFFF)
2349                 outofrange = val;
2350
2351             ptr++;
2352             cur = *ptr;
2353         }
2354         if (cur == ';')
2355             ptr++;
2356     } else if  ((cur == '&') && (ptr[1] == '#')){
2357         ptr += 2;
2358         cur = *ptr;
2359         while (cur != ';') { /* Non input consuming loops */
2360             if ((cur >= '0') && (cur <= '9'))
2361                 val = val * 10 + (cur - '0');
2362             else {
2363                 xmlFatalErr(ctxt, XML_ERR_INVALID_DEC_CHARREF, NULL);
2364                 val = 0;
2365                 break;
2366             }
2367             if (val > 0x10FFFF)
2368                 outofrange = val;
2369
2370             ptr++;
2371             cur = *ptr;
2372         }
2373         if (cur == ';')
2374             ptr++;
2375     } else {
2376         xmlFatalErr(ctxt, XML_ERR_INVALID_CHARREF, NULL);
2377         return(0);
2378     }
2379     *str = ptr;
2380
2381     /*
2382      * [ WFC: Legal Character ]
2383      * Characters referred to using character references must match the
2384      * production for Char.
2385      */
2386     if ((IS_CHAR(val) && (outofrange == 0))) {
2387         return(val);
2388     } else {
2389         xmlFatalErrMsgInt(ctxt, XML_ERR_INVALID_CHAR,
2390                           "xmlParseStringCharRef: invalid xmlChar value %d\n",
2391                           val);
2392     }
2393     return(0);
2394 }
2395
2396 /**
2397  * xmlNewBlanksWrapperInputStream:
2398  * @ctxt:  an XML parser context
2399  * @entity:  an Entity pointer
2400  *
2401  * Create a new input stream for wrapping
2402  * blanks around a PEReference
2403  *
2404  * Returns the new input stream or NULL
2405  */
2406
2407 static void deallocblankswrapper (xmlChar *str) {xmlFree(str);}
2408
2409 static xmlParserInputPtr
2410 xmlNewBlanksWrapperInputStream(xmlParserCtxtPtr ctxt, xmlEntityPtr entity) {
2411     xmlParserInputPtr input;
2412     xmlChar *buffer;
2413     size_t length;
2414     if (entity == NULL) {
2415         xmlFatalErr(ctxt, XML_ERR_INTERNAL_ERROR,
2416                     "xmlNewBlanksWrapperInputStream entity\n");
2417         return(NULL);
2418     }
2419     if (xmlParserDebugEntities)
2420         xmlGenericError(xmlGenericErrorContext,
2421                 "new blanks wrapper for entity: %s\n", entity->name);
2422     input = xmlNewInputStream(ctxt);
2423     if (input == NULL) {
2424         return(NULL);
2425     }
2426     length = xmlStrlen(entity->name) + 5;
2427     buffer = xmlMallocAtomic(length);
2428     if (buffer == NULL) {
2429         xmlErrMemory(ctxt, NULL);
2430         xmlFree(input);
2431         return(NULL);
2432     }
2433     buffer [0] = ' ';
2434     buffer [1] = '%';
2435     buffer [length-3] = ';';
2436     buffer [length-2] = ' ';
2437     buffer [length-1] = 0;
2438     memcpy(buffer + 2, entity->name, length - 5);
2439     input->free = deallocblankswrapper;
2440     input->base = buffer;
2441     input->cur = buffer;
2442     input->length = length;
2443     input->end = &buffer[length];
2444     return(input);
2445 }
2446
2447 /**
2448  * xmlParserHandlePEReference:
2449  * @ctxt:  the parser context
2450  *
2451  * [69] PEReference ::= '%' Name ';'
2452  *
2453  * [ WFC: No Recursion ]
2454  * A parsed entity must not contain a recursive
2455  * reference to itself, either directly or indirectly.
2456  *
2457  * [ WFC: Entity Declared ]
2458  * In a document without any DTD, a document with only an internal DTD
2459  * subset which contains no parameter entity references, or a document
2460  * with "standalone='yes'", ...  ... The declaration of a parameter
2461  * entity must precede any reference to it...
2462  *
2463  * [ VC: Entity Declared ]
2464  * In a document with an external subset or external parameter entities
2465  * with "standalone='no'", ...  ... The declaration of a parameter entity
2466  * must precede any reference to it...
2467  *
2468  * [ WFC: In DTD ]
2469  * Parameter-entity references may only appear in the DTD.
2470  * NOTE: misleading but this is handled.
2471  *
2472  * A PEReference may have been detected in the current input stream
2473  * the handling is done accordingly to
2474  *      http://www.w3.org/TR/REC-xml#entproc
2475  * i.e.
2476  *   - Included in literal in entity values
2477  *   - Included as Parameter Entity reference within DTDs
2478  */
2479 void
2480 xmlParserHandlePEReference(xmlParserCtxtPtr ctxt) {
2481     const xmlChar *name;
2482     xmlEntityPtr entity = NULL;
2483     xmlParserInputPtr input;
2484
2485     if (RAW != '%') return;
2486     switch(ctxt->instate) {
2487         case XML_PARSER_CDATA_SECTION:
2488             return;
2489         case XML_PARSER_COMMENT:
2490             return;
2491         case XML_PARSER_START_TAG:
2492             return;
2493         case XML_PARSER_END_TAG:
2494             return;
2495         case XML_PARSER_EOF:
2496             xmlFatalErr(ctxt, XML_ERR_PEREF_AT_EOF, NULL);
2497             return;
2498         case XML_PARSER_PROLOG:
2499         case XML_PARSER_START:
2500         case XML_PARSER_MISC:
2501             xmlFatalErr(ctxt, XML_ERR_PEREF_IN_PROLOG, NULL);
2502             return;
2503         case XML_PARSER_ENTITY_DECL:
2504         case XML_PARSER_CONTENT:
2505         case XML_PARSER_ATTRIBUTE_VALUE:
2506         case XML_PARSER_PI:
2507         case XML_PARSER_SYSTEM_LITERAL:
2508         case XML_PARSER_PUBLIC_LITERAL:
2509             /* we just ignore it there */
2510             return;
2511         case XML_PARSER_EPILOG:
2512             xmlFatalErr(ctxt, XML_ERR_PEREF_IN_EPILOG, NULL);
2513             return;
2514         case XML_PARSER_ENTITY_VALUE:
2515             /*
2516              * NOTE: in the case of entity values, we don't do the
2517              *       substitution here since we need the literal
2518              *       entity value to be able to save the internal
2519              *       subset of the document.
2520              *       This will be handled by xmlStringDecodeEntities
2521              */
2522             return;
2523         case XML_PARSER_DTD:
2524             /*
2525              * [WFC: Well-Formedness Constraint: PEs in Internal Subset]
2526              * In the internal DTD subset, parameter-entity references
2527              * can occur only where markup declarations can occur, not
2528              * within markup declarations.
2529              * In that case this is handled in xmlParseMarkupDecl
2530              */
2531             if ((ctxt->external == 0) && (ctxt->inputNr == 1))
2532                 return;
2533             if (IS_BLANK_CH(NXT(1)) || NXT(1) == 0)
2534                 return;
2535             break;
2536         case XML_PARSER_IGNORE:
2537             return;
2538     }
2539
2540     NEXT;
2541     name = xmlParseName(ctxt);
2542     if (xmlParserDebugEntities)
2543         xmlGenericError(xmlGenericErrorContext,
2544                 "PEReference: %s\n", name);
2545     if (name == NULL) {
2546         xmlFatalErr(ctxt, XML_ERR_PEREF_NO_NAME, NULL);
2547     } else {
2548         if (RAW == ';') {
2549             NEXT;
2550             if ((ctxt->sax != NULL) && (ctxt->sax->getParameterEntity != NULL))
2551                 entity = ctxt->sax->getParameterEntity(ctxt->userData, name);
2552             if (ctxt->instate == XML_PARSER_EOF)
2553                 return;
2554             if (entity == NULL) {
2555
2556                 /*
2557                  * [ WFC: Entity Declared ]
2558                  * In a document without any DTD, a document with only an
2559                  * internal DTD subset which contains no parameter entity
2560                  * references, or a document with "standalone='yes'", ...
2561                  * ... The declaration of a parameter entity must precede
2562                  * any reference to it...
2563                  */
2564                 if ((ctxt->standalone == 1) ||
2565                     ((ctxt->hasExternalSubset == 0) &&
2566                      (ctxt->hasPErefs == 0))) {
2567                     xmlFatalErrMsgStr(ctxt, XML_ERR_UNDECLARED_ENTITY,
2568                          "PEReference: %%%s; not found\n", name);
2569                 } else {
2570                     /*
2571                      * [ VC: Entity Declared ]
2572                      * In a document with an external subset or external
2573                      * parameter entities with "standalone='no'", ...
2574                      * ... The declaration of a parameter entity must precede
2575                      * any reference to it...
2576                      */
2577                     if ((ctxt->validate) && (ctxt->vctxt.error != NULL)) {
2578                         xmlValidityError(ctxt, XML_WAR_UNDECLARED_ENTITY,
2579                                          "PEReference: %%%s; not found\n",
2580                                          name, NULL);
2581                     } else
2582                         xmlWarningMsg(ctxt, XML_WAR_UNDECLARED_ENTITY,
2583                                       "PEReference: %%%s; not found\n",
2584                                       name, NULL);
2585                     ctxt->valid = 0;
2586                 }
2587             } else if (ctxt->input->free != deallocblankswrapper) {
2588                     input = xmlNewBlanksWrapperInputStream(ctxt, entity);
2589                     if (xmlPushInput(ctxt, input) < 0)
2590                         return;
2591             } else {
2592                 if ((entity->etype == XML_INTERNAL_PARAMETER_ENTITY) ||
2593                     (entity->etype == XML_EXTERNAL_PARAMETER_ENTITY)) {
2594                     xmlChar start[4];
2595                     xmlCharEncoding enc;
2596
2597                     /*
2598                      * handle the extra spaces added before and after
2599                      * c.f. http://www.w3.org/TR/REC-xml#as-PE
2600                      * this is done independently.
2601                      */
2602                     input = xmlNewEntityInputStream(ctxt, entity);
2603                     if (xmlPushInput(ctxt, input) < 0)
2604                         return;
2605
2606                     /*
2607                      * Get the 4 first bytes and decode the charset
2608                      * if enc != XML_CHAR_ENCODING_NONE
2609                      * plug some encoding conversion routines.
2610                      * Note that, since we may have some non-UTF8
2611                      * encoding (like UTF16, bug 135229), the 'length'
2612                      * is not known, but we can calculate based upon
2613                      * the amount of data in the buffer.
2614                      */
2615                     GROW
2616                     if (ctxt->instate == XML_PARSER_EOF)
2617                         return;
2618                     if ((ctxt->input->end - ctxt->input->cur)>=4) {
2619                         start[0] = RAW;
2620                         start[1] = NXT(1);
2621                         start[2] = NXT(2);
2622                         start[3] = NXT(3);
2623                         enc = xmlDetectCharEncoding(start, 4);
2624                         if (enc != XML_CHAR_ENCODING_NONE) {
2625                             xmlSwitchEncoding(ctxt, enc);
2626                         }
2627                     }
2628
2629                     if ((entity->etype == XML_EXTERNAL_PARAMETER_ENTITY) &&
2630                         (CMP5(CUR_PTR, '<', '?', 'x', 'm', 'l' )) &&
2631                         (IS_BLANK_CH(NXT(5)))) {
2632                         xmlParseTextDecl(ctxt);
2633                     }
2634                 } else {
2635                     xmlFatalErrMsgStr(ctxt, XML_ERR_ENTITY_IS_PARAMETER,
2636                              "PEReference: %s is not a parameter entity\n",
2637                                       name);
2638                 }
2639             }
2640         } else {
2641             xmlFatalErr(ctxt, XML_ERR_PEREF_SEMICOL_MISSING, NULL);
2642         }
2643     }
2644 }
2645
2646 /*
2647  * Macro used to grow the current buffer.
2648  * buffer##_size is expected to be a size_t
2649  * mem_error: is expected to handle memory allocation failures
2650  */
2651 #define growBuffer(buffer, n) {                                         \
2652     xmlChar *tmp;                                                       \
2653     size_t new_size = buffer##_size * 2 + n;                            \
2654     if (new_size < buffer##_size) goto mem_error;                       \
2655     tmp = (xmlChar *) xmlRealloc(buffer, new_size);                     \
2656     if (tmp == NULL) goto mem_error;                                    \
2657     buffer = tmp;                                                       \
2658     buffer##_size = new_size;                                           \
2659 }
2660
2661 /**
2662  * xmlStringLenDecodeEntities:
2663  * @ctxt:  the parser context
2664  * @str:  the input string
2665  * @len: the string length
2666  * @what:  combination of XML_SUBSTITUTE_REF and XML_SUBSTITUTE_PEREF
2667  * @end:  an end marker xmlChar, 0 if none
2668  * @end2:  an end marker xmlChar, 0 if none
2669  * @end3:  an end marker xmlChar, 0 if none
2670  *
2671  * Takes a entity string content and process to do the adequate substitutions.
2672  *
2673  * [67] Reference ::= EntityRef | CharRef
2674  *
2675  * [69] PEReference ::= '%' Name ';'
2676  *
2677  * Returns A newly allocated string with the substitution done. The caller
2678  *      must deallocate it !
2679  */
2680 xmlChar *
2681 xmlStringLenDecodeEntities(xmlParserCtxtPtr ctxt, const xmlChar *str, int len,
2682                       int what, xmlChar end, xmlChar  end2, xmlChar end3) {
2683     xmlChar *buffer = NULL;
2684     size_t buffer_size = 0;
2685     size_t nbchars = 0;
2686
2687     xmlChar *current = NULL;
2688     xmlChar *rep = NULL;
2689     const xmlChar *last;
2690     xmlEntityPtr ent;
2691     int c,l;
2692
2693     if ((ctxt == NULL) || (str == NULL) || (len < 0))
2694         return(NULL);
2695     last = str + len;
2696
2697     if (((ctxt->depth > 40) &&
2698          ((ctxt->options & XML_PARSE_HUGE) == 0)) ||
2699         (ctxt->depth > 1024)) {
2700         xmlFatalErr(ctxt, XML_ERR_ENTITY_LOOP, NULL);
2701         return(NULL);
2702     }
2703
2704     /*
2705      * allocate a translation buffer.
2706      */
2707     buffer_size = XML_PARSER_BIG_BUFFER_SIZE;
2708     buffer = (xmlChar *) xmlMallocAtomic(buffer_size);
2709     if (buffer == NULL) goto mem_error;
2710
2711     /*
2712      * OK loop until we reach one of the ending char or a size limit.
2713      * we are operating on already parsed values.
2714      */
2715     if (str < last)
2716         c = CUR_SCHAR(str, l);
2717     else
2718         c = 0;
2719     while ((c != 0) && (c != end) && /* non input consuming loop */
2720            (c != end2) && (c != end3)) {
2721
2722         if (c == 0) break;
2723         if ((c == '&') && (str[1] == '#')) {
2724             int val = xmlParseStringCharRef(ctxt, &str);
2725             if (val != 0) {
2726                 COPY_BUF(0,buffer,nbchars,val);
2727             }
2728             if (nbchars + XML_PARSER_BUFFER_SIZE > buffer_size) {
2729                 growBuffer(buffer, XML_PARSER_BUFFER_SIZE);
2730             }
2731         } else if ((c == '&') && (what & XML_SUBSTITUTE_REF)) {
2732             if (xmlParserDebugEntities)
2733                 xmlGenericError(xmlGenericErrorContext,
2734                         "String decoding Entity Reference: %.30s\n",
2735                         str);
2736             ent = xmlParseStringEntityRef(ctxt, &str);
2737             if ((ctxt->lastError.code == XML_ERR_ENTITY_LOOP) ||
2738                 (ctxt->lastError.code == XML_ERR_INTERNAL_ERROR))
2739                 goto int_error;
2740             if (ent != NULL)
2741                 ctxt->nbentities += ent->checked / 2;
2742             if ((ent != NULL) &&
2743                 (ent->etype == XML_INTERNAL_PREDEFINED_ENTITY)) {
2744                 if (ent->content != NULL) {
2745                     COPY_BUF(0,buffer,nbchars,ent->content[0]);
2746                     if (nbchars + XML_PARSER_BUFFER_SIZE > buffer_size) {
2747                         growBuffer(buffer, XML_PARSER_BUFFER_SIZE);
2748                     }
2749                 } else {
2750                     xmlFatalErrMsg(ctxt, XML_ERR_INTERNAL_ERROR,
2751                             "predefined entity has no content\n");
2752                 }
2753             } else if ((ent != NULL) && (ent->content != NULL)) {
2754                 ctxt->depth++;
2755                 rep = xmlStringDecodeEntities(ctxt, ent->content, what,
2756                                               0, 0, 0);
2757                 ctxt->depth--;
2758
2759                 if (rep != NULL) {
2760                     current = rep;
2761                     while (*current != 0) { /* non input consuming loop */
2762                         buffer[nbchars++] = *current++;
2763                         if (nbchars + XML_PARSER_BUFFER_SIZE > buffer_size) {
2764                             if (xmlParserEntityCheck(ctxt, nbchars, ent, 0))
2765                                 goto int_error;
2766                             growBuffer(buffer, XML_PARSER_BUFFER_SIZE);
2767                         }
2768                     }
2769                     xmlFree(rep);
2770                     rep = NULL;
2771                 }
2772             } else if (ent != NULL) {
2773                 int i = xmlStrlen(ent->name);
2774                 const xmlChar *cur = ent->name;
2775
2776                 buffer[nbchars++] = '&';
2777                 if (nbchars + i + XML_PARSER_BUFFER_SIZE > buffer_size) {
2778                     growBuffer(buffer, i + XML_PARSER_BUFFER_SIZE);
2779                 }
2780                 for (;i > 0;i--)
2781                     buffer[nbchars++] = *cur++;
2782                 buffer[nbchars++] = ';';
2783             }
2784         } else if (c == '%' && (what & XML_SUBSTITUTE_PEREF)) {
2785             if (xmlParserDebugEntities)
2786                 xmlGenericError(xmlGenericErrorContext,
2787                         "String decoding PE Reference: %.30s\n", str);
2788             ent = xmlParseStringPEReference(ctxt, &str);
2789             if (ctxt->lastError.code == XML_ERR_ENTITY_LOOP)
2790                 goto int_error;
2791             if (ent != NULL)
2792                 ctxt->nbentities += ent->checked / 2;
2793             if (ent != NULL) {
2794                 if (ent->content == NULL) {
2795                     xmlLoadEntityContent(ctxt, ent);
2796                 }
2797                 ctxt->depth++;
2798                 rep = xmlStringDecodeEntities(ctxt, ent->content, what,
2799                                               0, 0, 0);
2800                 ctxt->depth--;
2801                 if (rep != NULL) {
2802                     current = rep;
2803                     while (*current != 0) { /* non input consuming loop */
2804                         buffer[nbchars++] = *current++;
2805                         if (nbchars + XML_PARSER_BUFFER_SIZE > buffer_size) {
2806                             if (xmlParserEntityCheck(ctxt, nbchars, ent, 0))
2807                                 goto int_error;
2808                             growBuffer(buffer, XML_PARSER_BUFFER_SIZE);
2809                         }
2810                     }
2811                     xmlFree(rep);
2812                     rep = NULL;
2813                 }
2814             }
2815         } else {
2816             COPY_BUF(l,buffer,nbchars,c);
2817             str += l;
2818             if (nbchars + XML_PARSER_BUFFER_SIZE > buffer_size) {
2819                 growBuffer(buffer, XML_PARSER_BUFFER_SIZE);
2820             }
2821         }
2822         if (str < last)
2823             c = CUR_SCHAR(str, l);
2824         else
2825             c = 0;
2826     }
2827     buffer[nbchars] = 0;
2828     return(buffer);
2829
2830 mem_error:
2831     xmlErrMemory(ctxt, NULL);
2832 int_error:
2833     if (rep != NULL)
2834         xmlFree(rep);
2835     if (buffer != NULL)
2836         xmlFree(buffer);
2837     return(NULL);
2838 }
2839
2840 /**
2841  * xmlStringDecodeEntities:
2842  * @ctxt:  the parser context
2843  * @str:  the input string
2844  * @what:  combination of XML_SUBSTITUTE_REF and XML_SUBSTITUTE_PEREF
2845  * @end:  an end marker xmlChar, 0 if none
2846  * @end2:  an end marker xmlChar, 0 if none
2847  * @end3:  an end marker xmlChar, 0 if none
2848  *
2849  * Takes a entity string content and process to do the adequate substitutions.
2850  *
2851  * [67] Reference ::= EntityRef | CharRef
2852  *
2853  * [69] PEReference ::= '%' Name ';'
2854  *
2855  * Returns A newly allocated string with the substitution done. The caller
2856  *      must deallocate it !
2857  */
2858 xmlChar *
2859 xmlStringDecodeEntities(xmlParserCtxtPtr ctxt, const xmlChar *str, int what,
2860                         xmlChar end, xmlChar  end2, xmlChar end3) {
2861     if ((ctxt == NULL) || (str == NULL)) return(NULL);
2862     return(xmlStringLenDecodeEntities(ctxt, str, xmlStrlen(str), what,
2863            end, end2, end3));
2864 }
2865
2866 /************************************************************************
2867  *                                                                      *
2868  *              Commodity functions, cleanup needed ?                   *
2869  *                                                                      *
2870  ************************************************************************/
2871
2872 /**
2873  * areBlanks:
2874  * @ctxt:  an XML parser context
2875  * @str:  a xmlChar *
2876  * @len:  the size of @str
2877  * @blank_chars: we know the chars are blanks
2878  *
2879  * Is this a sequence of blank chars that one can ignore ?
2880  *
2881  * Returns 1 if ignorable 0 otherwise.
2882  */
2883
2884 static int areBlanks(xmlParserCtxtPtr ctxt, const xmlChar *str, int len,
2885                      int blank_chars) {
2886     int i, ret;
2887     xmlNodePtr lastChild;
2888
2889     /*
2890      * Don't spend time trying to differentiate them, the same callback is
2891      * used !
2892      */
2893     if (ctxt->sax->ignorableWhitespace == ctxt->sax->characters)
2894         return(0);
2895
2896     /*
2897      * Check for xml:space value.
2898      */
2899     if ((ctxt->space == NULL) || (*(ctxt->space) == 1) ||
2900         (*(ctxt->space) == -2))
2901         return(0);
2902
2903     /*
2904      * Check that the string is made of blanks
2905      */
2906     if (blank_chars == 0) {
2907         for (i = 0;i < len;i++)
2908             if (!(IS_BLANK_CH(str[i]))) return(0);
2909     }
2910
2911     /*
2912      * Look if the element is mixed content in the DTD if available
2913      */
2914     if (ctxt->node == NULL) return(0);
2915     if (ctxt->myDoc != NULL) {
2916         ret = xmlIsMixedElement(ctxt->myDoc, ctxt->node->name);
2917         if (ret == 0) return(1);
2918         if (ret == 1) return(0);
2919     }
2920
2921     /*
2922      * Otherwise, heuristic :-\
2923      */
2924     if ((RAW != '<') && (RAW != 0xD)) return(0);
2925     if ((ctxt->node->children == NULL) &&
2926         (RAW == '<') && (NXT(1) == '/')) return(0);
2927
2928     lastChild = xmlGetLastChild(ctxt->node);
2929     if (lastChild == NULL) {
2930         if ((ctxt->node->type != XML_ELEMENT_NODE) &&
2931             (ctxt->node->content != NULL)) return(0);
2932     } else if (xmlNodeIsText(lastChild))
2933         return(0);
2934     else if ((ctxt->node->children != NULL) &&
2935              (xmlNodeIsText(ctxt->node->children)))
2936         return(0);
2937     return(1);
2938 }
2939
2940 /************************************************************************
2941  *                                                                      *
2942  *              Extra stuff for namespace support                       *
2943  *      Relates to http://www.w3.org/TR/WD-xml-names                    *
2944  *                                                                      *
2945  ************************************************************************/
2946
2947 /**
2948  * xmlSplitQName:
2949  * @ctxt:  an XML parser context
2950  * @name:  an XML parser context
2951  * @prefix:  a xmlChar **
2952  *
2953  * parse an UTF8 encoded XML qualified name string
2954  *
2955  * [NS 5] QName ::= (Prefix ':')? LocalPart
2956  *
2957  * [NS 6] Prefix ::= NCName
2958  *
2959  * [NS 7] LocalPart ::= NCName
2960  *
2961  * Returns the local part, and prefix is updated
2962  *   to get the Prefix if any.
2963  */
2964
2965 xmlChar *
2966 xmlSplitQName(xmlParserCtxtPtr ctxt, const xmlChar *name, xmlChar **prefix) {
2967     xmlChar buf[XML_MAX_NAMELEN + 5];
2968     xmlChar *buffer = NULL;
2969     int len = 0;
2970     int max = XML_MAX_NAMELEN;
2971     xmlChar *ret = NULL;
2972     const xmlChar *cur = name;
2973     int c;
2974
2975     if (prefix == NULL) return(NULL);
2976     *prefix = NULL;
2977
2978     if (cur == NULL) return(NULL);
2979
2980 #ifndef XML_XML_NAMESPACE
2981     /* xml: prefix is not really a namespace */
2982     if ((cur[0] == 'x') && (cur[1] == 'm') &&
2983         (cur[2] == 'l') && (cur[3] == ':'))
2984         return(xmlStrdup(name));
2985 #endif
2986
2987     /* nasty but well=formed */
2988     if (cur[0] == ':')
2989         return(xmlStrdup(name));
2990
2991     c = *cur++;
2992     while ((c != 0) && (c != ':') && (len < max)) { /* tested bigname.xml */
2993         buf[len++] = c;
2994         c = *cur++;
2995     }
2996     if (len >= max) {
2997         /*
2998          * Okay someone managed to make a huge name, so he's ready to pay
2999          * for the processing speed.
3000          */
3001         max = len * 2;
3002
3003         buffer = (xmlChar *) xmlMallocAtomic(max * sizeof(xmlChar));
3004         if (buffer == NULL) {
3005             xmlErrMemory(ctxt, NULL);
3006             return(NULL);
3007         }
3008         memcpy(buffer, buf, len);
3009         while ((c != 0) && (c != ':')) { /* tested bigname.xml */
3010             if (len + 10 > max) {
3011                 xmlChar *tmp;
3012
3013                 max *= 2;
3014                 tmp = (xmlChar *) xmlRealloc(buffer,
3015                                                 max * sizeof(xmlChar));
3016                 if (tmp == NULL) {
3017                     xmlFree(buffer);
3018                     xmlErrMemory(ctxt, NULL);
3019                     return(NULL);
3020                 }
3021                 buffer = tmp;
3022             }
3023             buffer[len++] = c;
3024             c = *cur++;
3025         }
3026         buffer[len] = 0;
3027     }
3028
3029     if ((c == ':') && (*cur == 0)) {
3030         if (buffer != NULL)
3031             xmlFree(buffer);
3032         *prefix = NULL;
3033         return(xmlStrdup(name));
3034     }
3035
3036     if (buffer == NULL)
3037         ret = xmlStrndup(buf, len);
3038     else {
3039         ret = buffer;
3040         buffer = NULL;
3041         max = XML_MAX_NAMELEN;
3042     }
3043
3044
3045     if (c == ':') {
3046         c = *cur;
3047         *prefix = ret;
3048         if (c == 0) {
3049             return(xmlStrndup(BAD_CAST "", 0));
3050         }
3051         len = 0;
3052
3053         /*
3054          * Check that the first character is proper to start
3055          * a new name
3056          */
3057         if (!(((c >= 0x61) && (c <= 0x7A)) ||
3058               ((c >= 0x41) && (c <= 0x5A)) ||
3059               (c == '_') || (c == ':'))) {
3060             int l;
3061             int first = CUR_SCHAR(cur, l);
3062
3063             if (!IS_LETTER(first) && (first != '_')) {
3064                 xmlFatalErrMsgStr(ctxt, XML_NS_ERR_QNAME,
3065                             "Name %s is not XML Namespace compliant\n",
3066                                   name);
3067             }
3068         }
3069         cur++;
3070
3071         while ((c != 0) && (len < max)) { /* tested bigname2.xml */
3072             buf[len++] = c;
3073             c = *cur++;
3074         }
3075         if (len >= max) {
3076             /*
3077              * Okay someone managed to make a huge name, so he's ready to pay
3078              * for the processing speed.
3079              */
3080             max = len * 2;
3081
3082             buffer = (xmlChar *) xmlMallocAtomic(max * sizeof(xmlChar));
3083             if (buffer == NULL) {
3084                 xmlErrMemory(ctxt, NULL);
3085                 return(NULL);
3086             }
3087             memcpy(buffer, buf, len);
3088             while (c != 0) { /* tested bigname2.xml */
3089                 if (len + 10 > max) {
3090                     xmlChar *tmp;
3091
3092                     max *= 2;
3093                     tmp = (xmlChar *) xmlRealloc(buffer,
3094                                                     max * sizeof(xmlChar));
3095                     if (tmp == NULL) {
3096                         xmlErrMemory(ctxt, NULL);
3097                         xmlFree(buffer);
3098                         return(NULL);
3099                     }
3100                     buffer = tmp;
3101                 }
3102                 buffer[len++] = c;
3103                 c = *cur++;
3104             }
3105             buffer[len] = 0;
3106         }
3107
3108         if (buffer == NULL)
3109             ret = xmlStrndup(buf, len);
3110         else {
3111             ret = buffer;
3112         }
3113     }
3114
3115     return(ret);
3116 }
3117
3118 /************************************************************************
3119  *                                                                      *
3120  *                      The parser itself                               *
3121  *      Relates to http://www.w3.org/TR/REC-xml                         *
3122  *                                                                      *
3123  ************************************************************************/
3124
3125 /************************************************************************
3126  *                                                                      *
3127  *      Routines to parse Name, NCName and NmToken                      *
3128  *                                                                      *
3129  ************************************************************************/
3130 #ifdef DEBUG
3131 static unsigned long nbParseName = 0;
3132 static unsigned long nbParseNmToken = 0;
3133 static unsigned long nbParseNCName = 0;
3134 static unsigned long nbParseNCNameComplex = 0;
3135 static unsigned long nbParseNameComplex = 0;
3136 static unsigned long nbParseStringName = 0;
3137 #endif
3138
3139 /*
3140  * The two following functions are related to the change of accepted
3141  * characters for Name and NmToken in the Revision 5 of XML-1.0
3142  * They correspond to the modified production [4] and the new production [4a]
3143  * changes in that revision. Also note that the macros used for the
3144  * productions Letter, Digit, CombiningChar and Extender are not needed
3145  * anymore.
3146  * We still keep compatibility to pre-revision5 parsing semantic if the
3147  * new XML_PARSE_OLD10 option is given to the parser.
3148  */
3149 static int
3150 xmlIsNameStartChar(xmlParserCtxtPtr ctxt, int c) {
3151     if ((ctxt->options & XML_PARSE_OLD10) == 0) {
3152         /*
3153          * Use the new checks of production [4] [4a] amd [5] of the
3154          * Update 5 of XML-1.0
3155          */
3156         if ((c != ' ') && (c != '>') && (c != '/') && /* accelerators */
3157             (((c >= 'a') && (c <= 'z')) ||
3158              ((c >= 'A') && (c <= 'Z')) ||
3159              (c == '_') || (c == ':') ||
3160              ((c >= 0xC0) && (c <= 0xD6)) ||
3161              ((c >= 0xD8) && (c <= 0xF6)) ||
3162              ((c >= 0xF8) && (c <= 0x2FF)) ||
3163              ((c >= 0x370) && (c <= 0x37D)) ||
3164              ((c >= 0x37F) && (c <= 0x1FFF)) ||
3165              ((c >= 0x200C) && (c <= 0x200D)) ||
3166              ((c >= 0x2070) && (c <= 0x218F)) ||
3167              ((c >= 0x2C00) && (c <= 0x2FEF)) ||
3168              ((c >= 0x3001) && (c <= 0xD7FF)) ||
3169              ((c >= 0xF900) && (c <= 0xFDCF)) ||
3170              ((c >= 0xFDF0) && (c <= 0xFFFD)) ||
3171              ((c >= 0x10000) && (c <= 0xEFFFF))))
3172             return(1);
3173     } else {
3174         if (IS_LETTER(c) || (c == '_') || (c == ':'))
3175             return(1);
3176     }
3177     return(0);
3178 }
3179
3180 static int
3181 xmlIsNameChar(xmlParserCtxtPtr ctxt, int c) {
3182     if ((ctxt->options & XML_PARSE_OLD10) == 0) {
3183         /*
3184          * Use the new checks of production [4] [4a] amd [5] of the
3185          * Update 5 of XML-1.0
3186          */
3187         if ((c != ' ') && (c != '>') && (c != '/') && /* accelerators */
3188             (((c >= 'a') && (c <= 'z')) ||
3189              ((c >= 'A') && (c <= 'Z')) ||
3190              ((c >= '0') && (c <= '9')) || /* !start */
3191              (c == '_') || (c == ':') ||
3192              (c == '-') || (c == '.') || (c == 0xB7) || /* !start */
3193              ((c >= 0xC0) && (c <= 0xD6)) ||
3194              ((c >= 0xD8) && (c <= 0xF6)) ||
3195              ((c >= 0xF8) && (c <= 0x2FF)) ||
3196              ((c >= 0x300) && (c <= 0x36F)) || /* !start */
3197              ((c >= 0x370) && (c <= 0x37D)) ||
3198              ((c >= 0x37F) && (c <= 0x1FFF)) ||
3199              ((c >= 0x200C) && (c <= 0x200D)) ||
3200              ((c >= 0x203F) && (c <= 0x2040)) || /* !start */
3201              ((c >= 0x2070) && (c <= 0x218F)) ||
3202              ((c >= 0x2C00) && (c <= 0x2FEF)) ||
3203              ((c >= 0x3001) && (c <= 0xD7FF)) ||
3204              ((c >= 0xF900) && (c <= 0xFDCF)) ||
3205              ((c >= 0xFDF0) && (c <= 0xFFFD)) ||
3206              ((c >= 0x10000) && (c <= 0xEFFFF))))
3207              return(1);
3208     } else {
3209         if ((IS_LETTER(c)) || (IS_DIGIT(c)) ||
3210             (c == '.') || (c == '-') ||
3211             (c == '_') || (c == ':') ||
3212             (IS_COMBINING(c)) ||
3213             (IS_EXTENDER(c)))
3214             return(1);
3215     }
3216     return(0);
3217 }
3218
3219 static xmlChar * xmlParseAttValueInternal(xmlParserCtxtPtr ctxt,
3220                                           int *len, int *alloc, int normalize);
3221
3222 static const xmlChar *
3223 xmlParseNameComplex(xmlParserCtxtPtr ctxt) {
3224     int len = 0, l;
3225     int c;
3226     int count = 0;
3227
3228 #ifdef DEBUG
3229     nbParseNameComplex++;
3230 #endif
3231
3232     /*
3233      * Handler for more complex cases
3234      */
3235     GROW;
3236     if (ctxt->instate == XML_PARSER_EOF)
3237         return(NULL);
3238     c = CUR_CHAR(l);
3239     if ((ctxt->options & XML_PARSE_OLD10) == 0) {
3240         /*
3241          * Use the new checks of production [4] [4a] amd [5] of the
3242          * Update 5 of XML-1.0
3243          */
3244         if ((c == ' ') || (c == '>') || (c == '/') || /* accelerators */
3245             (!(((c >= 'a') && (c <= 'z')) ||
3246                ((c >= 'A') && (c <= 'Z')) ||
3247                (c == '_') || (c == ':') ||
3248                ((c >= 0xC0) && (c <= 0xD6)) ||
3249                ((c >= 0xD8) && (c <= 0xF6)) ||
3250                ((c >= 0xF8) && (c <= 0x2FF)) ||
3251                ((c >= 0x370) && (c <= 0x37D)) ||
3252                ((c >= 0x37F) && (c <= 0x1FFF)) ||
3253                ((c >= 0x200C) && (c <= 0x200D)) ||
3254                ((c >= 0x2070) && (c <= 0x218F)) ||
3255                ((c >= 0x2C00) && (c <= 0x2FEF)) ||
3256                ((c >= 0x3001) && (c <= 0xD7FF)) ||
3257                ((c >= 0xF900) && (c <= 0xFDCF)) ||
3258                ((c >= 0xFDF0) && (c <= 0xFFFD)) ||
3259                ((c >= 0x10000) && (c <= 0xEFFFF))))) {
3260             return(NULL);
3261         }
3262         len += l;
3263         NEXTL(l);
3264         c = CUR_CHAR(l);
3265         while ((c != ' ') && (c != '>') && (c != '/') && /* accelerators */
3266                (((c >= 'a') && (c <= 'z')) ||
3267                 ((c >= 'A') && (c <= 'Z')) ||
3268                 ((c >= '0') && (c <= '9')) || /* !start */
3269                 (c == '_') || (c == ':') ||
3270                 (c == '-') || (c == '.') || (c == 0xB7) || /* !start */
3271                 ((c >= 0xC0) && (c <= 0xD6)) ||
3272                 ((c >= 0xD8) && (c <= 0xF6)) ||
3273                 ((c >= 0xF8) && (c <= 0x2FF)) ||
3274                 ((c >= 0x300) && (c <= 0x36F)) || /* !start */
3275                 ((c >= 0x370) && (c <= 0x37D)) ||
3276                 ((c >= 0x37F) && (c <= 0x1FFF)) ||
3277                 ((c >= 0x200C) && (c <= 0x200D)) ||
3278                 ((c >= 0x203F) && (c <= 0x2040)) || /* !start */
3279                 ((c >= 0x2070) && (c <= 0x218F)) ||
3280                 ((c >= 0x2C00) && (c <= 0x2FEF)) ||
3281                 ((c >= 0x3001) && (c <= 0xD7FF)) ||
3282                 ((c >= 0xF900) && (c <= 0xFDCF)) ||
3283                 ((c >= 0xFDF0) && (c <= 0xFFFD)) ||
3284                 ((c >= 0x10000) && (c <= 0xEFFFF))
3285                 )) {
3286             if (count++ > XML_PARSER_CHUNK_SIZE) {
3287                 count = 0;
3288                 GROW;
3289                 if (ctxt->instate == XML_PARSER_EOF)
3290                     return(NULL);
3291             }
3292             len += l;
3293             NEXTL(l);
3294             c = CUR_CHAR(l);
3295         }
3296     } else {
3297         if ((c == ' ') || (c == '>') || (c == '/') || /* accelerators */
3298             (!IS_LETTER(c) && (c != '_') &&
3299              (c != ':'))) {
3300             return(NULL);
3301         }
3302         len += l;
3303         NEXTL(l);
3304         c = CUR_CHAR(l);
3305
3306         while ((c != ' ') && (c != '>') && (c != '/') && /* test bigname.xml */
3307                ((IS_LETTER(c)) || (IS_DIGIT(c)) ||
3308                 (c == '.') || (c == '-') ||
3309                 (c == '_') || (c == ':') ||
3310                 (IS_COMBINING(c)) ||
3311                 (IS_EXTENDER(c)))) {
3312             if (count++ > XML_PARSER_CHUNK_SIZE) {
3313                 count = 0;
3314                 GROW;
3315                 if (ctxt->instate == XML_PARSER_EOF)
3316                     return(NULL);
3317             }
3318             len += l;
3319             NEXTL(l);
3320             c = CUR_CHAR(l);
3321             if (c == 0) {
3322                 count = 0;
3323                 GROW;
3324                 if (ctxt->instate == XML_PARSER_EOF)
3325                     return(NULL);
3326                 c = CUR_CHAR(l);
3327             }
3328         }
3329     }
3330     if ((len > XML_MAX_NAME_LENGTH) &&
3331         ((ctxt->options & XML_PARSE_HUGE) == 0)) {
3332         xmlFatalErr(ctxt, XML_ERR_NAME_TOO_LONG, "Name");
3333         return(NULL);
3334     }
3335     if ((*ctxt->input->cur == '\n') && (ctxt->input->cur[-1] == '\r'))
3336         return(xmlDictLookup(ctxt->dict, ctxt->input->cur - (len + 1), len));
3337     return(xmlDictLookup(ctxt->dict, ctxt->input->cur - len, len));
3338 }
3339
3340 /**
3341  * xmlParseName:
3342  * @ctxt:  an XML parser context
3343  *
3344  * parse an XML name.
3345  *
3346  * [4] NameChar ::= Letter | Digit | '.' | '-' | '_' | ':' |
3347  *                  CombiningChar | Extender
3348  *
3349  * [5] Name ::= (Letter | '_' | ':') (NameChar)*
3350  *
3351  * [6] Names ::= Name (#x20 Name)*
3352  *
3353  * Returns the Name parsed or NULL
3354  */
3355
3356 const xmlChar *
3357 xmlParseName(xmlParserCtxtPtr ctxt) {
3358     const xmlChar *in;
3359     const xmlChar *ret;
3360     int count = 0;
3361
3362     GROW;
3363
3364 #ifdef DEBUG
3365     nbParseName++;
3366 #endif
3367
3368     /*
3369      * Accelerator for simple ASCII names
3370      */
3371     in = ctxt->input->cur;
3372     if (((*in >= 0x61) && (*in <= 0x7A)) ||
3373         ((*in >= 0x41) && (*in <= 0x5A)) ||
3374         (*in == '_') || (*in == ':')) {
3375         in++;
3376         while (((*in >= 0x61) && (*in <= 0x7A)) ||
3377                ((*in >= 0x41) && (*in <= 0x5A)) ||
3378                ((*in >= 0x30) && (*in <= 0x39)) ||
3379                (*in == '_') || (*in == '-') ||
3380                (*in == ':') || (*in == '.'))
3381             in++;
3382         if ((*in > 0) && (*in < 0x80)) {
3383             count = in - ctxt->input->cur;
3384             if ((count > XML_MAX_NAME_LENGTH) &&
3385                 ((ctxt->options & XML_PARSE_HUGE) == 0)) {
3386                 xmlFatalErr(ctxt, XML_ERR_NAME_TOO_LONG, "Name");
3387                 return(NULL);
3388             }
3389             ret = xmlDictLookup(ctxt->dict, ctxt->input->cur, count);
3390             ctxt->input->cur = in;
3391             ctxt->nbChars += count;
3392             ctxt->input->col += count;
3393             if (ret == NULL)
3394                 xmlErrMemory(ctxt, NULL);
3395             return(ret);
3396         }
3397     }
3398     /* accelerator for special cases */
3399     return(xmlParseNameComplex(ctxt));
3400 }
3401
3402 static const xmlChar *
3403 xmlParseNCNameComplex(xmlParserCtxtPtr ctxt) {
3404     int len = 0, l;
3405     int c;
3406     int count = 0;
3407
3408 #ifdef DEBUG
3409     nbParseNCNameComplex++;
3410 #endif
3411
3412     /*
3413      * Handler for more complex cases
3414      */
3415     GROW;
3416     c = CUR_CHAR(l);
3417     if ((c == ' ') || (c == '>') || (c == '/') || /* accelerators */
3418         (!xmlIsNameStartChar(ctxt, c) || (c == ':'))) {
3419         return(NULL);
3420     }
3421
3422     while ((c != ' ') && (c != '>') && (c != '/') && /* test bigname.xml */
3423            (xmlIsNameChar(ctxt, c) && (c != ':'))) {
3424         if (count++ > XML_PARSER_CHUNK_SIZE) {
3425             if ((len > XML_MAX_NAME_LENGTH) &&
3426                 ((ctxt->options & XML_PARSE_HUGE) == 0)) {
3427                 xmlFatalErr(ctxt, XML_ERR_NAME_TOO_LONG, "NCName");
3428                 return(NULL);
3429             }
3430             count = 0;
3431             GROW;
3432             if (ctxt->instate == XML_PARSER_EOF)
3433                 return(NULL);
3434         }
3435         len += l;
3436         NEXTL(l);
3437         c = CUR_CHAR(l);
3438         if (c == 0) {
3439             count = 0;
3440             GROW;
3441             if (ctxt->instate == XML_PARSER_EOF)
3442                 return(NULL);
3443             c = CUR_CHAR(l);
3444         }
3445     }
3446     if ((len > XML_MAX_NAME_LENGTH) &&
3447         ((ctxt->options & XML_PARSE_HUGE) == 0)) {
3448         xmlFatalErr(ctxt, XML_ERR_NAME_TOO_LONG, "NCName");
3449         return(NULL);
3450     }
3451     return(xmlDictLookup(ctxt->dict, ctxt->input->cur - len, len));
3452 }
3453
3454 /**
3455  * xmlParseNCName:
3456  * @ctxt:  an XML parser context
3457  * @len:  length of the string parsed
3458  *
3459  * parse an XML name.
3460  *
3461  * [4NS] NCNameChar ::= Letter | Digit | '.' | '-' | '_' |
3462  *                      CombiningChar | Extender
3463  *
3464  * [5NS] NCName ::= (Letter | '_') (NCNameChar)*
3465  *
3466  * Returns the Name parsed or NULL
3467  */
3468
3469 static const xmlChar *
3470 xmlParseNCName(xmlParserCtxtPtr ctxt) {
3471     const xmlChar *in;
3472     const xmlChar *ret;
3473     int count = 0;
3474
3475 #ifdef DEBUG
3476     nbParseNCName++;
3477 #endif
3478
3479     /*
3480      * Accelerator for simple ASCII names
3481      */
3482     in = ctxt->input->cur;
3483     if (((*in >= 0x61) && (*in <= 0x7A)) ||
3484         ((*in >= 0x41) && (*in <= 0x5A)) ||
3485         (*in == '_')) {
3486         in++;
3487         while (((*in >= 0x61) && (*in <= 0x7A)) ||
3488                ((*in >= 0x41) && (*in <= 0x5A)) ||
3489                ((*in >= 0x30) && (*in <= 0x39)) ||
3490                (*in == '_') || (*in == '-') ||
3491                (*in == '.'))
3492             in++;
3493         if ((*in > 0) && (*in < 0x80)) {
3494             count = in - ctxt->input->cur;
3495             if ((count > XML_MAX_NAME_LENGTH) &&
3496                 ((ctxt->options & XML_PARSE_HUGE) == 0)) {
3497                 xmlFatalErr(ctxt, XML_ERR_NAME_TOO_LONG, "NCName");
3498                 return(NULL);
3499             }
3500             ret = xmlDictLookup(ctxt->dict, ctxt->input->cur, count);
3501             ctxt->input->cur = in;
3502             ctxt->nbChars += count;
3503             ctxt->input->col += count;
3504             if (ret == NULL) {
3505                 xmlErrMemory(ctxt, NULL);
3506             }
3507             return(ret);
3508         }
3509     }
3510     return(xmlParseNCNameComplex(ctxt));
3511 }
3512
3513 /**
3514  * xmlParseNameAndCompare:
3515  * @ctxt:  an XML parser context
3516  *
3517  * parse an XML name and compares for match
3518  * (specialized for endtag parsing)
3519  *
3520  * Returns NULL for an illegal name, (xmlChar*) 1 for success
3521  * and the name for mismatch
3522  */
3523
3524 static const xmlChar *
3525 xmlParseNameAndCompare(xmlParserCtxtPtr ctxt, xmlChar const *other) {
3526     register const xmlChar *cmp = other;
3527     register const xmlChar *in;
3528     const xmlChar *ret;
3529
3530     GROW;
3531     if (ctxt->instate == XML_PARSER_EOF)
3532         return(NULL);
3533
3534     in = ctxt->input->cur;
3535     while (*in != 0 && *in == *cmp) {
3536         ++in;
3537         ++cmp;
3538         ctxt->input->col++;
3539     }
3540     if (*cmp == 0 && (*in == '>' || IS_BLANK_CH (*in))) {
3541         /* success */
3542         ctxt->input->cur = in;
3543         return (const xmlChar*) 1;
3544     }
3545     /* failure (or end of input buffer), check with full function */
3546     ret = xmlParseName (ctxt);
3547     /* strings coming from the dictionnary direct compare possible */
3548     if (ret == other) {
3549         return (const xmlChar*) 1;
3550     }
3551     return ret;
3552 }
3553
3554 /**
3555  * xmlParseStringName:
3556  * @ctxt:  an XML parser context
3557  * @str:  a pointer to the string pointer (IN/OUT)
3558  *
3559  * parse an XML name.
3560  *
3561  * [4] NameChar ::= Letter | Digit | '.' | '-' | '_' | ':' |
3562  *                  CombiningChar | Extender
3563  *
3564  * [5] Name ::= (Letter | '_' | ':') (NameChar)*
3565  *
3566  * [6] Names ::= Name (#x20 Name)*
3567  *
3568  * Returns the Name parsed or NULL. The @str pointer
3569  * is updated to the current location in the string.
3570  */
3571
3572 static xmlChar *
3573 xmlParseStringName(xmlParserCtxtPtr ctxt, const xmlChar** str) {
3574     xmlChar buf[XML_MAX_NAMELEN + 5];
3575     const xmlChar *cur = *str;
3576     int len = 0, l;
3577     int c;
3578
3579 #ifdef DEBUG
3580     nbParseStringName++;
3581 #endif
3582
3583     c = CUR_SCHAR(cur, l);
3584     if (!xmlIsNameStartChar(ctxt, c)) {
3585         return(NULL);
3586     }
3587
3588     COPY_BUF(l,buf,len,c);
3589     cur += l;
3590     c = CUR_SCHAR(cur, l);
3591     while (xmlIsNameChar(ctxt, c)) {
3592         COPY_BUF(l,buf,len,c);
3593         cur += l;
3594         c = CUR_SCHAR(cur, l);
3595         if (len >= XML_MAX_NAMELEN) { /* test bigentname.xml */
3596             /*
3597              * Okay someone managed to make a huge name, so he's ready to pay
3598              * for the processing speed.
3599              */
3600             xmlChar *buffer;
3601             int max = len * 2;
3602
3603             buffer = (xmlChar *) xmlMallocAtomic(max * sizeof(xmlChar));
3604             if (buffer == NULL) {
3605                 xmlErrMemory(ctxt, NULL);
3606                 return(NULL);
3607             }
3608             memcpy(buffer, buf, len);
3609             while (xmlIsNameChar(ctxt, c)) {
3610                 if (len + 10 > max) {
3611                     xmlChar *tmp;
3612
3613                     if ((len > XML_MAX_NAME_LENGTH) &&
3614                         ((ctxt->options & XML_PARSE_HUGE) == 0)) {
3615                         xmlFatalErr(ctxt, XML_ERR_NAME_TOO_LONG, "NCName");
3616                         xmlFree(buffer);
3617                         return(NULL);
3618                     }
3619                     max *= 2;
3620                     tmp = (xmlChar *) xmlRealloc(buffer,
3621                                                     max * sizeof(xmlChar));
3622                     if (tmp == NULL) {
3623                         xmlErrMemory(ctxt, NULL);
3624                         xmlFree(buffer);
3625                         return(NULL);
3626                     }
3627                     buffer = tmp;
3628                 }
3629                 COPY_BUF(l,buffer,len,c);
3630                 cur += l;
3631                 c = CUR_SCHAR(cur, l);
3632             }
3633             buffer[len] = 0;
3634             *str = cur;
3635             return(buffer);
3636         }
3637     }
3638     if ((len > XML_MAX_NAME_LENGTH) &&
3639         ((ctxt->options & XML_PARSE_HUGE) == 0)) {
3640         xmlFatalErr(ctxt, XML_ERR_NAME_TOO_LONG, "NCName");
3641         return(NULL);
3642     }
3643     *str = cur;
3644     return(xmlStrndup(buf, len));
3645 }
3646
3647 /**
3648  * xmlParseNmtoken:
3649  * @ctxt:  an XML parser context
3650  *
3651  * parse an XML Nmtoken.
3652  *
3653  * [7] Nmtoken ::= (NameChar)+
3654  *
3655  * [8] Nmtokens ::= Nmtoken (#x20 Nmtoken)*
3656  *
3657  * Returns the Nmtoken parsed or NULL
3658  */
3659
3660 xmlChar *
3661 xmlParseNmtoken(xmlParserCtxtPtr ctxt) {
3662     xmlChar buf[XML_MAX_NAMELEN + 5];
3663     int len = 0, l;
3664     int c;
3665     int count = 0;
3666
3667 #ifdef DEBUG
3668     nbParseNmToken++;
3669 #endif
3670
3671     GROW;
3672     if (ctxt->instate == XML_PARSER_EOF)
3673         return(NULL);
3674     c = CUR_CHAR(l);
3675
3676     while (xmlIsNameChar(ctxt, c)) {
3677         if (count++ > XML_PARSER_CHUNK_SIZE) {
3678             count = 0;
3679             GROW;
3680         }
3681         COPY_BUF(l,buf,len,c);
3682         NEXTL(l);
3683         c = CUR_CHAR(l);
3684         if (c == 0) {
3685             count = 0;
3686             GROW;
3687             if (ctxt->instate == XML_PARSER_EOF)
3688                 return(NULL);
3689             c = CUR_CHAR(l);
3690         }
3691         if (len >= XML_MAX_NAMELEN) {
3692             /*
3693              * Okay someone managed to make a huge token, so he's ready to pay
3694              * for the processing speed.
3695              */
3696             xmlChar *buffer;
3697             int max = len * 2;
3698
3699             buffer = (xmlChar *) xmlMallocAtomic(max * sizeof(xmlChar));
3700             if (buffer == NULL) {
3701                 xmlErrMemory(ctxt, NULL);
3702                 return(NULL);
3703             }
3704             memcpy(buffer, buf, len);
3705             while (xmlIsNameChar(ctxt, c)) {
3706                 if (count++ > XML_PARSER_CHUNK_SIZE) {
3707                     count = 0;
3708                     GROW;
3709                     if (ctxt->instate == XML_PARSER_EOF) {
3710                         xmlFree(buffer);
3711                         return(NULL);
3712                     }
3713                 }
3714                 if (len + 10 > max) {
3715                     xmlChar *tmp;
3716
3717                     if ((max > XML_MAX_NAME_LENGTH) &&
3718                         ((ctxt->options & XML_PARSE_HUGE) == 0)) {
3719                         xmlFatalErr(ctxt, XML_ERR_NAME_TOO_LONG, "NmToken");
3720                         xmlFree(buffer);
3721                         return(NULL);
3722                     }
3723                     max *= 2;
3724                     tmp = (xmlChar *) xmlRealloc(buffer,
3725                                                     max * sizeof(xmlChar));
3726                     if (tmp == NULL) {
3727                         xmlErrMemory(ctxt, NULL);
3728                         xmlFree(buffer);
3729                         return(NULL);
3730                     }
3731                     buffer = tmp;
3732                 }
3733                 COPY_BUF(l,buffer,len,c);
3734                 NEXTL(l);
3735                 c = CUR_CHAR(l);
3736             }
3737             buffer[len] = 0;
3738             return(buffer);
3739         }
3740     }
3741     if (len == 0)
3742         return(NULL);
3743     if ((len > XML_MAX_NAME_LENGTH) &&
3744         ((ctxt->options & XML_PARSE_HUGE) == 0)) {
3745         xmlFatalErr(ctxt, XML_ERR_NAME_TOO_LONG, "NmToken");
3746         return(NULL);
3747     }
3748     return(xmlStrndup(buf, len));
3749 }
3750
3751 /**
3752  * xmlParseEntityValue:
3753  * @ctxt:  an XML parser context
3754  * @orig:  if non-NULL store a copy of the original entity value
3755  *
3756  * parse a value for ENTITY declarations
3757  *
3758  * [9] EntityValue ::= '"' ([^%&"] | PEReference | Reference)* '"' |
3759  *                     "'" ([^%&'] | PEReference | Reference)* "'"
3760  *
3761  * Returns the EntityValue parsed with reference substituted or NULL
3762  */
3763
3764 xmlChar *
3765 xmlParseEntityValue(xmlParserCtxtPtr ctxt, xmlChar **orig) {
3766     xmlChar *buf = NULL;
3767     int len = 0;
3768     int size = XML_PARSER_BUFFER_SIZE;
3769     int c, l;
3770     xmlChar stop;
3771     xmlChar *ret = NULL;
3772     const xmlChar *cur = NULL;
3773     xmlParserInputPtr input;
3774
3775     if (RAW == '"') stop = '"';
3776     else if (RAW == '\'') stop = '\'';
3777     else {
3778         xmlFatalErr(ctxt, XML_ERR_ENTITY_NOT_STARTED, NULL);
3779         return(NULL);
3780     }
3781     buf = (xmlChar *) xmlMallocAtomic(size * sizeof(xmlChar));
3782     if (buf == NULL) {
3783         xmlErrMemory(ctxt, NULL);
3784         return(NULL);
3785     }
3786
3787     /*
3788      * The content of the entity definition is copied in a buffer.
3789      */
3790
3791     ctxt->instate = XML_PARSER_ENTITY_VALUE;
3792     input = ctxt->input;
3793     GROW;
3794     if (ctxt->instate == XML_PARSER_EOF) {
3795         xmlFree(buf);
3796         return(NULL);
3797     }
3798     NEXT;
3799     c = CUR_CHAR(l);
3800     /*
3801      * NOTE: 4.4.5 Included in Literal
3802      * When a parameter entity reference appears in a literal entity
3803      * value, ... a single or double quote character in the replacement
3804      * text is always treated as a normal data character and will not
3805      * terminate the literal.
3806      * In practice it means we stop the loop only when back at parsing
3807      * the initial entity and the quote is found
3808      */
3809     while (((IS_CHAR(c)) && ((c != stop) || /* checked */
3810             (ctxt->input != input))) && (ctxt->instate != XML_PARSER_EOF)) {
3811         if (len + 5 >= size) {
3812             xmlChar *tmp;
3813
3814             size *= 2;
3815             tmp = (xmlChar *) xmlRealloc(buf, size * sizeof(xmlChar));
3816             if (tmp == NULL) {
3817                 xmlErrMemory(ctxt, NULL);
3818                 xmlFree(buf);
3819                 return(NULL);
3820             }
3821             buf = tmp;
3822         }
3823         COPY_BUF(l,buf,len,c);
3824         NEXTL(l);
3825         /*
3826          * Pop-up of finished entities.
3827          */
3828         while ((RAW == 0) && (ctxt->inputNr > 1)) /* non input consuming */
3829             xmlPopInput(ctxt);
3830
3831         GROW;
3832         c = CUR_CHAR(l);
3833         if (c == 0) {
3834             GROW;
3835             c = CUR_CHAR(l);
3836         }
3837     }
3838     buf[len] = 0;
3839     if (ctxt->instate == XML_PARSER_EOF) {
3840         xmlFree(buf);
3841         return(NULL);
3842     }
3843
3844     /*
3845      * Raise problem w.r.t. '&' and '%' being used in non-entities
3846      * reference constructs. Note Charref will be handled in
3847      * xmlStringDecodeEntities()
3848      */
3849     cur = buf;
3850     while (*cur != 0) { /* non input consuming */
3851         if ((*cur == '%') || ((*cur == '&') && (cur[1] != '#'))) {
3852             xmlChar *name;
3853             xmlChar tmp = *cur;
3854
3855             cur++;
3856             name = xmlParseStringName(ctxt, &cur);
3857             if ((name == NULL) || (*cur != ';')) {
3858                 xmlFatalErrMsgInt(ctxt, XML_ERR_ENTITY_CHAR_ERROR,
3859             "EntityValue: '%c' forbidden except for entities references\n",
3860                                   tmp);
3861             }
3862             if ((tmp == '%') && (ctxt->inSubset == 1) &&
3863                 (ctxt->inputNr == 1)) {
3864                 xmlFatalErr(ctxt, XML_ERR_ENTITY_PE_INTERNAL, NULL);
3865             }
3866             if (name != NULL)
3867                 xmlFree(name);
3868             if (*cur == 0)
3869                 break;
3870         }
3871         cur++;
3872     }
3873
3874     /*
3875      * Then PEReference entities are substituted.
3876      */
3877     if (c != stop) {
3878         xmlFatalErr(ctxt, XML_ERR_ENTITY_NOT_FINISHED, NULL);
3879         xmlFree(buf);
3880     } else {
3881         NEXT;
3882         /*
3883          * NOTE: 4.4.7 Bypassed
3884          * When a general entity reference appears in the EntityValue in
3885          * an entity declaration, it is bypassed and left as is.
3886          * so XML_SUBSTITUTE_REF is not set here.
3887          */
3888         ret = xmlStringDecodeEntities(ctxt, buf, XML_SUBSTITUTE_PEREF,
3889                                       0, 0, 0);
3890         if (orig != NULL)
3891             *orig = buf;
3892         else
3893             xmlFree(buf);
3894     }
3895
3896     return(ret);
3897 }
3898
3899 /**
3900  * xmlParseAttValueComplex:
3901  * @ctxt:  an XML parser context
3902  * @len:   the resulting attribute len
3903  * @normalize:  wether to apply the inner normalization
3904  *
3905  * parse a value for an attribute, this is the fallback function
3906  * of xmlParseAttValue() when the attribute parsing requires handling
3907  * of non-ASCII characters, or normalization compaction.
3908  *
3909  * Returns the AttValue parsed or NULL. The value has to be freed by the caller.
3910  */
3911 static xmlChar *
3912 xmlParseAttValueComplex(xmlParserCtxtPtr ctxt, int *attlen, int normalize) {
3913     xmlChar limit = 0;
3914     xmlChar *buf = NULL;
3915     xmlChar *rep = NULL;
3916     size_t len = 0;
3917     size_t buf_size = 0;
3918     int c, l, in_space = 0;
3919     xmlChar *current = NULL;
3920     xmlEntityPtr ent;
3921
3922     if (NXT(0) == '"') {
3923         ctxt->instate = XML_PARSER_ATTRIBUTE_VALUE;
3924         limit = '"';
3925         NEXT;
3926     } else if (NXT(0) == '\'') {
3927         limit = '\'';
3928         ctxt->instate = XML_PARSER_ATTRIBUTE_VALUE;
3929         NEXT;
3930     } else {
3931         xmlFatalErr(ctxt, XML_ERR_ATTRIBUTE_NOT_STARTED, NULL);
3932         return(NULL);
3933     }
3934
3935     /*
3936      * allocate a translation buffer.
3937      */
3938     buf_size = XML_PARSER_BUFFER_SIZE;
3939     buf = (xmlChar *) xmlMallocAtomic(buf_size);
3940     if (buf == NULL) goto mem_error;
3941
3942     /*
3943      * OK loop until we reach one of the ending char or a size limit.
3944      */
3945     c = CUR_CHAR(l);
3946     while (((NXT(0) != limit) && /* checked */
3947             (IS_CHAR(c)) && (c != '<')) &&
3948             (ctxt->instate != XML_PARSER_EOF)) {
3949         /*
3950          * Impose a reasonable limit on attribute size, unless XML_PARSE_HUGE
3951          * special option is given
3952          */
3953         if ((len > XML_MAX_TEXT_LENGTH) &&
3954             ((ctxt->options & XML_PARSE_HUGE) == 0)) {
3955             xmlFatalErrMsg(ctxt, XML_ERR_ATTRIBUTE_NOT_FINISHED,
3956                            "AttValue length too long\n");
3957             goto mem_error;
3958         }
3959         if (c == 0) break;
3960         if (c == '&') {
3961             in_space = 0;
3962             if (NXT(1) == '#') {
3963                 int val = xmlParseCharRef(ctxt);
3964
3965                 if (val == '&') {
3966                     if (ctxt->replaceEntities) {
3967                         if (len + 10 > buf_size) {
3968                             growBuffer(buf, 10);
3969                         }
3970                         buf[len++] = '&';
3971                     } else {
3972                         /*
3973                          * The reparsing will be done in xmlStringGetNodeList()
3974                          * called by the attribute() function in SAX.c
3975                          */
3976                         if (len + 10 > buf_size) {
3977                             growBuffer(buf, 10);
3978                         }
3979                         buf[len++] = '&';
3980                         buf[len++] = '#';
3981                         buf[len++] = '3';
3982                         buf[len++] = '8';
3983                         buf[len++] = ';';
3984                     }
3985                 } else if (val != 0) {
3986                     if (len + 10 > buf_size) {
3987                         growBuffer(buf, 10);
3988                     }
3989                     len += xmlCopyChar(0, &buf[len], val);
3990                 }
3991             } else {
3992                 ent = xmlParseEntityRef(ctxt);
3993                 ctxt->nbentities++;
3994                 if (ent != NULL)
3995                     ctxt->nbentities += ent->owner;
3996                 if ((ent != NULL) &&
3997                     (ent->etype == XML_INTERNAL_PREDEFINED_ENTITY)) {
3998                     if (len + 10 > buf_size) {
3999                         growBuffer(buf, 10);
4000                     }
4001                     if ((ctxt->replaceEntities == 0) &&
4002                         (ent->content[0] == '&')) {
4003                         buf[len++] = '&';
4004                         buf[len++] = '#';
4005                         buf[len++] = '3';
4006                         buf[len++] = '8';
4007                         buf[len++] = ';';
4008                     } else {
4009                         buf[len++] = ent->content[0];
4010                     }
4011                 } else if ((ent != NULL) &&
4012                            (ctxt->replaceEntities != 0)) {
4013                     if (ent->etype != XML_INTERNAL_PREDEFINED_ENTITY) {
4014                         rep = xmlStringDecodeEntities(ctxt, ent->content,
4015                                                       XML_SUBSTITUTE_REF,
4016                                                       0, 0, 0);
4017                         if (rep != NULL) {
4018                             current = rep;
4019                             while (*current != 0) { /* non input consuming */
4020                                 if ((*current == 0xD) || (*current == 0xA) ||
4021                                     (*current == 0x9)) {
4022                                     buf[len++] = 0x20;
4023                                     current++;
4024                                 } else
4025                                     buf[len++] = *current++;
4026                                 if (len + 10 > buf_size) {
4027                                     growBuffer(buf, 10);
4028                                 }
4029                             }
4030                             xmlFree(rep);
4031                             rep = NULL;
4032                         }
4033                     } else {
4034                         if (len + 10 > buf_size) {
4035                             growBuffer(buf, 10);
4036                         }
4037                         if (ent->content != NULL)
4038                             buf[len++] = ent->content[0];
4039                     }
4040                 } else if (ent != NULL) {
4041                     int i = xmlStrlen(ent->name);
4042                     const xmlChar *cur = ent->name;
4043
4044                     /*
4045                      * This may look absurd but is needed to detect
4046                      * entities problems
4047                      */
4048                     if ((ent->etype != XML_INTERNAL_PREDEFINED_ENTITY) &&
4049                         (ent->content != NULL) && (ent->checked == 0)) {
4050                         unsigned long oldnbent = ctxt->nbentities;
4051
4052                         rep = xmlStringDecodeEntities(ctxt, ent->content,
4053                                                   XML_SUBSTITUTE_REF, 0, 0, 0);
4054
4055                         ent->checked = (ctxt->nbentities - oldnbent + 1) * 2;
4056                         if (rep != NULL) {
4057                             if (xmlStrchr(rep, '<'))
4058                                 ent->checked |= 1;
4059                             xmlFree(rep);
4060                             rep = NULL;
4061                         }
4062                     }
4063
4064                     /*
4065                      * Just output the reference
4066                      */
4067                     buf[len++] = '&';
4068                     while (len + i + 10 > buf_size) {
4069                         growBuffer(buf, i + 10);
4070                     }
4071                     for (;i > 0;i--)
4072                         buf[len++] = *cur++;
4073                     buf[len++] = ';';
4074                 }
4075             }
4076         } else {
4077             if ((c == 0x20) || (c == 0xD) || (c == 0xA) || (c == 0x9)) {
4078                 if ((len != 0) || (!normalize)) {
4079                     if ((!normalize) || (!in_space)) {
4080                         COPY_BUF(l,buf,len,0x20);
4081                         while (len + 10 > buf_size) {
4082                             growBuffer(buf, 10);
4083                         }
4084                     }
4085                     in_space = 1;
4086                 }
4087             } else {
4088                 in_space = 0;
4089                 COPY_BUF(l,buf,len,c);
4090                 if (len + 10 > buf_size) {
4091                     growBuffer(buf, 10);
4092                 }
4093             }
4094             NEXTL(l);
4095         }
4096         GROW;
4097         c = CUR_CHAR(l);
4098     }
4099     if (ctxt->instate == XML_PARSER_EOF)
4100         goto error;
4101
4102     if ((in_space) && (normalize)) {
4103         while ((len > 0) && (buf[len - 1] == 0x20)) len--;
4104     }
4105     buf[len] = 0;
4106     if (RAW == '<') {
4107         xmlFatalErr(ctxt, XML_ERR_LT_IN_ATTRIBUTE, NULL);
4108     } else if (RAW != limit) {
4109         if ((c != 0) && (!IS_CHAR(c))) {
4110             xmlFatalErrMsg(ctxt, XML_ERR_INVALID_CHAR,
4111                            "invalid character in attribute value\n");
4112         } else {
4113             xmlFatalErrMsg(ctxt, XML_ERR_ATTRIBUTE_NOT_FINISHED,
4114                            "AttValue: ' expected\n");
4115         }
4116     } else
4117         NEXT;
4118
4119     /*
4120      * There we potentially risk an overflow, don't allow attribute value of
4121      * length more than INT_MAX it is a very reasonnable assumption !
4122      */
4123     if (len >= INT_MAX) {
4124         xmlFatalErrMsg(ctxt, XML_ERR_ATTRIBUTE_NOT_FINISHED,
4125                        "AttValue length too long\n");
4126         goto mem_error;
4127     }
4128
4129     if (attlen != NULL) *attlen = (int) len;
4130     return(buf);
4131
4132 mem_error:
4133     xmlErrMemory(ctxt, NULL);
4134 error:
4135     if (buf != NULL)
4136         xmlFree(buf);
4137     if (rep != NULL)
4138         xmlFree(rep);
4139     return(NULL);
4140 }
4141
4142 /**
4143  * xmlParseAttValue:
4144  * @ctxt:  an XML parser context
4145  *
4146  * parse a value for an attribute
4147  * Note: the parser won't do substitution of entities here, this
4148  * will be handled later in xmlStringGetNodeList
4149  *
4150  * [10] AttValue ::= '"' ([^<&"] | Reference)* '"' |
4151  *                   "'" ([^<&'] | Reference)* "'"
4152  *
4153  * 3.3.3 Attribute-Value Normalization:
4154  * Before the value of an attribute is passed to the application or
4155  * checked for validity, the XML processor must normalize it as follows:
4156  * - a character reference is processed by appending the referenced
4157  *   character to the attribute value
4158  * - an entity reference is processed by recursively processing the
4159  *   replacement text of the entity
4160  * - a whitespace character (#x20, #xD, #xA, #x9) is processed by
4161  *   appending #x20 to the normalized value, except that only a single
4162  *   #x20 is appended for a "#xD#xA" sequence that is part of an external
4163  *   parsed entity or the literal entity value of an internal parsed entity
4164  * - other characters are processed by appending them to the normalized value
4165  * If the declared value is not CDATA, then the XML processor must further
4166  * process the normalized attribute value by discarding any leading and
4167  * trailing space (#x20) characters, and by replacing sequences of space
4168  * (#x20) characters by a single space (#x20) character.
4169  * All attributes for which no declaration has been read should be treated
4170  * by a non-validating parser as if declared CDATA.
4171  *
4172  * Returns the AttValue parsed or NULL. The value has to be freed by the caller.
4173  */
4174
4175
4176 xmlChar *
4177 xmlParseAttValue(xmlParserCtxtPtr ctxt) {
4178     if ((ctxt == NULL) || (ctxt->input == NULL)) return(NULL);
4179     return(xmlParseAttValueInternal(ctxt, NULL, NULL, 0));
4180 }
4181
4182 /**
4183  * xmlParseSystemLiteral:
4184  * @ctxt:  an XML parser context
4185  *
4186  * parse an XML Literal
4187  *
4188  * [11] SystemLiteral ::= ('"' [^"]* '"') | ("'" [^']* "'")
4189  *
4190  * Returns the SystemLiteral parsed or NULL
4191  */
4192
4193 xmlChar *
4194 xmlParseSystemLiteral(xmlParserCtxtPtr ctxt) {
4195     xmlChar *buf = NULL;
4196     int len = 0;
4197     int size = XML_PARSER_BUFFER_SIZE;
4198     int cur, l;
4199     xmlChar stop;
4200     int state = ctxt->instate;
4201     int count = 0;
4202
4203     SHRINK;
4204     if (RAW == '"') {
4205         NEXT;
4206         stop = '"';
4207     } else if (RAW == '\'') {
4208         NEXT;
4209         stop = '\'';
4210     } else {
4211         xmlFatalErr(ctxt, XML_ERR_LITERAL_NOT_STARTED, NULL);
4212         return(NULL);
4213     }
4214
4215     buf = (xmlChar *) xmlMallocAtomic(size * sizeof(xmlChar));
4216     if (buf == NULL) {
4217         xmlErrMemory(ctxt, NULL);
4218         return(NULL);
4219     }
4220     ctxt->instate = XML_PARSER_SYSTEM_LITERAL;
4221     cur = CUR_CHAR(l);
4222     while ((IS_CHAR(cur)) && (cur != stop)) { /* checked */
4223         if (len + 5 >= size) {
4224             xmlChar *tmp;
4225
4226             if ((size > XML_MAX_NAME_LENGTH) &&
4227                 ((ctxt->options & XML_PARSE_HUGE) == 0)) {
4228                 xmlFatalErr(ctxt, XML_ERR_NAME_TOO_LONG, "SystemLiteral");
4229                 xmlFree(buf);
4230                 ctxt->instate = (xmlParserInputState) state;
4231                 return(NULL);
4232             }
4233             size *= 2;
4234             tmp = (xmlChar *) xmlRealloc(buf, size * sizeof(xmlChar));
4235             if (tmp == NULL) {
4236                 xmlFree(buf);
4237                 xmlErrMemory(ctxt, NULL);
4238                 ctxt->instate = (xmlParserInputState) state;
4239                 return(NULL);
4240             }
4241             buf = tmp;
4242         }
4243         count++;
4244         if (count > 50) {
4245             GROW;
4246             count = 0;
4247             if (ctxt->instate == XML_PARSER_EOF) {
4248                 xmlFree(buf);
4249                 return(NULL);
4250             }
4251         }
4252         COPY_BUF(l,buf,len,cur);
4253         NEXTL(l);
4254         cur = CUR_CHAR(l);
4255         if (cur == 0) {
4256             GROW;
4257             SHRINK;
4258             cur = CUR_CHAR(l);
4259         }
4260     }
4261     buf[len] = 0;
4262     ctxt->instate = (xmlParserInputState) state;
4263     if (!IS_CHAR(cur)) {
4264         xmlFatalErr(ctxt, XML_ERR_LITERAL_NOT_FINISHED, NULL);
4265     } else {
4266         NEXT;
4267     }
4268     return(buf);
4269 }
4270
4271 /**
4272  * xmlParsePubidLiteral:
4273  * @ctxt:  an XML parser context
4274  *
4275  * parse an XML public literal
4276  *
4277  * [12] PubidLiteral ::= '"' PubidChar* '"' | "'" (PubidChar - "'")* "'"
4278  *
4279  * Returns the PubidLiteral parsed or NULL.
4280  */
4281
4282 xmlChar *
4283 xmlParsePubidLiteral(xmlParserCtxtPtr ctxt) {
4284     xmlChar *buf = NULL;
4285     int len = 0;
4286     int size = XML_PARSER_BUFFER_SIZE;
4287     xmlChar cur;
4288     xmlChar stop;
4289     int count = 0;
4290     xmlParserInputState oldstate = ctxt->instate;
4291
4292     SHRINK;
4293     if (RAW == '"') {
4294         NEXT;
4295         stop = '"';
4296     } else if (RAW == '\'') {
4297         NEXT;
4298         stop = '\'';
4299     } else {
4300         xmlFatalErr(ctxt, XML_ERR_LITERAL_NOT_STARTED, NULL);
4301         return(NULL);
4302     }
4303     buf = (xmlChar *) xmlMallocAtomic(size * sizeof(xmlChar));
4304     if (buf == NULL) {
4305         xmlErrMemory(ctxt, NULL);
4306         return(NULL);
4307     }
4308     ctxt->instate = XML_PARSER_PUBLIC_LITERAL;
4309     cur = CUR;
4310     while ((IS_PUBIDCHAR_CH(cur)) && (cur != stop)) { /* checked */
4311         if (len + 1 >= size) {
4312             xmlChar *tmp;
4313
4314             if ((size > XML_MAX_NAME_LENGTH) &&
4315                 ((ctxt->options & XML_PARSE_HUGE) == 0)) {
4316                 xmlFatalErr(ctxt, XML_ERR_NAME_TOO_LONG, "Public ID");
4317                 xmlFree(buf);
4318                 return(NULL);
4319             }
4320             size *= 2;
4321             tmp = (xmlChar *) xmlRealloc(buf, size * sizeof(xmlChar));
4322             if (tmp == NULL) {
4323                 xmlErrMemory(ctxt, NULL);
4324                 xmlFree(buf);
4325                 return(NULL);
4326             }
4327             buf = tmp;
4328         }
4329         buf[len++] = cur;
4330         count++;
4331         if (count > 50) {
4332             GROW;
4333             count = 0;
4334             if (ctxt->instate == XML_PARSER_EOF) {
4335                 xmlFree(buf);
4336                 return(NULL);
4337             }
4338         }
4339         NEXT;
4340         cur = CUR;
4341         if (cur == 0) {
4342             GROW;
4343             SHRINK;
4344             cur = CUR;
4345         }
4346     }
4347     buf[len] = 0;
4348     if (cur != stop) {
4349         xmlFatalErr(ctxt, XML_ERR_LITERAL_NOT_FINISHED, NULL);
4350     } else {
4351         NEXT;
4352     }
4353     ctxt->instate = oldstate;
4354     return(buf);
4355 }
4356
4357 static void xmlParseCharDataComplex(xmlParserCtxtPtr ctxt, int cdata);
4358
4359 /*
4360  * used for the test in the inner loop of the char data testing
4361  */
4362 static const unsigned char test_char_data[256] = {
4363     0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
4364     0x00, 0x09, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, /* 0x9, CR/LF separated */
4365     0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
4366     0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
4367     0x20, 0x21, 0x22, 0x23, 0x24, 0x25, 0x00, 0x27, /* & */
4368     0x28, 0x29, 0x2A, 0x2B, 0x2C, 0x2D, 0x2E, 0x2F,
4369     0x30, 0x31, 0x32, 0x33, 0x34, 0x35, 0x36, 0x37,
4370     0x38, 0x39, 0x3A, 0x3B, 0x00, 0x3D, 0x3E, 0x3F, /* < */
4371     0x40, 0x41, 0x42, 0x43, 0x44, 0x45, 0x46, 0x47,
4372     0x48, 0x49, 0x4A, 0x4B, 0x4C, 0x4D, 0x4E, 0x4F,
4373     0x50, 0x51, 0x52, 0x53, 0x54, 0x55, 0x56, 0x57,
4374     0x58, 0x59, 0x5A, 0x5B, 0x5C, 0x00, 0x5E, 0x5F, /* ] */
4375     0x60, 0x61, 0x62, 0x63, 0x64, 0x65, 0x66, 0x67,
4376     0x68, 0x69, 0x6A, 0x6B, 0x6C, 0x6D, 0x6E, 0x6F,
4377     0x70, 0x71, 0x72, 0x73, 0x74, 0x75, 0x76, 0x77,
4378     0x78, 0x79, 0x7A, 0x7B, 0x7C, 0x7D, 0x7E, 0x7F,
4379     0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, /* non-ascii */
4380     0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
4381     0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
4382     0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
4383     0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
4384     0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
4385     0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
4386     0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
4387     0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
4388     0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
4389     0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
4390     0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
4391     0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
4392     0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
4393     0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
4394     0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00
4395 };
4396
4397 /**
4398  * xmlParseCharData:
4399  * @ctxt:  an XML parser context
4400  * @cdata:  int indicating whether we are within a CDATA section
4401  *
4402  * parse a CharData section.
4403  * if we are within a CDATA section ']]>' marks an end of section.
4404  *
4405  * The right angle bracket (>) may be represented using the string "&gt;",
4406  * and must, for compatibility, be escaped using "&gt;" or a character
4407  * reference when it appears in the string "]]>" in content, when that
4408  * string is not marking the end of a CDATA section.
4409  *
4410  * [14] CharData ::= [^<&]* - ([^<&]* ']]>' [^<&]*)
4411  */
4412
4413 void
4414 xmlParseCharData(xmlParserCtxtPtr ctxt, int cdata) {
4415     const xmlChar *in;
4416     int nbchar = 0;
4417     int line = ctxt->input->line;
4418     int col = ctxt->input->col;
4419     int ccol;
4420
4421     SHRINK;
4422     GROW;
4423     /*
4424      * Accelerated common case where input don't need to be
4425      * modified before passing it to the handler.
4426      */
4427     if (!cdata) {
4428         in = ctxt->input->cur;
4429         do {
4430 get_more_space:
4431             while (*in == 0x20) { in++; ctxt->input->col++; }
4432             if (*in == 0xA) {
4433                 do {
4434                     ctxt->input->line++; ctxt->input->col = 1;
4435                     in++;
4436                 } while (*in == 0xA);
4437                 goto get_more_space;
4438             }
4439             if (*in == '<') {
4440                 nbchar = in - ctxt->input->cur;
4441                 if (nbchar > 0) {
4442                     const xmlChar *tmp = ctxt->input->cur;
4443                     ctxt->input->cur = in;
4444
4445                     if ((ctxt->sax != NULL) &&
4446                         (ctxt->sax->ignorableWhitespace !=
4447                          ctxt->sax->characters)) {
4448                         if (areBlanks(ctxt, tmp, nbchar, 1)) {
4449                             if (ctxt->sax->ignorableWhitespace != NULL)
4450                                 ctxt->sax->ignorableWhitespace(ctxt->userData,
4451                                                        tmp, nbchar);
4452                         } else {
4453                             if (ctxt->sax->characters != NULL)
4454                                 ctxt->sax->characters(ctxt->userData,
4455                                                       tmp, nbchar);
4456                             if (*ctxt->space == -1)
4457                                 *ctxt->space = -2;
4458                         }
4459                     } else if ((ctxt->sax != NULL) &&
4460                                (ctxt->sax->characters != NULL)) {
4461                         ctxt->sax->characters(ctxt->userData,
4462                                               tmp, nbchar);
4463                     }
4464                 }
4465                 return;
4466             }
4467
4468 get_more:
4469             ccol = ctxt->input->col;
4470             while (test_char_data[*in]) {
4471                 in++;
4472                 ccol++;
4473             }
4474             ctxt->input->col = ccol;
4475             if (*in == 0xA) {
4476                 do {
4477                     ctxt->input->line++; ctxt->input->col = 1;
4478                     in++;
4479                 } while (*in == 0xA);
4480                 goto get_more;
4481             }
4482             if (*in == ']') {
4483                 if ((in[1] == ']') && (in[2] == '>')) {
4484                     xmlFatalErr(ctxt, XML_ERR_MISPLACED_CDATA_END, NULL);
4485                     ctxt->input->cur = in;
4486                     return;
4487                 }
4488                 in++;
4489                 ctxt->input->col++;
4490                 goto get_more;
4491             }
4492             nbchar = in - ctxt->input->cur;
4493             if (nbchar > 0) {
4494                 if ((ctxt->sax != NULL) &&
4495                     (ctxt->sax->ignorableWhitespace !=
4496                      ctxt->sax->characters) &&
4497                     (IS_BLANK_CH(*ctxt->input->cur))) {
4498                     const xmlChar *tmp = ctxt->input->cur;
4499                     ctxt->input->cur = in;
4500
4501                     if (areBlanks(ctxt, tmp, nbchar, 0)) {
4502                         if (ctxt->sax->ignorableWhitespace != NULL)
4503                             ctxt->sax->ignorableWhitespace(ctxt->userData,
4504                                                            tmp, nbchar);
4505                     } else {
4506                         if (ctxt->sax->characters != NULL)
4507                             ctxt->sax->characters(ctxt->userData,
4508                                                   tmp, nbchar);
4509                         if (*ctxt->space == -1)
4510                             *ctxt->space = -2;
4511                     }
4512                     line = ctxt->input->line;
4513                     col = ctxt->input->col;
4514                 } else if (ctxt->sax != NULL) {
4515                     if (ctxt->sax->characters != NULL)
4516                         ctxt->sax->characters(ctxt->userData,
4517                                               ctxt->input->cur, nbchar);
4518                     line = ctxt->input->line;
4519                     col = ctxt->input->col;
4520                 }
4521                 /* something really bad happened in the SAX callback */
4522                 if (ctxt->instate != XML_PARSER_CONTENT)
4523                     return;
4524             }
4525             ctxt->input->cur = in;
4526             if (*in == 0xD) {
4527                 in++;
4528                 if (*in == 0xA) {
4529                     ctxt->input->cur = in;
4530                     in++;
4531                     ctxt->input->line++; ctxt->input->col = 1;
4532                     continue; /* while */
4533                 }
4534                 in--;
4535             }
4536             if (*in == '<') {
4537                 return;
4538             }
4539             if (*in == '&') {
4540                 return;
4541             }
4542             SHRINK;
4543             GROW;
4544             if (ctxt->instate == XML_PARSER_EOF)
4545                 return;
4546             in = ctxt->input->cur;
4547         } while (((*in >= 0x20) && (*in <= 0x7F)) || (*in == 0x09));
4548         nbchar = 0;
4549     }
4550     ctxt->input->line = line;
4551     ctxt->input->col = col;
4552     xmlParseCharDataComplex(ctxt, cdata);
4553 }
4554
4555 /**
4556  * xmlParseCharDataComplex:
4557  * @ctxt:  an XML parser context
4558  * @cdata:  int indicating whether we are within a CDATA section
4559  *
4560  * parse a CharData section.this is the fallback function
4561  * of xmlParseCharData() when the parsing requires handling
4562  * of non-ASCII characters.
4563  */
4564 static void
4565 xmlParseCharDataComplex(xmlParserCtxtPtr ctxt, int cdata) {
4566     xmlChar buf[XML_PARSER_BIG_BUFFER_SIZE + 5];
4567     int nbchar = 0;
4568     int cur, l;
4569     int count = 0;
4570
4571     SHRINK;
4572     GROW;
4573     cur = CUR_CHAR(l);
4574     while ((cur != '<') && /* checked */
4575            (cur != '&') &&
4576            (IS_CHAR(cur))) /* test also done in xmlCurrentChar() */ {
4577         if ((cur == ']') && (NXT(1) == ']') &&
4578             (NXT(2) == '>')) {
4579             if (cdata) break;
4580             else {
4581                 xmlFatalErr(ctxt, XML_ERR_MISPLACED_CDATA_END, NULL);
4582             }
4583         }
4584         COPY_BUF(l,buf,nbchar,cur);
4585         if (nbchar >= XML_PARSER_BIG_BUFFER_SIZE) {
4586             buf[nbchar] = 0;
4587
4588             /*
4589              * OK the segment is to be consumed as chars.
4590              */
4591             if ((ctxt->sax != NULL) && (!ctxt->disableSAX)) {
4592                 if (areBlanks(ctxt, buf, nbchar, 0)) {
4593                     if (ctxt->sax->ignorableWhitespace != NULL)
4594                         ctxt->sax->ignorableWhitespace(ctxt->userData,
4595                                                        buf, nbchar);
4596                 } else {
4597                     if (ctxt->sax->characters != NULL)
4598                         ctxt->sax->characters(ctxt->userData, buf, nbchar);
4599                     if ((ctxt->sax->characters !=
4600                          ctxt->sax->ignorableWhitespace) &&
4601                         (*ctxt->space == -1))
4602                         *ctxt->space = -2;
4603                 }
4604             }
4605             nbchar = 0;
4606             /* something really bad happened in the SAX callback */
4607             if (ctxt->instate != XML_PARSER_CONTENT)
4608                 return;
4609         }
4610         count++;
4611         if (count > 50) {
4612             GROW;
4613             count = 0;
4614             if (ctxt->instate == XML_PARSER_EOF)
4615                 return;
4616         }
4617         NEXTL(l);
4618         cur = CUR_CHAR(l);
4619     }
4620     if (nbchar != 0) {
4621         buf[nbchar] = 0;
4622         /*
4623          * OK the segment is to be consumed as chars.
4624          */
4625         if ((ctxt->sax != NULL) && (!ctxt->disableSAX)) {
4626             if (areBlanks(ctxt, buf, nbchar, 0)) {
4627                 if (ctxt->sax->ignorableWhitespace != NULL)
4628                     ctxt->sax->ignorableWhitespace(ctxt->userData, buf, nbchar);
4629             } else {
4630                 if (ctxt->sax->characters != NULL)
4631                     ctxt->sax->characters(ctxt->userData, buf, nbchar);
4632                 if ((ctxt->sax->characters != ctxt->sax->ignorableWhitespace) &&
4633                     (*ctxt->space == -1))
4634                     *ctxt->space = -2;
4635             }
4636         }
4637     }
4638     if ((cur != 0) && (!IS_CHAR(cur))) {
4639         /* Generate the error and skip the offending character */
4640         xmlFatalErrMsgInt(ctxt, XML_ERR_INVALID_CHAR,
4641                           "PCDATA invalid Char value %d\n",
4642                           cur);
4643         NEXTL(l);
4644     }
4645 }
4646
4647 /**
4648  * xmlParseExternalID:
4649  * @ctxt:  an XML parser context
4650  * @publicID:  a xmlChar** receiving PubidLiteral
4651  * @strict: indicate whether we should restrict parsing to only
4652  *          production [75], see NOTE below
4653  *
4654  * Parse an External ID or a Public ID
4655  *
4656  * NOTE: Productions [75] and [83] interact badly since [75] can generate
4657  *       'PUBLIC' S PubidLiteral S SystemLiteral
4658  *
4659  * [75] ExternalID ::= 'SYSTEM' S SystemLiteral
4660  *                   | 'PUBLIC' S PubidLiteral S SystemLiteral
4661  *
4662  * [83] PublicID ::= 'PUBLIC' S PubidLiteral
4663  *
4664  * Returns the function returns SystemLiteral and in the second
4665  *                case publicID receives PubidLiteral, is strict is off
4666  *                it is possible to return NULL and have publicID set.
4667  */
4668
4669 xmlChar *
4670 xmlParseExternalID(xmlParserCtxtPtr ctxt, xmlChar **publicID, int strict) {
4671     xmlChar *URI = NULL;
4672
4673     SHRINK;
4674
4675     *publicID = NULL;
4676     if (CMP6(CUR_PTR, 'S', 'Y', 'S', 'T', 'E', 'M')) {
4677         SKIP(6);
4678         if (!IS_BLANK_CH(CUR)) {
4679             xmlFatalErrMsg(ctxt, XML_ERR_SPACE_REQUIRED,
4680                            "Space required after 'SYSTEM'\n");
4681         }
4682         SKIP_BLANKS;
4683         URI = xmlParseSystemLiteral(ctxt);
4684         if (URI == NULL) {
4685             xmlFatalErr(ctxt, XML_ERR_URI_REQUIRED, NULL);
4686         }
4687     } else if (CMP6(CUR_PTR, 'P', 'U', 'B', 'L', 'I', 'C')) {
4688         SKIP(6);
4689         if (!IS_BLANK_CH(CUR)) {
4690             xmlFatalErrMsg(ctxt, XML_ERR_SPACE_REQUIRED,
4691                     "Space required after 'PUBLIC'\n");
4692         }
4693         SKIP_BLANKS;
4694         *publicID = xmlParsePubidLiteral(ctxt);
4695         if (*publicID == NULL) {
4696             xmlFatalErr(ctxt, XML_ERR_PUBID_REQUIRED, NULL);
4697         }
4698         if (strict) {
4699             /*
4700              * We don't handle [83] so "S SystemLiteral" is required.
4701              */
4702             if (!IS_BLANK_CH(CUR)) {
4703                 xmlFatalErrMsg(ctxt, XML_ERR_SPACE_REQUIRED,
4704                         "Space required after the Public Identifier\n");
4705             }
4706         } else {
4707             /*
4708              * We handle [83] so we return immediately, if
4709              * "S SystemLiteral" is not detected. From a purely parsing
4710              * point of view that's a nice mess.
4711              */
4712             const xmlChar *ptr;
4713             GROW;
4714
4715             ptr = CUR_PTR;
4716             if (!IS_BLANK_CH(*ptr)) return(NULL);
4717
4718             while (IS_BLANK_CH(*ptr)) ptr++; /* TODO: dangerous, fix ! */
4719             if ((*ptr != '\'') && (*ptr != '"')) return(NULL);
4720         }
4721         SKIP_BLANKS;
4722         URI = xmlParseSystemLiteral(ctxt);
4723         if (URI == NULL) {
4724             xmlFatalErr(ctxt, XML_ERR_URI_REQUIRED, NULL);
4725         }
4726     }
4727     return(URI);
4728 }
4729
4730 /**
4731  * xmlParseCommentComplex:
4732  * @ctxt:  an XML parser context
4733  * @buf:  the already parsed part of the buffer
4734  * @len:  number of bytes filles in the buffer
4735  * @size:  allocated size of the buffer
4736  *
4737  * Skip an XML (SGML) comment <!-- .... -->
4738  *  The spec says that "For compatibility, the string "--" (double-hyphen)
4739  *  must not occur within comments. "
4740  * This is the slow routine in case the accelerator for ascii didn't work
4741  *
4742  * [15] Comment ::= '<!--' ((Char - '-') | ('-' (Char - '-')))* '-->'
4743  */
4744 static void
4745 xmlParseCommentComplex(xmlParserCtxtPtr ctxt, xmlChar *buf,
4746                        size_t len, size_t size) {
4747     int q, ql;
4748     int r, rl;
4749     int cur, l;
4750     size_t count = 0;
4751     int inputid;
4752
4753     inputid = ctxt->input->id;
4754
4755     if (buf == NULL) {
4756         len = 0;
4757         size = XML_PARSER_BUFFER_SIZE;
4758         buf = (xmlChar *) xmlMallocAtomic(size * sizeof(xmlChar));
4759         if (buf == NULL) {
4760             xmlErrMemory(ctxt, NULL);
4761             return;
4762         }
4763     }
4764     GROW;       /* Assure there's enough input data */
4765     q = CUR_CHAR(ql);
4766     if (q == 0)
4767         goto not_terminated;
4768     if (!IS_CHAR(q)) {
4769         xmlFatalErrMsgInt(ctxt, XML_ERR_INVALID_CHAR,
4770                           "xmlParseComment: invalid xmlChar value %d\n",
4771                           q);
4772         xmlFree (buf);
4773         return;
4774     }
4775     NEXTL(ql);
4776     r = CUR_CHAR(rl);
4777     if (r == 0)
4778         goto not_terminated;
4779     if (!IS_CHAR(r)) {
4780         xmlFatalErrMsgInt(ctxt, XML_ERR_INVALID_CHAR,
4781                           "xmlParseComment: invalid xmlChar value %d\n",
4782                           q);
4783         xmlFree (buf);
4784         return;
4785     }
4786     NEXTL(rl);
4787     cur = CUR_CHAR(l);
4788     if (cur == 0)
4789         goto not_terminated;
4790     while (IS_CHAR(cur) && /* checked */
4791            ((cur != '>') ||
4792             (r != '-') || (q != '-'))) {
4793         if ((r == '-') && (q == '-')) {
4794             xmlFatalErr(ctxt, XML_ERR_HYPHEN_IN_COMMENT, NULL);
4795         }
4796         if ((len > XML_MAX_TEXT_LENGTH) &&
4797             ((ctxt->options & XML_PARSE_HUGE) == 0)) {
4798             xmlFatalErrMsgStr(ctxt, XML_ERR_COMMENT_NOT_FINISHED,
4799                          "Comment too big found", NULL);
4800             xmlFree (buf);
4801             return;
4802         }
4803         if (len + 5 >= size) {
4804             xmlChar *new_buf;
4805             size_t new_size;
4806
4807             new_size = size * 2;
4808             new_buf = (xmlChar *) xmlRealloc(buf, new_size);
4809             if (new_buf == NULL) {
4810                 xmlFree (buf);
4811                 xmlErrMemory(ctxt, NULL);
4812                 return;
4813             }
4814             buf = new_buf;
4815             size = new_size;
4816         }
4817         COPY_BUF(ql,buf,len,q);
4818         q = r;
4819         ql = rl;
4820         r = cur;
4821         rl = l;
4822
4823         count++;
4824         if (count > 50) {
4825             GROW;
4826             count = 0;
4827             if (ctxt->instate == XML_PARSER_EOF) {
4828                 xmlFree(buf);
4829                 return;
4830             }
4831         }
4832         NEXTL(l);
4833         cur = CUR_CHAR(l);
4834         if (cur == 0) {
4835             SHRINK;
4836             GROW;
4837             cur = CUR_CHAR(l);
4838         }
4839     }
4840     buf[len] = 0;
4841     if (cur == 0) {
4842         xmlFatalErrMsgStr(ctxt, XML_ERR_COMMENT_NOT_FINISHED,
4843                              "Comment not terminated \n<!--%.50s\n", buf);
4844     } else if (!IS_CHAR(cur)) {
4845         xmlFatalErrMsgInt(ctxt, XML_ERR_INVALID_CHAR,
4846                           "xmlParseComment: invalid xmlChar value %d\n",
4847                           cur);
4848     } else {
4849         if (inputid != ctxt->input->id) {
4850             xmlFatalErrMsg(ctxt, XML_ERR_ENTITY_BOUNDARY,
4851                 "Comment doesn't start and stop in the same entity\n");
4852         }
4853         NEXT;
4854         if ((ctxt->sax != NULL) && (ctxt->sax->comment != NULL) &&
4855             (!ctxt->disableSAX))
4856             ctxt->sax->comment(ctxt->userData, buf);
4857     }
4858     xmlFree(buf);
4859     return;
4860 not_terminated:
4861     xmlFatalErrMsgStr(ctxt, XML_ERR_COMMENT_NOT_FINISHED,
4862                          "Comment not terminated\n", NULL);
4863     xmlFree(buf);
4864     return;
4865 }
4866
4867 /**
4868  * xmlParseComment:
4869  * @ctxt:  an XML parser context
4870  *
4871  * Skip an XML (SGML) comment <!-- .... -->
4872  *  The spec says that "For compatibility, the string "--" (double-hyphen)
4873  *  must not occur within comments. "
4874  *
4875  * [15] Comment ::= '<!--' ((Char - '-') | ('-' (Char - '-')))* '-->'
4876  */
4877 void
4878 xmlParseComment(xmlParserCtxtPtr ctxt) {
4879     xmlChar *buf = NULL;
4880     size_t size = XML_PARSER_BUFFER_SIZE;
4881     size_t len = 0;
4882     xmlParserInputState state;
4883     const xmlChar *in;
4884     size_t nbchar = 0;
4885     int ccol;
4886     int inputid;
4887
4888     /*
4889      * Check that there is a comment right here.
4890      */
4891     if ((RAW != '<') || (NXT(1) != '!') ||
4892         (NXT(2) != '-') || (NXT(3) != '-')) return;
4893     state = ctxt->instate;
4894     ctxt->instate = XML_PARSER_COMMENT;
4895     inputid = ctxt->input->id;
4896     SKIP(4);
4897     SHRINK;
4898     GROW;
4899
4900     /*
4901      * Accelerated common case where input don't need to be
4902      * modified before passing it to the handler.
4903      */
4904     in = ctxt->input->cur;
4905     do {
4906         if (*in == 0xA) {
4907             do {
4908                 ctxt->input->line++; ctxt->input->col = 1;
4909                 in++;
4910             } while (*in == 0xA);
4911         }
4912 get_more:
4913         ccol = ctxt->input->col;
4914         while (((*in > '-') && (*in <= 0x7F)) ||
4915                ((*in >= 0x20) && (*in < '-')) ||
4916                (*in == 0x09)) {
4917                     in++;
4918                     ccol++;
4919         }
4920         ctxt->input->col = ccol;
4921         if (*in == 0xA) {
4922             do {
4923                 ctxt->input->line++; ctxt->input->col = 1;
4924                 in++;
4925             } while (*in == 0xA);
4926             goto get_more;
4927         }
4928         nbchar = in - ctxt->input->cur;
4929         /*
4930          * save current set of data
4931          */
4932         if (nbchar > 0) {
4933             if ((ctxt->sax != NULL) &&
4934                 (ctxt->sax->comment != NULL)) {
4935                 if (buf == NULL) {
4936                     if ((*in == '-') && (in[1] == '-'))
4937                         size = nbchar + 1;
4938                     else
4939                         size = XML_PARSER_BUFFER_SIZE + nbchar;
4940                     buf = (xmlChar *) xmlMallocAtomic(size * sizeof(xmlChar));
4941                     if (buf == NULL) {
4942                         xmlErrMemory(ctxt, NULL);
4943                         ctxt->instate = state;
4944                         return;
4945                     }
4946                     len = 0;
4947                 } else if (len + nbchar + 1 >= size) {
4948                     xmlChar *new_buf;
4949                     size  += len + nbchar + XML_PARSER_BUFFER_SIZE;
4950                     new_buf = (xmlChar *) xmlRealloc(buf,
4951                                                      size * sizeof(xmlChar));
4952                     if (new_buf == NULL) {
4953                         xmlFree (buf);
4954                         xmlErrMemory(ctxt, NULL);
4955                         ctxt->instate = state;
4956                         return;
4957                     }
4958                     buf = new_buf;
4959                 }
4960                 memcpy(&buf[len], ctxt->input->cur, nbchar);
4961                 len += nbchar;
4962                 buf[len] = 0;
4963             }
4964         }
4965         if ((len > XML_MAX_TEXT_LENGTH) &&
4966             ((ctxt->options & XML_PARSE_HUGE) == 0)) {
4967             xmlFatalErrMsgStr(ctxt, XML_ERR_COMMENT_NOT_FINISHED,
4968                          "Comment too big found", NULL);
4969             xmlFree (buf);
4970             return;
4971         }
4972         ctxt->input->cur = in;
4973         if (*in == 0xA) {
4974             in++;
4975             ctxt->input->line++; ctxt->input->col = 1;
4976         }
4977         if (*in == 0xD) {
4978             in++;
4979             if (*in == 0xA) {
4980                 ctxt->input->cur = in;
4981                 in++;
4982                 ctxt->input->line++; ctxt->input->col = 1;
4983                 continue; /* while */
4984             }
4985             in--;
4986         }
4987         SHRINK;
4988         GROW;
4989         if (ctxt->instate == XML_PARSER_EOF) {
4990             xmlFree(buf);
4991             return;
4992         }
4993         in = ctxt->input->cur;
4994         if (*in == '-') {
4995             if (in[1] == '-') {
4996                 if (in[2] == '>') {
4997                     if (ctxt->input->id != inputid) {
4998                         xmlFatalErrMsg(ctxt, XML_ERR_ENTITY_BOUNDARY,
4999                         "comment doesn't start and stop in the same entity\n");
5000                     }
5001                     SKIP(3);
5002                     if ((ctxt->sax != NULL) && (ctxt->sax->comment != NULL) &&
5003                         (!ctxt->disableSAX)) {
5004                         if (buf != NULL)
5005                             ctxt->sax->comment(ctxt->userData, buf);
5006                         else
5007                             ctxt->sax->comment(ctxt->userData, BAD_CAST "");
5008                     }
5009                     if (buf != NULL)
5010                         xmlFree(buf);
5011                     if (ctxt->instate != XML_PARSER_EOF)
5012                         ctxt->instate = state;
5013                     return;
5014                 }
5015                 if (buf != NULL) {
5016                     xmlFatalErrMsgStr(ctxt, XML_ERR_HYPHEN_IN_COMMENT,
5017                                       "Double hyphen within comment: "
5018                                       "<!--%.50s\n",
5019                                       buf);
5020                 } else
5021                     xmlFatalErrMsgStr(ctxt, XML_ERR_HYPHEN_IN_COMMENT,
5022                                       "Double hyphen within comment\n", NULL);
5023                 in++;
5024                 ctxt->input->col++;
5025             }
5026             in++;
5027             ctxt->input->col++;
5028             goto get_more;
5029         }
5030     } while (((*in >= 0x20) && (*in <= 0x7F)) || (*in == 0x09));
5031     xmlParseCommentComplex(ctxt, buf, len, size);
5032     ctxt->instate = state;
5033     return;
5034 }
5035
5036
5037 /**
5038  * xmlParsePITarget:
5039  * @ctxt:  an XML parser context
5040  *
5041  * parse the name of a PI
5042  *
5043  * [17] PITarget ::= Name - (('X' | 'x') ('M' | 'm') ('L' | 'l'))
5044  *
5045  * Returns the PITarget name or NULL
5046  */
5047
5048 const xmlChar *
5049 xmlParsePITarget(xmlParserCtxtPtr ctxt) {
5050     const xmlChar *name;
5051
5052     name = xmlParseName(ctxt);
5053     if ((name != NULL) &&
5054         ((name[0] == 'x') || (name[0] == 'X')) &&
5055         ((name[1] == 'm') || (name[1] == 'M')) &&
5056         ((name[2] == 'l') || (name[2] == 'L'))) {
5057         int i;
5058         if ((name[0] == 'x') && (name[1] == 'm') &&
5059             (name[2] == 'l') && (name[3] == 0)) {
5060             xmlFatalErrMsg(ctxt, XML_ERR_RESERVED_XML_NAME,
5061                  "XML declaration allowed only at the start of the document\n");
5062             return(name);
5063         } else if (name[3] == 0) {
5064             xmlFatalErr(ctxt, XML_ERR_RESERVED_XML_NAME, NULL);
5065             return(name);
5066         }
5067         for (i = 0;;i++) {
5068             if (xmlW3CPIs[i] == NULL) break;
5069             if (xmlStrEqual(name, (const xmlChar *)xmlW3CPIs[i]))
5070                 return(name);
5071         }
5072         xmlWarningMsg(ctxt, XML_ERR_RESERVED_XML_NAME,
5073                       "xmlParsePITarget: invalid name prefix 'xml'\n",
5074                       NULL, NULL);
5075     }
5076     if ((name != NULL) && (xmlStrchr(name, ':') != NULL)) {
5077         xmlNsErr(ctxt, XML_NS_ERR_COLON,
5078                  "colon are forbidden from PI names '%s'\n", name, NULL, NULL);
5079     }
5080     return(name);
5081 }
5082
5083 #ifdef LIBXML_CATALOG_ENABLED
5084 /**
5085  * xmlParseCatalogPI:
5086  * @ctxt:  an XML parser context
5087  * @catalog:  the PI value string
5088  *
5089  * parse an XML Catalog Processing Instruction.
5090  *
5091  * <?oasis-xml-catalog catalog="http://example.com/catalog.xml"?>
5092  *
5093  * Occurs only if allowed by the user and if happening in the Misc
5094  * part of the document before any doctype informations
5095  * This will add the given catalog to the parsing context in order
5096  * to be used if there is a resolution need further down in the document
5097  */
5098
5099 static void
5100 xmlParseCatalogPI(xmlParserCtxtPtr ctxt, const xmlChar *catalog) {
5101     xmlChar *URL = NULL;
5102     const xmlChar *tmp, *base;
5103     xmlChar marker;
5104
5105     tmp = catalog;
5106     while (IS_BLANK_CH(*tmp)) tmp++;
5107     if (xmlStrncmp(tmp, BAD_CAST"catalog", 7))
5108         goto error;
5109     tmp += 7;
5110     while (IS_BLANK_CH(*tmp)) tmp++;
5111     if (*tmp != '=') {
5112         return;
5113     }
5114     tmp++;
5115     while (IS_BLANK_CH(*tmp)) tmp++;
5116     marker = *tmp;
5117     if ((marker != '\'') && (marker != '"'))
5118         goto error;
5119     tmp++;
5120     base = tmp;
5121     while ((*tmp != 0) && (*tmp != marker)) tmp++;
5122     if (*tmp == 0)
5123         goto error;
5124     URL = xmlStrndup(base, tmp - base);
5125     tmp++;
5126     while (IS_BLANK_CH(*tmp)) tmp++;
5127     if (*tmp != 0)
5128         goto error;
5129
5130     if (URL != NULL) {
5131         ctxt->catalogs = xmlCatalogAddLocal(ctxt->catalogs, URL);
5132         xmlFree(URL);
5133     }
5134     return;
5135
5136 error:
5137     xmlWarningMsg(ctxt, XML_WAR_CATALOG_PI,
5138                   "Catalog PI syntax error: %s\n",
5139                   catalog, NULL);
5140     if (URL != NULL)
5141         xmlFree(URL);
5142 }
5143 #endif
5144
5145 /**
5146  * xmlParsePI:
5147  * @ctxt:  an XML parser context
5148  *
5149  * parse an XML Processing Instruction.
5150  *
5151  * [16] PI ::= '<?' PITarget (S (Char* - (Char* '?>' Char*)))? '?>'
5152  *
5153  * The processing is transfered to SAX once parsed.
5154  */
5155
5156 void
5157 xmlParsePI(xmlParserCtxtPtr ctxt) {
5158     xmlChar *buf = NULL;
5159     size_t len = 0;
5160     size_t size = XML_PARSER_BUFFER_SIZE;
5161     int cur, l;
5162     const xmlChar *target;
5163     xmlParserInputState state;
5164     int count = 0;
5165
5166     if ((RAW == '<') && (NXT(1) == '?')) {
5167         xmlParserInputPtr input = ctxt->input;
5168         state = ctxt->instate;
5169         ctxt->instate = XML_PARSER_PI;
5170         /*
5171          * this is a Processing Instruction.
5172          */
5173         SKIP(2);
5174         SHRINK;
5175
5176         /*
5177          * Parse the target name and check for special support like
5178          * namespace.
5179          */
5180         target = xmlParsePITarget(ctxt);
5181         if (target != NULL) {
5182             if ((RAW == '?') && (NXT(1) == '>')) {
5183                 if (input != ctxt->input) {
5184                     xmlFatalErrMsg(ctxt, XML_ERR_ENTITY_BOUNDARY,
5185             "PI declaration doesn't start and stop in the same entity\n");
5186                 }
5187                 SKIP(2);
5188
5189                 /*
5190                  * SAX: PI detected.
5191                  */
5192                 if ((ctxt->sax) && (!ctxt->disableSAX) &&
5193                     (ctxt->sax->processingInstruction != NULL))
5194                     ctxt->sax->processingInstruction(ctxt->userData,
5195                                                      target, NULL);
5196                 if (ctxt->instate != XML_PARSER_EOF)
5197                     ctxt->instate = state;
5198                 return;
5199             }
5200             buf = (xmlChar *) xmlMallocAtomic(size * sizeof(xmlChar));
5201             if (buf == NULL) {
5202                 xmlErrMemory(ctxt, NULL);
5203                 ctxt->instate = state;
5204                 return;
5205             }
5206             cur = CUR;
5207             if (!IS_BLANK(cur)) {
5208                 xmlFatalErrMsgStr(ctxt, XML_ERR_SPACE_REQUIRED,
5209                           "ParsePI: PI %s space expected\n", target);
5210             }
5211             SKIP_BLANKS;
5212             cur = CUR_CHAR(l);
5213             while (IS_CHAR(cur) && /* checked */
5214                    ((cur != '?') || (NXT(1) != '>'))) {
5215                 if (len + 5 >= size) {
5216                     xmlChar *tmp;
5217                     size_t new_size = size * 2;
5218                     tmp = (xmlChar *) xmlRealloc(buf, new_size);
5219                     if (tmp == NULL) {
5220                         xmlErrMemory(ctxt, NULL);
5221                         xmlFree(buf);
5222                         ctxt->instate = state;
5223                         return;
5224                     }
5225                     buf = tmp;
5226                     size = new_size;
5227                 }
5228                 count++;
5229                 if (count > 50) {
5230                     GROW;
5231                     if (ctxt->instate == XML_PARSER_EOF) {
5232                         xmlFree(buf);
5233                         return;
5234                     }
5235                     count = 0;
5236                     if ((len > XML_MAX_TEXT_LENGTH) &&
5237                         ((ctxt->options & XML_PARSE_HUGE) == 0)) {
5238                         xmlFatalErrMsgStr(ctxt, XML_ERR_PI_NOT_FINISHED,
5239                                           "PI %s too big found", target);
5240                         xmlFree(buf);
5241                         ctxt->instate = state;
5242                         return;
5243                     }
5244                 }
5245                 COPY_BUF(l,buf,len,cur);
5246                 NEXTL(l);
5247                 cur = CUR_CHAR(l);
5248                 if (cur == 0) {
5249                     SHRINK;
5250                     GROW;
5251                     cur = CUR_CHAR(l);
5252                 }
5253             }
5254             if ((len > XML_MAX_TEXT_LENGTH) &&
5255                 ((ctxt->options & XML_PARSE_HUGE) == 0)) {
5256                 xmlFatalErrMsgStr(ctxt, XML_ERR_PI_NOT_FINISHED,
5257                                   "PI %s too big found", target);
5258                 xmlFree(buf);
5259                 ctxt->instate = state;
5260                 return;
5261             }
5262             buf[len] = 0;
5263             if (cur != '?') {
5264                 xmlFatalErrMsgStr(ctxt, XML_ERR_PI_NOT_FINISHED,
5265                       "ParsePI: PI %s never end ...\n", target);
5266             } else {
5267                 if (input != ctxt->input) {
5268                     xmlFatalErrMsg(ctxt, XML_ERR_SPACE_REQUIRED,
5269             "PI declaration doesn't start and stop in the same entity\n");
5270                 }
5271                 SKIP(2);
5272
5273 #ifdef LIBXML_CATALOG_ENABLED
5274                 if (((state == XML_PARSER_MISC) ||
5275                      (state == XML_PARSER_START)) &&
5276                     (xmlStrEqual(target, XML_CATALOG_PI))) {
5277                     xmlCatalogAllow allow = xmlCatalogGetDefaults();
5278                     if ((allow == XML_CATA_ALLOW_DOCUMENT) ||
5279                         (allow == XML_CATA_ALLOW_ALL))
5280                         xmlParseCatalogPI(ctxt, buf);
5281                 }
5282 #endif
5283
5284
5285                 /*
5286                  * SAX: PI detected.
5287                  */
5288                 if ((ctxt->sax) && (!ctxt->disableSAX) &&
5289                     (ctxt->sax->processingInstruction != NULL))
5290                     ctxt->sax->processingInstruction(ctxt->userData,
5291                                                      target, buf);
5292             }
5293             xmlFree(buf);
5294         } else {
5295             xmlFatalErr(ctxt, XML_ERR_PI_NOT_STARTED, NULL);
5296         }
5297         if (ctxt->instate != XML_PARSER_EOF)
5298             ctxt->instate = state;
5299     }
5300 }
5301
5302 /**
5303  * xmlParseNotationDecl:
5304  * @ctxt:  an XML parser context
5305  *
5306  * parse a notation declaration
5307  *
5308  * [82] NotationDecl ::= '<!NOTATION' S Name S (ExternalID |  PublicID) S? '>'
5309  *
5310  * Hence there is actually 3 choices:
5311  *     'PUBLIC' S PubidLiteral
5312  *     'PUBLIC' S PubidLiteral S SystemLiteral
5313  * and 'SYSTEM' S SystemLiteral
5314  *
5315  * See the NOTE on xmlParseExternalID().
5316  */
5317
5318 void
5319 xmlParseNotationDecl(xmlParserCtxtPtr ctxt) {
5320     const xmlChar *name;
5321     xmlChar *Pubid;
5322     xmlChar *Systemid;
5323
5324     if (CMP10(CUR_PTR, '<', '!', 'N', 'O', 'T', 'A', 'T', 'I', 'O', 'N')) {
5325         xmlParserInputPtr input = ctxt->input;
5326         SHRINK;
5327         SKIP(10);
5328         if (!IS_BLANK_CH(CUR)) {
5329             xmlFatalErrMsg(ctxt, XML_ERR_SPACE_REQUIRED,
5330                            "Space required after '<!NOTATION'\n");
5331             return;
5332         }
5333         SKIP_BLANKS;
5334
5335         name = xmlParseName(ctxt);
5336         if (name == NULL) {
5337             xmlFatalErr(ctxt, XML_ERR_NOTATION_NOT_STARTED, NULL);
5338             return;
5339         }
5340         if (!IS_BLANK_CH(CUR)) {
5341             xmlFatalErrMsg(ctxt, XML_ERR_SPACE_REQUIRED,
5342                      "Space required after the NOTATION name'\n");
5343             return;
5344         }
5345         if (xmlStrchr(name, ':') != NULL) {
5346             xmlNsErr(ctxt, XML_NS_ERR_COLON,
5347                      "colon are forbidden from notation names '%s'\n",
5348                      name, NULL, NULL);
5349         }
5350         SKIP_BLANKS;
5351
5352         /*
5353          * Parse the IDs.
5354          */
5355         Systemid = xmlParseExternalID(ctxt, &Pubid, 0);
5356         SKIP_BLANKS;
5357
5358         if (RAW == '>') {
5359             if (input != ctxt->input) {
5360                 xmlFatalErrMsg(ctxt, XML_ERR_SPACE_REQUIRED,
5361         "Notation declaration doesn't start and stop in the same entity\n");
5362             }
5363             NEXT;
5364             if ((ctxt->sax != NULL) && (!ctxt->disableSAX) &&
5365                 (ctxt->sax->notationDecl != NULL))
5366                 ctxt->sax->notationDecl(ctxt->userData, name, Pubid, Systemid);
5367         } else {
5368             xmlFatalErr(ctxt, XML_ERR_NOTATION_NOT_FINISHED, NULL);
5369         }
5370         if (Systemid != NULL) xmlFree(Systemid);
5371         if (Pubid != NULL) xmlFree(Pubid);
5372     }
5373 }
5374
5375 /**
5376  * xmlParseEntityDecl:
5377  * @ctxt:  an XML parser context
5378  *
5379  * parse <!ENTITY declarations
5380  *
5381  * [70] EntityDecl ::= GEDecl | PEDecl
5382  *
5383  * [71] GEDecl ::= '<!ENTITY' S Name S EntityDef S? '>'
5384  *
5385  * [72] PEDecl ::= '<!ENTITY' S '%' S Name S PEDef S? '>'
5386  *
5387  * [73] EntityDef ::= EntityValue | (ExternalID NDataDecl?)
5388  *
5389  * [74] PEDef ::= EntityValue | ExternalID
5390  *
5391  * [76] NDataDecl ::= S 'NDATA' S Name
5392  *
5393  * [ VC: Notation Declared ]
5394  * The Name must match the declared name of a notation.
5395  */
5396
5397 void
5398 xmlParseEntityDecl(xmlParserCtxtPtr ctxt) {
5399     const xmlChar *name = NULL;
5400     xmlChar *value = NULL;
5401     xmlChar *URI = NULL, *literal = NULL;
5402     const xmlChar *ndata = NULL;
5403     int isParameter = 0;
5404     xmlChar *orig = NULL;
5405     int skipped;
5406
5407     /* GROW; done in the caller */
5408     if (CMP8(CUR_PTR, '<', '!', 'E', 'N', 'T', 'I', 'T', 'Y')) {
5409         xmlParserInputPtr input = ctxt->input;
5410         SHRINK;
5411         SKIP(8);
5412         skipped = SKIP_BLANKS;
5413         if (skipped == 0) {
5414             xmlFatalErrMsg(ctxt, XML_ERR_SPACE_REQUIRED,
5415                            "Space required after '<!ENTITY'\n");
5416         }
5417
5418         if (RAW == '%') {
5419             NEXT;
5420             skipped = SKIP_BLANKS;
5421             if (skipped == 0) {
5422                 xmlFatalErrMsg(ctxt, XML_ERR_SPACE_REQUIRED,
5423                                "Space required after '%'\n");
5424             }
5425             isParameter = 1;
5426         }
5427
5428         name = xmlParseName(ctxt);
5429         if (name == NULL) {
5430             xmlFatalErrMsg(ctxt, XML_ERR_NAME_REQUIRED,
5431                            "xmlParseEntityDecl: no name\n");
5432             return;
5433         }
5434         if (xmlStrchr(name, ':') != NULL) {
5435             xmlNsErr(ctxt, XML_NS_ERR_COLON,
5436                      "colon are forbidden from entities names '%s'\n",
5437                      name, NULL, NULL);
5438         }
5439         skipped = SKIP_BLANKS;
5440         if (skipped == 0) {
5441             xmlFatalErrMsg(ctxt, XML_ERR_SPACE_REQUIRED,
5442                            "Space required after the entity name\n");
5443         }
5444
5445         ctxt->instate = XML_PARSER_ENTITY_DECL;
5446         /*
5447          * handle the various case of definitions...
5448          */
5449         if (isParameter) {
5450             if ((RAW == '"') || (RAW == '\'')) {
5451                 value = xmlParseEntityValue(ctxt, &orig);
5452                 if (value) {
5453                     if ((ctxt->sax != NULL) &&
5454                         (!ctxt->disableSAX) && (ctxt->sax->entityDecl != NULL))
5455                         ctxt->sax->entityDecl(ctxt->userData, name,
5456                                     XML_INTERNAL_PARAMETER_ENTITY,
5457                                     NULL, NULL, value);
5458                 }
5459             } else {
5460                 URI = xmlParseExternalID(ctxt, &literal, 1);
5461                 if ((URI == NULL) && (literal == NULL)) {
5462                     xmlFatalErr(ctxt, XML_ERR_VALUE_REQUIRED, NULL);
5463                 }
5464                 if (URI) {
5465                     xmlURIPtr uri;
5466
5467                     uri = xmlParseURI((const char *) URI);
5468                     if (uri == NULL) {
5469                         xmlErrMsgStr(ctxt, XML_ERR_INVALID_URI,
5470                                      "Invalid URI: %s\n", URI);
5471                         /*
5472                          * This really ought to be a well formedness error
5473                          * but the XML Core WG decided otherwise c.f. issue
5474                          * E26 of the XML erratas.
5475                          */
5476                     } else {
5477                         if (uri->fragment != NULL) {
5478                             /*
5479                              * Okay this is foolish to block those but not
5480                              * invalid URIs.
5481                              */
5482                             xmlFatalErr(ctxt, XML_ERR_URI_FRAGMENT, NULL);
5483                         } else {
5484                             if ((ctxt->sax != NULL) &&
5485                                 (!ctxt->disableSAX) &&
5486                                 (ctxt->sax->entityDecl != NULL))
5487                                 ctxt->sax->entityDecl(ctxt->userData, name,
5488                                             XML_EXTERNAL_PARAMETER_ENTITY,
5489                                             literal, URI, NULL);
5490                         }
5491                         xmlFreeURI(uri);
5492                     }
5493                 }
5494             }
5495         } else {
5496             if ((RAW == '"') || (RAW == '\'')) {
5497                 value = xmlParseEntityValue(ctxt, &orig);
5498                 if ((ctxt->sax != NULL) &&
5499                     (!ctxt->disableSAX) && (ctxt->sax->entityDecl != NULL))
5500                     ctxt->sax->entityDecl(ctxt->userData, name,
5501                                 XML_INTERNAL_GENERAL_ENTITY,
5502                                 NULL, NULL, value);
5503                 /*
5504                  * For expat compatibility in SAX mode.
5505                  */
5506                 if ((ctxt->myDoc == NULL) ||
5507                     (xmlStrEqual(ctxt->myDoc->version, SAX_COMPAT_MODE))) {
5508                     if (ctxt->myDoc == NULL) {
5509                         ctxt->myDoc = xmlNewDoc(SAX_COMPAT_MODE);
5510                         if (ctxt->myDoc == NULL) {
5511                             xmlErrMemory(ctxt, "New Doc failed");
5512                             return;
5513                         }
5514                         ctxt->myDoc->properties = XML_DOC_INTERNAL;
5515                     }
5516                     if (ctxt->myDoc->intSubset == NULL)
5517                         ctxt->myDoc->intSubset = xmlNewDtd(ctxt->myDoc,
5518                                             BAD_CAST "fake", NULL, NULL);
5519
5520                     xmlSAX2EntityDecl(ctxt, name, XML_INTERNAL_GENERAL_ENTITY,
5521                                       NULL, NULL, value);
5522                 }
5523             } else {
5524                 URI = xmlParseExternalID(ctxt, &literal, 1);
5525                 if ((URI == NULL) && (literal == NULL)) {
5526                     xmlFatalErr(ctxt, XML_ERR_VALUE_REQUIRED, NULL);
5527                 }
5528                 if (URI) {
5529                     xmlURIPtr uri;
5530
5531                     uri = xmlParseURI((const char *)URI);
5532                     if (uri == NULL) {
5533                         xmlErrMsgStr(ctxt, XML_ERR_INVALID_URI,
5534                                      "Invalid URI: %s\n", URI);
5535                         /*
5536                          * This really ought to be a well formedness error
5537                          * but the XML Core WG decided otherwise c.f. issue
5538                          * E26 of the XML erratas.
5539                          */
5540                     } else {
5541                         if (uri->fragment != NULL) {
5542                             /*
5543                              * Okay this is foolish to block those but not
5544                              * invalid URIs.
5545                              */
5546                             xmlFatalErr(ctxt, XML_ERR_URI_FRAGMENT, NULL);
5547                         }
5548                         xmlFreeURI(uri);
5549                     }
5550                 }
5551                 if ((RAW != '>') && (!IS_BLANK_CH(CUR))) {
5552                     xmlFatalErrMsg(ctxt, XML_ERR_SPACE_REQUIRED,
5553                                    "Space required before 'NDATA'\n");
5554                 }
5555                 SKIP_BLANKS;
5556                 if (CMP5(CUR_PTR, 'N', 'D', 'A', 'T', 'A')) {
5557                     SKIP(5);
5558                     if (!IS_BLANK_CH(CUR)) {
5559                         xmlFatalErrMsg(ctxt, XML_ERR_SPACE_REQUIRED,
5560                                        "Space required after 'NDATA'\n");
5561                     }
5562                     SKIP_BLANKS;
5563                     ndata = xmlParseName(ctxt);
5564                     if ((ctxt->sax != NULL) && (!ctxt->disableSAX) &&
5565                         (ctxt->sax->unparsedEntityDecl != NULL))
5566                         ctxt->sax->unparsedEntityDecl(ctxt->userData, name,
5567                                     literal, URI, ndata);
5568                 } else {
5569                     if ((ctxt->sax != NULL) &&
5570                         (!ctxt->disableSAX) && (ctxt->sax->entityDecl != NULL))
5571                         ctxt->sax->entityDecl(ctxt->userData, name,
5572                                     XML_EXTERNAL_GENERAL_PARSED_ENTITY,
5573                                     literal, URI, NULL);
5574                     /*
5575                      * For expat compatibility in SAX mode.
5576                      * assuming the entity repalcement was asked for
5577                      */
5578                     if ((ctxt->replaceEntities != 0) &&
5579                         ((ctxt->myDoc == NULL) ||
5580                         (xmlStrEqual(ctxt->myDoc->version, SAX_COMPAT_MODE)))) {
5581                         if (ctxt->myDoc == NULL) {
5582                             ctxt->myDoc = xmlNewDoc(SAX_COMPAT_MODE);
5583                             if (ctxt->myDoc == NULL) {
5584                                 xmlErrMemory(ctxt, "New Doc failed");
5585                                 return;
5586                             }
5587                             ctxt->myDoc->properties = XML_DOC_INTERNAL;
5588                         }
5589
5590                         if (ctxt->myDoc->intSubset == NULL)
5591                             ctxt->myDoc->intSubset = xmlNewDtd(ctxt->myDoc,
5592                                                 BAD_CAST "fake", NULL, NULL);
5593                         xmlSAX2EntityDecl(ctxt, name,
5594                                           XML_EXTERNAL_GENERAL_PARSED_ENTITY,
5595                                           literal, URI, NULL);
5596                     }
5597                 }
5598             }
5599         }
5600         if (ctxt->instate == XML_PARSER_EOF)
5601             return;
5602         SKIP_BLANKS;
5603         if (RAW != '>') {
5604             xmlFatalErrMsgStr(ctxt, XML_ERR_ENTITY_NOT_FINISHED,
5605                     "xmlParseEntityDecl: entity %s not terminated\n", name);
5606         } else {
5607             if (input != ctxt->input) {
5608                 xmlFatalErrMsg(ctxt, XML_ERR_ENTITY_BOUNDARY,
5609         "Entity declaration doesn't start and stop in the same entity\n");
5610             }
5611             NEXT;
5612         }
5613         if (orig != NULL) {
5614             /*
5615              * Ugly mechanism to save the raw entity value.
5616              */
5617             xmlEntityPtr cur = NULL;
5618
5619             if (isParameter) {
5620                 if ((ctxt->sax != NULL) &&
5621                     (ctxt->sax->getParameterEntity != NULL))
5622                     cur = ctxt->sax->getParameterEntity(ctxt->userData, name);
5623             } else {
5624                 if ((ctxt->sax != NULL) &&
5625                     (ctxt->sax->getEntity != NULL))
5626                     cur = ctxt->sax->getEntity(ctxt->userData, name);
5627                 if ((cur == NULL) && (ctxt->userData==ctxt)) {
5628                     cur = xmlSAX2GetEntity(ctxt, name);
5629                 }
5630             }
5631             if (cur != NULL) {
5632                 if (cur->orig != NULL)
5633                     xmlFree(orig);
5634                 else
5635                     cur->orig = orig;
5636             } else
5637                 xmlFree(orig);
5638         }
5639         if (value != NULL) xmlFree(value);
5640         if (URI != NULL) xmlFree(URI);
5641         if (literal != NULL) xmlFree(literal);
5642     }
5643 }
5644
5645 /**
5646  * xmlParseDefaultDecl:
5647  * @ctxt:  an XML parser context
5648  * @value:  Receive a possible fixed default value for the attribute
5649  *
5650  * Parse an attribute default declaration
5651  *
5652  * [60] DefaultDecl ::= '#REQUIRED' | '#IMPLIED' | (('#FIXED' S)? AttValue)
5653  *
5654  * [ VC: Required Attribute ]
5655  * if the default declaration is the keyword #REQUIRED, then the
5656  * attribute must be specified for all elements of the type in the
5657  * attribute-list declaration.
5658  *
5659  * [ VC: Attribute Default Legal ]
5660  * The declared default value must meet the lexical constraints of
5661  * the declared attribute type c.f. xmlValidateAttributeDecl()
5662  *
5663  * [ VC: Fixed Attribute Default ]
5664  * if an attribute has a default value declared with the #FIXED
5665  * keyword, instances of that attribute must match the default value.
5666  *
5667  * [ WFC: No < in Attribute Values ]
5668  * handled in xmlParseAttValue()
5669  *
5670  * returns: XML_ATTRIBUTE_NONE, XML_ATTRIBUTE_REQUIRED, XML_ATTRIBUTE_IMPLIED
5671  *          or XML_ATTRIBUTE_FIXED.
5672  */
5673
5674 int
5675 xmlParseDefaultDecl(xmlParserCtxtPtr ctxt, xmlChar **value) {
5676     int val;
5677     xmlChar *ret;
5678
5679     *value = NULL;
5680     if (CMP9(CUR_PTR, '#', 'R', 'E', 'Q', 'U', 'I', 'R', 'E', 'D')) {
5681         SKIP(9);
5682         return(XML_ATTRIBUTE_REQUIRED);
5683     }
5684     if (CMP8(CUR_PTR, '#', 'I', 'M', 'P', 'L', 'I', 'E', 'D')) {
5685         SKIP(8);
5686         return(XML_ATTRIBUTE_IMPLIED);
5687     }
5688     val = XML_ATTRIBUTE_NONE;
5689     if (CMP6(CUR_PTR, '#', 'F', 'I', 'X', 'E', 'D')) {
5690         SKIP(6);
5691         val = XML_ATTRIBUTE_FIXED;
5692         if (!IS_BLANK_CH(CUR)) {
5693             xmlFatalErrMsg(ctxt, XML_ERR_SPACE_REQUIRED,
5694                            "Space required after '#FIXED'\n");
5695         }
5696         SKIP_BLANKS;
5697     }
5698     ret = xmlParseAttValue(ctxt);
5699     ctxt->instate = XML_PARSER_DTD;
5700     if (ret == NULL) {
5701         xmlFatalErrMsg(ctxt, (xmlParserErrors)ctxt->errNo,
5702                        "Attribute default value declaration error\n");
5703     } else
5704         *value = ret;
5705     return(val);
5706 }
5707
5708 /**
5709  * xmlParseNotationType:
5710  * @ctxt:  an XML parser context
5711  *
5712  * parse an Notation attribute type.
5713  *
5714  * Note: the leading 'NOTATION' S part has already being parsed...
5715  *
5716  * [58] NotationType ::= 'NOTATION' S '(' S? Name (S? '|' S? Name)* S? ')'
5717  *
5718  * [ VC: Notation Attributes ]
5719  * Values of this type must match one of the notation names included
5720  * in the declaration; all notation names in the declaration must be declared.
5721  *
5722  * Returns: the notation attribute tree built while parsing
5723  */
5724
5725 xmlEnumerationPtr
5726 xmlParseNotationType(xmlParserCtxtPtr ctxt) {
5727     const xmlChar *name;
5728     xmlEnumerationPtr ret = NULL, last = NULL, cur, tmp;
5729
5730     if (RAW != '(') {
5731         xmlFatalErr(ctxt, XML_ERR_NOTATION_NOT_STARTED, NULL);
5732         return(NULL);
5733     }
5734     SHRINK;
5735     do {
5736         NEXT;
5737         SKIP_BLANKS;
5738         name = xmlParseName(ctxt);
5739         if (name == NULL) {
5740             xmlFatalErrMsg(ctxt, XML_ERR_NAME_REQUIRED,
5741                            "Name expected in NOTATION declaration\n");
5742             xmlFreeEnumeration(ret);
5743             return(NULL);
5744         }
5745         tmp = ret;
5746         while (tmp != NULL) {
5747             if (xmlStrEqual(name, tmp->name)) {
5748                 xmlValidityError(ctxt, XML_DTD_DUP_TOKEN,
5749           "standalone: attribute notation value token %s duplicated\n",
5750                                  name, NULL);
5751                 if (!xmlDictOwns(ctxt->dict, name))
5752                     xmlFree((xmlChar *) name);
5753                 break;
5754             }
5755             tmp = tmp->next;
5756         }
5757         if (tmp == NULL) {
5758             cur = xmlCreateEnumeration(name);
5759             if (cur == NULL) {
5760                 xmlFreeEnumeration(ret);
5761                 return(NULL);
5762             }
5763             if (last == NULL) ret = last = cur;
5764             else {
5765                 last->next = cur;
5766                 last = cur;
5767             }
5768         }
5769         SKIP_BLANKS;
5770     } while (RAW == '|');
5771     if (RAW != ')') {
5772         xmlFatalErr(ctxt, XML_ERR_NOTATION_NOT_FINISHED, NULL);
5773         xmlFreeEnumeration(ret);
5774         return(NULL);
5775     }
5776     NEXT;
5777     return(ret);
5778 }
5779
5780 /**
5781  * xmlParseEnumerationType:
5782  * @ctxt:  an XML parser context
5783  *
5784  * parse an Enumeration attribute type.
5785  *
5786  * [59] Enumeration ::= '(' S? Nmtoken (S? '|' S? Nmtoken)* S? ')'
5787  *
5788  * [ VC: Enumeration ]
5789  * Values of this type must match one of the Nmtoken tokens in
5790  * the declaration
5791  *
5792  * Returns: the enumeration attribute tree built while parsing
5793  */
5794
5795 xmlEnumerationPtr
5796 xmlParseEnumerationType(xmlParserCtxtPtr ctxt) {
5797     xmlChar *name;
5798     xmlEnumerationPtr ret = NULL, last = NULL, cur, tmp;
5799
5800     if (RAW != '(') {
5801         xmlFatalErr(ctxt, XML_ERR_ATTLIST_NOT_STARTED, NULL);
5802         return(NULL);
5803     }
5804     SHRINK;
5805     do {
5806         NEXT;
5807         SKIP_BLANKS;
5808         name = xmlParseNmtoken(ctxt);
5809         if (name == NULL) {
5810             xmlFatalErr(ctxt, XML_ERR_NMTOKEN_REQUIRED, NULL);
5811             return(ret);
5812         }
5813         tmp = ret;
5814         while (tmp != NULL) {
5815             if (xmlStrEqual(name, tmp->name)) {
5816                 xmlValidityError(ctxt, XML_DTD_DUP_TOKEN,
5817           "standalone: attribute enumeration value token %s duplicated\n",
5818                                  name, NULL);
5819                 if (!xmlDictOwns(ctxt->dict, name))
5820                     xmlFree(name);
5821                 break;
5822             }
5823             tmp = tmp->next;
5824         }
5825         if (tmp == NULL) {
5826             cur = xmlCreateEnumeration(name);
5827             if (!xmlDictOwns(ctxt->dict, name))
5828                 xmlFree(name);
5829             if (cur == NULL) {
5830                 xmlFreeEnumeration(ret);
5831                 return(NULL);
5832             }
5833             if (last == NULL) ret = last = cur;
5834             else {
5835                 last->next = cur;
5836                 last = cur;
5837             }
5838         }
5839         SKIP_BLANKS;
5840     } while (RAW == '|');
5841     if (RAW != ')') {
5842         xmlFatalErr(ctxt, XML_ERR_ATTLIST_NOT_FINISHED, NULL);
5843         return(ret);
5844     }
5845     NEXT;
5846     return(ret);
5847 }
5848
5849 /**
5850  * xmlParseEnumeratedType:
5851  * @ctxt:  an XML parser context
5852  * @tree:  the enumeration tree built while parsing
5853  *
5854  * parse an Enumerated attribute type.
5855  *
5856  * [57] EnumeratedType ::= NotationType | Enumeration
5857  *
5858  * [58] NotationType ::= 'NOTATION' S '(' S? Name (S? '|' S? Name)* S? ')'
5859  *
5860  *
5861  * Returns: XML_ATTRIBUTE_ENUMERATION or XML_ATTRIBUTE_NOTATION
5862  */
5863
5864 int
5865 xmlParseEnumeratedType(xmlParserCtxtPtr ctxt, xmlEnumerationPtr *tree) {
5866     if (CMP8(CUR_PTR, 'N', 'O', 'T', 'A', 'T', 'I', 'O', 'N')) {
5867         SKIP(8);
5868         if (!IS_BLANK_CH(CUR)) {
5869             xmlFatalErrMsg(ctxt, XML_ERR_SPACE_REQUIRED,
5870                            "Space required after 'NOTATION'\n");
5871             return(0);
5872         }
5873         SKIP_BLANKS;
5874         *tree = xmlParseNotationType(ctxt);
5875         if (*tree == NULL) return(0);
5876         return(XML_ATTRIBUTE_NOTATION);
5877     }
5878     *tree = xmlParseEnumerationType(ctxt);
5879     if (*tree == NULL) return(0);
5880     return(XML_ATTRIBUTE_ENUMERATION);
5881 }
5882
5883 /**
5884  * xmlParseAttributeType:
5885  * @ctxt:  an XML parser context
5886  * @tree:  the enumeration tree built while parsing
5887  *
5888  * parse the Attribute list def for an element
5889  *
5890  * [54] AttType ::= StringType | TokenizedType | EnumeratedType
5891  *
5892  * [55] StringType ::= 'CDATA'
5893  *
5894  * [56] TokenizedType ::= 'ID' | 'IDREF' | 'IDREFS' | 'ENTITY' |
5895  *                        'ENTITIES' | 'NMTOKEN' | 'NMTOKENS'
5896  *
5897  * Validity constraints for attribute values syntax are checked in
5898  * xmlValidateAttributeValue()
5899  *
5900  * [ VC: ID ]
5901  * Values of type ID must match the Name production. A name must not
5902  * appear more than once in an XML document as a value of this type;
5903  * i.e., ID values must uniquely identify the elements which bear them.
5904  *
5905  * [ VC: One ID per Element Type ]
5906  * No element type may have more than one ID attribute specified.
5907  *
5908  * [ VC: ID Attribute Default ]
5909  * An ID attribute must have a declared default of #IMPLIED or #REQUIRED.
5910  *
5911  * [ VC: IDREF ]
5912  * Values of type IDREF must match the Name production, and values
5913  * of type IDREFS must match Names; each IDREF Name must match the value
5914  * of an ID attribute on some element in the XML document; i.e. IDREF
5915  * values must match the value of some ID attribute.
5916  *
5917  * [ VC: Entity Name ]
5918  * Values of type ENTITY must match the Name production, values
5919  * of type ENTITIES must match Names; each Entity Name must match the
5920  * name of an unparsed entity declared in the DTD.
5921  *
5922  * [ VC: Name Token ]
5923  * Values of type NMTOKEN must match the Nmtoken production; values
5924  * of type NMTOKENS must match Nmtokens.
5925  *
5926  * Returns the attribute type
5927  */
5928 int
5929 xmlParseAttributeType(xmlParserCtxtPtr ctxt, xmlEnumerationPtr *tree) {
5930     SHRINK;
5931     if (CMP5(CUR_PTR, 'C', 'D', 'A', 'T', 'A')) {
5932         SKIP(5);
5933         return(XML_ATTRIBUTE_CDATA);
5934      } else if (CMP6(CUR_PTR, 'I', 'D', 'R', 'E', 'F', 'S')) {
5935         SKIP(6);
5936         return(XML_ATTRIBUTE_IDREFS);
5937      } else if (CMP5(CUR_PTR, 'I', 'D', 'R', 'E', 'F')) {
5938         SKIP(5);
5939         return(XML_ATTRIBUTE_IDREF);
5940      } else if ((RAW == 'I') && (NXT(1) == 'D')) {
5941         SKIP(2);
5942         return(XML_ATTRIBUTE_ID);
5943      } else if (CMP6(CUR_PTR, 'E', 'N', 'T', 'I', 'T', 'Y')) {
5944         SKIP(6);
5945         return(XML_ATTRIBUTE_ENTITY);
5946      } else if (CMP8(CUR_PTR, 'E', 'N', 'T', 'I', 'T', 'I', 'E', 'S')) {
5947         SKIP(8);
5948         return(XML_ATTRIBUTE_ENTITIES);
5949      } else if (CMP8(CUR_PTR, 'N', 'M', 'T', 'O', 'K', 'E', 'N', 'S')) {
5950         SKIP(8);
5951         return(XML_ATTRIBUTE_NMTOKENS);
5952      } else if (CMP7(CUR_PTR, 'N', 'M', 'T', 'O', 'K', 'E', 'N')) {
5953         SKIP(7);
5954         return(XML_ATTRIBUTE_NMTOKEN);
5955      }
5956      return(xmlParseEnumeratedType(ctxt, tree));
5957 }
5958
5959 /**
5960  * xmlParseAttributeListDecl:
5961  * @ctxt:  an XML parser context
5962  *
5963  * : parse the Attribute list def for an element
5964  *
5965  * [52] AttlistDecl ::= '<!ATTLIST' S Name AttDef* S? '>'
5966  *
5967  * [53] AttDef ::= S Name S AttType S DefaultDecl
5968  *
5969  */
5970 void
5971 xmlParseAttributeListDecl(xmlParserCtxtPtr ctxt) {
5972     const xmlChar *elemName;
5973     const xmlChar *attrName;
5974     xmlEnumerationPtr tree;
5975
5976     if (CMP9(CUR_PTR, '<', '!', 'A', 'T', 'T', 'L', 'I', 'S', 'T')) {
5977         xmlParserInputPtr input = ctxt->input;
5978
5979         SKIP(9);
5980         if (!IS_BLANK_CH(CUR)) {
5981             xmlFatalErrMsg(ctxt, XML_ERR_SPACE_REQUIRED,
5982                                  "Space required after '<!ATTLIST'\n");
5983         }
5984         SKIP_BLANKS;
5985         elemName = xmlParseName(ctxt);
5986         if (elemName == NULL) {
5987             xmlFatalErrMsg(ctxt, XML_ERR_NAME_REQUIRED,
5988                            "ATTLIST: no name for Element\n");
5989             return;
5990         }
5991         SKIP_BLANKS;
5992         GROW;
5993         while ((RAW != '>') && (ctxt->instate != XML_PARSER_EOF)) {
5994             const xmlChar *check = CUR_PTR;
5995             int type;
5996             int def;
5997             xmlChar *defaultValue = NULL;
5998
5999             GROW;
6000             tree = NULL;
6001             attrName = xmlParseName(ctxt);
6002             if (attrName == NULL) {
6003                 xmlFatalErrMsg(ctxt, XML_ERR_NAME_REQUIRED,
6004                                "ATTLIST: no name for Attribute\n");
6005                 break;
6006             }
6007             GROW;
6008             if (!IS_BLANK_CH(CUR)) {
6009                 xmlFatalErrMsg(ctxt, XML_ERR_SPACE_REQUIRED,
6010                         "Space required after the attribute name\n");
6011                 break;
6012             }
6013             SKIP_BLANKS;
6014
6015             type = xmlParseAttributeType(ctxt, &tree);
6016             if (type <= 0) {
6017                 break;
6018             }
6019
6020             GROW;
6021             if (!IS_BLANK_CH(CUR)) {
6022                 xmlFatalErrMsg(ctxt, XML_ERR_SPACE_REQUIRED,
6023                                "Space required after the attribute type\n");
6024                 if (tree != NULL)
6025                     xmlFreeEnumeration(tree);
6026                 break;
6027             }
6028             SKIP_BLANKS;
6029
6030             def = xmlParseDefaultDecl(ctxt, &defaultValue);
6031             if (def <= 0) {
6032                 if (defaultValue != NULL)
6033                     xmlFree(defaultValue);
6034                 if (tree != NULL)
6035                     xmlFreeEnumeration(tree);
6036                 break;
6037             }
6038             if ((type != XML_ATTRIBUTE_CDATA) && (defaultValue != NULL))
6039                 xmlAttrNormalizeSpace(defaultValue, defaultValue);
6040
6041             GROW;
6042             if (RAW != '>') {
6043                 if (!IS_BLANK_CH(CUR)) {
6044                     xmlFatalErrMsg(ctxt, XML_ERR_SPACE_REQUIRED,
6045                         "Space required after the attribute default value\n");
6046                     if (defaultValue != NULL)
6047                         xmlFree(defaultValue);
6048                     if (tree != NULL)
6049                         xmlFreeEnumeration(tree);
6050                     break;
6051                 }
6052                 SKIP_BLANKS;
6053             }
6054             if (check == CUR_PTR) {
6055                 xmlFatalErr(ctxt, XML_ERR_INTERNAL_ERROR,
6056                             "in xmlParseAttributeListDecl\n");
6057                 if (defaultValue != NULL)
6058                     xmlFree(defaultValue);
6059                 if (tree != NULL)
6060                     xmlFreeEnumeration(tree);
6061                 break;
6062             }
6063             if ((ctxt->sax != NULL) && (!ctxt->disableSAX) &&
6064                 (ctxt->sax->attributeDecl != NULL))
6065                 ctxt->sax->attributeDecl(ctxt->userData, elemName, attrName,
6066                                 type, def, defaultValue, tree);
6067             else if (tree != NULL)
6068                 xmlFreeEnumeration(tree);
6069
6070             if ((ctxt->sax2) && (defaultValue != NULL) &&
6071                 (def != XML_ATTRIBUTE_IMPLIED) &&
6072                 (def != XML_ATTRIBUTE_REQUIRED)) {
6073                 xmlAddDefAttrs(ctxt, elemName, attrName, defaultValue);
6074             }
6075             if (ctxt->sax2) {
6076                 xmlAddSpecialAttr(ctxt, elemName, attrName, type);
6077             }
6078             if (defaultValue != NULL)
6079                 xmlFree(defaultValue);
6080             GROW;
6081         }
6082         if (RAW == '>') {
6083             if (input != ctxt->input) {
6084                 xmlValidityError(ctxt, XML_ERR_ENTITY_BOUNDARY,
6085     "Attribute list declaration doesn't start and stop in the same entity\n",
6086                                  NULL, NULL);
6087             }
6088             NEXT;
6089         }
6090     }
6091 }
6092
6093 /**
6094  * xmlParseElementMixedContentDecl:
6095  * @ctxt:  an XML parser context
6096  * @inputchk:  the input used for the current entity, needed for boundary checks
6097  *
6098  * parse the declaration for a Mixed Element content
6099  * The leading '(' and spaces have been skipped in xmlParseElementContentDecl
6100  *
6101  * [51] Mixed ::= '(' S? '#PCDATA' (S? '|' S? Name)* S? ')*' |
6102  *                '(' S? '#PCDATA' S? ')'
6103  *
6104  * [ VC: Proper Group/PE Nesting ] applies to [51] too (see [49])
6105  *
6106  * [ VC: No Duplicate Types ]
6107  * The same name must not appear more than once in a single
6108  * mixed-content declaration.
6109  *
6110  * returns: the list of the xmlElementContentPtr describing the element choices
6111  */
6112 xmlElementContentPtr
6113 xmlParseElementMixedContentDecl(xmlParserCtxtPtr ctxt, int inputchk) {
6114     xmlElementContentPtr ret = NULL, cur = NULL, n;
6115     const xmlChar *elem = NULL;
6116
6117     GROW;
6118     if (CMP7(CUR_PTR, '#', 'P', 'C', 'D', 'A', 'T', 'A')) {
6119         SKIP(7);
6120         SKIP_BLANKS;
6121         SHRINK;
6122         if (RAW == ')') {
6123             if ((ctxt->validate) && (ctxt->input->id != inputchk)) {
6124                 xmlValidityError(ctxt, XML_ERR_ENTITY_BOUNDARY,
6125 "Element content declaration doesn't start and stop in the same entity\n",
6126                                  NULL, NULL);
6127             }
6128             NEXT;
6129             ret = xmlNewDocElementContent(ctxt->myDoc, NULL, XML_ELEMENT_CONTENT_PCDATA);
6130             if (ret == NULL)
6131                 return(NULL);
6132             if (RAW == '*') {
6133                 ret->ocur = XML_ELEMENT_CONTENT_MULT;
6134                 NEXT;
6135             }
6136             return(ret);
6137         }
6138         if ((RAW == '(') || (RAW == '|')) {
6139             ret = cur = xmlNewDocElementContent(ctxt->myDoc, NULL, XML_ELEMENT_CONTENT_PCDATA);
6140             if (ret == NULL) return(NULL);
6141         }
6142         while ((RAW == '|') && (ctxt->instate != XML_PARSER_EOF)) {
6143             NEXT;
6144             if (elem == NULL) {
6145                 ret = xmlNewDocElementContent(ctxt->myDoc, NULL, XML_ELEMENT_CONTENT_OR);
6146                 if (ret == NULL) return(NULL);
6147                 ret->c1 = cur;
6148                 if (cur != NULL)
6149                     cur->parent = ret;
6150                 cur = ret;
6151             } else {
6152                 n = xmlNewDocElementContent(ctxt->myDoc, NULL, XML_ELEMENT_CONTENT_OR);
6153                 if (n == NULL) return(NULL);
6154                 n->c1 = xmlNewDocElementContent(ctxt->myDoc, elem, XML_ELEMENT_CONTENT_ELEMENT);
6155                 if (n->c1 != NULL)
6156                     n->c1->parent = n;
6157                 cur->c2 = n;
6158                 if (n != NULL)
6159                     n->parent = cur;
6160                 cur = n;
6161             }
6162             SKIP_BLANKS;
6163             elem = xmlParseName(ctxt);
6164             if (elem == NULL) {
6165                 xmlFatalErrMsg(ctxt, XML_ERR_NAME_REQUIRED,
6166                         "xmlParseElementMixedContentDecl : Name expected\n");
6167                 xmlFreeDocElementContent(ctxt->myDoc, cur);
6168                 return(NULL);
6169             }
6170             SKIP_BLANKS;
6171             GROW;
6172         }
6173         if ((RAW == ')') && (NXT(1) == '*')) {
6174             if (elem != NULL) {
6175                 cur->c2 = xmlNewDocElementContent(ctxt->myDoc, elem,
6176                                                XML_ELEMENT_CONTENT_ELEMENT);
6177                 if (cur->c2 != NULL)
6178                     cur->c2->parent = cur;
6179             }
6180             if (ret != NULL)
6181                 ret->ocur = XML_ELEMENT_CONTENT_MULT;
6182             if ((ctxt->validate) && (ctxt->input->id != inputchk)) {
6183                 xmlValidityError(ctxt, XML_ERR_ENTITY_BOUNDARY,
6184 "Element content declaration doesn't start and stop in the same entity\n",
6185                                  NULL, NULL);
6186             }
6187             SKIP(2);
6188         } else {
6189             xmlFreeDocElementContent(ctxt->myDoc, ret);
6190             xmlFatalErr(ctxt, XML_ERR_MIXED_NOT_STARTED, NULL);
6191             return(NULL);
6192         }
6193
6194     } else {
6195         xmlFatalErr(ctxt, XML_ERR_PCDATA_REQUIRED, NULL);
6196     }
6197     return(ret);
6198 }
6199
6200 /**
6201  * xmlParseElementChildrenContentDeclPriv:
6202  * @ctxt:  an XML parser context
6203  * @inputchk:  the input used for the current entity, needed for boundary checks
6204  * @depth: the level of recursion
6205  *
6206  * parse the declaration for a Mixed Element content
6207  * The leading '(' and spaces have been skipped in xmlParseElementContentDecl
6208  *
6209  *
6210  * [47] children ::= (choice | seq) ('?' | '*' | '+')?
6211  *
6212  * [48] cp ::= (Name | choice | seq) ('?' | '*' | '+')?
6213  *
6214  * [49] choice ::= '(' S? cp ( S? '|' S? cp )* S? ')'
6215  *
6216  * [50] seq ::= '(' S? cp ( S? ',' S? cp )* S? ')'
6217  *
6218  * [ VC: Proper Group/PE Nesting ] applies to [49] and [50]
6219  * TODO Parameter-entity replacement text must be properly nested
6220  *      with parenthesized groups. That is to say, if either of the
6221  *      opening or closing parentheses in a choice, seq, or Mixed
6222  *      construct is contained in the replacement text for a parameter
6223  *      entity, both must be contained in the same replacement text. For
6224  *      interoperability, if a parameter-entity reference appears in a
6225  *      choice, seq, or Mixed construct, its replacement text should not
6226  *      be empty, and neither the first nor last non-blank character of
6227  *      the replacement text should be a connector (| or ,).
6228  *
6229  * Returns the tree of xmlElementContentPtr describing the element
6230  *          hierarchy.
6231  */
6232 static xmlElementContentPtr
6233 xmlParseElementChildrenContentDeclPriv(xmlParserCtxtPtr ctxt, int inputchk,
6234                                        int depth) {
6235     xmlElementContentPtr ret = NULL, cur = NULL, last = NULL, op = NULL;
6236     const xmlChar *elem;
6237     xmlChar type = 0;
6238
6239     if (((depth > 128) && ((ctxt->options & XML_PARSE_HUGE) == 0)) ||
6240         (depth >  2048)) {
6241         xmlFatalErrMsgInt(ctxt, XML_ERR_ELEMCONTENT_NOT_FINISHED,
6242 "xmlParseElementChildrenContentDecl : depth %d too deep, use XML_PARSE_HUGE\n",
6243                           depth);
6244         return(NULL);
6245     }
6246     SKIP_BLANKS;
6247     GROW;
6248     if (RAW == '(') {
6249         int inputid = ctxt->input->id;
6250
6251         /* Recurse on first child */
6252         NEXT;
6253         SKIP_BLANKS;
6254         cur = ret = xmlParseElementChildrenContentDeclPriv(ctxt, inputid,
6255                                                            depth + 1);
6256         SKIP_BLANKS;
6257         GROW;
6258     } else {
6259         elem = xmlParseName(ctxt);
6260         if (elem == NULL) {
6261             xmlFatalErr(ctxt, XML_ERR_ELEMCONTENT_NOT_STARTED, NULL);
6262             return(NULL);
6263         }
6264         cur = ret = xmlNewDocElementContent(ctxt->myDoc, elem, XML_ELEMENT_CONTENT_ELEMENT);
6265         if (cur == NULL) {
6266             xmlErrMemory(ctxt, NULL);
6267             return(NULL);
6268         }
6269         GROW;
6270         if (RAW == '?') {
6271             cur->ocur = XML_ELEMENT_CONTENT_OPT;
6272             NEXT;
6273         } else if (RAW == '*') {
6274             cur->ocur = XML_ELEMENT_CONTENT_MULT;
6275             NEXT;
6276         } else if (RAW == '+') {
6277             cur->ocur = XML_ELEMENT_CONTENT_PLUS;
6278             NEXT;
6279         } else {
6280             cur->ocur = XML_ELEMENT_CONTENT_ONCE;
6281         }
6282         GROW;
6283     }
6284     SKIP_BLANKS;
6285     SHRINK;
6286     while ((RAW != ')') && (ctxt->instate != XML_PARSER_EOF)) {
6287         /*
6288          * Each loop we parse one separator and one element.
6289          */
6290         if (RAW == ',') {
6291             if (type == 0) type = CUR;
6292
6293             /*
6294              * Detect "Name | Name , Name" error
6295              */
6296             else if (type != CUR) {
6297                 xmlFatalErrMsgInt(ctxt, XML_ERR_SEPARATOR_REQUIRED,
6298                     "xmlParseElementChildrenContentDecl : '%c' expected\n",
6299                                   type);
6300                 if ((last != NULL) && (last != ret))
6301                     xmlFreeDocElementContent(ctxt->myDoc, last);
6302                 if (ret != NULL)
6303                     xmlFreeDocElementContent(ctxt->myDoc, ret);
6304                 return(NULL);
6305             }
6306             NEXT;
6307
6308             op = xmlNewDocElementContent(ctxt->myDoc, NULL, XML_ELEMENT_CONTENT_SEQ);
6309             if (op == NULL) {
6310                 if ((last != NULL) && (last != ret))
6311                     xmlFreeDocElementContent(ctxt->myDoc, last);
6312                 xmlFreeDocElementContent(ctxt->myDoc, ret);
6313                 return(NULL);
6314             }
6315             if (last == NULL) {
6316                 op->c1 = ret;
6317                 if (ret != NULL)
6318                     ret->parent = op;
6319                 ret = cur = op;
6320             } else {
6321                 cur->c2 = op;
6322                 if (op != NULL)
6323                     op->parent = cur;
6324                 op->c1 = last;
6325                 if (last != NULL)
6326                     last->parent = op;
6327                 cur =op;
6328                 last = NULL;
6329             }
6330         } else if (RAW == '|') {
6331             if (type == 0) type = CUR;
6332
6333             /*
6334              * Detect "Name , Name | Name" error
6335              */
6336             else if (type != CUR) {
6337                 xmlFatalErrMsgInt(ctxt, XML_ERR_SEPARATOR_REQUIRED,
6338                     "xmlParseElementChildrenContentDecl : '%c' expected\n",
6339                                   type);
6340                 if ((last != NULL) && (last != ret))
6341                     xmlFreeDocElementContent(ctxt->myDoc, last);
6342                 if (ret != NULL)
6343                     xmlFreeDocElementContent(ctxt->myDoc, ret);
6344                 return(NULL);
6345             }
6346             NEXT;
6347
6348             op = xmlNewDocElementContent(ctxt->myDoc, NULL, XML_ELEMENT_CONTENT_OR);
6349             if (op == NULL) {
6350                 if ((last != NULL) && (last != ret))
6351                     xmlFreeDocElementContent(ctxt->myDoc, last);
6352                 if (ret != NULL)
6353                     xmlFreeDocElementContent(ctxt->myDoc, ret);
6354                 return(NULL);
6355             }
6356             if (last == NULL) {
6357                 op->c1 = ret;
6358                 if (ret != NULL)
6359                     ret->parent = op;
6360                 ret = cur = op;
6361             } else {
6362                 cur->c2 = op;
6363                 if (op != NULL)
6364                     op->parent = cur;
6365                 op->c1 = last;
6366                 if (last != NULL)
6367                     last->parent = op;
6368                 cur =op;
6369                 last = NULL;
6370             }
6371         } else {
6372             xmlFatalErr(ctxt, XML_ERR_ELEMCONTENT_NOT_FINISHED, NULL);
6373             if ((last != NULL) && (last != ret))
6374                 xmlFreeDocElementContent(ctxt->myDoc, last);
6375             if (ret != NULL)
6376                 xmlFreeDocElementContent(ctxt->myDoc, ret);
6377             return(NULL);
6378         }
6379         GROW;
6380         SKIP_BLANKS;
6381         GROW;
6382         if (RAW == '(') {
6383             int inputid = ctxt->input->id;
6384             /* Recurse on second child */
6385             NEXT;
6386             SKIP_BLANKS;
6387             last = xmlParseElementChildrenContentDeclPriv(ctxt, inputid,
6388                                                           depth + 1);
6389             SKIP_BLANKS;
6390         } else {
6391             elem = xmlParseName(ctxt);
6392             if (elem == NULL) {
6393                 xmlFatalErr(ctxt, XML_ERR_ELEMCONTENT_NOT_STARTED, NULL);
6394                 if (ret != NULL)
6395                     xmlFreeDocElementContent(ctxt->myDoc, ret);
6396                 return(NULL);
6397             }
6398             last = xmlNewDocElementContent(ctxt->myDoc, elem, XML_ELEMENT_CONTENT_ELEMENT);
6399             if (last == NULL) {
6400                 if (ret != NULL)
6401                     xmlFreeDocElementContent(ctxt->myDoc, ret);
6402                 return(NULL);
6403             }
6404             if (RAW == '?') {
6405                 last->ocur = XML_ELEMENT_CONTENT_OPT;
6406                 NEXT;
6407             } else if (RAW == '*') {
6408                 last->ocur = XML_ELEMENT_CONTENT_MULT;
6409                 NEXT;
6410             } else if (RAW == '+') {
6411                 last->ocur = XML_ELEMENT_CONTENT_PLUS;
6412                 NEXT;
6413             } else {
6414                 last->ocur = XML_ELEMENT_CONTENT_ONCE;
6415             }
6416         }
6417         SKIP_BLANKS;
6418         GROW;
6419     }
6420     if ((cur != NULL) && (last != NULL)) {
6421         cur->c2 = last;
6422         if (last != NULL)
6423             last->parent = cur;
6424     }
6425     if ((ctxt->validate) && (ctxt->input->id != inputchk)) {
6426         xmlValidityError(ctxt, XML_ERR_ENTITY_BOUNDARY,
6427 "Element content declaration doesn't start and stop in the same entity\n",
6428                          NULL, NULL);
6429     }
6430     NEXT;
6431     if (RAW == '?') {
6432         if (ret != NULL) {
6433             if ((ret->ocur == XML_ELEMENT_CONTENT_PLUS) ||
6434                 (ret->ocur == XML_ELEMENT_CONTENT_MULT))
6435                 ret->ocur = XML_ELEMENT_CONTENT_MULT;
6436             else
6437                 ret->ocur = XML_ELEMENT_CONTENT_OPT;
6438         }
6439         NEXT;
6440     } else if (RAW == '*') {
6441         if (ret != NULL) {
6442             ret->ocur = XML_ELEMENT_CONTENT_MULT;
6443             cur = ret;
6444             /*
6445              * Some normalization:
6446              * (a | b* | c?)* == (a | b | c)*
6447              */
6448             while ((cur != NULL) && (cur->type == XML_ELEMENT_CONTENT_OR)) {
6449                 if ((cur->c1 != NULL) &&
6450                     ((cur->c1->ocur == XML_ELEMENT_CONTENT_OPT) ||
6451                      (cur->c1->ocur == XML_ELEMENT_CONTENT_MULT)))
6452                     cur->c1->ocur = XML_ELEMENT_CONTENT_ONCE;
6453                 if ((cur->c2 != NULL) &&
6454                     ((cur->c2->ocur == XML_ELEMENT_CONTENT_OPT) ||
6455                      (cur->c2->ocur == XML_ELEMENT_CONTENT_MULT)))
6456                     cur->c2->ocur = XML_ELEMENT_CONTENT_ONCE;
6457                 cur = cur->c2;
6458             }
6459         }
6460         NEXT;
6461     } else if (RAW == '+') {
6462         if (ret != NULL) {
6463             int found = 0;
6464
6465             if ((ret->ocur == XML_ELEMENT_CONTENT_OPT) ||
6466                 (ret->ocur == XML_ELEMENT_CONTENT_MULT))
6467                 ret->ocur = XML_ELEMENT_CONTENT_MULT;
6468             else
6469                 ret->ocur = XML_ELEMENT_CONTENT_PLUS;
6470             /*
6471              * Some normalization:
6472              * (a | b*)+ == (a | b)*
6473              * (a | b?)+ == (a | b)*
6474              */
6475             while ((cur != NULL) && (cur->type == XML_ELEMENT_CONTENT_OR)) {
6476                 if ((cur->c1 != NULL) &&
6477                     ((cur->c1->ocur == XML_ELEMENT_CONTENT_OPT) ||
6478                      (cur->c1->ocur == XML_ELEMENT_CONTENT_MULT))) {
6479                     cur->c1->ocur = XML_ELEMENT_CONTENT_ONCE;
6480                     found = 1;
6481                 }
6482                 if ((cur->c2 != NULL) &&
6483                     ((cur->c2->ocur == XML_ELEMENT_CONTENT_OPT) ||
6484                      (cur->c2->ocur == XML_ELEMENT_CONTENT_MULT))) {
6485                     cur->c2->ocur = XML_ELEMENT_CONTENT_ONCE;
6486                     found = 1;
6487                 }
6488                 cur = cur->c2;
6489             }
6490             if (found)
6491                 ret->ocur = XML_ELEMENT_CONTENT_MULT;
6492         }
6493         NEXT;
6494     }
6495     return(ret);
6496 }
6497
6498 /**
6499  * xmlParseElementChildrenContentDecl:
6500  * @ctxt:  an XML parser context
6501  * @inputchk:  the input used for the current entity, needed for boundary checks
6502  *
6503  * parse the declaration for a Mixed Element content
6504  * The leading '(' and spaces have been skipped in xmlParseElementContentDecl
6505  *
6506  * [47] children ::= (choice | seq) ('?' | '*' | '+')?
6507  *
6508  * [48] cp ::= (Name | choice | seq) ('?' | '*' | '+')?
6509  *
6510  * [49] choice ::= '(' S? cp ( S? '|' S? cp )* S? ')'
6511  *
6512  * [50] seq ::= '(' S? cp ( S? ',' S? cp )* S? ')'
6513  *
6514  * [ VC: Proper Group/PE Nesting ] applies to [49] and [50]
6515  * TODO Parameter-entity replacement text must be properly nested
6516  *      with parenthesized groups. That is to say, if either of the
6517  *      opening or closing parentheses in a choice, seq, or Mixed
6518  *      construct is contained in the replacement text for a parameter
6519  *      entity, both must be contained in the same replacement text. For
6520  *      interoperability, if a parameter-entity reference appears in a
6521  *      choice, seq, or Mixed construct, its replacement text should not
6522  *      be empty, and neither the first nor last non-blank character of
6523  *      the replacement text should be a connector (| or ,).
6524  *
6525  * Returns the tree of xmlElementContentPtr describing the element
6526  *          hierarchy.
6527  */
6528 xmlElementContentPtr
6529 xmlParseElementChildrenContentDecl(xmlParserCtxtPtr ctxt, int inputchk) {
6530     /* stub left for API/ABI compat */
6531     return(xmlParseElementChildrenContentDeclPriv(ctxt, inputchk, 1));
6532 }
6533
6534 /**
6535  * xmlParseElementContentDecl:
6536  * @ctxt:  an XML parser context
6537  * @name:  the name of the element being defined.
6538  * @result:  the Element Content pointer will be stored here if any
6539  *
6540  * parse the declaration for an Element content either Mixed or Children,
6541  * the cases EMPTY and ANY are handled directly in xmlParseElementDecl
6542  *
6543  * [46] contentspec ::= 'EMPTY' | 'ANY' | Mixed | children
6544  *
6545  * returns: the type of element content XML_ELEMENT_TYPE_xxx
6546  */
6547
6548 int
6549 xmlParseElementContentDecl(xmlParserCtxtPtr ctxt, const xmlChar *name,
6550                            xmlElementContentPtr *result) {
6551
6552     xmlElementContentPtr tree = NULL;
6553     int inputid = ctxt->input->id;
6554     int res;
6555
6556     *result = NULL;
6557
6558     if (RAW != '(') {
6559         xmlFatalErrMsgStr(ctxt, XML_ERR_ELEMCONTENT_NOT_STARTED,
6560                 "xmlParseElementContentDecl : %s '(' expected\n", name);
6561         return(-1);
6562     }
6563     NEXT;
6564     GROW;
6565     if (ctxt->instate == XML_PARSER_EOF)
6566         return(-1);
6567     SKIP_BLANKS;
6568     if (CMP7(CUR_PTR, '#', 'P', 'C', 'D', 'A', 'T', 'A')) {
6569         tree = xmlParseElementMixedContentDecl(ctxt, inputid);
6570         res = XML_ELEMENT_TYPE_MIXED;
6571     } else {
6572         tree = xmlParseElementChildrenContentDeclPriv(ctxt, inputid, 1);
6573         res = XML_ELEMENT_TYPE_ELEMENT;
6574     }
6575     SKIP_BLANKS;
6576     *result = tree;
6577     return(res);
6578 }
6579
6580 /**
6581  * xmlParseElementDecl:
6582  * @ctxt:  an XML parser context
6583  *
6584  * parse an Element declaration.
6585  *
6586  * [45] elementdecl ::= '<!ELEMENT' S Name S contentspec S? '>'
6587  *
6588  * [ VC: Unique Element Type Declaration ]
6589  * No element type may be declared more than once
6590  *
6591  * Returns the type of the element, or -1 in case of error
6592  */
6593 int
6594 xmlParseElementDecl(xmlParserCtxtPtr ctxt) {
6595     const xmlChar *name;
6596     int ret = -1;
6597     xmlElementContentPtr content  = NULL;
6598
6599     /* GROW; done in the caller */
6600     if (CMP9(CUR_PTR, '<', '!', 'E', 'L', 'E', 'M', 'E', 'N', 'T')) {
6601         xmlParserInputPtr input = ctxt->input;
6602
6603         SKIP(9);
6604         if (!IS_BLANK_CH(CUR)) {
6605             xmlFatalErrMsg(ctxt, XML_ERR_SPACE_REQUIRED,
6606                            "Space required after 'ELEMENT'\n");
6607         }
6608         SKIP_BLANKS;
6609         name = xmlParseName(ctxt);
6610         if (name == NULL) {
6611             xmlFatalErrMsg(ctxt, XML_ERR_NAME_REQUIRED,
6612                            "xmlParseElementDecl: no name for Element\n");
6613             return(-1);
6614         }
6615         while ((RAW == 0) && (ctxt->inputNr > 1))
6616             xmlPopInput(ctxt);
6617         if (!IS_BLANK_CH(CUR)) {
6618             xmlFatalErrMsg(ctxt, XML_ERR_SPACE_REQUIRED,
6619                            "Space required after the element name\n");
6620         }
6621         SKIP_BLANKS;
6622         if (CMP5(CUR_PTR, 'E', 'M', 'P', 'T', 'Y')) {
6623             SKIP(5);
6624             /*
6625              * Element must always be empty.
6626              */
6627             ret = XML_ELEMENT_TYPE_EMPTY;
6628         } else if ((RAW == 'A') && (NXT(1) == 'N') &&
6629                    (NXT(2) == 'Y')) {
6630             SKIP(3);
6631             /*
6632              * Element is a generic container.
6633              */
6634             ret = XML_ELEMENT_TYPE_ANY;
6635         } else if (RAW == '(') {
6636             ret = xmlParseElementContentDecl(ctxt, name, &content);
6637         } else {
6638             /*
6639              * [ WFC: PEs in Internal Subset ] error handling.
6640              */
6641             if ((RAW == '%') && (ctxt->external == 0) &&
6642                 (ctxt->inputNr == 1)) {
6643                 xmlFatalErrMsg(ctxt, XML_ERR_PEREF_IN_INT_SUBSET,
6644           "PEReference: forbidden within markup decl in internal subset\n");
6645             } else {
6646                 xmlFatalErrMsg(ctxt, XML_ERR_ELEMCONTENT_NOT_STARTED,
6647                       "xmlParseElementDecl: 'EMPTY', 'ANY' or '(' expected\n");
6648             }
6649             return(-1);
6650         }
6651
6652         SKIP_BLANKS;
6653         /*
6654          * Pop-up of finished entities.
6655          */
6656         while ((RAW == 0) && (ctxt->inputNr > 1))
6657             xmlPopInput(ctxt);
6658         SKIP_BLANKS;
6659
6660         if (RAW != '>') {
6661             xmlFatalErr(ctxt, XML_ERR_GT_REQUIRED, NULL);
6662             if (content != NULL) {
6663                 xmlFreeDocElementContent(ctxt->myDoc, content);
6664             }
6665         } else {
6666             if (input != ctxt->input) {
6667                 xmlFatalErrMsg(ctxt, XML_ERR_ENTITY_BOUNDARY,
6668     "Element declaration doesn't start and stop in the same entity\n");
6669             }
6670
6671             NEXT;
6672             if ((ctxt->sax != NULL) && (!ctxt->disableSAX) &&
6673                 (ctxt->sax->elementDecl != NULL)) {
6674                 if (content != NULL)
6675                     content->parent = NULL;
6676                 ctxt->sax->elementDecl(ctxt->userData, name, ret,
6677                                        content);
6678                 if ((content != NULL) && (content->parent == NULL)) {
6679                     /*
6680                      * this is a trick: if xmlAddElementDecl is called,
6681                      * instead of copying the full tree it is plugged directly
6682                      * if called from the parser. Avoid duplicating the
6683                      * interfaces or change the API/ABI
6684                      */
6685                     xmlFreeDocElementContent(ctxt->myDoc, content);
6686                 }
6687             } else if (content != NULL) {
6688                 xmlFreeDocElementContent(ctxt->myDoc, content);
6689             }
6690         }
6691     }
6692     return(ret);
6693 }
6694
6695 /**
6696  * xmlParseConditionalSections
6697  * @ctxt:  an XML parser context
6698  *
6699  * [61] conditionalSect ::= includeSect | ignoreSect
6700  * [62] includeSect ::= '<![' S? 'INCLUDE' S? '[' extSubsetDecl ']]>'
6701  * [63] ignoreSect ::= '<![' S? 'IGNORE' S? '[' ignoreSectContents* ']]>'
6702  * [64] ignoreSectContents ::= Ignore ('<![' ignoreSectContents ']]>' Ignore)*
6703  * [65] Ignore ::= Char* - (Char* ('<![' | ']]>') Char*)
6704  */
6705
6706 static void
6707 xmlParseConditionalSections(xmlParserCtxtPtr ctxt) {
6708     int id = ctxt->input->id;
6709
6710     SKIP(3);
6711     SKIP_BLANKS;
6712     if (CMP7(CUR_PTR, 'I', 'N', 'C', 'L', 'U', 'D', 'E')) {
6713         SKIP(7);
6714         SKIP_BLANKS;
6715         if (RAW != '[') {
6716             xmlFatalErr(ctxt, XML_ERR_CONDSEC_INVALID, NULL);
6717         } else {
6718             if (ctxt->input->id != id) {
6719                 xmlValidityError(ctxt, XML_ERR_ENTITY_BOUNDARY,
6720             "All markup of the conditional section is not in the same entity\n",
6721                                      NULL, NULL);
6722             }
6723             NEXT;
6724         }
6725         if (xmlParserDebugEntities) {
6726             if ((ctxt->input != NULL) && (ctxt->input->filename))
6727                 xmlGenericError(xmlGenericErrorContext,
6728                         "%s(%d): ", ctxt->input->filename,
6729                         ctxt->input->line);
6730             xmlGenericError(xmlGenericErrorContext,
6731                     "Entering INCLUDE Conditional Section\n");
6732         }
6733
6734         while (((RAW != 0) && ((RAW != ']') || (NXT(1) != ']') ||
6735                 (NXT(2) != '>'))) && (ctxt->instate != XML_PARSER_EOF)) {
6736             const xmlChar *check = CUR_PTR;
6737             unsigned int cons = ctxt->input->consumed;
6738
6739             if ((RAW == '<') && (NXT(1) == '!') && (NXT(2) == '[')) {
6740                 xmlParseConditionalSections(ctxt);
6741             } else if (IS_BLANK_CH(CUR)) {
6742                 NEXT;
6743             } else if (RAW == '%') {
6744                 xmlParsePEReference(ctxt);
6745             } else
6746                 xmlParseMarkupDecl(ctxt);
6747
6748             /*
6749              * Pop-up of finished entities.
6750              */
6751             while ((RAW == 0) && (ctxt->inputNr > 1))
6752                 xmlPopInput(ctxt);
6753
6754             if ((CUR_PTR == check) && (cons == ctxt->input->consumed)) {
6755                 xmlFatalErr(ctxt, XML_ERR_EXT_SUBSET_NOT_FINISHED, NULL);
6756                 break;
6757             }
6758         }
6759         if (xmlParserDebugEntities) {
6760             if ((ctxt->input != NULL) && (ctxt->input->filename))
6761                 xmlGenericError(xmlGenericErrorContext,
6762                         "%s(%d): ", ctxt->input->filename,
6763                         ctxt->input->line);
6764             xmlGenericError(xmlGenericErrorContext,
6765                     "Leaving INCLUDE Conditional Section\n");
6766         }
6767
6768     } else if (CMP6(CUR_PTR, 'I', 'G', 'N', 'O', 'R', 'E')) {
6769         int state;
6770         xmlParserInputState instate;
6771         int depth = 0;
6772
6773         SKIP(6);
6774         SKIP_BLANKS;
6775         if (RAW != '[') {
6776             xmlFatalErr(ctxt, XML_ERR_CONDSEC_INVALID, NULL);
6777         } else {
6778             if (ctxt->input->id != id) {
6779                 xmlValidityError(ctxt, XML_ERR_ENTITY_BOUNDARY,
6780             "All markup of the conditional section is not in the same entity\n",
6781                                      NULL, NULL);
6782             }
6783             NEXT;
6784         }
6785         if (xmlParserDebugEntities) {
6786             if ((ctxt->input != NULL) && (ctxt->input->filename))
6787                 xmlGenericError(xmlGenericErrorContext,
6788                         "%s(%d): ", ctxt->input->filename,
6789                         ctxt->input->line);
6790             xmlGenericError(xmlGenericErrorContext,
6791                     "Entering IGNORE Conditional Section\n");
6792         }
6793
6794         /*
6795          * Parse up to the end of the conditional section
6796          * But disable SAX event generating DTD building in the meantime
6797          */
6798         state = ctxt->disableSAX;
6799         instate = ctxt->instate;
6800         if (ctxt->recovery == 0) ctxt->disableSAX = 1;
6801         ctxt->instate = XML_PARSER_IGNORE;
6802
6803         while (((depth >= 0) && (RAW != 0)) &&
6804                (ctxt->instate != XML_PARSER_EOF)) {
6805           if ((RAW == '<') && (NXT(1) == '!') && (NXT(2) == '[')) {
6806             depth++;
6807             SKIP(3);
6808             continue;
6809           }
6810           if ((RAW == ']') && (NXT(1) == ']') && (NXT(2) == '>')) {
6811             if (--depth >= 0) SKIP(3);
6812             continue;
6813           }
6814           NEXT;
6815           continue;
6816         }
6817
6818         ctxt->disableSAX = state;
6819         ctxt->instate = instate;
6820
6821         if (xmlParserDebugEntities) {
6822             if ((ctxt->input != NULL) && (ctxt->input->filename))
6823                 xmlGenericError(xmlGenericErrorContext,
6824                         "%s(%d): ", ctxt->input->filename,
6825                         ctxt->input->line);
6826             xmlGenericError(xmlGenericErrorContext,
6827                     "Leaving IGNORE Conditional Section\n");
6828         }
6829
6830     } else {
6831         xmlFatalErr(ctxt, XML_ERR_CONDSEC_INVALID_KEYWORD, NULL);
6832     }
6833
6834     if (RAW == 0)
6835         SHRINK;
6836
6837     if (RAW == 0) {
6838         xmlFatalErr(ctxt, XML_ERR_CONDSEC_NOT_FINISHED, NULL);
6839     } else {
6840         if (ctxt->input->id != id) {
6841             xmlValidityError(ctxt, XML_ERR_ENTITY_BOUNDARY,
6842         "All markup of the conditional section is not in the same entity\n",
6843                                  NULL, NULL);
6844         }
6845         SKIP(3);
6846     }
6847 }
6848
6849 /**
6850  * xmlParseMarkupDecl:
6851  * @ctxt:  an XML parser context
6852  *
6853  * parse Markup declarations
6854  *
6855  * [29] markupdecl ::= elementdecl | AttlistDecl | EntityDecl |
6856  *                     NotationDecl | PI | Comment
6857  *
6858  * [ VC: Proper Declaration/PE Nesting ]
6859  * Parameter-entity replacement text must be properly nested with
6860  * markup declarations. That is to say, if either the first character
6861  * or the last character of a markup declaration (markupdecl above) is
6862  * contained in the replacement text for a parameter-entity reference,
6863  * both must be contained in the same replacement text.
6864  *
6865  * [ WFC: PEs in Internal Subset ]
6866  * In the internal DTD subset, parameter-entity references can occur
6867  * only where markup declarations can occur, not within markup declarations.
6868  * (This does not apply to references that occur in external parameter
6869  * entities or to the external subset.)
6870  */
6871 void
6872 xmlParseMarkupDecl(xmlParserCtxtPtr ctxt) {
6873     GROW;
6874     if (CUR == '<') {
6875         if (NXT(1) == '!') {
6876             switch (NXT(2)) {
6877                 case 'E':
6878                     if (NXT(3) == 'L')
6879                         xmlParseElementDecl(ctxt);
6880                     else if (NXT(3) == 'N')
6881                         xmlParseEntityDecl(ctxt);
6882                     break;
6883                 case 'A':
6884                     xmlParseAttributeListDecl(ctxt);
6885                     break;
6886                 case 'N':
6887                     xmlParseNotationDecl(ctxt);
6888                     break;
6889                 case '-':
6890                     xmlParseComment(ctxt);
6891                     break;
6892                 default:
6893                     /* there is an error but it will be detected later */
6894                     break;
6895             }
6896         } else if (NXT(1) == '?') {
6897             xmlParsePI(ctxt);
6898         }
6899     }
6900     /*
6901      * This is only for internal subset. On external entities,
6902      * the replacement is done before parsing stage
6903      */
6904     if ((ctxt->external == 0) && (ctxt->inputNr == 1))
6905         xmlParsePEReference(ctxt);
6906
6907     /*
6908      * Conditional sections are allowed from entities included
6909      * by PE References in the internal subset.
6910      */
6911     if ((ctxt->external == 0) && (ctxt->inputNr > 1)) {
6912         if ((RAW == '<') && (NXT(1) == '!') && (NXT(2) == '[')) {
6913             xmlParseConditionalSections(ctxt);
6914         }
6915     }
6916
6917     ctxt->instate = XML_PARSER_DTD;
6918 }
6919
6920 /**
6921  * xmlParseTextDecl:
6922  * @ctxt:  an XML parser context
6923  *
6924  * parse an XML declaration header for external entities
6925  *
6926  * [77] TextDecl ::= '<?xml' VersionInfo? EncodingDecl S? '?>'
6927  */
6928
6929 void
6930 xmlParseTextDecl(xmlParserCtxtPtr ctxt) {
6931     xmlChar *version;
6932     const xmlChar *encoding;
6933
6934     /*
6935      * We know that '<?xml' is here.
6936      */
6937     if ((CMP5(CUR_PTR, '<', '?', 'x', 'm', 'l')) && (IS_BLANK_CH(NXT(5)))) {
6938         SKIP(5);
6939     } else {
6940         xmlFatalErr(ctxt, XML_ERR_XMLDECL_NOT_STARTED, NULL);
6941         return;
6942     }
6943
6944     if (!IS_BLANK_CH(CUR)) {
6945         xmlFatalErrMsg(ctxt, XML_ERR_SPACE_REQUIRED,
6946                        "Space needed after '<?xml'\n");
6947     }
6948     SKIP_BLANKS;
6949
6950     /*
6951      * We may have the VersionInfo here.
6952      */
6953     version = xmlParseVersionInfo(ctxt);
6954     if (version == NULL)
6955         version = xmlCharStrdup(XML_DEFAULT_VERSION);
6956     else {
6957         if (!IS_BLANK_CH(CUR)) {
6958             xmlFatalErrMsg(ctxt, XML_ERR_SPACE_REQUIRED,
6959                            "Space needed here\n");
6960         }
6961     }
6962     ctxt->input->version = version;
6963
6964     /*
6965      * We must have the encoding declaration
6966      */
6967     encoding = xmlParseEncodingDecl(ctxt);
6968     if (ctxt->errNo == XML_ERR_UNSUPPORTED_ENCODING) {
6969         /*
6970          * The XML REC instructs us to stop parsing right here
6971          */
6972         return;
6973     }
6974     if ((encoding == NULL) && (ctxt->errNo == XML_ERR_OK)) {
6975         xmlFatalErrMsg(ctxt, XML_ERR_MISSING_ENCODING,
6976                        "Missing encoding in text declaration\n");
6977     }
6978
6979     SKIP_BLANKS;
6980     if ((RAW == '?') && (NXT(1) == '>')) {
6981         SKIP(2);
6982     } else if (RAW == '>') {
6983         /* Deprecated old WD ... */
6984         xmlFatalErr(ctxt, XML_ERR_XMLDECL_NOT_FINISHED, NULL);
6985         NEXT;
6986     } else {
6987         xmlFatalErr(ctxt, XML_ERR_XMLDECL_NOT_FINISHED, NULL);
6988         MOVETO_ENDTAG(CUR_PTR);
6989         NEXT;
6990     }
6991 }
6992
6993 /**
6994  * xmlParseExternalSubset:
6995  * @ctxt:  an XML parser context
6996  * @ExternalID: the external identifier
6997  * @SystemID: the system identifier (or URL)
6998  *
6999  * parse Markup declarations from an external subset
7000  *
7001  * [30] extSubset ::= textDecl? extSubsetDecl
7002  *
7003  * [31] extSubsetDecl ::= (markupdecl | conditionalSect | PEReference | S) *
7004  */
7005 void
7006 xmlParseExternalSubset(xmlParserCtxtPtr ctxt, const xmlChar *ExternalID,
7007                        const xmlChar *SystemID) {
7008     xmlDetectSAX2(ctxt);
7009     GROW;
7010
7011     if ((ctxt->encoding == NULL) &&
7012         (ctxt->input->end - ctxt->input->cur >= 4)) {
7013         xmlChar start[4];
7014         xmlCharEncoding enc;
7015
7016         start[0] = RAW;
7017         start[1] = NXT(1);
7018         start[2] = NXT(2);
7019         start[3] = NXT(3);
7020         enc = xmlDetectCharEncoding(start, 4);
7021         if (enc != XML_CHAR_ENCODING_NONE)
7022             xmlSwitchEncoding(ctxt, enc);
7023     }
7024
7025     if (CMP5(CUR_PTR, '<', '?', 'x', 'm', 'l')) {
7026         xmlParseTextDecl(ctxt);
7027         if (ctxt->errNo == XML_ERR_UNSUPPORTED_ENCODING) {
7028             /*
7029              * The XML REC instructs us to stop parsing right here
7030              */
7031             ctxt->instate = XML_PARSER_EOF;
7032             return;
7033         }
7034     }
7035     if (ctxt->myDoc == NULL) {
7036         ctxt->myDoc = xmlNewDoc(BAD_CAST "1.0");
7037         if (ctxt->myDoc == NULL) {
7038             xmlErrMemory(ctxt, "New Doc failed");
7039             return;
7040         }
7041         ctxt->myDoc->properties = XML_DOC_INTERNAL;
7042     }
7043     if ((ctxt->myDoc != NULL) && (ctxt->myDoc->intSubset == NULL))
7044         xmlCreateIntSubset(ctxt->myDoc, NULL, ExternalID, SystemID);
7045
7046     ctxt->instate = XML_PARSER_DTD;
7047     ctxt->external = 1;
7048     while (((RAW == '<') && (NXT(1) == '?')) ||
7049            ((RAW == '<') && (NXT(1) == '!')) ||
7050            (RAW == '%') || IS_BLANK_CH(CUR)) {
7051         const xmlChar *check = CUR_PTR;
7052         unsigned int cons = ctxt->input->consumed;
7053
7054         GROW;
7055         if ((RAW == '<') && (NXT(1) == '!') && (NXT(2) == '[')) {
7056             xmlParseConditionalSections(ctxt);
7057         } else if (IS_BLANK_CH(CUR)) {
7058             NEXT;
7059         } else if (RAW == '%') {
7060             xmlParsePEReference(ctxt);
7061         } else
7062             xmlParseMarkupDecl(ctxt);
7063
7064         /*
7065          * Pop-up of finished entities.
7066          */
7067         while ((RAW == 0) && (ctxt->inputNr > 1))
7068             xmlPopInput(ctxt);
7069
7070         if ((CUR_PTR == check) && (cons == ctxt->input->consumed)) {
7071             xmlFatalErr(ctxt, XML_ERR_EXT_SUBSET_NOT_FINISHED, NULL);
7072             break;
7073         }
7074     }
7075
7076     if (RAW != 0) {
7077         xmlFatalErr(ctxt, XML_ERR_EXT_SUBSET_NOT_FINISHED, NULL);
7078     }
7079
7080 }
7081
7082 /**
7083  * xmlParseReference:
7084  * @ctxt:  an XML parser context
7085  *
7086  * parse and handle entity references in content, depending on the SAX
7087  * interface, this may end-up in a call to character() if this is a
7088  * CharRef, a predefined entity, if there is no reference() callback.
7089  * or if the parser was asked to switch to that mode.
7090  *
7091  * [67] Reference ::= EntityRef | CharRef
7092  */
7093 void
7094 xmlParseReference(xmlParserCtxtPtr ctxt) {
7095     xmlEntityPtr ent;
7096     xmlChar *val;
7097     int was_checked;
7098     xmlNodePtr list = NULL;
7099     xmlParserErrors ret = XML_ERR_OK;
7100
7101
7102     if (RAW != '&')
7103         return;
7104
7105     /*
7106      * Simple case of a CharRef
7107      */
7108     if (NXT(1) == '#') {
7109         int i = 0;
7110         xmlChar out[10];
7111         int hex = NXT(2);
7112         int value = xmlParseCharRef(ctxt);
7113
7114         if (value == 0)
7115             return;
7116         if (ctxt->charset != XML_CHAR_ENCODING_UTF8) {
7117             /*
7118              * So we are using non-UTF-8 buffers
7119              * Check that the char fit on 8bits, if not
7120              * generate a CharRef.
7121              */
7122             if (value <= 0xFF) {
7123                 out[0] = value;
7124                 out[1] = 0;
7125                 if ((ctxt->sax != NULL) && (ctxt->sax->characters != NULL) &&
7126                     (!ctxt->disableSAX))
7127                     ctxt->sax->characters(ctxt->userData, out, 1);
7128             } else {
7129                 if ((hex == 'x') || (hex == 'X'))
7130                     snprintf((char *)out, sizeof(out), "#x%X", value);
7131                 else
7132                     snprintf((char *)out, sizeof(out), "#%d", value);
7133                 if ((ctxt->sax != NULL) && (ctxt->sax->reference != NULL) &&
7134                     (!ctxt->disableSAX))
7135                     ctxt->sax->reference(ctxt->userData, out);
7136             }
7137         } else {
7138             /*
7139              * Just encode the value in UTF-8
7140              */
7141             COPY_BUF(0 ,out, i, value);
7142             out[i] = 0;
7143             if ((ctxt->sax != NULL) && (ctxt->sax->characters != NULL) &&
7144                 (!ctxt->disableSAX))
7145                 ctxt->sax->characters(ctxt->userData, out, i);
7146         }
7147         return;
7148     }
7149
7150     /*
7151      * We are seeing an entity reference
7152      */
7153     ent = xmlParseEntityRef(ctxt);
7154     if (ent == NULL) return;
7155     if (!ctxt->wellFormed)
7156         return;
7157     was_checked = ent->checked;
7158
7159     /* special case of predefined entities */
7160     if ((ent->name == NULL) ||
7161         (ent->etype == XML_INTERNAL_PREDEFINED_ENTITY)) {
7162         val = ent->content;
7163         if (val == NULL) return;
7164         /*
7165          * inline the entity.
7166          */
7167         if ((ctxt->sax != NULL) && (ctxt->sax->characters != NULL) &&
7168             (!ctxt->disableSAX))
7169             ctxt->sax->characters(ctxt->userData, val, xmlStrlen(val));
7170         return;
7171     }
7172
7173     /*
7174      * The first reference to the entity trigger a parsing phase
7175      * where the ent->children is filled with the result from
7176      * the parsing.
7177      * Note: external parsed entities will not be loaded, it is not
7178      * required for a non-validating parser, unless the parsing option
7179      * of validating, or substituting entities were given. Doing so is
7180      * far more secure as the parser will only process data coming from
7181      * the document entity by default.
7182      */
7183     if ((ent->checked == 0) &&
7184         ((ent->etype != XML_EXTERNAL_GENERAL_PARSED_ENTITY) ||
7185          (ctxt->options & (XML_PARSE_NOENT | XML_PARSE_DTDVALID)))) {
7186         unsigned long oldnbent = ctxt->nbentities;
7187
7188         /*
7189          * This is a bit hackish but this seems the best
7190          * way to make sure both SAX and DOM entity support
7191          * behaves okay.
7192          */
7193         void *user_data;
7194         if (ctxt->userData == ctxt)
7195             user_data = NULL;
7196         else
7197             user_data = ctxt->userData;
7198
7199         /*
7200          * Check that this entity is well formed
7201          * 4.3.2: An internal general parsed entity is well-formed
7202          * if its replacement text matches the production labeled
7203          * content.
7204          */
7205         if (ent->etype == XML_INTERNAL_GENERAL_ENTITY) {
7206             ctxt->depth++;
7207             ret = xmlParseBalancedChunkMemoryInternal(ctxt, ent->content,
7208                                                       user_data, &list);
7209             ctxt->depth--;
7210
7211         } else if (ent->etype == XML_EXTERNAL_GENERAL_PARSED_ENTITY) {
7212             ctxt->depth++;
7213             ret = xmlParseExternalEntityPrivate(ctxt->myDoc, ctxt, ctxt->sax,
7214                                            user_data, ctxt->depth, ent->URI,
7215                                            ent->ExternalID, &list);
7216             ctxt->depth--;
7217         } else {
7218             ret = XML_ERR_ENTITY_PE_INTERNAL;
7219             xmlErrMsgStr(ctxt, XML_ERR_INTERNAL_ERROR,
7220                          "invalid entity type found\n", NULL);
7221         }
7222
7223         /*
7224          * Store the number of entities needing parsing for this entity
7225          * content and do checkings
7226          */
7227         ent->checked = (ctxt->nbentities - oldnbent + 1) * 2;
7228         if ((ent->content != NULL) && (xmlStrchr(ent->content, '<')))
7229             ent->checked |= 1;
7230         if (ret == XML_ERR_ENTITY_LOOP) {
7231             xmlFatalErr(ctxt, XML_ERR_ENTITY_LOOP, NULL);
7232             xmlFreeNodeList(list);
7233             return;
7234         }
7235         if (xmlParserEntityCheck(ctxt, 0, ent, 0)) {
7236             xmlFreeNodeList(list);
7237             return;
7238         }
7239
7240         if ((ret == XML_ERR_OK) && (list != NULL)) {
7241             if (((ent->etype == XML_INTERNAL_GENERAL_ENTITY) ||
7242              (ent->etype == XML_EXTERNAL_GENERAL_PARSED_ENTITY))&&
7243                 (ent->children == NULL)) {
7244                 ent->children = list;
7245                 if (ctxt->replaceEntities) {
7246                     /*
7247                      * Prune it directly in the generated document
7248                      * except for single text nodes.
7249                      */
7250                     if (((list->type == XML_TEXT_NODE) &&
7251                          (list->next == NULL)) ||
7252                         (ctxt->parseMode == XML_PARSE_READER)) {
7253                         list->parent = (xmlNodePtr) ent;
7254                         list = NULL;
7255                         ent->owner = 1;
7256                     } else {
7257                         ent->owner = 0;
7258                         while (list != NULL) {
7259                             list->parent = (xmlNodePtr) ctxt->node;
7260                             list->doc = ctxt->myDoc;
7261                             if (list->next == NULL)
7262                                 ent->last = list;
7263                             list = list->next;
7264                         }
7265                         list = ent->children;
7266 #ifdef LIBXML_LEGACY_ENABLED
7267                         if (ent->etype == XML_EXTERNAL_GENERAL_PARSED_ENTITY)
7268                           xmlAddEntityReference(ent, list, NULL);
7269 #endif /* LIBXML_LEGACY_ENABLED */
7270                     }
7271                 } else {
7272                     ent->owner = 1;
7273                     while (list != NULL) {
7274                         list->parent = (xmlNodePtr) ent;
7275                         xmlSetTreeDoc(list, ent->doc);
7276                         if (list->next == NULL)
7277                             ent->last = list;
7278                         list = list->next;
7279                     }
7280                 }
7281             } else {
7282                 xmlFreeNodeList(list);
7283                 list = NULL;
7284             }
7285         } else if ((ret != XML_ERR_OK) &&
7286                    (ret != XML_WAR_UNDECLARED_ENTITY)) {
7287             xmlFatalErrMsgStr(ctxt, XML_ERR_UNDECLARED_ENTITY,
7288                      "Entity '%s' failed to parse\n", ent->name);
7289         } else if (list != NULL) {
7290             xmlFreeNodeList(list);
7291             list = NULL;
7292         }
7293         if (ent->checked == 0)
7294             ent->checked = 2;
7295     } else if (ent->checked != 1) {
7296         ctxt->nbentities += ent->checked / 2;
7297     }
7298
7299     /*
7300      * Now that the entity content has been gathered
7301      * provide it to the application, this can take different forms based
7302      * on the parsing modes.
7303      */
7304     if (ent->children == NULL) {
7305         /*
7306          * Probably running in SAX mode and the callbacks don't
7307          * build the entity content. So unless we already went
7308          * though parsing for first checking go though the entity
7309          * content to generate callbacks associated to the entity
7310          */
7311         if (was_checked != 0) {
7312             void *user_data;
7313             /*
7314              * This is a bit hackish but this seems the best
7315              * way to make sure both SAX and DOM entity support
7316              * behaves okay.
7317              */
7318             if (ctxt->userData == ctxt)
7319                 user_data = NULL;
7320             else
7321                 user_data = ctxt->userData;
7322
7323             if (ent->etype == XML_INTERNAL_GENERAL_ENTITY) {
7324                 ctxt->depth++;
7325                 ret = xmlParseBalancedChunkMemoryInternal(ctxt,
7326                                    ent->content, user_data, NULL);
7327                 ctxt->depth--;
7328             } else if (ent->etype ==
7329                        XML_EXTERNAL_GENERAL_PARSED_ENTITY) {
7330                 ctxt->depth++;
7331                 ret = xmlParseExternalEntityPrivate(ctxt->myDoc, ctxt,
7332                            ctxt->sax, user_data, ctxt->depth,
7333                            ent->URI, ent->ExternalID, NULL);
7334                 ctxt->depth--;
7335             } else {
7336                 ret = XML_ERR_ENTITY_PE_INTERNAL;
7337                 xmlErrMsgStr(ctxt, XML_ERR_INTERNAL_ERROR,
7338                              "invalid entity type found\n", NULL);
7339             }
7340             if (ret == XML_ERR_ENTITY_LOOP) {
7341                 xmlFatalErr(ctxt, XML_ERR_ENTITY_LOOP, NULL);
7342                 return;
7343             }
7344         }
7345         if ((ctxt->sax != NULL) && (ctxt->sax->reference != NULL) &&
7346             (ctxt->replaceEntities == 0) && (!ctxt->disableSAX)) {
7347             /*
7348              * Entity reference callback comes second, it's somewhat
7349              * superfluous but a compatibility to historical behaviour
7350              */
7351             ctxt->sax->reference(ctxt->userData, ent->name);
7352         }
7353         return;
7354     }
7355
7356     /*
7357      * If we didn't get any children for the entity being built
7358      */
7359     if ((ctxt->sax != NULL) && (ctxt->sax->reference != NULL) &&
7360         (ctxt->replaceEntities == 0) && (!ctxt->disableSAX)) {
7361         /*
7362          * Create a node.
7363          */
7364         ctxt->sax->reference(ctxt->userData, ent->name);
7365         return;
7366     }
7367
7368     if ((ctxt->replaceEntities) || (ent->children == NULL))  {
7369         /*
7370          * There is a problem on the handling of _private for entities
7371          * (bug 155816): Should we copy the content of the field from
7372          * the entity (possibly overwriting some value set by the user
7373          * when a copy is created), should we leave it alone, or should
7374          * we try to take care of different situations?  The problem
7375          * is exacerbated by the usage of this field by the xmlReader.
7376          * To fix this bug, we look at _private on the created node
7377          * and, if it's NULL, we copy in whatever was in the entity.
7378          * If it's not NULL we leave it alone.  This is somewhat of a
7379          * hack - maybe we should have further tests to determine
7380          * what to do.
7381          */
7382         if ((ctxt->node != NULL) && (ent->children != NULL)) {
7383             /*
7384              * Seems we are generating the DOM content, do
7385              * a simple tree copy for all references except the first
7386              * In the first occurrence list contains the replacement.
7387              */
7388             if (((list == NULL) && (ent->owner == 0)) ||
7389                 (ctxt->parseMode == XML_PARSE_READER)) {
7390                 xmlNodePtr nw = NULL, cur, firstChild = NULL;
7391
7392                 /*
7393                  * We are copying here, make sure there is no abuse
7394                  */
7395                 ctxt->sizeentcopy += ent->length;
7396                 if (xmlParserEntityCheck(ctxt, 0, ent, ctxt->sizeentcopy))
7397                     return;
7398
7399                 /*
7400                  * when operating on a reader, the entities definitions
7401                  * are always owning the entities subtree.
7402                 if (ctxt->parseMode == XML_PARSE_READER)
7403                     ent->owner = 1;
7404                  */
7405
7406                 cur = ent->children;
7407                 while (cur != NULL) {
7408                     nw = xmlDocCopyNode(cur, ctxt->myDoc, 1);
7409                     if (nw != NULL) {
7410                         if (nw->_private == NULL)
7411                             nw->_private = cur->_private;
7412                         if (firstChild == NULL){
7413                             firstChild = nw;
7414                         }
7415                         nw = xmlAddChild(ctxt->node, nw);
7416                     }
7417                     if (cur == ent->last) {
7418                         /*
7419                          * needed to detect some strange empty
7420                          * node cases in the reader tests
7421                          */
7422                         if ((ctxt->parseMode == XML_PARSE_READER) &&
7423                             (nw != NULL) &&
7424                             (nw->type == XML_ELEMENT_NODE) &&
7425                             (nw->children == NULL))
7426                             nw->extra = 1;
7427
7428                         break;
7429                     }
7430                     cur = cur->next;
7431                 }
7432 #ifdef LIBXML_LEGACY_ENABLED
7433                 if (ent->etype == XML_EXTERNAL_GENERAL_PARSED_ENTITY)
7434                   xmlAddEntityReference(ent, firstChild, nw);
7435 #endif /* LIBXML_LEGACY_ENABLED */
7436             } else if ((list == NULL) || (ctxt->inputNr > 0)) {
7437                 xmlNodePtr nw = NULL, cur, next, last,
7438                            firstChild = NULL;
7439
7440                 /*
7441                  * We are copying here, make sure there is no abuse
7442                  */
7443                 ctxt->sizeentcopy += ent->length;
7444                 if (xmlParserEntityCheck(ctxt, 0, ent, ctxt->sizeentcopy))
7445                     return;
7446
7447                 /*
7448                  * Copy the entity child list and make it the new
7449                  * entity child list. The goal is to make sure any
7450                  * ID or REF referenced will be the one from the
7451                  * document content and not the entity copy.
7452                  */
7453                 cur = ent->children;
7454                 ent->children = NULL;
7455                 last = ent->last;
7456                 ent->last = NULL;
7457                 while (cur != NULL) {
7458                     next = cur->next;
7459                     cur->next = NULL;
7460                     cur->parent = NULL;
7461                     nw = xmlDocCopyNode(cur, ctxt->myDoc, 1);
7462                     if (nw != NULL) {
7463                         if (nw->_private == NULL)
7464                             nw->_private = cur->_private;
7465                         if (firstChild == NULL){
7466                             firstChild = cur;
7467                         }
7468                         xmlAddChild((xmlNodePtr) ent, nw);
7469                         xmlAddChild(ctxt->node, cur);
7470                     }
7471                     if (cur == last)
7472                         break;
7473                     cur = next;
7474                 }
7475                 if (ent->owner == 0)
7476                     ent->owner = 1;
7477 #ifdef LIBXML_LEGACY_ENABLED
7478                 if (ent->etype == XML_EXTERNAL_GENERAL_PARSED_ENTITY)
7479                   xmlAddEntityReference(ent, firstChild, nw);
7480 #endif /* LIBXML_LEGACY_ENABLED */
7481             } else {
7482                 const xmlChar *nbktext;
7483
7484                 /*
7485                  * the name change is to avoid coalescing of the
7486                  * node with a possible previous text one which
7487                  * would make ent->children a dangling pointer
7488                  */
7489                 nbktext = xmlDictLookup(ctxt->dict, BAD_CAST "nbktext",
7490                                         -1);
7491                 if (ent->children->type == XML_TEXT_NODE)
7492                     ent->children->name = nbktext;
7493                 if ((ent->last != ent->children) &&
7494                     (ent->last->type == XML_TEXT_NODE))
7495                     ent->last->name = nbktext;
7496                 xmlAddChildList(ctxt->node, ent->children);
7497             }
7498
7499             /*
7500              * This is to avoid a nasty side effect, see
7501              * characters() in SAX.c
7502              */
7503             ctxt->nodemem = 0;
7504             ctxt->nodelen = 0;
7505             return;
7506         }
7507     }
7508 }
7509
7510 /**
7511  * xmlParseEntityRef:
7512  * @ctxt:  an XML parser context
7513  *
7514  * parse ENTITY references declarations
7515  *
7516  * [68] EntityRef ::= '&' Name ';'
7517  *
7518  * [ WFC: Entity Declared ]
7519  * In a document without any DTD, a document with only an internal DTD
7520  * subset which contains no parameter entity references, or a document
7521  * with "standalone='yes'", the Name given in the entity reference
7522  * must match that in an entity declaration, except that well-formed
7523  * documents need not declare any of the following entities: amp, lt,
7524  * gt, apos, quot.  The declaration of a parameter entity must precede
7525  * any reference to it.  Similarly, the declaration of a general entity
7526  * must precede any reference to it which appears in a default value in an
7527  * attribute-list declaration. Note that if entities are declared in the
7528  * external subset or in external parameter entities, a non-validating
7529  * processor is not obligated to read and process their declarations;
7530  * for such documents, the rule that an entity must be declared is a
7531  * well-formedness constraint only if standalone='yes'.
7532  *
7533  * [ WFC: Parsed Entity ]
7534  * An entity reference must not contain the name of an unparsed entity
7535  *
7536  * Returns the xmlEntityPtr if found, or NULL otherwise.
7537  */
7538 xmlEntityPtr
7539 xmlParseEntityRef(xmlParserCtxtPtr ctxt) {
7540     const xmlChar *name;
7541     xmlEntityPtr ent = NULL;
7542
7543     GROW;
7544     if (ctxt->instate == XML_PARSER_EOF)
7545         return(NULL);
7546
7547     if (RAW != '&')
7548         return(NULL);
7549     NEXT;
7550     name = xmlParseName(ctxt);
7551     if (name == NULL) {
7552         xmlFatalErrMsg(ctxt, XML_ERR_NAME_REQUIRED,
7553                        "xmlParseEntityRef: no name\n");
7554         return(NULL);
7555     }
7556     if (RAW != ';') {
7557         xmlFatalErr(ctxt, XML_ERR_ENTITYREF_SEMICOL_MISSING, NULL);
7558         return(NULL);
7559     }
7560     NEXT;
7561
7562     /*
7563      * Predefined entities override any extra definition
7564      */
7565     if ((ctxt->options & XML_PARSE_OLDSAX) == 0) {
7566         ent = xmlGetPredefinedEntity(name);
7567         if (ent != NULL)
7568             return(ent);
7569     }
7570
7571     /*
7572      * Increase the number of entity references parsed
7573      */
7574     ctxt->nbentities++;
7575
7576     /*
7577      * Ask first SAX for entity resolution, otherwise try the
7578      * entities which may have stored in the parser context.
7579      */
7580     if (ctxt->sax != NULL) {
7581         if (ctxt->sax->getEntity != NULL)
7582             ent = ctxt->sax->getEntity(ctxt->userData, name);
7583         if ((ctxt->wellFormed == 1 ) && (ent == NULL) &&
7584             (ctxt->options & XML_PARSE_OLDSAX))
7585             ent = xmlGetPredefinedEntity(name);
7586         if ((ctxt->wellFormed == 1 ) && (ent == NULL) &&
7587             (ctxt->userData==ctxt)) {
7588             ent = xmlSAX2GetEntity(ctxt, name);
7589         }
7590     }
7591     if (ctxt->instate == XML_PARSER_EOF)
7592         return(NULL);
7593     /*
7594      * [ WFC: Entity Declared ]
7595      * In a document without any DTD, a document with only an
7596      * internal DTD subset which contains no parameter entity
7597      * references, or a document with "standalone='yes'", the
7598      * Name given in the entity reference must match that in an
7599      * entity declaration, except that well-formed documents
7600      * need not declare any of the following entities: amp, lt,
7601      * gt, apos, quot.
7602      * The declaration of a parameter entity must precede any
7603      * reference to it.
7604      * Similarly, the declaration of a general entity must
7605      * precede any reference to it which appears in a default
7606      * value in an attribute-list declaration. Note that if
7607      * entities are declared in the external subset or in
7608      * external parameter entities, a non-validating processor
7609      * is not obligated to read and process their declarations;
7610      * for such documents, the rule that an entity must be
7611      * declared is a well-formedness constraint only if
7612      * standalone='yes'.
7613      */
7614     if (ent == NULL) {
7615         if ((ctxt->standalone == 1) ||
7616             ((ctxt->hasExternalSubset == 0) &&
7617              (ctxt->hasPErefs == 0))) {
7618             xmlFatalErrMsgStr(ctxt, XML_ERR_UNDECLARED_ENTITY,
7619                      "Entity '%s' not defined\n", name);
7620         } else {
7621             xmlErrMsgStr(ctxt, XML_WAR_UNDECLARED_ENTITY,
7622                      "Entity '%s' not defined\n", name);
7623             if ((ctxt->inSubset == 0) &&
7624                 (ctxt->sax != NULL) &&
7625                 (ctxt->sax->reference != NULL)) {
7626                 ctxt->sax->reference(ctxt->userData, name);
7627             }
7628         }
7629         ctxt->valid = 0;
7630     }
7631
7632     /*
7633      * [ WFC: Parsed Entity ]
7634      * An entity reference must not contain the name of an
7635      * unparsed entity
7636      */
7637     else if (ent->etype == XML_EXTERNAL_GENERAL_UNPARSED_ENTITY) {
7638         xmlFatalErrMsgStr(ctxt, XML_ERR_UNPARSED_ENTITY,
7639                  "Entity reference to unparsed entity %s\n", name);
7640     }
7641
7642     /*
7643      * [ WFC: No External Entity References ]
7644      * Attribute values cannot contain direct or indirect
7645      * entity references to external entities.
7646      */
7647     else if ((ctxt->instate == XML_PARSER_ATTRIBUTE_VALUE) &&
7648              (ent->etype == XML_EXTERNAL_GENERAL_PARSED_ENTITY)) {
7649         xmlFatalErrMsgStr(ctxt, XML_ERR_ENTITY_IS_EXTERNAL,
7650              "Attribute references external entity '%s'\n", name);
7651     }
7652     /*
7653      * [ WFC: No < in Attribute Values ]
7654      * The replacement text of any entity referred to directly or
7655      * indirectly in an attribute value (other than "&lt;") must
7656      * not contain a <.
7657      */
7658     else if ((ctxt->instate == XML_PARSER_ATTRIBUTE_VALUE) &&
7659              (ent != NULL) &&
7660              (ent->etype != XML_INTERNAL_PREDEFINED_ENTITY)) {
7661         if ((ent->checked & 1) || ((ent->checked == 0) &&
7662              (ent->content != NULL) &&(xmlStrchr(ent->content, '<')))) {
7663             xmlFatalErrMsgStr(ctxt, XML_ERR_LT_IN_ATTRIBUTE,
7664         "'<' in entity '%s' is not allowed in attributes values\n", name);
7665         }
7666     }
7667
7668     /*
7669      * Internal check, no parameter entities here ...
7670      */
7671     else {
7672         switch (ent->etype) {
7673             case XML_INTERNAL_PARAMETER_ENTITY:
7674             case XML_EXTERNAL_PARAMETER_ENTITY:
7675             xmlFatalErrMsgStr(ctxt, XML_ERR_ENTITY_IS_PARAMETER,
7676              "Attempt to reference the parameter entity '%s'\n",
7677                               name);
7678             break;
7679             default:
7680             break;
7681         }
7682     }
7683
7684     /*
7685      * [ WFC: No Recursion ]
7686      * A parsed entity must not contain a recursive reference
7687      * to itself, either directly or indirectly.
7688      * Done somewhere else
7689      */
7690     return(ent);
7691 }
7692
7693 /**
7694  * xmlParseStringEntityRef:
7695  * @ctxt:  an XML parser context
7696  * @str:  a pointer to an index in the string
7697  *
7698  * parse ENTITY references declarations, but this version parses it from
7699  * a string value.
7700  *
7701  * [68] EntityRef ::= '&' Name ';'
7702  *
7703  * [ WFC: Entity Declared ]
7704  * In a document without any DTD, a document with only an internal DTD
7705  * subset which contains no parameter entity references, or a document
7706  * with "standalone='yes'", the Name given in the entity reference
7707  * must match that in an entity declaration, except that well-formed
7708  * documents need not declare any of the following entities: amp, lt,
7709  * gt, apos, quot.  The declaration of a parameter entity must precede
7710  * any reference to it.  Similarly, the declaration of a general entity
7711  * must precede any reference to it which appears in a default value in an
7712  * attribute-list declaration. Note that if entities are declared in the
7713  * external subset or in external parameter entities, a non-validating
7714  * processor is not obligated to read and process their declarations;
7715  * for such documents, the rule that an entity must be declared is a
7716  * well-formedness constraint only if standalone='yes'.
7717  *
7718  * [ WFC: Parsed Entity ]
7719  * An entity reference must not contain the name of an unparsed entity
7720  *
7721  * Returns the xmlEntityPtr if found, or NULL otherwise. The str pointer
7722  * is updated to the current location in the string.
7723  */
7724 static xmlEntityPtr
7725 xmlParseStringEntityRef(xmlParserCtxtPtr ctxt, const xmlChar ** str) {
7726     xmlChar *name;
7727     const xmlChar *ptr;
7728     xmlChar cur;
7729     xmlEntityPtr ent = NULL;
7730
7731     if ((str == NULL) || (*str == NULL))
7732         return(NULL);
7733     ptr = *str;
7734     cur = *ptr;
7735     if (cur != '&')
7736         return(NULL);
7737
7738     ptr++;
7739     name = xmlParseStringName(ctxt, &ptr);
7740     if (name == NULL) {
7741         xmlFatalErrMsg(ctxt, XML_ERR_NAME_REQUIRED,
7742                        "xmlParseStringEntityRef: no name\n");
7743         *str = ptr;
7744         return(NULL);
7745     }
7746     if (*ptr != ';') {
7747         xmlFatalErr(ctxt, XML_ERR_ENTITYREF_SEMICOL_MISSING, NULL);
7748         xmlFree(name);
7749         *str = ptr;
7750         return(NULL);
7751     }
7752     ptr++;
7753
7754
7755     /*
7756      * Predefined entites override any extra definition
7757      */
7758     if ((ctxt->options & XML_PARSE_OLDSAX) == 0) {
7759         ent = xmlGetPredefinedEntity(name);
7760         if (ent != NULL) {
7761             xmlFree(name);
7762             *str = ptr;
7763             return(ent);
7764         }
7765     }
7766
7767     /*
7768      * Increate the number of entity references parsed
7769      */
7770     ctxt->nbentities++;
7771
7772     /*
7773      * Ask first SAX for entity resolution, otherwise try the
7774      * entities which may have stored in the parser context.
7775      */
7776     if (ctxt->sax != NULL) {
7777         if (ctxt->sax->getEntity != NULL)
7778             ent = ctxt->sax->getEntity(ctxt->userData, name);
7779         if ((ent == NULL) && (ctxt->options & XML_PARSE_OLDSAX))
7780             ent = xmlGetPredefinedEntity(name);
7781         if ((ent == NULL) && (ctxt->userData==ctxt)) {
7782             ent = xmlSAX2GetEntity(ctxt, name);
7783         }
7784     }
7785     if (ctxt->instate == XML_PARSER_EOF) {
7786         xmlFree(name);
7787         return(NULL);
7788     }
7789
7790     /*
7791      * [ WFC: Entity Declared ]
7792      * In a document without any DTD, a document with only an
7793      * internal DTD subset which contains no parameter entity
7794      * references, or a document with "standalone='yes'", the
7795      * Name given in the entity reference must match that in an
7796      * entity declaration, except that well-formed documents
7797      * need not declare any of the following entities: amp, lt,
7798      * gt, apos, quot.
7799      * The declaration of a parameter entity must precede any
7800      * reference to it.
7801      * Similarly, the declaration of a general entity must
7802      * precede any reference to it which appears in a default
7803      * value in an attribute-list declaration. Note that if
7804      * entities are declared in the external subset or in
7805      * external parameter entities, a non-validating processor
7806      * is not obligated to read and process their declarations;
7807      * for such documents, the rule that an entity must be
7808      * declared is a well-formedness constraint only if
7809      * standalone='yes'.
7810      */
7811     if (ent == NULL) {
7812         if ((ctxt->standalone == 1) ||
7813             ((ctxt->hasExternalSubset == 0) &&
7814              (ctxt->hasPErefs == 0))) {
7815             xmlFatalErrMsgStr(ctxt, XML_ERR_UNDECLARED_ENTITY,
7816                      "Entity '%s' not defined\n", name);
7817         } else {
7818             xmlErrMsgStr(ctxt, XML_WAR_UNDECLARED_ENTITY,
7819                           "Entity '%s' not defined\n",
7820                           name);
7821         }
7822         /* TODO ? check regressions ctxt->valid = 0; */
7823     }
7824
7825     /*
7826      * [ WFC: Parsed Entity ]
7827      * An entity reference must not contain the name of an
7828      * unparsed entity
7829      */
7830     else if (ent->etype == XML_EXTERNAL_GENERAL_UNPARSED_ENTITY) {
7831         xmlFatalErrMsgStr(ctxt, XML_ERR_UNPARSED_ENTITY,
7832                  "Entity reference to unparsed entity %s\n", name);
7833     }
7834
7835     /*
7836      * [ WFC: No External Entity References ]
7837      * Attribute values cannot contain direct or indirect
7838      * entity references to external entities.
7839      */
7840     else if ((ctxt->instate == XML_PARSER_ATTRIBUTE_VALUE) &&
7841              (ent->etype == XML_EXTERNAL_GENERAL_PARSED_ENTITY)) {
7842         xmlFatalErrMsgStr(ctxt, XML_ERR_ENTITY_IS_EXTERNAL,
7843          "Attribute references external entity '%s'\n", name);
7844     }
7845     /*
7846      * [ WFC: No < in Attribute Values ]
7847      * The replacement text of any entity referred to directly or
7848      * indirectly in an attribute value (other than "&lt;") must
7849      * not contain a <.
7850      */
7851     else if ((ctxt->instate == XML_PARSER_ATTRIBUTE_VALUE) &&
7852              (ent != NULL) && (ent->content != NULL) &&
7853              (ent->etype != XML_INTERNAL_PREDEFINED_ENTITY) &&
7854              (xmlStrchr(ent->content, '<'))) {
7855         xmlFatalErrMsgStr(ctxt, XML_ERR_LT_IN_ATTRIBUTE,
7856      "'<' in entity '%s' is not allowed in attributes values\n",
7857                           name);
7858     }
7859
7860     /*
7861      * Internal check, no parameter entities here ...
7862      */
7863     else {
7864         switch (ent->etype) {
7865             case XML_INTERNAL_PARAMETER_ENTITY:
7866             case XML_EXTERNAL_PARAMETER_ENTITY:
7867                 xmlFatalErrMsgStr(ctxt, XML_ERR_ENTITY_IS_PARAMETER,
7868              "Attempt to reference the parameter entity '%s'\n",
7869                                   name);
7870             break;
7871             default:
7872             break;
7873         }
7874     }
7875
7876     /*
7877      * [ WFC: No Recursion ]
7878      * A parsed entity must not contain a recursive reference
7879      * to itself, either directly or indirectly.
7880      * Done somewhere else
7881      */
7882
7883     xmlFree(name);
7884     *str = ptr;
7885     return(ent);
7886 }
7887
7888 /**
7889  * xmlParsePEReference:
7890  * @ctxt:  an XML parser context
7891  *
7892  * parse PEReference declarations
7893  * The entity content is handled directly by pushing it's content as
7894  * a new input stream.
7895  *
7896  * [69] PEReference ::= '%' Name ';'
7897  *
7898  * [ WFC: No Recursion ]
7899  * A parsed entity must not contain a recursive
7900  * reference to itself, either directly or indirectly.
7901  *
7902  * [ WFC: Entity Declared ]
7903  * In a document without any DTD, a document with only an internal DTD
7904  * subset which contains no parameter entity references, or a document
7905  * with "standalone='yes'", ...  ... The declaration of a parameter
7906  * entity must precede any reference to it...
7907  *
7908  * [ VC: Entity Declared ]
7909  * In a document with an external subset or external parameter entities
7910  * with "standalone='no'", ...  ... The declaration of a parameter entity
7911  * must precede any reference to it...
7912  *
7913  * [ WFC: In DTD ]
7914  * Parameter-entity references may only appear in the DTD.
7915  * NOTE: misleading but this is handled.
7916  */
7917 void
7918 xmlParsePEReference(xmlParserCtxtPtr ctxt)
7919 {
7920     const xmlChar *name;
7921     xmlEntityPtr entity = NULL;
7922     xmlParserInputPtr input;
7923
7924     if (RAW != '%')
7925         return;
7926     NEXT;
7927     name = xmlParseName(ctxt);
7928     if (name == NULL) {
7929         xmlFatalErrMsg(ctxt, XML_ERR_NAME_REQUIRED,
7930                        "xmlParsePEReference: no name\n");
7931         return;
7932     }
7933     if (RAW != ';') {
7934         xmlFatalErr(ctxt, XML_ERR_ENTITYREF_SEMICOL_MISSING, NULL);
7935         return;
7936     }
7937
7938     NEXT;
7939
7940     /*
7941      * Increate the number of entity references parsed
7942      */
7943     ctxt->nbentities++;
7944
7945     /*
7946      * Request the entity from SAX
7947      */
7948     if ((ctxt->sax != NULL) &&
7949         (ctxt->sax->getParameterEntity != NULL))
7950         entity = ctxt->sax->getParameterEntity(ctxt->userData, name);
7951     if (ctxt->instate == XML_PARSER_EOF)
7952         return;
7953     if (entity == NULL) {
7954         /*
7955          * [ WFC: Entity Declared ]
7956          * In a document without any DTD, a document with only an
7957          * internal DTD subset which contains no parameter entity
7958          * references, or a document with "standalone='yes'", ...
7959          * ... The declaration of a parameter entity must precede
7960          * any reference to it...
7961          */
7962         if ((ctxt->standalone == 1) ||
7963             ((ctxt->hasExternalSubset == 0) &&
7964              (ctxt->hasPErefs == 0))) {
7965             xmlFatalErrMsgStr(ctxt, XML_ERR_UNDECLARED_ENTITY,
7966                               "PEReference: %%%s; not found\n",
7967                               name);
7968         } else {
7969             /*
7970              * [ VC: Entity Declared ]
7971              * In a document with an external subset or external
7972              * parameter entities with "standalone='no'", ...
7973              * ... The declaration of a parameter entity must
7974              * precede any reference to it...
7975              */
7976             xmlWarningMsg(ctxt, XML_WAR_UNDECLARED_ENTITY,
7977                           "PEReference: %%%s; not found\n",
7978                           name, NULL);
7979             ctxt->valid = 0;
7980         }
7981     } else {
7982         /*
7983          * Internal checking in case the entity quest barfed
7984          */
7985         if ((entity->etype != XML_INTERNAL_PARAMETER_ENTITY) &&
7986             (entity->etype != XML_EXTERNAL_PARAMETER_ENTITY)) {
7987             xmlWarningMsg(ctxt, XML_WAR_UNDECLARED_ENTITY,
7988                   "Internal: %%%s; is not a parameter entity\n",
7989                           name, NULL);
7990         } else if (ctxt->input->free != deallocblankswrapper) {
7991             input = xmlNewBlanksWrapperInputStream(ctxt, entity);
7992             if (xmlPushInput(ctxt, input) < 0)
7993                 return;
7994         } else {
7995             /*
7996              * TODO !!!
7997              * handle the extra spaces added before and after
7998              * c.f. http://www.w3.org/TR/REC-xml#as-PE
7999              */
8000             input = xmlNewEntityInputStream(ctxt, entity);
8001             if (xmlPushInput(ctxt, input) < 0)
8002                 return;
8003             if ((entity->etype == XML_EXTERNAL_PARAMETER_ENTITY) &&
8004                 (CMP5(CUR_PTR, '<', '?', 'x', 'm', 'l')) &&
8005                 (IS_BLANK_CH(NXT(5)))) {
8006                 xmlParseTextDecl(ctxt);
8007                 if (ctxt->errNo ==
8008                     XML_ERR_UNSUPPORTED_ENCODING) {
8009                     /*
8010                      * The XML REC instructs us to stop parsing
8011                      * right here
8012                      */
8013                     ctxt->instate = XML_PARSER_EOF;
8014                     return;
8015                 }
8016             }
8017         }
8018     }
8019     ctxt->hasPErefs = 1;
8020 }
8021
8022 /**
8023  * xmlLoadEntityContent:
8024  * @ctxt:  an XML parser context
8025  * @entity: an unloaded system entity
8026  *
8027  * Load the original content of the given system entity from the
8028  * ExternalID/SystemID given. This is to be used for Included in Literal
8029  * http://www.w3.org/TR/REC-xml/#inliteral processing of entities references
8030  *
8031  * Returns 0 in case of success and -1 in case of failure
8032  */
8033 static int
8034 xmlLoadEntityContent(xmlParserCtxtPtr ctxt, xmlEntityPtr entity) {
8035     xmlParserInputPtr input;
8036     xmlBufferPtr buf;
8037     int l, c;
8038     int count = 0;
8039
8040     if ((ctxt == NULL) || (entity == NULL) ||
8041         ((entity->etype != XML_EXTERNAL_PARAMETER_ENTITY) &&
8042          (entity->etype != XML_EXTERNAL_GENERAL_PARSED_ENTITY)) ||
8043         (entity->content != NULL)) {
8044         xmlFatalErr(ctxt, XML_ERR_INTERNAL_ERROR,
8045                     "xmlLoadEntityContent parameter error");
8046         return(-1);
8047     }
8048
8049     if (xmlParserDebugEntities)
8050         xmlGenericError(xmlGenericErrorContext,
8051                 "Reading %s entity content input\n", entity->name);
8052
8053     buf = xmlBufferCreate();
8054     if (buf == NULL) {
8055         xmlFatalErr(ctxt, XML_ERR_INTERNAL_ERROR,
8056                     "xmlLoadEntityContent parameter error");
8057         return(-1);
8058     }
8059
8060     input = xmlNewEntityInputStream(ctxt, entity);
8061     if (input == NULL) {
8062         xmlFatalErr(ctxt, XML_ERR_INTERNAL_ERROR,
8063                     "xmlLoadEntityContent input error");
8064         xmlBufferFree(buf);
8065         return(-1);
8066     }
8067
8068     /*
8069      * Push the entity as the current input, read char by char
8070      * saving to the buffer until the end of the entity or an error
8071      */
8072     if (xmlPushInput(ctxt, input) < 0) {
8073         xmlBufferFree(buf);
8074         return(-1);
8075     }
8076
8077     GROW;
8078     c = CUR_CHAR(l);
8079     while ((ctxt->input == input) && (ctxt->input->cur < ctxt->input->end) &&
8080            (IS_CHAR(c))) {
8081         xmlBufferAdd(buf, ctxt->input->cur, l);
8082         if (count++ > XML_PARSER_CHUNK_SIZE) {
8083             count = 0;
8084             GROW;
8085             if (ctxt->instate == XML_PARSER_EOF) {
8086                 xmlBufferFree(buf);
8087                 return(-1);
8088             }
8089         }
8090         NEXTL(l);
8091         c = CUR_CHAR(l);
8092         if (c == 0) {
8093             count = 0;
8094             GROW;
8095             if (ctxt->instate == XML_PARSER_EOF) {
8096                 xmlBufferFree(buf);
8097                 return(-1);
8098             }
8099             c = CUR_CHAR(l);
8100         }
8101     }
8102
8103     if ((ctxt->input == input) && (ctxt->input->cur >= ctxt->input->end)) {
8104         xmlPopInput(ctxt);
8105     } else if (!IS_CHAR(c)) {
8106         xmlFatalErrMsgInt(ctxt, XML_ERR_INVALID_CHAR,
8107                           "xmlLoadEntityContent: invalid char value %d\n",
8108                           c);
8109         xmlBufferFree(buf);
8110         return(-1);
8111     }
8112     entity->content = buf->content;
8113     buf->content = NULL;
8114     xmlBufferFree(buf);
8115
8116     return(0);
8117 }
8118
8119 /**
8120  * xmlParseStringPEReference:
8121  * @ctxt:  an XML parser context
8122  * @str:  a pointer to an index in the string
8123  *
8124  * parse PEReference declarations
8125  *
8126  * [69] PEReference ::= '%' Name ';'
8127  *
8128  * [ WFC: No Recursion ]
8129  * A parsed entity must not contain a recursive
8130  * reference to itself, either directly or indirectly.
8131  *
8132  * [ WFC: Entity Declared ]
8133  * In a document without any DTD, a document with only an internal DTD
8134  * subset which contains no parameter entity references, or a document
8135  * with "standalone='yes'", ...  ... The declaration of a parameter
8136  * entity must precede any reference to it...
8137  *
8138  * [ VC: Entity Declared ]
8139  * In a document with an external subset or external parameter entities
8140  * with "standalone='no'", ...  ... The declaration of a parameter entity
8141  * must precede any reference to it...
8142  *
8143  * [ WFC: In DTD ]
8144  * Parameter-entity references may only appear in the DTD.
8145  * NOTE: misleading but this is handled.
8146  *
8147  * Returns the string of the entity content.
8148  *         str is updated to the current value of the index
8149  */
8150 static xmlEntityPtr
8151 xmlParseStringPEReference(xmlParserCtxtPtr ctxt, const xmlChar **str) {
8152     const xmlChar *ptr;
8153     xmlChar cur;
8154     xmlChar *name;
8155     xmlEntityPtr entity = NULL;
8156
8157     if ((str == NULL) || (*str == NULL)) return(NULL);
8158     ptr = *str;
8159     cur = *ptr;
8160     if (cur != '%')
8161         return(NULL);
8162     ptr++;
8163     name = xmlParseStringName(ctxt, &ptr);
8164     if (name == NULL) {
8165         xmlFatalErrMsg(ctxt, XML_ERR_NAME_REQUIRED,
8166                        "xmlParseStringPEReference: no name\n");
8167         *str = ptr;
8168         return(NULL);
8169     }
8170     cur = *ptr;
8171     if (cur != ';') {
8172         xmlFatalErr(ctxt, XML_ERR_ENTITYREF_SEMICOL_MISSING, NULL);
8173         xmlFree(name);
8174         *str = ptr;
8175         return(NULL);
8176     }
8177     ptr++;
8178
8179     /*
8180      * Increate the number of entity references parsed
8181      */
8182     ctxt->nbentities++;
8183
8184     /*
8185      * Request the entity from SAX
8186      */
8187     if ((ctxt->sax != NULL) &&
8188         (ctxt->sax->getParameterEntity != NULL))
8189         entity = ctxt->sax->getParameterEntity(ctxt->userData, name);
8190     if (ctxt->instate == XML_PARSER_EOF) {
8191         xmlFree(name);
8192         return(NULL);
8193     }
8194     if (entity == NULL) {
8195         /*
8196          * [ WFC: Entity Declared ]
8197          * In a document without any DTD, a document with only an
8198          * internal DTD subset which contains no parameter entity
8199          * references, or a document with "standalone='yes'", ...
8200          * ... The declaration of a parameter entity must precede
8201          * any reference to it...
8202          */
8203         if ((ctxt->standalone == 1) ||
8204             ((ctxt->hasExternalSubset == 0) && (ctxt->hasPErefs == 0))) {
8205             xmlFatalErrMsgStr(ctxt, XML_ERR_UNDECLARED_ENTITY,
8206                  "PEReference: %%%s; not found\n", name);
8207         } else {
8208             /*
8209              * [ VC: Entity Declared ]
8210              * In a document with an external subset or external
8211              * parameter entities with "standalone='no'", ...
8212              * ... The declaration of a parameter entity must
8213              * precede any reference to it...
8214              */
8215             xmlWarningMsg(ctxt, XML_WAR_UNDECLARED_ENTITY,
8216                           "PEReference: %%%s; not found\n",
8217                           name, NULL);
8218             ctxt->valid = 0;
8219         }
8220     } else {
8221         /*
8222          * Internal checking in case the entity quest barfed
8223          */
8224         if ((entity->etype != XML_INTERNAL_PARAMETER_ENTITY) &&
8225             (entity->etype != XML_EXTERNAL_PARAMETER_ENTITY)) {
8226             xmlWarningMsg(ctxt, XML_WAR_UNDECLARED_ENTITY,
8227                           "%%%s; is not a parameter entity\n",
8228                           name, NULL);
8229         }
8230     }
8231     ctxt->hasPErefs = 1;
8232     xmlFree(name);
8233     *str = ptr;
8234     return(entity);
8235 }
8236
8237 /**
8238  * xmlParseDocTypeDecl:
8239  * @ctxt:  an XML parser context
8240  *
8241  * parse a DOCTYPE declaration
8242  *
8243  * [28] doctypedecl ::= '<!DOCTYPE' S Name (S ExternalID)? S?
8244  *                      ('[' (markupdecl | PEReference | S)* ']' S?)? '>'
8245  *
8246  * [ VC: Root Element Type ]
8247  * The Name in the document type declaration must match the element
8248  * type of the root element.
8249  */
8250
8251 void
8252 xmlParseDocTypeDecl(xmlParserCtxtPtr ctxt) {
8253     const xmlChar *name = NULL;
8254     xmlChar *ExternalID = NULL;
8255     xmlChar *URI = NULL;
8256
8257     /*
8258      * We know that '<!DOCTYPE' has been detected.
8259      */
8260     SKIP(9);
8261
8262     SKIP_BLANKS;
8263
8264     /*
8265      * Parse the DOCTYPE name.
8266      */
8267     name = xmlParseName(ctxt);
8268     if (name == NULL) {
8269         xmlFatalErrMsg(ctxt, XML_ERR_NAME_REQUIRED,
8270                        "xmlParseDocTypeDecl : no DOCTYPE name !\n");
8271     }
8272     ctxt->intSubName = name;
8273
8274     SKIP_BLANKS;
8275
8276     /*
8277      * Check for SystemID and ExternalID
8278      */
8279     URI = xmlParseExternalID(ctxt, &ExternalID, 1);
8280
8281     if ((URI != NULL) || (ExternalID != NULL)) {
8282         ctxt->hasExternalSubset = 1;
8283     }
8284     ctxt->extSubURI = URI;
8285     ctxt->extSubSystem = ExternalID;
8286
8287     SKIP_BLANKS;
8288
8289     /*
8290      * Create and update the internal subset.
8291      */
8292     if ((ctxt->sax != NULL) && (ctxt->sax->internalSubset != NULL) &&
8293         (!ctxt->disableSAX))
8294         ctxt->sax->internalSubset(ctxt->userData, name, ExternalID, URI);
8295     if (ctxt->instate == XML_PARSER_EOF)
8296         return;
8297
8298     /*
8299      * Is there any internal subset declarations ?
8300      * they are handled separately in xmlParseInternalSubset()
8301      */
8302     if (RAW == '[')
8303         return;
8304
8305     /*
8306      * We should be at the end of the DOCTYPE declaration.
8307      */
8308     if (RAW != '>') {
8309         xmlFatalErr(ctxt, XML_ERR_DOCTYPE_NOT_FINISHED, NULL);
8310     }
8311     NEXT;
8312 }
8313
8314 /**
8315  * xmlParseInternalSubset:
8316  * @ctxt:  an XML parser context
8317  *
8318  * parse the internal subset declaration
8319  *
8320  * [28 end] ('[' (markupdecl | PEReference | S)* ']' S?)? '>'
8321  */
8322
8323 static void
8324 xmlParseInternalSubset(xmlParserCtxtPtr ctxt) {
8325     /*
8326      * Is there any DTD definition ?
8327      */
8328     if (RAW == '[') {
8329         ctxt->instate = XML_PARSER_DTD;
8330         NEXT;
8331         /*
8332          * Parse the succession of Markup declarations and
8333          * PEReferences.
8334          * Subsequence (markupdecl | PEReference | S)*
8335          */
8336         while ((RAW != ']') && (ctxt->instate != XML_PARSER_EOF)) {
8337             const xmlChar *check = CUR_PTR;
8338             unsigned int cons = ctxt->input->consumed;
8339
8340             SKIP_BLANKS;
8341             xmlParseMarkupDecl(ctxt);
8342             xmlParsePEReference(ctxt);
8343
8344             /*
8345              * Pop-up of finished entities.
8346              */
8347             while ((RAW == 0) && (ctxt->inputNr > 1))
8348                 xmlPopInput(ctxt);
8349
8350             if ((CUR_PTR == check) && (cons == ctxt->input->consumed)) {
8351                 xmlFatalErr(ctxt, XML_ERR_INTERNAL_ERROR,
8352              "xmlParseInternalSubset: error detected in Markup declaration\n");
8353                 break;
8354             }
8355         }
8356         if (RAW == ']') {
8357             NEXT;
8358             SKIP_BLANKS;
8359         }
8360     }
8361
8362     /*
8363      * We should be at the end of the DOCTYPE declaration.
8364      */
8365     if (RAW != '>') {
8366         xmlFatalErr(ctxt, XML_ERR_DOCTYPE_NOT_FINISHED, NULL);
8367     }
8368     NEXT;
8369 }
8370
8371 #ifdef LIBXML_SAX1_ENABLED
8372 /**
8373  * xmlParseAttribute:
8374  * @ctxt:  an XML parser context
8375  * @value:  a xmlChar ** used to store the value of the attribute
8376  *
8377  * parse an attribute
8378  *
8379  * [41] Attribute ::= Name Eq AttValue
8380  *
8381  * [ WFC: No External Entity References ]
8382  * Attribute values cannot contain direct or indirect entity references
8383  * to external entities.
8384  *
8385  * [ WFC: No < in Attribute Values ]
8386  * The replacement text of any entity referred to directly or indirectly in
8387  * an attribute value (other than "&lt;") must not contain a <.
8388  *
8389  * [ VC: Attribute Value Type ]
8390  * The attribute must have been declared; the value must be of the type
8391  * declared for it.
8392  *
8393  * [25] Eq ::= S? '=' S?
8394  *
8395  * With namespace:
8396  *
8397  * [NS 11] Attribute ::= QName Eq AttValue
8398  *
8399  * Also the case QName == xmlns:??? is handled independently as a namespace
8400  * definition.
8401  *
8402  * Returns the attribute name, and the value in *value.
8403  */
8404
8405 const xmlChar *
8406 xmlParseAttribute(xmlParserCtxtPtr ctxt, xmlChar **value) {
8407     const xmlChar *name;
8408     xmlChar *val;
8409
8410     *value = NULL;
8411     GROW;
8412     name = xmlParseName(ctxt);
8413     if (name == NULL) {
8414         xmlFatalErrMsg(ctxt, XML_ERR_NAME_REQUIRED,
8415                        "error parsing attribute name\n");
8416         return(NULL);
8417     }
8418
8419     /*
8420      * read the value
8421      */
8422     SKIP_BLANKS;
8423     if (RAW == '=') {
8424         NEXT;
8425         SKIP_BLANKS;
8426         val = xmlParseAttValue(ctxt);
8427         ctxt->instate = XML_PARSER_CONTENT;
8428     } else {
8429         xmlFatalErrMsgStr(ctxt, XML_ERR_ATTRIBUTE_WITHOUT_VALUE,
8430                "Specification mandate value for attribute %s\n", name);
8431         return(NULL);
8432     }
8433
8434     /*
8435      * Check that xml:lang conforms to the specification
8436      * No more registered as an error, just generate a warning now
8437      * since this was deprecated in XML second edition
8438      */
8439     if ((ctxt->pedantic) && (xmlStrEqual(name, BAD_CAST "xml:lang"))) {
8440         if (!xmlCheckLanguageID(val)) {
8441             xmlWarningMsg(ctxt, XML_WAR_LANG_VALUE,
8442                           "Malformed value for xml:lang : %s\n",
8443                           val, NULL);
8444         }
8445     }
8446
8447     /*
8448      * Check that xml:space conforms to the specification
8449      */
8450     if (xmlStrEqual(name, BAD_CAST "xml:space")) {
8451         if (xmlStrEqual(val, BAD_CAST "default"))
8452             *(ctxt->space) = 0;
8453         else if (xmlStrEqual(val, BAD_CAST "preserve"))
8454             *(ctxt->space) = 1;
8455         else {
8456                 xmlWarningMsg(ctxt, XML_WAR_SPACE_VALUE,
8457 "Invalid value \"%s\" for xml:space : \"default\" or \"preserve\" expected\n",
8458                                  val, NULL);
8459         }
8460     }
8461
8462     *value = val;
8463     return(name);
8464 }
8465
8466 /**
8467  * xmlParseStartTag:
8468  * @ctxt:  an XML parser context
8469  *
8470  * parse a start of tag either for rule element or
8471  * EmptyElement. In both case we don't parse the tag closing chars.
8472  *
8473  * [40] STag ::= '<' Name (S Attribute)* S? '>'
8474  *
8475  * [ WFC: Unique Att Spec ]
8476  * No attribute name may appear more than once in the same start-tag or
8477  * empty-element tag.
8478  *
8479  * [44] EmptyElemTag ::= '<' Name (S Attribute)* S? '/>'
8480  *
8481  * [ WFC: Unique Att Spec ]
8482  * No attribute name may appear more than once in the same start-tag or
8483  * empty-element tag.
8484  *
8485  * With namespace:
8486  *
8487  * [NS 8] STag ::= '<' QName (S Attribute)* S? '>'
8488  *
8489  * [NS 10] EmptyElement ::= '<' QName (S Attribute)* S? '/>'
8490  *
8491  * Returns the element name parsed
8492  */
8493
8494 const xmlChar *
8495 xmlParseStartTag(xmlParserCtxtPtr ctxt) {
8496     const xmlChar *name;
8497     const xmlChar *attname;
8498     xmlChar *attvalue;
8499     const xmlChar **atts = ctxt->atts;
8500     int nbatts = 0;
8501     int maxatts = ctxt->maxatts;
8502     int i;
8503
8504     if (RAW != '<') return(NULL);
8505     NEXT1;
8506
8507     name = xmlParseName(ctxt);
8508     if (name == NULL) {
8509         xmlFatalErrMsg(ctxt, XML_ERR_NAME_REQUIRED,
8510              "xmlParseStartTag: invalid element name\n");
8511         return(NULL);
8512     }
8513
8514     /*
8515      * Now parse the attributes, it ends up with the ending
8516      *
8517      * (S Attribute)* S?
8518      */
8519     SKIP_BLANKS;
8520     GROW;
8521
8522     while (((RAW != '>') &&
8523            ((RAW != '/') || (NXT(1) != '>')) &&
8524            (IS_BYTE_CHAR(RAW))) && (ctxt->instate != XML_PARSER_EOF)) {
8525         const xmlChar *q = CUR_PTR;
8526         unsigned int cons = ctxt->input->consumed;
8527
8528         attname = xmlParseAttribute(ctxt, &attvalue);
8529         if ((attname != NULL) && (attvalue != NULL)) {
8530             /*
8531              * [ WFC: Unique Att Spec ]
8532              * No attribute name may appear more than once in the same
8533              * start-tag or empty-element tag.
8534              */
8535             for (i = 0; i < nbatts;i += 2) {
8536                 if (xmlStrEqual(atts[i], attname)) {
8537                     xmlErrAttributeDup(ctxt, NULL, attname);
8538                     xmlFree(attvalue);
8539                     goto failed;
8540                 }
8541             }
8542             /*
8543              * Add the pair to atts
8544              */
8545             if (atts == NULL) {
8546                 maxatts = 22; /* allow for 10 attrs by default */
8547                 atts = (const xmlChar **)
8548                        xmlMalloc(maxatts * sizeof(xmlChar *));
8549                 if (atts == NULL) {
8550                     xmlErrMemory(ctxt, NULL);
8551                     if (attvalue != NULL)
8552                         xmlFree(attvalue);
8553                     goto failed;
8554                 }
8555                 ctxt->atts = atts;
8556                 ctxt->maxatts = maxatts;
8557             } else if (nbatts + 4 > maxatts) {
8558                 const xmlChar **n;
8559
8560                 maxatts *= 2;
8561                 n = (const xmlChar **) xmlRealloc((void *) atts,
8562                                              maxatts * sizeof(const xmlChar *));
8563                 if (n == NULL) {
8564                     xmlErrMemory(ctxt, NULL);
8565                     if (attvalue != NULL)
8566                         xmlFree(attvalue);
8567                     goto failed;
8568                 }
8569                 atts = n;
8570                 ctxt->atts = atts;
8571                 ctxt->maxatts = maxatts;
8572             }
8573             atts[nbatts++] = attname;
8574             atts[nbatts++] = attvalue;
8575             atts[nbatts] = NULL;
8576             atts[nbatts + 1] = NULL;
8577         } else {
8578             if (attvalue != NULL)
8579                 xmlFree(attvalue);
8580         }
8581
8582 failed:
8583
8584         GROW
8585         if ((RAW == '>') || (((RAW == '/') && (NXT(1) == '>'))))
8586             break;
8587         if (!IS_BLANK_CH(RAW)) {
8588             xmlFatalErrMsg(ctxt, XML_ERR_SPACE_REQUIRED,
8589                            "attributes construct error\n");
8590         }
8591         SKIP_BLANKS;
8592         if ((cons == ctxt->input->consumed) && (q == CUR_PTR) &&
8593             (attname == NULL) && (attvalue == NULL)) {
8594             xmlFatalErrMsg(ctxt, XML_ERR_INTERNAL_ERROR,
8595                            "xmlParseStartTag: problem parsing attributes\n");
8596             break;
8597         }
8598         SHRINK;
8599         GROW;
8600     }
8601
8602     /*
8603      * SAX: Start of Element !
8604      */
8605     if ((ctxt->sax != NULL) && (ctxt->sax->startElement != NULL) &&
8606         (!ctxt->disableSAX)) {
8607         if (nbatts > 0)
8608             ctxt->sax->startElement(ctxt->userData, name, atts);
8609         else
8610             ctxt->sax->startElement(ctxt->userData, name, NULL);
8611     }
8612
8613     if (atts != NULL) {
8614         /* Free only the content strings */
8615         for (i = 1;i < nbatts;i+=2)
8616             if (atts[i] != NULL)
8617                xmlFree((xmlChar *) atts[i]);
8618     }
8619     return(name);
8620 }
8621
8622 /**
8623  * xmlParseEndTag1:
8624  * @ctxt:  an XML parser context
8625  * @line:  line of the start tag
8626  * @nsNr:  number of namespaces on the start tag
8627  *
8628  * parse an end of tag
8629  *
8630  * [42] ETag ::= '</' Name S? '>'
8631  *
8632  * With namespace
8633  *
8634  * [NS 9] ETag ::= '</' QName S? '>'
8635  */
8636
8637 static void
8638 xmlParseEndTag1(xmlParserCtxtPtr ctxt, int line) {
8639     const xmlChar *name;
8640
8641     GROW;
8642     if ((RAW != '<') || (NXT(1) != '/')) {
8643         xmlFatalErrMsg(ctxt, XML_ERR_LTSLASH_REQUIRED,
8644                        "xmlParseEndTag: '</' not found\n");
8645         return;
8646     }
8647     SKIP(2);
8648
8649     name = xmlParseNameAndCompare(ctxt,ctxt->name);
8650
8651     /*
8652      * We should definitely be at the ending "S? '>'" part
8653      */
8654     GROW;
8655     SKIP_BLANKS;
8656     if ((!IS_BYTE_CHAR(RAW)) || (RAW != '>')) {
8657         xmlFatalErr(ctxt, XML_ERR_GT_REQUIRED, NULL);
8658     } else
8659         NEXT1;
8660
8661     /*
8662      * [ WFC: Element Type Match ]
8663      * The Name in an element's end-tag must match the element type in the
8664      * start-tag.
8665      *
8666      */
8667     if (name != (xmlChar*)1) {
8668         if (name == NULL) name = BAD_CAST "unparseable";
8669         xmlFatalErrMsgStrIntStr(ctxt, XML_ERR_TAG_NAME_MISMATCH,
8670                      "Opening and ending tag mismatch: %s line %d and %s\n",
8671                                 ctxt->name, line, name);
8672     }
8673
8674     /*
8675      * SAX: End of Tag
8676      */
8677     if ((ctxt->sax != NULL) && (ctxt->sax->endElement != NULL) &&
8678         (!ctxt->disableSAX))
8679         ctxt->sax->endElement(ctxt->userData, ctxt->name);
8680
8681     namePop(ctxt);
8682     spacePop(ctxt);
8683     return;
8684 }
8685
8686 /**
8687  * xmlParseEndTag:
8688  * @ctxt:  an XML parser context
8689  *
8690  * parse an end of tag
8691  *
8692  * [42] ETag ::= '</' Name S? '>'
8693  *
8694  * With namespace
8695  *
8696  * [NS 9] ETag ::= '</' QName S? '>'
8697  */
8698
8699 void
8700 xmlParseEndTag(xmlParserCtxtPtr ctxt) {
8701     xmlParseEndTag1(ctxt, 0);
8702 }
8703 #endif /* LIBXML_SAX1_ENABLED */
8704
8705 /************************************************************************
8706  *                                                                      *
8707  *                    SAX 2 specific operations                         *
8708  *                                                                      *
8709  ************************************************************************/
8710
8711 /*
8712  * xmlGetNamespace:
8713  * @ctxt:  an XML parser context
8714  * @prefix:  the prefix to lookup
8715  *
8716  * Lookup the namespace name for the @prefix (which ca be NULL)
8717  * The prefix must come from the @ctxt->dict dictionnary
8718  *
8719  * Returns the namespace name or NULL if not bound
8720  */
8721 static const xmlChar *
8722 xmlGetNamespace(xmlParserCtxtPtr ctxt, const xmlChar *prefix) {
8723     int i;
8724
8725     if (prefix == ctxt->str_xml) return(ctxt->str_xml_ns);
8726     for (i = ctxt->nsNr - 2;i >= 0;i-=2)
8727         if (ctxt->nsTab[i] == prefix) {
8728             if ((prefix == NULL) && (*ctxt->nsTab[i + 1] == 0))
8729                 return(NULL);
8730             return(ctxt->nsTab[i + 1]);
8731         }
8732     return(NULL);
8733 }
8734
8735 /**
8736  * xmlParseQName:
8737  * @ctxt:  an XML parser context
8738  * @prefix:  pointer to store the prefix part
8739  *
8740  * parse an XML Namespace QName
8741  *
8742  * [6]  QName  ::= (Prefix ':')? LocalPart
8743  * [7]  Prefix  ::= NCName
8744  * [8]  LocalPart  ::= NCName
8745  *
8746  * Returns the Name parsed or NULL
8747  */
8748
8749 static const xmlChar *
8750 xmlParseQName(xmlParserCtxtPtr ctxt, const xmlChar **prefix) {
8751     const xmlChar *l, *p;
8752
8753     GROW;
8754
8755     l = xmlParseNCName(ctxt);
8756     if (l == NULL) {
8757         if (CUR == ':') {
8758             l = xmlParseName(ctxt);
8759             if (l != NULL) {
8760                 xmlNsErr(ctxt, XML_NS_ERR_QNAME,
8761                          "Failed to parse QName '%s'\n", l, NULL, NULL);
8762                 *prefix = NULL;
8763                 return(l);
8764             }
8765         }
8766         return(NULL);
8767     }
8768     if (CUR == ':') {
8769         NEXT;
8770         p = l;
8771         l = xmlParseNCName(ctxt);
8772         if (l == NULL) {
8773             xmlChar *tmp;
8774
8775             xmlNsErr(ctxt, XML_NS_ERR_QNAME,
8776                      "Failed to parse QName '%s:'\n", p, NULL, NULL);
8777             l = xmlParseNmtoken(ctxt);
8778             if (l == NULL)
8779                 tmp = xmlBuildQName(BAD_CAST "", p, NULL, 0);
8780             else {
8781                 tmp = xmlBuildQName(l, p, NULL, 0);
8782                 xmlFree((char *)l);
8783             }
8784             p = xmlDictLookup(ctxt->dict, tmp, -1);
8785             if (tmp != NULL) xmlFree(tmp);
8786             *prefix = NULL;
8787             return(p);
8788         }
8789         if (CUR == ':') {
8790             xmlChar *tmp;
8791
8792             xmlNsErr(ctxt, XML_NS_ERR_QNAME,
8793                      "Failed to parse QName '%s:%s:'\n", p, l, NULL);
8794             NEXT;
8795             tmp = (xmlChar *) xmlParseName(ctxt);
8796             if (tmp != NULL) {
8797                 tmp = xmlBuildQName(tmp, l, NULL, 0);
8798                 l = xmlDictLookup(ctxt->dict, tmp, -1);
8799                 if (tmp != NULL) xmlFree(tmp);
8800                 *prefix = p;
8801                 return(l);
8802             }
8803             tmp = xmlBuildQName(BAD_CAST "", l, NULL, 0);
8804             l = xmlDictLookup(ctxt->dict, tmp, -1);
8805             if (tmp != NULL) xmlFree(tmp);
8806             *prefix = p;
8807             return(l);
8808         }
8809         *prefix = p;
8810     } else
8811         *prefix = NULL;
8812     return(l);
8813 }
8814
8815 /**
8816  * xmlParseQNameAndCompare:
8817  * @ctxt:  an XML parser context
8818  * @name:  the localname
8819  * @prefix:  the prefix, if any.
8820  *
8821  * parse an XML name and compares for match
8822  * (specialized for endtag parsing)
8823  *
8824  * Returns NULL for an illegal name, (xmlChar*) 1 for success
8825  * and the name for mismatch
8826  */
8827
8828 static const xmlChar *
8829 xmlParseQNameAndCompare(xmlParserCtxtPtr ctxt, xmlChar const *name,
8830                         xmlChar const *prefix) {
8831     const xmlChar *cmp;
8832     const xmlChar *in;
8833     const xmlChar *ret;
8834     const xmlChar *prefix2;
8835
8836     if (prefix == NULL) return(xmlParseNameAndCompare(ctxt, name));
8837
8838     GROW;
8839     in = ctxt->input->cur;
8840
8841     cmp = prefix;
8842     while (*in != 0 && *in == *cmp) {
8843         ++in;
8844         ++cmp;
8845     }
8846     if ((*cmp == 0) && (*in == ':')) {
8847         in++;
8848         cmp = name;
8849         while (*in != 0 && *in == *cmp) {
8850             ++in;
8851             ++cmp;
8852         }
8853         if (*cmp == 0 && (*in == '>' || IS_BLANK_CH (*in))) {
8854             /* success */
8855             ctxt->input->cur = in;
8856             return((const xmlChar*) 1);
8857         }
8858     }
8859     /*
8860      * all strings coms from the dictionary, equality can be done directly
8861      */
8862     ret = xmlParseQName (ctxt, &prefix2);
8863     if ((ret == name) && (prefix == prefix2))
8864         return((const xmlChar*) 1);
8865     return ret;
8866 }
8867
8868 /**
8869  * xmlParseAttValueInternal:
8870  * @ctxt:  an XML parser context
8871  * @len:  attribute len result
8872  * @alloc:  whether the attribute was reallocated as a new string
8873  * @normalize:  if 1 then further non-CDATA normalization must be done
8874  *
8875  * parse a value for an attribute.
8876  * NOTE: if no normalization is needed, the routine will return pointers
8877  *       directly from the data buffer.
8878  *
8879  * 3.3.3 Attribute-Value Normalization:
8880  * Before the value of an attribute is passed to the application or
8881  * checked for validity, the XML processor must normalize it as follows:
8882  * - a character reference is processed by appending the referenced
8883  *   character to the attribute value
8884  * - an entity reference is processed by recursively processing the
8885  *   replacement text of the entity
8886  * - a whitespace character (#x20, #xD, #xA, #x9) is processed by
8887  *   appending #x20 to the normalized value, except that only a single
8888  *   #x20 is appended for a "#xD#xA" sequence that is part of an external
8889  *   parsed entity or the literal entity value of an internal parsed entity
8890  * - other characters are processed by appending them to the normalized value
8891  * If the declared value is not CDATA, then the XML processor must further
8892  * process the normalized attribute value by discarding any leading and
8893  * trailing space (#x20) characters, and by replacing sequences of space
8894  * (#x20) characters by a single space (#x20) character.
8895  * All attributes for which no declaration has been read should be treated
8896  * by a non-validating parser as if declared CDATA.
8897  *
8898  * Returns the AttValue parsed or NULL. The value has to be freed by the
8899  *     caller if it was copied, this can be detected by val[*len] == 0.
8900  */
8901
8902 static xmlChar *
8903 xmlParseAttValueInternal(xmlParserCtxtPtr ctxt, int *len, int *alloc,
8904                          int normalize)
8905 {
8906     xmlChar limit = 0;
8907     const xmlChar *in = NULL, *start, *end, *last;
8908     xmlChar *ret = NULL;
8909
8910     GROW;
8911     in = (xmlChar *) CUR_PTR;
8912     if (*in != '"' && *in != '\'') {
8913         xmlFatalErr(ctxt, XML_ERR_ATTRIBUTE_NOT_STARTED, NULL);
8914         return (NULL);
8915     }
8916     ctxt->instate = XML_PARSER_ATTRIBUTE_VALUE;
8917
8918     /*
8919      * try to handle in this routine the most common case where no
8920      * allocation of a new string is required and where content is
8921      * pure ASCII.
8922      */
8923     limit = *in++;
8924     end = ctxt->input->end;
8925     start = in;
8926     if (in >= end) {
8927         const xmlChar *oldbase = ctxt->input->base;
8928         GROW;
8929         if (oldbase != ctxt->input->base) {
8930             long delta = ctxt->input->base - oldbase;
8931             start = start + delta;
8932             in = in + delta;
8933         }
8934         end = ctxt->input->end;
8935     }
8936     if (normalize) {
8937         /*
8938          * Skip any leading spaces
8939          */
8940         while ((in < end) && (*in != limit) &&
8941                ((*in == 0x20) || (*in == 0x9) ||
8942                 (*in == 0xA) || (*in == 0xD))) {
8943             in++;
8944             start = in;
8945             if (in >= end) {
8946                 const xmlChar *oldbase = ctxt->input->base;
8947                 GROW;
8948                 if (ctxt->instate == XML_PARSER_EOF)
8949                     return(NULL);
8950                 if (oldbase != ctxt->input->base) {
8951                     long delta = ctxt->input->base - oldbase;
8952                     start = start + delta;
8953                     in = in + delta;
8954                 }
8955                 end = ctxt->input->end;
8956                 if (((in - start) > XML_MAX_TEXT_LENGTH) &&
8957                     ((ctxt->options & XML_PARSE_HUGE) == 0)) {
8958                     xmlFatalErrMsg(ctxt, XML_ERR_ATTRIBUTE_NOT_FINISHED,
8959                                    "AttValue length too long\n");
8960                     return(NULL);
8961                 }
8962             }
8963         }
8964         while ((in < end) && (*in != limit) && (*in >= 0x20) &&
8965                (*in <= 0x7f) && (*in != '&') && (*in != '<')) {
8966             if ((*in++ == 0x20) && (*in == 0x20)) break;
8967             if (in >= end) {
8968                 const xmlChar *oldbase = ctxt->input->base;
8969                 GROW;
8970                 if (ctxt->instate == XML_PARSER_EOF)
8971                     return(NULL);
8972                 if (oldbase != ctxt->input->base) {
8973                     long delta = ctxt->input->base - oldbase;
8974                     start = start + delta;
8975                     in = in + delta;
8976                 }
8977                 end = ctxt->input->end;
8978                 if (((in - start) > XML_MAX_TEXT_LENGTH) &&
8979                     ((ctxt->options & XML_PARSE_HUGE) == 0)) {
8980                     xmlFatalErrMsg(ctxt, XML_ERR_ATTRIBUTE_NOT_FINISHED,
8981                                    "AttValue length too long\n");
8982                     return(NULL);
8983                 }
8984             }
8985         }
8986         last = in;
8987         /*
8988          * skip the trailing blanks
8989          */
8990         while ((last[-1] == 0x20) && (last > start)) last--;
8991         while ((in < end) && (*in != limit) &&
8992                ((*in == 0x20) || (*in == 0x9) ||
8993                 (*in == 0xA) || (*in == 0xD))) {
8994             in++;
8995             if (in >= end) {
8996                 const xmlChar *oldbase = ctxt->input->base;
8997                 GROW;
8998                 if (ctxt->instate == XML_PARSER_EOF)
8999                     return(NULL);
9000                 if (oldbase != ctxt->input->base) {
9001                     long delta = ctxt->input->base - oldbase;
9002                     start = start + delta;
9003                     in = in + delta;
9004                     last = last + delta;
9005                 }
9006                 end = ctxt->input->end;
9007                 if (((in - start) > XML_MAX_TEXT_LENGTH) &&
9008                     ((ctxt->options & XML_PARSE_HUGE) == 0)) {
9009                     xmlFatalErrMsg(ctxt, XML_ERR_ATTRIBUTE_NOT_FINISHED,
9010                                    "AttValue length too long\n");
9011                     return(NULL);
9012                 }
9013             }
9014         }
9015         if (((in - start) > XML_MAX_TEXT_LENGTH) &&
9016             ((ctxt->options & XML_PARSE_HUGE) == 0)) {
9017             xmlFatalErrMsg(ctxt, XML_ERR_ATTRIBUTE_NOT_FINISHED,
9018                            "AttValue length too long\n");
9019             return(NULL);
9020         }
9021         if (*in != limit) goto need_complex;
9022     } else {
9023         while ((in < end) && (*in != limit) && (*in >= 0x20) &&
9024                (*in <= 0x7f) && (*in != '&') && (*in != '<')) {
9025             in++;
9026             if (in >= end) {
9027                 const xmlChar *oldbase = ctxt->input->base;
9028                 GROW;
9029                 if (ctxt->instate == XML_PARSER_EOF)
9030                     return(NULL);
9031                 if (oldbase != ctxt->input->base) {
9032                     long delta = ctxt->input->base - oldbase;
9033                     start = start + delta;
9034                     in = in + delta;
9035                 }
9036                 end = ctxt->input->end;
9037                 if (((in - start) > XML_MAX_TEXT_LENGTH) &&
9038                     ((ctxt->options & XML_PARSE_HUGE) == 0)) {
9039                     xmlFatalErrMsg(ctxt, XML_ERR_ATTRIBUTE_NOT_FINISHED,
9040                                    "AttValue length too long\n");
9041                     return(NULL);
9042                 }
9043             }
9044         }
9045         last = in;
9046         if (((in - start) > XML_MAX_TEXT_LENGTH) &&
9047             ((ctxt->options & XML_PARSE_HUGE) == 0)) {
9048             xmlFatalErrMsg(ctxt, XML_ERR_ATTRIBUTE_NOT_FINISHED,
9049                            "AttValue length too long\n");
9050             return(NULL);
9051         }
9052         if (*in != limit) goto need_complex;
9053     }
9054     in++;
9055     if (len != NULL) {
9056         *len = last - start;
9057         ret = (xmlChar *) start;
9058     } else {
9059         if (alloc) *alloc = 1;
9060         ret = xmlStrndup(start, last - start);
9061     }
9062     CUR_PTR = in;
9063     if (alloc) *alloc = 0;
9064     return ret;
9065 need_complex:
9066     if (alloc) *alloc = 1;
9067     return xmlParseAttValueComplex(ctxt, len, normalize);
9068 }
9069
9070 /**
9071  * xmlParseAttribute2:
9072  * @ctxt:  an XML parser context
9073  * @pref:  the element prefix
9074  * @elem:  the element name
9075  * @prefix:  a xmlChar ** used to store the value of the attribute prefix
9076  * @value:  a xmlChar ** used to store the value of the attribute
9077  * @len:  an int * to save the length of the attribute
9078  * @alloc:  an int * to indicate if the attribute was allocated
9079  *
9080  * parse an attribute in the new SAX2 framework.
9081  *
9082  * Returns the attribute name, and the value in *value, .
9083  */
9084
9085 static const xmlChar *
9086 xmlParseAttribute2(xmlParserCtxtPtr ctxt,
9087                    const xmlChar * pref, const xmlChar * elem,
9088                    const xmlChar ** prefix, xmlChar ** value,
9089                    int *len, int *alloc)
9090 {
9091     const xmlChar *name;
9092     xmlChar *val, *internal_val = NULL;
9093     int normalize = 0;
9094
9095     *value = NULL;
9096     GROW;
9097     name = xmlParseQName(ctxt, prefix);
9098     if (name == NULL) {
9099         xmlFatalErrMsg(ctxt, XML_ERR_NAME_REQUIRED,
9100                        "error parsing attribute name\n");
9101         return (NULL);
9102     }
9103
9104     /*
9105      * get the type if needed
9106      */
9107     if (ctxt->attsSpecial != NULL) {
9108         int type;
9109
9110         type = (int) (long) xmlHashQLookup2(ctxt->attsSpecial,
9111                                             pref, elem, *prefix, name);
9112         if (type != 0)
9113             normalize = 1;
9114     }
9115
9116     /*
9117      * read the value
9118      */
9119     SKIP_BLANKS;
9120     if (RAW == '=') {
9121         NEXT;
9122         SKIP_BLANKS;
9123         val = xmlParseAttValueInternal(ctxt, len, alloc, normalize);
9124         if (normalize) {
9125             /*
9126              * Sometimes a second normalisation pass for spaces is needed
9127              * but that only happens if charrefs or entities refernces
9128              * have been used in the attribute value, i.e. the attribute
9129              * value have been extracted in an allocated string already.
9130              */
9131             if (*alloc) {
9132                 const xmlChar *val2;
9133
9134                 val2 = xmlAttrNormalizeSpace2(ctxt, val, len);
9135                 if ((val2 != NULL) && (val2 != val)) {
9136                     xmlFree(val);
9137                     val = (xmlChar *) val2;
9138                 }
9139             }
9140         }
9141         ctxt->instate = XML_PARSER_CONTENT;
9142     } else {
9143         xmlFatalErrMsgStr(ctxt, XML_ERR_ATTRIBUTE_WITHOUT_VALUE,
9144                           "Specification mandate value for attribute %s\n",
9145                           name);
9146         return (NULL);
9147     }
9148
9149     if (*prefix == ctxt->str_xml) {
9150         /*
9151          * Check that xml:lang conforms to the specification
9152          * No more registered as an error, just generate a warning now
9153          * since this was deprecated in XML second edition
9154          */
9155         if ((ctxt->pedantic) && (xmlStrEqual(name, BAD_CAST "lang"))) {
9156             internal_val = xmlStrndup(val, *len);
9157             if (!xmlCheckLanguageID(internal_val)) {
9158                 xmlWarningMsg(ctxt, XML_WAR_LANG_VALUE,
9159                               "Malformed value for xml:lang : %s\n",
9160                               internal_val, NULL);
9161             }
9162         }
9163
9164         /*
9165          * Check that xml:space conforms to the specification
9166          */
9167         if (xmlStrEqual(name, BAD_CAST "space")) {
9168             internal_val = xmlStrndup(val, *len);
9169             if (xmlStrEqual(internal_val, BAD_CAST "default"))
9170                 *(ctxt->space) = 0;
9171             else if (xmlStrEqual(internal_val, BAD_CAST "preserve"))
9172                 *(ctxt->space) = 1;
9173             else {
9174                 xmlWarningMsg(ctxt, XML_WAR_SPACE_VALUE,
9175                               "Invalid value \"%s\" for xml:space : \"default\" or \"preserve\" expected\n",
9176                               internal_val, NULL);
9177             }
9178         }
9179         if (internal_val) {
9180             xmlFree(internal_val);
9181         }
9182     }
9183
9184     *value = val;
9185     return (name);
9186 }
9187 /**
9188  * xmlParseStartTag2:
9189  * @ctxt:  an XML parser context
9190  *
9191  * parse a start of tag either for rule element or
9192  * EmptyElement. In both case we don't parse the tag closing chars.
9193  * This routine is called when running SAX2 parsing
9194  *
9195  * [40] STag ::= '<' Name (S Attribute)* S? '>'
9196  *
9197  * [ WFC: Unique Att Spec ]
9198  * No attribute name may appear more than once in the same start-tag or
9199  * empty-element tag.
9200  *
9201  * [44] EmptyElemTag ::= '<' Name (S Attribute)* S? '/>'
9202  *
9203  * [ WFC: Unique Att Spec ]
9204  * No attribute name may appear more than once in the same start-tag or
9205  * empty-element tag.
9206  *
9207  * With namespace:
9208  *
9209  * [NS 8] STag ::= '<' QName (S Attribute)* S? '>'
9210  *
9211  * [NS 10] EmptyElement ::= '<' QName (S Attribute)* S? '/>'
9212  *
9213  * Returns the element name parsed
9214  */
9215
9216 static const xmlChar *
9217 xmlParseStartTag2(xmlParserCtxtPtr ctxt, const xmlChar **pref,
9218                   const xmlChar **URI, int *tlen) {
9219     const xmlChar *localname;
9220     const xmlChar *prefix;
9221     const xmlChar *attname;
9222     const xmlChar *aprefix;
9223     const xmlChar *nsname;
9224     xmlChar *attvalue;
9225     const xmlChar **atts = ctxt->atts;
9226     int maxatts = ctxt->maxatts;
9227     int nratts, nbatts, nbdef;
9228     int i, j, nbNs, attval, oldline, oldcol;
9229     const xmlChar *base;
9230     unsigned long cur;
9231     int nsNr = ctxt->nsNr;
9232
9233     if (RAW != '<') return(NULL);
9234     NEXT1;
9235
9236     /*
9237      * NOTE: it is crucial with the SAX2 API to never call SHRINK beyond that
9238      *       point since the attribute values may be stored as pointers to
9239      *       the buffer and calling SHRINK would destroy them !
9240      *       The Shrinking is only possible once the full set of attribute
9241      *       callbacks have been done.
9242      */
9243 reparse:
9244     SHRINK;
9245     base = ctxt->input->base;
9246     cur = ctxt->input->cur - ctxt->input->base;
9247     oldline = ctxt->input->line;
9248     oldcol = ctxt->input->col;
9249     nbatts = 0;
9250     nratts = 0;
9251     nbdef = 0;
9252     nbNs = 0;
9253     attval = 0;
9254     /* Forget any namespaces added during an earlier parse of this element. */
9255     ctxt->nsNr = nsNr;
9256
9257     localname = xmlParseQName(ctxt, &prefix);
9258     if (localname == NULL) {
9259         xmlFatalErrMsg(ctxt, XML_ERR_NAME_REQUIRED,
9260                        "StartTag: invalid element name\n");
9261         return(NULL);
9262     }
9263     *tlen = ctxt->input->cur - ctxt->input->base - cur;
9264
9265     /*
9266      * Now parse the attributes, it ends up with the ending
9267      *
9268      * (S Attribute)* S?
9269      */
9270     SKIP_BLANKS;
9271     GROW;
9272     if (ctxt->input->base != base) goto base_changed;
9273
9274     while (((RAW != '>') &&
9275            ((RAW != '/') || (NXT(1) != '>')) &&
9276            (IS_BYTE_CHAR(RAW))) && (ctxt->instate != XML_PARSER_EOF)) {
9277         const xmlChar *q = CUR_PTR;
9278         unsigned int cons = ctxt->input->consumed;
9279         int len = -1, alloc = 0;
9280
9281         attname = xmlParseAttribute2(ctxt, prefix, localname,
9282                                      &aprefix, &attvalue, &len, &alloc);
9283         if (ctxt->input->base != base) {
9284             if ((attvalue != NULL) && (alloc != 0))
9285                 xmlFree(attvalue);
9286             attvalue = NULL;
9287             goto base_changed;
9288         }
9289         if ((attname != NULL) && (attvalue != NULL)) {
9290             if (len < 0) len = xmlStrlen(attvalue);
9291             if ((attname == ctxt->str_xmlns) && (aprefix == NULL)) {
9292                 const xmlChar *URL = xmlDictLookup(ctxt->dict, attvalue, len);
9293                 xmlURIPtr uri;
9294
9295                 if (*URL != 0) {
9296                     uri = xmlParseURI((const char *) URL);
9297                     if (uri == NULL) {
9298                         xmlNsErr(ctxt, XML_WAR_NS_URI,
9299                                  "xmlns: '%s' is not a valid URI\n",
9300                                            URL, NULL, NULL);
9301                     } else {
9302                         if (uri->scheme == NULL) {
9303                             xmlNsWarn(ctxt, XML_WAR_NS_URI_RELATIVE,
9304                                       "xmlns: URI %s is not absolute\n",
9305                                       URL, NULL, NULL);
9306                         }
9307                         xmlFreeURI(uri);
9308                     }
9309                     if (URL == ctxt->str_xml_ns) {
9310                         if (attname != ctxt->str_xml) {
9311                             xmlNsErr(ctxt, XML_NS_ERR_XML_NAMESPACE,
9312                          "xml namespace URI cannot be the default namespace\n",
9313                                      NULL, NULL, NULL);
9314                         }
9315                         goto skip_default_ns;
9316                     }
9317                     if ((len == 29) &&
9318                         (xmlStrEqual(URL,
9319                                  BAD_CAST "http://www.w3.org/2000/xmlns/"))) {
9320                         xmlNsErr(ctxt, XML_NS_ERR_XML_NAMESPACE,
9321                              "reuse of the xmlns namespace name is forbidden\n",
9322                                  NULL, NULL, NULL);
9323                         goto skip_default_ns;
9324                     }
9325                 }
9326                 /*
9327                  * check that it's not a defined namespace
9328                  */
9329                 for (j = 1;j <= nbNs;j++)
9330                     if (ctxt->nsTab[ctxt->nsNr - 2 * j] == NULL)
9331                         break;
9332                 if (j <= nbNs)
9333                     xmlErrAttributeDup(ctxt, NULL, attname);
9334                 else
9335                     if (nsPush(ctxt, NULL, URL) > 0) nbNs++;
9336 skip_default_ns:
9337                 if (alloc != 0) xmlFree(attvalue);
9338                 SKIP_BLANKS;
9339                 continue;
9340             }
9341             if (aprefix == ctxt->str_xmlns) {
9342                 const xmlChar *URL = xmlDictLookup(ctxt->dict, attvalue, len);
9343                 xmlURIPtr uri;
9344
9345                 if (attname == ctxt->str_xml) {
9346                     if (URL != ctxt->str_xml_ns) {
9347                         xmlNsErr(ctxt, XML_NS_ERR_XML_NAMESPACE,
9348                                  "xml namespace prefix mapped to wrong URI\n",
9349                                  NULL, NULL, NULL);
9350                     }
9351                     /*
9352                      * Do not keep a namespace definition node
9353                      */
9354                     goto skip_ns;
9355                 }
9356                 if (URL == ctxt->str_xml_ns) {
9357                     if (attname != ctxt->str_xml) {
9358                         xmlNsErr(ctxt, XML_NS_ERR_XML_NAMESPACE,
9359                                  "xml namespace URI mapped to wrong prefix\n",
9360                                  NULL, NULL, NULL);
9361                     }
9362                     goto skip_ns;
9363                 }
9364                 if (attname == ctxt->str_xmlns) {
9365                     xmlNsErr(ctxt, XML_NS_ERR_XML_NAMESPACE,
9366                              "redefinition of the xmlns prefix is forbidden\n",
9367                              NULL, NULL, NULL);
9368                     goto skip_ns;
9369                 }
9370                 if ((len == 29) &&
9371                     (xmlStrEqual(URL,
9372                                  BAD_CAST "http://www.w3.org/2000/xmlns/"))) {
9373                     xmlNsErr(ctxt, XML_NS_ERR_XML_NAMESPACE,
9374                              "reuse of the xmlns namespace name is forbidden\n",
9375                              NULL, NULL, NULL);
9376                     goto skip_ns;
9377                 }
9378                 if ((URL == NULL) || (URL[0] == 0)) {
9379                     xmlNsErr(ctxt, XML_NS_ERR_XML_NAMESPACE,
9380                              "xmlns:%s: Empty XML namespace is not allowed\n",
9381                                   attname, NULL, NULL);
9382                     goto skip_ns;
9383                 } else {
9384                     uri = xmlParseURI((const char *) URL);
9385                     if (uri == NULL) {
9386                         xmlNsErr(ctxt, XML_WAR_NS_URI,
9387                              "xmlns:%s: '%s' is not a valid URI\n",
9388                                            attname, URL, NULL);
9389                     } else {
9390                         if ((ctxt->pedantic) && (uri->scheme == NULL)) {
9391                             xmlNsWarn(ctxt, XML_WAR_NS_URI_RELATIVE,
9392                                       "xmlns:%s: URI %s is not absolute\n",
9393                                       attname, URL, NULL);
9394                         }
9395                         xmlFreeURI(uri);
9396                     }
9397                 }
9398
9399                 /*
9400                  * check that it's not a defined namespace
9401                  */
9402                 for (j = 1;j <= nbNs;j++)
9403                     if (ctxt->nsTab[ctxt->nsNr - 2 * j] == attname)
9404                         break;
9405                 if (j <= nbNs)
9406                     xmlErrAttributeDup(ctxt, aprefix, attname);
9407                 else
9408                     if (nsPush(ctxt, attname, URL) > 0) nbNs++;
9409 skip_ns:
9410                 if (alloc != 0) xmlFree(attvalue);
9411                 SKIP_BLANKS;
9412                 if (ctxt->input->base != base) goto base_changed;
9413                 continue;
9414             }
9415
9416             /*
9417              * Add the pair to atts
9418              */
9419             if ((atts == NULL) || (nbatts + 5 > maxatts)) {
9420                 if (xmlCtxtGrowAttrs(ctxt, nbatts + 5) < 0) {
9421                     if (attvalue[len] == 0)
9422                         xmlFree(attvalue);
9423                     goto failed;
9424                 }
9425                 maxatts = ctxt->maxatts;
9426                 atts = ctxt->atts;
9427             }
9428             ctxt->attallocs[nratts++] = alloc;
9429             atts[nbatts++] = attname;
9430             atts[nbatts++] = aprefix;
9431             atts[nbatts++] = NULL; /* the URI will be fetched later */
9432             atts[nbatts++] = attvalue;
9433             attvalue += len;
9434             atts[nbatts++] = attvalue;
9435             /*
9436              * tag if some deallocation is needed
9437              */
9438             if (alloc != 0) attval = 1;
9439         } else {
9440             if ((attvalue != NULL) && (attvalue[len] == 0))
9441                 xmlFree(attvalue);
9442         }
9443
9444 failed:
9445
9446         GROW
9447         if (ctxt->instate == XML_PARSER_EOF)
9448             break;
9449         if (ctxt->input->base != base) goto base_changed;
9450         if ((RAW == '>') || (((RAW == '/') && (NXT(1) == '>'))))
9451             break;
9452         if (!IS_BLANK_CH(RAW)) {
9453             xmlFatalErrMsg(ctxt, XML_ERR_SPACE_REQUIRED,
9454                            "attributes construct error\n");
9455             break;
9456         }
9457         SKIP_BLANKS;
9458         if ((cons == ctxt->input->consumed) && (q == CUR_PTR) &&
9459             (attname == NULL) && (attvalue == NULL)) {
9460             xmlFatalErr(ctxt, XML_ERR_INTERNAL_ERROR,
9461                  "xmlParseStartTag: problem parsing attributes\n");
9462             break;
9463         }
9464         GROW;
9465         if (ctxt->input->base != base) goto base_changed;
9466     }
9467
9468     /*
9469      * The attributes defaulting
9470      */
9471     if (ctxt->attsDefault != NULL) {
9472         xmlDefAttrsPtr defaults;
9473
9474         defaults = xmlHashLookup2(ctxt->attsDefault, localname, prefix);
9475         if (defaults != NULL) {
9476             for (i = 0;i < defaults->nbAttrs;i++) {
9477                 attname = defaults->values[5 * i];
9478                 aprefix = defaults->values[5 * i + 1];
9479
9480                 /*
9481                  * special work for namespaces defaulted defs
9482                  */
9483                 if ((attname == ctxt->str_xmlns) && (aprefix == NULL)) {
9484                     /*
9485                      * check that it's not a defined namespace
9486                      */
9487                     for (j = 1;j <= nbNs;j++)
9488                         if (ctxt->nsTab[ctxt->nsNr - 2 * j] == NULL)
9489                             break;
9490                     if (j <= nbNs) continue;
9491
9492                     nsname = xmlGetNamespace(ctxt, NULL);
9493                     if (nsname != defaults->values[5 * i + 2]) {
9494                         if (nsPush(ctxt, NULL,
9495                                    defaults->values[5 * i + 2]) > 0)
9496                             nbNs++;
9497                     }
9498                 } else if (aprefix == ctxt->str_xmlns) {
9499                     /*
9500                      * check that it's not a defined namespace
9501                      */
9502                     for (j = 1;j <= nbNs;j++)
9503                         if (ctxt->nsTab[ctxt->nsNr - 2 * j] == attname)
9504                             break;
9505                     if (j <= nbNs) continue;
9506
9507                     nsname = xmlGetNamespace(ctxt, attname);
9508                     if (nsname != defaults->values[2]) {
9509                         if (nsPush(ctxt, attname,
9510                                    defaults->values[5 * i + 2]) > 0)
9511                             nbNs++;
9512                     }
9513                 } else {
9514                     /*
9515                      * check that it's not a defined attribute
9516                      */
9517                     for (j = 0;j < nbatts;j+=5) {
9518                         if ((attname == atts[j]) && (aprefix == atts[j+1]))
9519                             break;
9520                     }
9521                     if (j < nbatts) continue;
9522
9523                     if ((atts == NULL) || (nbatts + 5 > maxatts)) {
9524                         if (xmlCtxtGrowAttrs(ctxt, nbatts + 5) < 0) {
9525                             return(NULL);
9526                         }
9527                         maxatts = ctxt->maxatts;
9528                         atts = ctxt->atts;
9529                     }
9530                     atts[nbatts++] = attname;
9531                     atts[nbatts++] = aprefix;
9532                     if (aprefix == NULL)
9533                         atts[nbatts++] = NULL;
9534                     else
9535                         atts[nbatts++] = xmlGetNamespace(ctxt, aprefix);
9536                     atts[nbatts++] = defaults->values[5 * i + 2];
9537                     atts[nbatts++] = defaults->values[5 * i + 3];
9538                     if ((ctxt->standalone == 1) &&
9539                         (defaults->values[5 * i + 4] != NULL)) {
9540                         xmlValidityError(ctxt, XML_DTD_STANDALONE_DEFAULTED,
9541           "standalone: attribute %s on %s defaulted from external subset\n",
9542                                          attname, localname);
9543                     }
9544                     nbdef++;
9545                 }
9546             }
9547         }
9548     }
9549
9550     /*
9551      * The attributes checkings
9552      */
9553     for (i = 0; i < nbatts;i += 5) {
9554         /*
9555         * The default namespace does not apply to attribute names.
9556         */
9557         if (atts[i + 1] != NULL) {
9558             nsname = xmlGetNamespace(ctxt, atts[i + 1]);
9559             if (nsname == NULL) {
9560                 xmlNsErr(ctxt, XML_NS_ERR_UNDEFINED_NAMESPACE,
9561                     "Namespace prefix %s for %s on %s is not defined\n",
9562                     atts[i + 1], atts[i], localname);
9563             }
9564             atts[i + 2] = nsname;
9565         } else
9566             nsname = NULL;
9567         /*
9568          * [ WFC: Unique Att Spec ]
9569          * No attribute name may appear more than once in the same
9570          * start-tag or empty-element tag.
9571          * As extended by the Namespace in XML REC.
9572          */
9573         for (j = 0; j < i;j += 5) {
9574             if (atts[i] == atts[j]) {
9575                 if (atts[i+1] == atts[j+1]) {
9576                     xmlErrAttributeDup(ctxt, atts[i+1], atts[i]);
9577                     break;
9578                 }
9579                 if ((nsname != NULL) && (atts[j + 2] == nsname)) {
9580                     xmlNsErr(ctxt, XML_NS_ERR_ATTRIBUTE_REDEFINED,
9581                              "Namespaced Attribute %s in '%s' redefined\n",
9582                              atts[i], nsname, NULL);
9583                     break;
9584                 }
9585             }
9586         }
9587     }
9588
9589     nsname = xmlGetNamespace(ctxt, prefix);
9590     if ((prefix != NULL) && (nsname == NULL)) {
9591         xmlNsErr(ctxt, XML_NS_ERR_UNDEFINED_NAMESPACE,
9592                  "Namespace prefix %s on %s is not defined\n",
9593                  prefix, localname, NULL);
9594     }
9595     *pref = prefix;
9596     *URI = nsname;
9597
9598     /*
9599      * SAX: Start of Element !
9600      */
9601     if ((ctxt->sax != NULL) && (ctxt->sax->startElementNs != NULL) &&
9602         (!ctxt->disableSAX)) {
9603         if (nbNs > 0)
9604             ctxt->sax->startElementNs(ctxt->userData, localname, prefix,
9605                           nsname, nbNs, &ctxt->nsTab[ctxt->nsNr - 2 * nbNs],
9606                           nbatts / 5, nbdef, atts);
9607         else
9608             ctxt->sax->startElementNs(ctxt->userData, localname, prefix,
9609                           nsname, 0, NULL, nbatts / 5, nbdef, atts);
9610     }
9611
9612     /*
9613      * Free up attribute allocated strings if needed
9614      */
9615     if (attval != 0) {
9616         for (i = 3,j = 0; j < nratts;i += 5,j++)
9617             if ((ctxt->attallocs[j] != 0) && (atts[i] != NULL))
9618                 xmlFree((xmlChar *) atts[i]);
9619     }
9620
9621     return(localname);
9622
9623 base_changed:
9624     /*
9625      * the attribute strings are valid iif the base didn't changed
9626      */
9627     if (attval != 0) {
9628         for (i = 3,j = 0; j < nratts;i += 5,j++)
9629             if ((ctxt->attallocs[j] != 0) && (atts[i] != NULL))
9630                 xmlFree((xmlChar *) atts[i]);
9631     }
9632     ctxt->input->cur = ctxt->input->base + cur;
9633     ctxt->input->line = oldline;
9634     ctxt->input->col = oldcol;
9635     if (ctxt->wellFormed == 1) {
9636         goto reparse;
9637     }
9638     return(NULL);
9639 }
9640
9641 /**
9642  * xmlParseEndTag2:
9643  * @ctxt:  an XML parser context
9644  * @line:  line of the start tag
9645  * @nsNr:  number of namespaces on the start tag
9646  *
9647  * parse an end of tag
9648  *
9649  * [42] ETag ::= '</' Name S? '>'
9650  *
9651  * With namespace
9652  *
9653  * [NS 9] ETag ::= '</' QName S? '>'
9654  */
9655
9656 static void
9657 xmlParseEndTag2(xmlParserCtxtPtr ctxt, const xmlChar *prefix,
9658                 const xmlChar *URI, int line, int nsNr, int tlen) {
9659     const xmlChar *name;
9660
9661     GROW;
9662     if ((RAW != '<') || (NXT(1) != '/')) {
9663         xmlFatalErr(ctxt, XML_ERR_LTSLASH_REQUIRED, NULL);
9664         return;
9665     }
9666     SKIP(2);
9667
9668     if ((tlen > 0) && (xmlStrncmp(ctxt->input->cur, ctxt->name, tlen) == 0)) {
9669         if (ctxt->input->cur[tlen] == '>') {
9670             ctxt->input->cur += tlen + 1;
9671             goto done;
9672         }
9673         ctxt->input->cur += tlen;
9674         name = (xmlChar*)1;
9675     } else {
9676         if (prefix == NULL)
9677             name = xmlParseNameAndCompare(ctxt, ctxt->name);
9678         else
9679             name = xmlParseQNameAndCompare(ctxt, ctxt->name, prefix);
9680     }
9681
9682     /*
9683      * We should definitely be at the ending "S? '>'" part
9684      */
9685     GROW;
9686     if (ctxt->instate == XML_PARSER_EOF)
9687         return;
9688     SKIP_BLANKS;
9689     if ((!IS_BYTE_CHAR(RAW)) || (RAW != '>')) {
9690         xmlFatalErr(ctxt, XML_ERR_GT_REQUIRED, NULL);
9691     } else
9692         NEXT1;
9693
9694     /*
9695      * [ WFC: Element Type Match ]
9696      * The Name in an element's end-tag must match the element type in the
9697      * start-tag.
9698      *
9699      */
9700     if (name != (xmlChar*)1) {
9701         if (name == NULL) name = BAD_CAST "unparseable";
9702         if ((line == 0) && (ctxt->node != NULL))
9703             line = ctxt->node->line;
9704         xmlFatalErrMsgStrIntStr(ctxt, XML_ERR_TAG_NAME_MISMATCH,
9705                      "Opening and ending tag mismatch: %s line %d and %s\n",
9706                                 ctxt->name, line, name);
9707     }
9708
9709     /*
9710      * SAX: End of Tag
9711      */
9712 done:
9713     if ((ctxt->sax != NULL) && (ctxt->sax->endElementNs != NULL) &&
9714         (!ctxt->disableSAX))
9715         ctxt->sax->endElementNs(ctxt->userData, ctxt->name, prefix, URI);
9716
9717     spacePop(ctxt);
9718     if (nsNr != 0)
9719         nsPop(ctxt, nsNr);
9720     return;
9721 }
9722
9723 /**
9724  * xmlParseCDSect:
9725  * @ctxt:  an XML parser context
9726  *
9727  * Parse escaped pure raw content.
9728  *
9729  * [18] CDSect ::= CDStart CData CDEnd
9730  *
9731  * [19] CDStart ::= '<![CDATA['
9732  *
9733  * [20] Data ::= (Char* - (Char* ']]>' Char*))
9734  *
9735  * [21] CDEnd ::= ']]>'
9736  */
9737 void
9738 xmlParseCDSect(xmlParserCtxtPtr ctxt) {
9739     xmlChar *buf = NULL;
9740     int len = 0;
9741     int size = XML_PARSER_BUFFER_SIZE;
9742     int r, rl;
9743     int s, sl;
9744     int cur, l;
9745     int count = 0;
9746
9747     /* Check 2.6.0 was NXT(0) not RAW */
9748     if (CMP9(CUR_PTR, '<', '!', '[', 'C', 'D', 'A', 'T', 'A', '[')) {
9749         SKIP(9);
9750     } else
9751         return;
9752
9753     ctxt->instate = XML_PARSER_CDATA_SECTION;
9754     r = CUR_CHAR(rl);
9755     if (!IS_CHAR(r)) {
9756         xmlFatalErr(ctxt, XML_ERR_CDATA_NOT_FINISHED, NULL);
9757         ctxt->instate = XML_PARSER_CONTENT;
9758         return;
9759     }
9760     NEXTL(rl);
9761     s = CUR_CHAR(sl);
9762     if (!IS_CHAR(s)) {
9763         xmlFatalErr(ctxt, XML_ERR_CDATA_NOT_FINISHED, NULL);
9764         ctxt->instate = XML_PARSER_CONTENT;
9765         return;
9766     }
9767     NEXTL(sl);
9768     cur = CUR_CHAR(l);
9769     buf = (xmlChar *) xmlMallocAtomic(size * sizeof(xmlChar));
9770     if (buf == NULL) {
9771         xmlErrMemory(ctxt, NULL);
9772         return;
9773     }
9774     while (IS_CHAR(cur) &&
9775            ((r != ']') || (s != ']') || (cur != '>'))) {
9776         if (len + 5 >= size) {
9777             xmlChar *tmp;
9778
9779             if ((size > XML_MAX_TEXT_LENGTH) &&
9780                 ((ctxt->options & XML_PARSE_HUGE) == 0)) {
9781                 xmlFatalErrMsgStr(ctxt, XML_ERR_CDATA_NOT_FINISHED,
9782                              "CData section too big found", NULL);
9783                 xmlFree (buf);
9784                 return;
9785             }
9786             tmp = (xmlChar *) xmlRealloc(buf, size * 2 * sizeof(xmlChar));
9787             if (tmp == NULL) {
9788                 xmlFree(buf);
9789                 xmlErrMemory(ctxt, NULL);
9790                 return;
9791             }
9792             buf = tmp;
9793             size *= 2;
9794         }
9795         COPY_BUF(rl,buf,len,r);
9796         r = s;
9797         rl = sl;
9798         s = cur;
9799         sl = l;
9800         count++;
9801         if (count > 50) {
9802             GROW;
9803             if (ctxt->instate == XML_PARSER_EOF) {
9804                 xmlFree(buf);
9805                 return;
9806             }
9807             count = 0;
9808         }
9809         NEXTL(l);
9810         cur = CUR_CHAR(l);
9811     }
9812     buf[len] = 0;
9813     ctxt->instate = XML_PARSER_CONTENT;
9814     if (cur != '>') {
9815         xmlFatalErrMsgStr(ctxt, XML_ERR_CDATA_NOT_FINISHED,
9816                              "CData section not finished\n%.50s\n", buf);
9817         xmlFree(buf);
9818         return;
9819     }
9820     NEXTL(l);
9821
9822     /*
9823      * OK the buffer is to be consumed as cdata.
9824      */
9825     if ((ctxt->sax != NULL) && (!ctxt->disableSAX)) {
9826         if (ctxt->sax->cdataBlock != NULL)
9827             ctxt->sax->cdataBlock(ctxt->userData, buf, len);
9828         else if (ctxt->sax->characters != NULL)
9829             ctxt->sax->characters(ctxt->userData, buf, len);
9830     }
9831     xmlFree(buf);
9832 }
9833
9834 /**
9835  * xmlParseContent:
9836  * @ctxt:  an XML parser context
9837  *
9838  * Parse a content:
9839  *
9840  * [43] content ::= (element | CharData | Reference | CDSect | PI | Comment)*
9841  */
9842
9843 void
9844 xmlParseContent(xmlParserCtxtPtr ctxt) {
9845     GROW;
9846     while ((RAW != 0) &&
9847            ((RAW != '<') || (NXT(1) != '/')) &&
9848            (ctxt->instate != XML_PARSER_EOF)) {
9849         const xmlChar *test = CUR_PTR;
9850         unsigned int cons = ctxt->input->consumed;
9851         const xmlChar *cur = ctxt->input->cur;
9852
9853         /*
9854          * First case : a Processing Instruction.
9855          */
9856         if ((*cur == '<') && (cur[1] == '?')) {
9857             xmlParsePI(ctxt);
9858         }
9859
9860         /*
9861          * Second case : a CDSection
9862          */
9863         /* 2.6.0 test was *cur not RAW */
9864         else if (CMP9(CUR_PTR, '<', '!', '[', 'C', 'D', 'A', 'T', 'A', '[')) {
9865             xmlParseCDSect(ctxt);
9866         }
9867
9868         /*
9869          * Third case :  a comment
9870          */
9871         else if ((*cur == '<') && (NXT(1) == '!') &&
9872                  (NXT(2) == '-') && (NXT(3) == '-')) {
9873             xmlParseComment(ctxt);
9874             ctxt->instate = XML_PARSER_CONTENT;
9875         }
9876
9877         /*
9878          * Fourth case :  a sub-element.
9879          */
9880         else if (*cur == '<') {
9881             xmlParseElement(ctxt);
9882         }
9883
9884         /*
9885          * Fifth case : a reference. If if has not been resolved,
9886          *    parsing returns it's Name, create the node
9887          */
9888
9889         else if (*cur == '&') {
9890             xmlParseReference(ctxt);
9891         }
9892
9893         /*
9894          * Last case, text. Note that References are handled directly.
9895          */
9896         else {
9897             xmlParseCharData(ctxt, 0);
9898         }
9899
9900         GROW;
9901         /*
9902          * Pop-up of finished entities.
9903          */
9904         while ((RAW == 0) && (ctxt->inputNr > 1))
9905             xmlPopInput(ctxt);
9906         SHRINK;
9907
9908         if ((cons == ctxt->input->consumed) && (test == CUR_PTR)) {
9909             xmlFatalErr(ctxt, XML_ERR_INTERNAL_ERROR,
9910                         "detected an error in element content\n");
9911             ctxt->instate = XML_PARSER_EOF;
9912             break;
9913         }
9914     }
9915 }
9916
9917 /**
9918  * xmlParseElement:
9919  * @ctxt:  an XML parser context
9920  *
9921  * parse an XML element, this is highly recursive
9922  *
9923  * [39] element ::= EmptyElemTag | STag content ETag
9924  *
9925  * [ WFC: Element Type Match ]
9926  * The Name in an element's end-tag must match the element type in the
9927  * start-tag.
9928  *
9929  */
9930
9931 void
9932 xmlParseElement(xmlParserCtxtPtr ctxt) {
9933     const xmlChar *name;
9934     const xmlChar *prefix = NULL;
9935     const xmlChar *URI = NULL;
9936     xmlParserNodeInfo node_info;
9937     int line, tlen = 0;
9938     xmlNodePtr ret;
9939     int nsNr = ctxt->nsNr;
9940
9941     if (((unsigned int) ctxt->nameNr > xmlParserMaxDepth) &&
9942         ((ctxt->options & XML_PARSE_HUGE) == 0)) {
9943         xmlFatalErrMsgInt(ctxt, XML_ERR_INTERNAL_ERROR,
9944                  "Excessive depth in document: %d use XML_PARSE_HUGE option\n",
9945                           xmlParserMaxDepth);
9946         ctxt->instate = XML_PARSER_EOF;
9947         return;
9948     }
9949
9950     /* Capture start position */
9951     if (ctxt->record_info) {
9952         node_info.begin_pos = ctxt->input->consumed +
9953                           (CUR_PTR - ctxt->input->base);
9954         node_info.begin_line = ctxt->input->line;
9955     }
9956
9957     if (ctxt->spaceNr == 0)
9958         spacePush(ctxt, -1);
9959     else if (*ctxt->space == -2)
9960         spacePush(ctxt, -1);
9961     else
9962         spacePush(ctxt, *ctxt->space);
9963
9964     line = ctxt->input->line;
9965 #ifdef LIBXML_SAX1_ENABLED
9966     if (ctxt->sax2)
9967 #endif /* LIBXML_SAX1_ENABLED */
9968         name = xmlParseStartTag2(ctxt, &prefix, &URI, &tlen);
9969 #ifdef LIBXML_SAX1_ENABLED
9970     else
9971         name = xmlParseStartTag(ctxt);
9972 #endif /* LIBXML_SAX1_ENABLED */
9973     if (ctxt->instate == XML_PARSER_EOF)
9974         return;
9975     if (name == NULL) {
9976         spacePop(ctxt);
9977         return;
9978     }
9979     namePush(ctxt, name);
9980     ret = ctxt->node;
9981
9982 #ifdef LIBXML_VALID_ENABLED
9983     /*
9984      * [ VC: Root Element Type ]
9985      * The Name in the document type declaration must match the element
9986      * type of the root element.
9987      */
9988     if (ctxt->validate && ctxt->wellFormed && ctxt->myDoc &&
9989         ctxt->node && (ctxt->node == ctxt->myDoc->children))
9990         ctxt->valid &= xmlValidateRoot(&ctxt->vctxt, ctxt->myDoc);
9991 #endif /* LIBXML_VALID_ENABLED */
9992
9993     /*
9994      * Check for an Empty Element.
9995      */
9996     if ((RAW == '/') && (NXT(1) == '>')) {
9997         SKIP(2);
9998         if (ctxt->sax2) {
9999             if ((ctxt->sax != NULL) && (ctxt->sax->endElementNs != NULL) &&
10000                 (!ctxt->disableSAX))
10001                 ctxt->sax->endElementNs(ctxt->userData, name, prefix, URI);
10002 #ifdef LIBXML_SAX1_ENABLED
10003         } else {
10004             if ((ctxt->sax != NULL) && (ctxt->sax->endElement != NULL) &&
10005                 (!ctxt->disableSAX))
10006                 ctxt->sax->endElement(ctxt->userData, name);
10007 #endif /* LIBXML_SAX1_ENABLED */
10008         }
10009         namePop(ctxt);
10010         spacePop(ctxt);
10011         if (nsNr != ctxt->nsNr)
10012             nsPop(ctxt, ctxt->nsNr - nsNr);
10013         if ( ret != NULL && ctxt->record_info ) {
10014            node_info.end_pos = ctxt->input->consumed +
10015                               (CUR_PTR - ctxt->input->base);
10016            node_info.end_line = ctxt->input->line;
10017            node_info.node = ret;
10018            xmlParserAddNodeInfo(ctxt, &node_info);
10019         }
10020         return;
10021     }
10022     if (RAW == '>') {
10023         NEXT1;
10024     } else {
10025         xmlFatalErrMsgStrIntStr(ctxt, XML_ERR_GT_REQUIRED,
10026                      "Couldn't find end of Start Tag %s line %d\n",
10027                                 name, line, NULL);
10028
10029         /*
10030          * end of parsing of this node.
10031          */
10032         nodePop(ctxt);
10033         namePop(ctxt);
10034         spacePop(ctxt);
10035         if (nsNr != ctxt->nsNr)
10036             nsPop(ctxt, ctxt->nsNr - nsNr);
10037
10038         /*
10039          * Capture end position and add node
10040          */
10041         if ( ret != NULL && ctxt->record_info ) {
10042            node_info.end_pos = ctxt->input->consumed +
10043                               (CUR_PTR - ctxt->input->base);
10044            node_info.end_line = ctxt->input->line;
10045            node_info.node = ret;
10046            xmlParserAddNodeInfo(ctxt, &node_info);
10047         }
10048         return;
10049     }
10050
10051     /*
10052      * Parse the content of the element:
10053      */
10054     xmlParseContent(ctxt);
10055     if (ctxt->instate == XML_PARSER_EOF)
10056         return;
10057     if (!IS_BYTE_CHAR(RAW)) {
10058         xmlFatalErrMsgStrIntStr(ctxt, XML_ERR_TAG_NOT_FINISHED,
10059          "Premature end of data in tag %s line %d\n",
10060                                 name, line, NULL);
10061
10062         /*
10063          * end of parsing of this node.
10064          */
10065         nodePop(ctxt);
10066         namePop(ctxt);
10067         spacePop(ctxt);
10068         if (nsNr != ctxt->nsNr)
10069             nsPop(ctxt, ctxt->nsNr - nsNr);
10070         return;
10071     }
10072
10073     /*
10074      * parse the end of tag: '</' should be here.
10075      */
10076     if (ctxt->sax2) {
10077         xmlParseEndTag2(ctxt, prefix, URI, line, ctxt->nsNr - nsNr, tlen);
10078         namePop(ctxt);
10079     }
10080 #ifdef LIBXML_SAX1_ENABLED
10081       else
10082         xmlParseEndTag1(ctxt, line);
10083 #endif /* LIBXML_SAX1_ENABLED */
10084
10085     /*
10086      * Capture end position and add node
10087      */
10088     if ( ret != NULL && ctxt->record_info ) {
10089        node_info.end_pos = ctxt->input->consumed +
10090                           (CUR_PTR - ctxt->input->base);
10091        node_info.end_line = ctxt->input->line;
10092        node_info.node = ret;
10093        xmlParserAddNodeInfo(ctxt, &node_info);
10094     }
10095 }
10096
10097 /**
10098  * xmlParseVersionNum:
10099  * @ctxt:  an XML parser context
10100  *
10101  * parse the XML version value.
10102  *
10103  * [26] VersionNum ::= '1.' [0-9]+
10104  *
10105  * In practice allow [0-9].[0-9]+ at that level
10106  *
10107  * Returns the string giving the XML version number, or NULL
10108  */
10109 xmlChar *
10110 xmlParseVersionNum(xmlParserCtxtPtr ctxt) {
10111     xmlChar *buf = NULL;
10112     int len = 0;
10113     int size = 10;
10114     xmlChar cur;
10115
10116     buf = (xmlChar *) xmlMallocAtomic(size * sizeof(xmlChar));
10117     if (buf == NULL) {
10118         xmlErrMemory(ctxt, NULL);
10119         return(NULL);
10120     }
10121     cur = CUR;
10122     if (!((cur >= '0') && (cur <= '9'))) {
10123         xmlFree(buf);
10124         return(NULL);
10125     }
10126     buf[len++] = cur;
10127     NEXT;
10128     cur=CUR;
10129     if (cur != '.') {
10130         xmlFree(buf);
10131         return(NULL);
10132     }
10133     buf[len++] = cur;
10134     NEXT;
10135     cur=CUR;
10136     while ((cur >= '0') && (cur <= '9')) {
10137         if (len + 1 >= size) {
10138             xmlChar *tmp;
10139
10140             size *= 2;
10141             tmp = (xmlChar *) xmlRealloc(buf, size * sizeof(xmlChar));
10142             if (tmp == NULL) {
10143                 xmlFree(buf);
10144                 xmlErrMemory(ctxt, NULL);
10145                 return(NULL);
10146             }
10147             buf = tmp;
10148         }
10149         buf[len++] = cur;
10150         NEXT;
10151         cur=CUR;
10152     }
10153     buf[len] = 0;
10154     return(buf);
10155 }
10156
10157 /**
10158  * xmlParseVersionInfo:
10159  * @ctxt:  an XML parser context
10160  *
10161  * parse the XML version.
10162  *
10163  * [24] VersionInfo ::= S 'version' Eq (' VersionNum ' | " VersionNum ")
10164  *
10165  * [25] Eq ::= S? '=' S?
10166  *
10167  * Returns the version string, e.g. "1.0"
10168  */
10169
10170 xmlChar *
10171 xmlParseVersionInfo(xmlParserCtxtPtr ctxt) {
10172     xmlChar *version = NULL;
10173
10174     if (CMP7(CUR_PTR, 'v', 'e', 'r', 's', 'i', 'o', 'n')) {
10175         SKIP(7);
10176         SKIP_BLANKS;
10177         if (RAW != '=') {
10178             xmlFatalErr(ctxt, XML_ERR_EQUAL_REQUIRED, NULL);
10179             return(NULL);
10180         }
10181         NEXT;
10182         SKIP_BLANKS;
10183         if (RAW == '"') {
10184             NEXT;
10185             version = xmlParseVersionNum(ctxt);
10186             if (RAW != '"') {
10187                 xmlFatalErr(ctxt, XML_ERR_STRING_NOT_CLOSED, NULL);
10188             } else
10189                 NEXT;
10190         } else if (RAW == '\''){
10191             NEXT;
10192             version = xmlParseVersionNum(ctxt);
10193             if (RAW != '\'') {
10194                 xmlFatalErr(ctxt, XML_ERR_STRING_NOT_CLOSED, NULL);
10195             } else
10196                 NEXT;
10197         } else {
10198             xmlFatalErr(ctxt, XML_ERR_STRING_NOT_STARTED, NULL);
10199         }
10200     }
10201     return(version);
10202 }
10203
10204 /**
10205  * xmlParseEncName:
10206  * @ctxt:  an XML parser context
10207  *
10208  * parse the XML encoding name
10209  *
10210  * [81] EncName ::= [A-Za-z] ([A-Za-z0-9._] | '-')*
10211  *
10212  * Returns the encoding name value or NULL
10213  */
10214 xmlChar *
10215 xmlParseEncName(xmlParserCtxtPtr ctxt) {
10216     xmlChar *buf = NULL;
10217     int len = 0;
10218     int size = 10;
10219     xmlChar cur;
10220
10221     cur = CUR;
10222     if (((cur >= 'a') && (cur <= 'z')) ||
10223         ((cur >= 'A') && (cur <= 'Z'))) {
10224         buf = (xmlChar *) xmlMallocAtomic(size * sizeof(xmlChar));
10225         if (buf == NULL) {
10226             xmlErrMemory(ctxt, NULL);
10227             return(NULL);
10228         }
10229
10230         buf[len++] = cur;
10231         NEXT;
10232         cur = CUR;
10233         while (((cur >= 'a') && (cur <= 'z')) ||
10234                ((cur >= 'A') && (cur <= 'Z')) ||
10235                ((cur >= '0') && (cur <= '9')) ||
10236                (cur == '.') || (cur == '_') ||
10237                (cur == '-')) {
10238             if (len + 1 >= size) {
10239                 xmlChar *tmp;
10240
10241                 size *= 2;
10242                 tmp = (xmlChar *) xmlRealloc(buf, size * sizeof(xmlChar));
10243                 if (tmp == NULL) {
10244                     xmlErrMemory(ctxt, NULL);
10245                     xmlFree(buf);
10246                     return(NULL);
10247                 }
10248                 buf = tmp;
10249             }
10250             buf[len++] = cur;
10251             NEXT;
10252             cur = CUR;
10253             if (cur == 0) {
10254                 SHRINK;
10255                 GROW;
10256                 cur = CUR;
10257             }
10258         }
10259         buf[len] = 0;
10260     } else {
10261         xmlFatalErr(ctxt, XML_ERR_ENCODING_NAME, NULL);
10262     }
10263     return(buf);
10264 }
10265
10266 /**
10267  * xmlParseEncodingDecl:
10268  * @ctxt:  an XML parser context
10269  *
10270  * parse the XML encoding declaration
10271  *
10272  * [80] EncodingDecl ::= S 'encoding' Eq ('"' EncName '"' |  "'" EncName "'")
10273  *
10274  * this setups the conversion filters.
10275  *
10276  * Returns the encoding value or NULL
10277  */
10278
10279 const xmlChar *
10280 xmlParseEncodingDecl(xmlParserCtxtPtr ctxt) {
10281     xmlChar *encoding = NULL;
10282
10283     SKIP_BLANKS;
10284     if (CMP8(CUR_PTR, 'e', 'n', 'c', 'o', 'd', 'i', 'n', 'g')) {
10285         SKIP(8);
10286         SKIP_BLANKS;
10287         if (RAW != '=') {
10288             xmlFatalErr(ctxt, XML_ERR_EQUAL_REQUIRED, NULL);
10289             return(NULL);
10290         }
10291         NEXT;
10292         SKIP_BLANKS;
10293         if (RAW == '"') {
10294             NEXT;
10295             encoding = xmlParseEncName(ctxt);
10296             if (RAW != '"') {
10297                 xmlFatalErr(ctxt, XML_ERR_STRING_NOT_CLOSED, NULL);
10298             } else
10299                 NEXT;
10300         } else if (RAW == '\''){
10301             NEXT;
10302             encoding = xmlParseEncName(ctxt);
10303             if (RAW != '\'') {
10304                 xmlFatalErr(ctxt, XML_ERR_STRING_NOT_CLOSED, NULL);
10305             } else
10306                 NEXT;
10307         } else {
10308             xmlFatalErr(ctxt, XML_ERR_STRING_NOT_STARTED, NULL);
10309         }
10310
10311         /*
10312          * Non standard parsing, allowing the user to ignore encoding
10313          */
10314         if (ctxt->options & XML_PARSE_IGNORE_ENC)
10315             return(encoding);
10316
10317         /*
10318          * UTF-16 encoding stwich has already taken place at this stage,
10319          * more over the little-endian/big-endian selection is already done
10320          */
10321         if ((encoding != NULL) &&
10322             ((!xmlStrcasecmp(encoding, BAD_CAST "UTF-16")) ||
10323              (!xmlStrcasecmp(encoding, BAD_CAST "UTF16")))) {
10324             /*
10325              * If no encoding was passed to the parser, that we are
10326              * using UTF-16 and no decoder is present i.e. the
10327              * document is apparently UTF-8 compatible, then raise an
10328              * encoding mismatch fatal error
10329              */
10330             if ((ctxt->encoding == NULL) &&
10331                 (ctxt->input->buf != NULL) &&
10332                 (ctxt->input->buf->encoder == NULL)) {
10333                 xmlFatalErrMsg(ctxt, XML_ERR_INVALID_ENCODING,
10334                   "Document labelled UTF-16 but has UTF-8 content\n");
10335             }
10336             if (ctxt->encoding != NULL)
10337                 xmlFree((xmlChar *) ctxt->encoding);
10338             ctxt->encoding = encoding;
10339         }
10340         /*
10341          * UTF-8 encoding is handled natively
10342          */
10343         else if ((encoding != NULL) &&
10344             ((!xmlStrcasecmp(encoding, BAD_CAST "UTF-8")) ||
10345              (!xmlStrcasecmp(encoding, BAD_CAST "UTF8")))) {
10346             if (ctxt->encoding != NULL)
10347                 xmlFree((xmlChar *) ctxt->encoding);
10348             ctxt->encoding = encoding;
10349         }
10350         else if (encoding != NULL) {
10351             xmlCharEncodingHandlerPtr handler;
10352
10353             if (ctxt->input->encoding != NULL)
10354                 xmlFree((xmlChar *) ctxt->input->encoding);
10355             ctxt->input->encoding = encoding;
10356
10357             handler = xmlFindCharEncodingHandler((const char *) encoding);
10358             if (handler != NULL) {
10359                 xmlSwitchToEncoding(ctxt, handler);
10360             } else {
10361                 xmlFatalErrMsgStr(ctxt, XML_ERR_UNSUPPORTED_ENCODING,
10362                         "Unsupported encoding %s\n", encoding);
10363                 return(NULL);
10364             }
10365         }
10366     }
10367     return(encoding);
10368 }
10369
10370 /**
10371  * xmlParseSDDecl:
10372  * @ctxt:  an XML parser context
10373  *
10374  * parse the XML standalone declaration
10375  *
10376  * [32] SDDecl ::= S 'standalone' Eq
10377  *                 (("'" ('yes' | 'no') "'") | ('"' ('yes' | 'no')'"'))
10378  *
10379  * [ VC: Standalone Document Declaration ]
10380  * TODO The standalone document declaration must have the value "no"
10381  * if any external markup declarations contain declarations of:
10382  *  - attributes with default values, if elements to which these
10383  *    attributes apply appear in the document without specifications
10384  *    of values for these attributes, or
10385  *  - entities (other than amp, lt, gt, apos, quot), if references
10386  *    to those entities appear in the document, or
10387  *  - attributes with values subject to normalization, where the
10388  *    attribute appears in the document with a value which will change
10389  *    as a result of normalization, or
10390  *  - element types with element content, if white space occurs directly
10391  *    within any instance of those types.
10392  *
10393  * Returns:
10394  *   1 if standalone="yes"
10395  *   0 if standalone="no"
10396  *  -2 if standalone attribute is missing or invalid
10397  *        (A standalone value of -2 means that the XML declaration was found,
10398  *         but no value was specified for the standalone attribute).
10399  */
10400
10401 int
10402 xmlParseSDDecl(xmlParserCtxtPtr ctxt) {
10403     int standalone = -2;
10404
10405     SKIP_BLANKS;
10406     if (CMP10(CUR_PTR, 's', 't', 'a', 'n', 'd', 'a', 'l', 'o', 'n', 'e')) {
10407         SKIP(10);
10408         SKIP_BLANKS;
10409         if (RAW != '=') {
10410             xmlFatalErr(ctxt, XML_ERR_EQUAL_REQUIRED, NULL);
10411             return(standalone);
10412         }
10413         NEXT;
10414         SKIP_BLANKS;
10415         if (RAW == '\''){
10416             NEXT;
10417             if ((RAW == 'n') && (NXT(1) == 'o')) {
10418                 standalone = 0;
10419                 SKIP(2);
10420             } else if ((RAW == 'y') && (NXT(1) == 'e') &&
10421                        (NXT(2) == 's')) {
10422                 standalone = 1;
10423                 SKIP(3);
10424             } else {
10425                 xmlFatalErr(ctxt, XML_ERR_STANDALONE_VALUE, NULL);
10426             }
10427             if (RAW != '\'') {
10428                 xmlFatalErr(ctxt, XML_ERR_STRING_NOT_CLOSED, NULL);
10429             } else
10430                 NEXT;
10431         } else if (RAW == '"'){
10432             NEXT;
10433             if ((RAW == 'n') && (NXT(1) == 'o')) {
10434                 standalone = 0;
10435                 SKIP(2);
10436             } else if ((RAW == 'y') && (NXT(1) == 'e') &&
10437                        (NXT(2) == 's')) {
10438                 standalone = 1;
10439                 SKIP(3);
10440             } else {
10441                 xmlFatalErr(ctxt, XML_ERR_STANDALONE_VALUE, NULL);
10442             }
10443             if (RAW != '"') {
10444                 xmlFatalErr(ctxt, XML_ERR_STRING_NOT_CLOSED, NULL);
10445             } else
10446                 NEXT;
10447         } else {
10448             xmlFatalErr(ctxt, XML_ERR_STRING_NOT_STARTED, NULL);
10449         }
10450     }
10451     return(standalone);
10452 }
10453
10454 /**
10455  * xmlParseXMLDecl:
10456  * @ctxt:  an XML parser context
10457  *
10458  * parse an XML declaration header
10459  *
10460  * [23] XMLDecl ::= '<?xml' VersionInfo EncodingDecl? SDDecl? S? '?>'
10461  */
10462
10463 void
10464 xmlParseXMLDecl(xmlParserCtxtPtr ctxt) {
10465     xmlChar *version;
10466
10467     /*
10468      * This value for standalone indicates that the document has an
10469      * XML declaration but it does not have a standalone attribute.
10470      * It will be overwritten later if a standalone attribute is found.
10471      */
10472     ctxt->input->standalone = -2;
10473
10474     /*
10475      * We know that '<?xml' is here.
10476      */
10477     SKIP(5);
10478
10479     if (!IS_BLANK_CH(RAW)) {
10480         xmlFatalErrMsg(ctxt, XML_ERR_SPACE_REQUIRED,
10481                        "Blank needed after '<?xml'\n");
10482     }
10483     SKIP_BLANKS;
10484
10485     /*
10486      * We must have the VersionInfo here.
10487      */
10488     version = xmlParseVersionInfo(ctxt);
10489     if (version == NULL) {
10490         xmlFatalErr(ctxt, XML_ERR_VERSION_MISSING, NULL);
10491     } else {
10492         if (!xmlStrEqual(version, (const xmlChar *) XML_DEFAULT_VERSION)) {
10493             /*
10494              * Changed here for XML-1.0 5th edition
10495              */
10496             if (ctxt->options & XML_PARSE_OLD10) {
10497                 xmlFatalErrMsgStr(ctxt, XML_ERR_UNKNOWN_VERSION,
10498                                   "Unsupported version '%s'\n",
10499                                   version);
10500             } else {
10501                 if ((version[0] == '1') && ((version[1] == '.'))) {
10502                     xmlWarningMsg(ctxt, XML_WAR_UNKNOWN_VERSION,
10503                                   "Unsupported version '%s'\n",
10504                                   version, NULL);
10505                 } else {
10506                     xmlFatalErrMsgStr(ctxt, XML_ERR_UNKNOWN_VERSION,
10507                                       "Unsupported version '%s'\n",
10508                                       version);
10509                 }
10510             }
10511         }
10512         if (ctxt->version != NULL)
10513             xmlFree((void *) ctxt->version);
10514         ctxt->version = version;
10515     }
10516
10517     /*
10518      * We may have the encoding declaration
10519      */
10520     if (!IS_BLANK_CH(RAW)) {
10521         if ((RAW == '?') && (NXT(1) == '>')) {
10522             SKIP(2);
10523             return;
10524         }
10525         xmlFatalErrMsg(ctxt, XML_ERR_SPACE_REQUIRED, "Blank needed here\n");
10526     }
10527     xmlParseEncodingDecl(ctxt);
10528     if (ctxt->errNo == XML_ERR_UNSUPPORTED_ENCODING) {
10529         /*
10530          * The XML REC instructs us to stop parsing right here
10531          */
10532         return;
10533     }
10534
10535     /*
10536      * We may have the standalone status.
10537      */
10538     if ((ctxt->input->encoding != NULL) && (!IS_BLANK_CH(RAW))) {
10539         if ((RAW == '?') && (NXT(1) == '>')) {
10540             SKIP(2);
10541             return;
10542         }
10543         xmlFatalErrMsg(ctxt, XML_ERR_SPACE_REQUIRED, "Blank needed here\n");
10544     }
10545
10546     /*
10547      * We can grow the input buffer freely at that point
10548      */
10549     GROW;
10550
10551     SKIP_BLANKS;
10552     ctxt->input->standalone = xmlParseSDDecl(ctxt);
10553
10554     SKIP_BLANKS;
10555     if ((RAW == '?') && (NXT(1) == '>')) {
10556         SKIP(2);
10557     } else if (RAW == '>') {
10558         /* Deprecated old WD ... */
10559         xmlFatalErr(ctxt, XML_ERR_XMLDECL_NOT_FINISHED, NULL);
10560         NEXT;
10561     } else {
10562         xmlFatalErr(ctxt, XML_ERR_XMLDECL_NOT_FINISHED, NULL);
10563         MOVETO_ENDTAG(CUR_PTR);
10564         NEXT;
10565     }
10566 }
10567
10568 /**
10569  * xmlParseMisc:
10570  * @ctxt:  an XML parser context
10571  *
10572  * parse an XML Misc* optional field.
10573  *
10574  * [27] Misc ::= Comment | PI |  S
10575  */
10576
10577 void
10578 xmlParseMisc(xmlParserCtxtPtr ctxt) {
10579     while ((ctxt->instate != XML_PARSER_EOF) &&
10580            (((RAW == '<') && (NXT(1) == '?')) ||
10581             (CMP4(CUR_PTR, '<', '!', '-', '-')) ||
10582             IS_BLANK_CH(CUR))) {
10583         if ((RAW == '<') && (NXT(1) == '?')) {
10584             xmlParsePI(ctxt);
10585         } else if (IS_BLANK_CH(CUR)) {
10586             NEXT;
10587         } else
10588             xmlParseComment(ctxt);
10589     }
10590 }
10591
10592 /**
10593  * xmlParseDocument:
10594  * @ctxt:  an XML parser context
10595  *
10596  * parse an XML document (and build a tree if using the standard SAX
10597  * interface).
10598  *
10599  * [1] document ::= prolog element Misc*
10600  *
10601  * [22] prolog ::= XMLDecl? Misc* (doctypedecl Misc*)?
10602  *
10603  * Returns 0, -1 in case of error. the parser context is augmented
10604  *                as a result of the parsing.
10605  */
10606
10607 int
10608 xmlParseDocument(xmlParserCtxtPtr ctxt) {
10609     xmlChar start[4];
10610     xmlCharEncoding enc;
10611
10612     xmlInitParser();
10613
10614     if ((ctxt == NULL) || (ctxt->input == NULL))
10615         return(-1);
10616
10617     GROW;
10618
10619     /*
10620      * SAX: detecting the level.
10621      */
10622     xmlDetectSAX2(ctxt);
10623
10624     /*
10625      * SAX: beginning of the document processing.
10626      */
10627     if ((ctxt->sax) && (ctxt->sax->setDocumentLocator))
10628         ctxt->sax->setDocumentLocator(ctxt->userData, &xmlDefaultSAXLocator);
10629     if (ctxt->instate == XML_PARSER_EOF)
10630         return(-1);
10631
10632     if ((ctxt->encoding == NULL) &&
10633         ((ctxt->input->end - ctxt->input->cur) >= 4)) {
10634         /*
10635          * Get the 4 first bytes and decode the charset
10636          * if enc != XML_CHAR_ENCODING_NONE
10637          * plug some encoding conversion routines.
10638          */
10639         start[0] = RAW;
10640         start[1] = NXT(1);
10641         start[2] = NXT(2);
10642         start[3] = NXT(3);
10643         enc = xmlDetectCharEncoding(&start[0], 4);
10644         if (enc != XML_CHAR_ENCODING_NONE) {
10645             xmlSwitchEncoding(ctxt, enc);
10646         }
10647     }
10648
10649
10650     if (CUR == 0) {
10651         xmlFatalErr(ctxt, XML_ERR_DOCUMENT_EMPTY, NULL);
10652     }
10653
10654     /*
10655      * Check for the XMLDecl in the Prolog.
10656      * do not GROW here to avoid the detected encoder to decode more
10657      * than just the first line, unless the amount of data is really
10658      * too small to hold "<?xml version="1.0" encoding="foo"
10659      */
10660     if ((ctxt->input->end - ctxt->input->cur) < 35) {
10661        GROW;
10662     }
10663     if ((CMP5(CUR_PTR, '<', '?', 'x', 'm', 'l')) && (IS_BLANK_CH(NXT(5)))) {
10664
10665         /*
10666          * Note that we will switch encoding on the fly.
10667          */
10668         xmlParseXMLDecl(ctxt);
10669         if (ctxt->errNo == XML_ERR_UNSUPPORTED_ENCODING) {
10670             /*
10671              * The XML REC instructs us to stop parsing right here
10672              */
10673             return(-1);
10674         }
10675         ctxt->standalone = ctxt->input->standalone;
10676         SKIP_BLANKS;
10677     } else {
10678         ctxt->version = xmlCharStrdup(XML_DEFAULT_VERSION);
10679     }
10680     if ((ctxt->sax) && (ctxt->sax->startDocument) && (!ctxt->disableSAX))
10681         ctxt->sax->startDocument(ctxt->userData);
10682     if (ctxt->instate == XML_PARSER_EOF)
10683         return(-1);
10684
10685     /*
10686      * The Misc part of the Prolog
10687      */
10688     GROW;
10689     xmlParseMisc(ctxt);
10690
10691     /*
10692      * Then possibly doc type declaration(s) and more Misc
10693      * (doctypedecl Misc*)?
10694      */
10695     GROW;
10696     if (CMP9(CUR_PTR, '<', '!', 'D', 'O', 'C', 'T', 'Y', 'P', 'E')) {
10697
10698         ctxt->inSubset = 1;
10699         xmlParseDocTypeDecl(ctxt);
10700         if (RAW == '[') {
10701             ctxt->instate = XML_PARSER_DTD;
10702             xmlParseInternalSubset(ctxt);
10703             if (ctxt->instate == XML_PARSER_EOF)
10704                 return(-1);
10705         }
10706
10707         /*
10708          * Create and update the external subset.
10709          */
10710         ctxt->inSubset = 2;
10711         if ((ctxt->sax != NULL) && (ctxt->sax->externalSubset != NULL) &&
10712             (!ctxt->disableSAX))
10713             ctxt->sax->externalSubset(ctxt->userData, ctxt->intSubName,
10714                                       ctxt->extSubSystem, ctxt->extSubURI);
10715         if (ctxt->instate == XML_PARSER_EOF)
10716             return(-1);
10717         ctxt->inSubset = 0;
10718
10719         xmlCleanSpecialAttr(ctxt);
10720
10721         ctxt->instate = XML_PARSER_PROLOG;
10722         xmlParseMisc(ctxt);
10723     }
10724
10725     /*
10726      * Time to start parsing the tree itself
10727      */
10728     GROW;
10729     if (RAW != '<') {
10730         xmlFatalErrMsg(ctxt, XML_ERR_DOCUMENT_EMPTY,
10731                        "Start tag expected, '<' not found\n");
10732     } else {
10733         ctxt->instate = XML_PARSER_CONTENT;
10734         xmlParseElement(ctxt);
10735         ctxt->instate = XML_PARSER_EPILOG;
10736
10737
10738         /*
10739          * The Misc part at the end
10740          */
10741         xmlParseMisc(ctxt);
10742
10743         if (RAW != 0) {
10744             xmlFatalErr(ctxt, XML_ERR_DOCUMENT_END, NULL);
10745         }
10746         ctxt->instate = XML_PARSER_EOF;
10747     }
10748
10749     /*
10750      * SAX: end of the document processing.
10751      */
10752     if ((ctxt->sax) && (ctxt->sax->endDocument != NULL))
10753         ctxt->sax->endDocument(ctxt->userData);
10754
10755     /*
10756      * Remove locally kept entity definitions if the tree was not built
10757      */
10758     if ((ctxt->myDoc != NULL) &&
10759         (xmlStrEqual(ctxt->myDoc->version, SAX_COMPAT_MODE))) {
10760         xmlFreeDoc(ctxt->myDoc);
10761         ctxt->myDoc = NULL;
10762     }
10763
10764     if ((ctxt->wellFormed) && (ctxt->myDoc != NULL)) {
10765         ctxt->myDoc->properties |= XML_DOC_WELLFORMED;
10766         if (ctxt->valid)
10767             ctxt->myDoc->properties |= XML_DOC_DTDVALID;
10768         if (ctxt->nsWellFormed)
10769             ctxt->myDoc->properties |= XML_DOC_NSVALID;
10770         if (ctxt->options & XML_PARSE_OLD10)
10771             ctxt->myDoc->properties |= XML_DOC_OLD10;
10772     }
10773     if (! ctxt->wellFormed) {
10774         ctxt->valid = 0;
10775         return(-1);
10776     }
10777     return(0);
10778 }
10779
10780 /**
10781  * xmlParseExtParsedEnt:
10782  * @ctxt:  an XML parser context
10783  *
10784  * parse a general parsed entity
10785  * An external general parsed entity is well-formed if it matches the
10786  * production labeled extParsedEnt.
10787  *
10788  * [78] extParsedEnt ::= TextDecl? content
10789  *
10790  * Returns 0, -1 in case of error. the parser context is augmented
10791  *                as a result of the parsing.
10792  */
10793
10794 int
10795 xmlParseExtParsedEnt(xmlParserCtxtPtr ctxt) {
10796     xmlChar start[4];
10797     xmlCharEncoding enc;
10798
10799     if ((ctxt == NULL) || (ctxt->input == NULL))
10800         return(-1);
10801
10802     xmlDefaultSAXHandlerInit();
10803
10804     xmlDetectSAX2(ctxt);
10805
10806     GROW;
10807
10808     /*
10809      * SAX: beginning of the document processing.
10810      */
10811     if ((ctxt->sax) && (ctxt->sax->setDocumentLocator))
10812         ctxt->sax->setDocumentLocator(ctxt->userData, &xmlDefaultSAXLocator);
10813
10814     /*
10815      * Get the 4 first bytes and decode the charset
10816      * if enc != XML_CHAR_ENCODING_NONE
10817      * plug some encoding conversion routines.
10818      */
10819     if ((ctxt->input->end - ctxt->input->cur) >= 4) {
10820         start[0] = RAW;
10821         start[1] = NXT(1);
10822         start[2] = NXT(2);
10823         start[3] = NXT(3);
10824         enc = xmlDetectCharEncoding(start, 4);
10825         if (enc != XML_CHAR_ENCODING_NONE) {
10826             xmlSwitchEncoding(ctxt, enc);
10827         }
10828     }
10829
10830
10831     if (CUR == 0) {
10832         xmlFatalErr(ctxt, XML_ERR_DOCUMENT_EMPTY, NULL);
10833     }
10834
10835     /*
10836      * Check for the XMLDecl in the Prolog.
10837      */
10838     GROW;
10839     if ((CMP5(CUR_PTR, '<', '?', 'x', 'm', 'l')) && (IS_BLANK_CH(NXT(5)))) {
10840
10841         /*
10842          * Note that we will switch encoding on the fly.
10843          */
10844         xmlParseXMLDecl(ctxt);
10845         if (ctxt->errNo == XML_ERR_UNSUPPORTED_ENCODING) {
10846             /*
10847              * The XML REC instructs us to stop parsing right here
10848              */
10849             return(-1);
10850         }
10851         SKIP_BLANKS;
10852     } else {
10853         ctxt->version = xmlCharStrdup(XML_DEFAULT_VERSION);
10854     }
10855     if ((ctxt->sax) && (ctxt->sax->startDocument) && (!ctxt->disableSAX))
10856         ctxt->sax->startDocument(ctxt->userData);
10857     if (ctxt->instate == XML_PARSER_EOF)
10858         return(-1);
10859
10860     /*
10861      * Doing validity checking on chunk doesn't make sense
10862      */
10863     ctxt->instate = XML_PARSER_CONTENT;
10864     ctxt->validate = 0;
10865     ctxt->loadsubset = 0;
10866     ctxt->depth = 0;
10867
10868     xmlParseContent(ctxt);
10869     if (ctxt->instate == XML_PARSER_EOF)
10870         return(-1);
10871
10872     if ((RAW == '<') && (NXT(1) == '/')) {
10873         xmlFatalErr(ctxt, XML_ERR_NOT_WELL_BALANCED, NULL);
10874     } else if (RAW != 0) {
10875         xmlFatalErr(ctxt, XML_ERR_EXTRA_CONTENT, NULL);
10876     }
10877
10878     /*
10879      * SAX: end of the document processing.
10880      */
10881     if ((ctxt->sax) && (ctxt->sax->endDocument != NULL))
10882         ctxt->sax->endDocument(ctxt->userData);
10883
10884     if (! ctxt->wellFormed) return(-1);
10885     return(0);
10886 }
10887
10888 #ifdef LIBXML_PUSH_ENABLED
10889 /************************************************************************
10890  *                                                                      *
10891  *              Progressive parsing interfaces                          *
10892  *                                                                      *
10893  ************************************************************************/
10894
10895 /**
10896  * xmlParseLookupSequence:
10897  * @ctxt:  an XML parser context
10898  * @first:  the first char to lookup
10899  * @next:  the next char to lookup or zero
10900  * @third:  the next char to lookup or zero
10901  *
10902  * Try to find if a sequence (first, next, third) or  just (first next) or
10903  * (first) is available in the input stream.
10904  * This function has a side effect of (possibly) incrementing ctxt->checkIndex
10905  * to avoid rescanning sequences of bytes, it DOES change the state of the
10906  * parser, do not use liberally.
10907  *
10908  * Returns the index to the current parsing point if the full sequence
10909  *      is available, -1 otherwise.
10910  */
10911 static int
10912 xmlParseLookupSequence(xmlParserCtxtPtr ctxt, xmlChar first,
10913                        xmlChar next, xmlChar third) {
10914     int base, len;
10915     xmlParserInputPtr in;
10916     const xmlChar *buf;
10917
10918     in = ctxt->input;
10919     if (in == NULL) return(-1);
10920     base = in->cur - in->base;
10921     if (base < 0) return(-1);
10922     if (ctxt->checkIndex > base)
10923         base = ctxt->checkIndex;
10924     if (in->buf == NULL) {
10925         buf = in->base;
10926         len = in->length;
10927     } else {
10928         buf = xmlBufContent(in->buf->buffer);
10929         len = xmlBufUse(in->buf->buffer);
10930     }
10931     /* take into account the sequence length */
10932     if (third) len -= 2;
10933     else if (next) len --;
10934     for (;base < len;base++) {
10935         if (buf[base] == first) {
10936             if (third != 0) {
10937                 if ((buf[base + 1] != next) ||
10938                     (buf[base + 2] != third)) continue;
10939             } else if (next != 0) {
10940                 if (buf[base + 1] != next) continue;
10941             }
10942             ctxt->checkIndex = 0;
10943 #ifdef DEBUG_PUSH
10944             if (next == 0)
10945                 xmlGenericError(xmlGenericErrorContext,
10946                         "PP: lookup '%c' found at %d\n",
10947                         first, base);
10948             else if (third == 0)
10949                 xmlGenericError(xmlGenericErrorContext,
10950                         "PP: lookup '%c%c' found at %d\n",
10951                         first, next, base);
10952             else
10953                 xmlGenericError(xmlGenericErrorContext,
10954                         "PP: lookup '%c%c%c' found at %d\n",
10955                         first, next, third, base);
10956 #endif
10957             return(base - (in->cur - in->base));
10958         }
10959     }
10960     ctxt->checkIndex = base;
10961 #ifdef DEBUG_PUSH
10962     if (next == 0)
10963         xmlGenericError(xmlGenericErrorContext,
10964                 "PP: lookup '%c' failed\n", first);
10965     else if (third == 0)
10966         xmlGenericError(xmlGenericErrorContext,
10967                 "PP: lookup '%c%c' failed\n", first, next);
10968     else
10969         xmlGenericError(xmlGenericErrorContext,
10970                 "PP: lookup '%c%c%c' failed\n", first, next, third);
10971 #endif
10972     return(-1);
10973 }
10974
10975 /**
10976  * xmlParseGetLasts:
10977  * @ctxt:  an XML parser context
10978  * @lastlt:  pointer to store the last '<' from the input
10979  * @lastgt:  pointer to store the last '>' from the input
10980  *
10981  * Lookup the last < and > in the current chunk
10982  */
10983 static void
10984 xmlParseGetLasts(xmlParserCtxtPtr ctxt, const xmlChar **lastlt,
10985                  const xmlChar **lastgt) {
10986     const xmlChar *tmp;
10987
10988     if ((ctxt == NULL) || (lastlt == NULL) || (lastgt == NULL)) {
10989         xmlGenericError(xmlGenericErrorContext,
10990                     "Internal error: xmlParseGetLasts\n");
10991         return;
10992     }
10993     if ((ctxt->progressive != 0) && (ctxt->inputNr == 1)) {
10994         tmp = ctxt->input->end;
10995         tmp--;
10996         while ((tmp >= ctxt->input->base) && (*tmp != '<')) tmp--;
10997         if (tmp < ctxt->input->base) {
10998             *lastlt = NULL;
10999             *lastgt = NULL;
11000         } else {
11001             *lastlt = tmp;
11002             tmp++;
11003             while ((tmp < ctxt->input->end) && (*tmp != '>')) {
11004                 if (*tmp == '\'') {
11005                     tmp++;
11006                     while ((tmp < ctxt->input->end) && (*tmp != '\'')) tmp++;
11007                     if (tmp < ctxt->input->end) tmp++;
11008                 } else if (*tmp == '"') {
11009                     tmp++;
11010                     while ((tmp < ctxt->input->end) && (*tmp != '"')) tmp++;
11011                     if (tmp < ctxt->input->end) tmp++;
11012                 } else
11013                     tmp++;
11014             }
11015             if (tmp < ctxt->input->end)
11016                 *lastgt = tmp;
11017             else {
11018                 tmp = *lastlt;
11019                 tmp--;
11020                 while ((tmp >= ctxt->input->base) && (*tmp != '>')) tmp--;
11021                 if (tmp >= ctxt->input->base)
11022                     *lastgt = tmp;
11023                 else
11024                     *lastgt = NULL;
11025             }
11026         }
11027     } else {
11028         *lastlt = NULL;
11029         *lastgt = NULL;
11030     }
11031 }
11032 /**
11033  * xmlCheckCdataPush:
11034  * @cur: pointer to the bock of characters
11035  * @len: length of the block in bytes
11036  *
11037  * Check that the block of characters is okay as SCdata content [20]
11038  *
11039  * Returns the number of bytes to pass if okay, a negative index where an
11040  *         UTF-8 error occured otherwise
11041  */
11042 static int
11043 xmlCheckCdataPush(const xmlChar *utf, int len) {
11044     int ix;
11045     unsigned char c;
11046     int codepoint;
11047
11048     if ((utf == NULL) || (len <= 0))
11049         return(0);
11050
11051     for (ix = 0; ix < len;) {      /* string is 0-terminated */
11052         c = utf[ix];
11053         if ((c & 0x80) == 0x00) {       /* 1-byte code, starts with 10 */
11054             if (c >= 0x20)
11055                 ix++;
11056             else if ((c == 0xA) || (c == 0xD) || (c == 0x9))
11057                 ix++;
11058             else
11059                 return(-ix);
11060         } else if ((c & 0xe0) == 0xc0) {/* 2-byte code, starts with 110 */
11061             if (ix + 2 > len) return(ix);
11062             if ((utf[ix+1] & 0xc0 ) != 0x80)
11063                 return(-ix);
11064             codepoint = (utf[ix] & 0x1f) << 6;
11065             codepoint |= utf[ix+1] & 0x3f;
11066             if (!xmlIsCharQ(codepoint))
11067                 return(-ix);
11068             ix += 2;
11069         } else if ((c & 0xf0) == 0xe0) {/* 3-byte code, starts with 1110 */
11070             if (ix + 3 > len) return(ix);
11071             if (((utf[ix+1] & 0xc0) != 0x80) ||
11072                 ((utf[ix+2] & 0xc0) != 0x80))
11073                     return(-ix);
11074             codepoint = (utf[ix] & 0xf) << 12;
11075             codepoint |= (utf[ix+1] & 0x3f) << 6;
11076             codepoint |= utf[ix+2] & 0x3f;
11077             if (!xmlIsCharQ(codepoint))
11078                 return(-ix);
11079             ix += 3;
11080         } else if ((c & 0xf8) == 0xf0) {/* 4-byte code, starts with 11110 */
11081             if (ix + 4 > len) return(ix);
11082             if (((utf[ix+1] & 0xc0) != 0x80) ||
11083                 ((utf[ix+2] & 0xc0) != 0x80) ||
11084                 ((utf[ix+3] & 0xc0) != 0x80))
11085                     return(-ix);
11086             codepoint = (utf[ix] & 0x7) << 18;
11087             codepoint |= (utf[ix+1] & 0x3f) << 12;
11088             codepoint |= (utf[ix+2] & 0x3f) << 6;
11089             codepoint |= utf[ix+3] & 0x3f;
11090             if (!xmlIsCharQ(codepoint))
11091                 return(-ix);
11092             ix += 4;
11093         } else                          /* unknown encoding */
11094             return(-ix);
11095       }
11096       return(ix);
11097 }
11098
11099 /**
11100  * xmlParseTryOrFinish:
11101  * @ctxt:  an XML parser context
11102  * @terminate:  last chunk indicator
11103  *
11104  * Try to progress on parsing
11105  *
11106  * Returns zero if no parsing was possible
11107  */
11108 static int
11109 xmlParseTryOrFinish(xmlParserCtxtPtr ctxt, int terminate) {
11110     int ret = 0;
11111     int avail, tlen;
11112     xmlChar cur, next;
11113     const xmlChar *lastlt, *lastgt;
11114
11115     if (ctxt->input == NULL)
11116         return(0);
11117
11118 #ifdef DEBUG_PUSH
11119     switch (ctxt->instate) {
11120         case XML_PARSER_EOF:
11121             xmlGenericError(xmlGenericErrorContext,
11122                     "PP: try EOF\n"); break;
11123         case XML_PARSER_START:
11124             xmlGenericError(xmlGenericErrorContext,
11125                     "PP: try START\n"); break;
11126         case XML_PARSER_MISC:
11127             xmlGenericError(xmlGenericErrorContext,
11128                     "PP: try MISC\n");break;
11129         case XML_PARSER_COMMENT:
11130             xmlGenericError(xmlGenericErrorContext,
11131                     "PP: try COMMENT\n");break;
11132         case XML_PARSER_PROLOG:
11133             xmlGenericError(xmlGenericErrorContext,
11134                     "PP: try PROLOG\n");break;
11135         case XML_PARSER_START_TAG:
11136             xmlGenericError(xmlGenericErrorContext,
11137                     "PP: try START_TAG\n");break;
11138         case XML_PARSER_CONTENT:
11139             xmlGenericError(xmlGenericErrorContext,
11140                     "PP: try CONTENT\n");break;
11141         case XML_PARSER_CDATA_SECTION:
11142             xmlGenericError(xmlGenericErrorContext,
11143                     "PP: try CDATA_SECTION\n");break;
11144         case XML_PARSER_END_TAG:
11145             xmlGenericError(xmlGenericErrorContext,
11146                     "PP: try END_TAG\n");break;
11147         case XML_PARSER_ENTITY_DECL:
11148             xmlGenericError(xmlGenericErrorContext,
11149                     "PP: try ENTITY_DECL\n");break;
11150         case XML_PARSER_ENTITY_VALUE:
11151             xmlGenericError(xmlGenericErrorContext,
11152                     "PP: try ENTITY_VALUE\n");break;
11153         case XML_PARSER_ATTRIBUTE_VALUE:
11154             xmlGenericError(xmlGenericErrorContext,
11155                     "PP: try ATTRIBUTE_VALUE\n");break;
11156         case XML_PARSER_DTD:
11157             xmlGenericError(xmlGenericErrorContext,
11158                     "PP: try DTD\n");break;
11159         case XML_PARSER_EPILOG:
11160             xmlGenericError(xmlGenericErrorContext,
11161                     "PP: try EPILOG\n");break;
11162         case XML_PARSER_PI:
11163             xmlGenericError(xmlGenericErrorContext,
11164                     "PP: try PI\n");break;
11165         case XML_PARSER_IGNORE:
11166             xmlGenericError(xmlGenericErrorContext,
11167                     "PP: try IGNORE\n");break;
11168     }
11169 #endif
11170
11171     if ((ctxt->input != NULL) &&
11172         (ctxt->input->cur - ctxt->input->base > 4096)) {
11173         xmlSHRINK(ctxt);
11174         ctxt->checkIndex = 0;
11175     }
11176     xmlParseGetLasts(ctxt, &lastlt, &lastgt);
11177
11178     while (ctxt->instate != XML_PARSER_EOF) {
11179         if ((ctxt->errNo != XML_ERR_OK) && (ctxt->disableSAX == 1))
11180             return(0);
11181
11182
11183         /*
11184          * Pop-up of finished entities.
11185          */
11186         while ((RAW == 0) && (ctxt->inputNr > 1))
11187             xmlPopInput(ctxt);
11188
11189         if (ctxt->input == NULL) break;
11190         if (ctxt->input->buf == NULL)
11191             avail = ctxt->input->length -
11192                     (ctxt->input->cur - ctxt->input->base);
11193         else {
11194             /*
11195              * If we are operating on converted input, try to flush
11196              * remainng chars to avoid them stalling in the non-converted
11197              * buffer. But do not do this in document start where
11198              * encoding="..." may not have been read and we work on a
11199              * guessed encoding.
11200              */
11201             if ((ctxt->instate != XML_PARSER_START) &&
11202                 (ctxt->input->buf->raw != NULL) &&
11203                 (xmlBufIsEmpty(ctxt->input->buf->raw) == 0)) {
11204                 size_t base = xmlBufGetInputBase(ctxt->input->buf->buffer,
11205                                                  ctxt->input);
11206                 size_t current = ctxt->input->cur - ctxt->input->base;
11207
11208                 xmlParserInputBufferPush(ctxt->input->buf, 0, "");
11209                 xmlBufSetInputBaseCur(ctxt->input->buf->buffer, ctxt->input,
11210                                       base, current);
11211             }
11212             avail = xmlBufUse(ctxt->input->buf->buffer) -
11213                     (ctxt->input->cur - ctxt->input->base);
11214         }
11215         if (avail < 1)
11216             goto done;
11217         switch (ctxt->instate) {
11218             case XML_PARSER_EOF:
11219                 /*
11220                  * Document parsing is done !
11221                  */
11222                 goto done;
11223             case XML_PARSER_START:
11224                 if (ctxt->charset == XML_CHAR_ENCODING_NONE) {
11225                     xmlChar start[4];
11226                     xmlCharEncoding enc;
11227
11228                     /*
11229                      * Very first chars read from the document flow.
11230                      */
11231                     if (avail < 4)
11232                         goto done;
11233
11234                     /*
11235                      * Get the 4 first bytes and decode the charset
11236                      * if enc != XML_CHAR_ENCODING_NONE
11237                      * plug some encoding conversion routines,
11238                      * else xmlSwitchEncoding will set to (default)
11239                      * UTF8.
11240                      */
11241                     start[0] = RAW;
11242                     start[1] = NXT(1);
11243                     start[2] = NXT(2);
11244                     start[3] = NXT(3);
11245                     enc = xmlDetectCharEncoding(start, 4);
11246                     xmlSwitchEncoding(ctxt, enc);
11247                     break;
11248                 }
11249
11250                 if (avail < 2)
11251                     goto done;
11252                 cur = ctxt->input->cur[0];
11253                 next = ctxt->input->cur[1];
11254                 if (cur == 0) {
11255                     if ((ctxt->sax) && (ctxt->sax->setDocumentLocator))
11256                         ctxt->sax->setDocumentLocator(ctxt->userData,
11257                                                       &xmlDefaultSAXLocator);
11258                     xmlFatalErr(ctxt, XML_ERR_DOCUMENT_EMPTY, NULL);
11259                     ctxt->instate = XML_PARSER_EOF;
11260 #ifdef DEBUG_PUSH
11261                     xmlGenericError(xmlGenericErrorContext,
11262                             "PP: entering EOF\n");
11263 #endif
11264                     if ((ctxt->sax) && (ctxt->sax->endDocument != NULL))
11265                         ctxt->sax->endDocument(ctxt->userData);
11266                     goto done;
11267                 }
11268                 if ((cur == '<') && (next == '?')) {
11269                     /* PI or XML decl */
11270                     if (avail < 5) return(ret);
11271                     if ((!terminate) &&
11272                         (xmlParseLookupSequence(ctxt, '?', '>', 0) < 0))
11273                         return(ret);
11274                     if ((ctxt->sax) && (ctxt->sax->setDocumentLocator))
11275                         ctxt->sax->setDocumentLocator(ctxt->userData,
11276                                                       &xmlDefaultSAXLocator);
11277                     if ((ctxt->input->cur[2] == 'x') &&
11278                         (ctxt->input->cur[3] == 'm') &&
11279                         (ctxt->input->cur[4] == 'l') &&
11280                         (IS_BLANK_CH(ctxt->input->cur[5]))) {
11281                         ret += 5;
11282 #ifdef DEBUG_PUSH
11283                         xmlGenericError(xmlGenericErrorContext,
11284                                 "PP: Parsing XML Decl\n");
11285 #endif
11286                         xmlParseXMLDecl(ctxt);
11287                         if (ctxt->errNo == XML_ERR_UNSUPPORTED_ENCODING) {
11288                             /*
11289                              * The XML REC instructs us to stop parsing right
11290                              * here
11291                              */
11292                             ctxt->instate = XML_PARSER_EOF;
11293                             return(0);
11294                         }
11295                         ctxt->standalone = ctxt->input->standalone;
11296                         if ((ctxt->encoding == NULL) &&
11297                             (ctxt->input->encoding != NULL))
11298                             ctxt->encoding = xmlStrdup(ctxt->input->encoding);
11299                         if ((ctxt->sax) && (ctxt->sax->startDocument) &&
11300                             (!ctxt->disableSAX))
11301                             ctxt->sax->startDocument(ctxt->userData);
11302                         ctxt->instate = XML_PARSER_MISC;
11303 #ifdef DEBUG_PUSH
11304                         xmlGenericError(xmlGenericErrorContext,
11305                                 "PP: entering MISC\n");
11306 #endif
11307                     } else {
11308                         ctxt->version = xmlCharStrdup(XML_DEFAULT_VERSION);
11309                         if ((ctxt->sax) && (ctxt->sax->startDocument) &&
11310                             (!ctxt->disableSAX))
11311                             ctxt->sax->startDocument(ctxt->userData);
11312                         ctxt->instate = XML_PARSER_MISC;
11313 #ifdef DEBUG_PUSH
11314                         xmlGenericError(xmlGenericErrorContext,
11315                                 "PP: entering MISC\n");
11316 #endif
11317                     }
11318                 } else {
11319                     if ((ctxt->sax) && (ctxt->sax->setDocumentLocator))
11320                         ctxt->sax->setDocumentLocator(ctxt->userData,
11321                                                       &xmlDefaultSAXLocator);
11322                     ctxt->version = xmlCharStrdup(XML_DEFAULT_VERSION);
11323                     if (ctxt->version == NULL) {
11324                         xmlErrMemory(ctxt, NULL);
11325                         break;
11326                     }
11327                     if ((ctxt->sax) && (ctxt->sax->startDocument) &&
11328                         (!ctxt->disableSAX))
11329                         ctxt->sax->startDocument(ctxt->userData);
11330                     ctxt->instate = XML_PARSER_MISC;
11331 #ifdef DEBUG_PUSH
11332                     xmlGenericError(xmlGenericErrorContext,
11333                             "PP: entering MISC\n");
11334 #endif
11335                 }
11336                 break;
11337             case XML_PARSER_START_TAG: {
11338                 const xmlChar *name;
11339                 const xmlChar *prefix = NULL;
11340                 const xmlChar *URI = NULL;
11341                 int nsNr = ctxt->nsNr;
11342
11343                 if ((avail < 2) && (ctxt->inputNr == 1))
11344                     goto done;
11345                 cur = ctxt->input->cur[0];
11346                 if (cur != '<') {
11347                     xmlFatalErr(ctxt, XML_ERR_DOCUMENT_EMPTY, NULL);
11348                     ctxt->instate = XML_PARSER_EOF;
11349                     if ((ctxt->sax) && (ctxt->sax->endDocument != NULL))
11350                         ctxt->sax->endDocument(ctxt->userData);
11351                     goto done;
11352                 }
11353                 if (!terminate) {
11354                     if (ctxt->progressive) {
11355                         /* > can be found unescaped in attribute values */
11356                         if ((lastgt == NULL) || (ctxt->input->cur >= lastgt))
11357                             goto done;
11358                     } else if (xmlParseLookupSequence(ctxt, '>', 0, 0) < 0) {
11359                         goto done;
11360                     }
11361                 }
11362                 if (ctxt->spaceNr == 0)
11363                     spacePush(ctxt, -1);
11364                 else if (*ctxt->space == -2)
11365                     spacePush(ctxt, -1);
11366                 else
11367                     spacePush(ctxt, *ctxt->space);
11368 #ifdef LIBXML_SAX1_ENABLED
11369                 if (ctxt->sax2)
11370 #endif /* LIBXML_SAX1_ENABLED */
11371                     name = xmlParseStartTag2(ctxt, &prefix, &URI, &tlen);
11372 #ifdef LIBXML_SAX1_ENABLED
11373                 else
11374                     name = xmlParseStartTag(ctxt);
11375 #endif /* LIBXML_SAX1_ENABLED */
11376                 if (ctxt->instate == XML_PARSER_EOF)
11377                     goto done;
11378                 if (name == NULL) {
11379                     spacePop(ctxt);
11380                     ctxt->instate = XML_PARSER_EOF;
11381                     if ((ctxt->sax) && (ctxt->sax->endDocument != NULL))
11382                         ctxt->sax->endDocument(ctxt->userData);
11383                     goto done;
11384                 }
11385 #ifdef LIBXML_VALID_ENABLED
11386                 /*
11387                  * [ VC: Root Element Type ]
11388                  * The Name in the document type declaration must match
11389                  * the element type of the root element.
11390                  */
11391                 if (ctxt->validate && ctxt->wellFormed && ctxt->myDoc &&
11392                     ctxt->node && (ctxt->node == ctxt->myDoc->children))
11393                     ctxt->valid &= xmlValidateRoot(&ctxt->vctxt, ctxt->myDoc);
11394 #endif /* LIBXML_VALID_ENABLED */
11395
11396                 /*
11397                  * Check for an Empty Element.
11398                  */
11399                 if ((RAW == '/') && (NXT(1) == '>')) {
11400                     SKIP(2);
11401
11402                     if (ctxt->sax2) {
11403                         if ((ctxt->sax != NULL) &&
11404                             (ctxt->sax->endElementNs != NULL) &&
11405                             (!ctxt->disableSAX))
11406                             ctxt->sax->endElementNs(ctxt->userData, name,
11407                                                     prefix, URI);
11408                         if (ctxt->nsNr - nsNr > 0)
11409                             nsPop(ctxt, ctxt->nsNr - nsNr);
11410 #ifdef LIBXML_SAX1_ENABLED
11411                     } else {
11412                         if ((ctxt->sax != NULL) &&
11413                             (ctxt->sax->endElement != NULL) &&
11414                             (!ctxt->disableSAX))
11415                             ctxt->sax->endElement(ctxt->userData, name);
11416 #endif /* LIBXML_SAX1_ENABLED */
11417                     }
11418                     if (ctxt->instate == XML_PARSER_EOF)
11419                         goto done;
11420                     spacePop(ctxt);
11421                     if (ctxt->nameNr == 0) {
11422                         ctxt->instate = XML_PARSER_EPILOG;
11423                     } else {
11424                         ctxt->instate = XML_PARSER_CONTENT;
11425                     }
11426                     ctxt->progressive = 1;
11427                     break;
11428                 }
11429                 if (RAW == '>') {
11430                     NEXT;
11431                 } else {
11432                     xmlFatalErrMsgStr(ctxt, XML_ERR_GT_REQUIRED,
11433                                          "Couldn't find end of Start Tag %s\n",
11434                                          name);
11435                     nodePop(ctxt);
11436                     spacePop(ctxt);
11437                 }
11438                 if (ctxt->sax2)
11439                     nameNsPush(ctxt, name, prefix, URI, ctxt->nsNr - nsNr);
11440 #ifdef LIBXML_SAX1_ENABLED
11441                 else
11442                     namePush(ctxt, name);
11443 #endif /* LIBXML_SAX1_ENABLED */
11444
11445                 ctxt->instate = XML_PARSER_CONTENT;
11446                 ctxt->progressive = 1;
11447                 break;
11448             }
11449             case XML_PARSER_CONTENT: {
11450                 const xmlChar *test;
11451                 unsigned int cons;
11452                 if ((avail < 2) && (ctxt->inputNr == 1))
11453                     goto done;
11454                 cur = ctxt->input->cur[0];
11455                 next = ctxt->input->cur[1];
11456
11457                 test = CUR_PTR;
11458                 cons = ctxt->input->consumed;
11459                 if ((cur == '<') && (next == '/')) {
11460                     ctxt->instate = XML_PARSER_END_TAG;
11461                     break;
11462                 } else if ((cur == '<') && (next == '?')) {
11463                     if ((!terminate) &&
11464                         (xmlParseLookupSequence(ctxt, '?', '>', 0) < 0)) {
11465                         ctxt->progressive = XML_PARSER_PI;
11466                         goto done;
11467                     }
11468                     xmlParsePI(ctxt);
11469                     ctxt->instate = XML_PARSER_CONTENT;
11470                     ctxt->progressive = 1;
11471                 } else if ((cur == '<') && (next != '!')) {
11472                     ctxt->instate = XML_PARSER_START_TAG;
11473                     break;
11474                 } else if ((cur == '<') && (next == '!') &&
11475                            (ctxt->input->cur[2] == '-') &&
11476                            (ctxt->input->cur[3] == '-')) {
11477                     int term;
11478
11479                     if (avail < 4)
11480                         goto done;
11481                     ctxt->input->cur += 4;
11482                     term = xmlParseLookupSequence(ctxt, '-', '-', '>');
11483                     ctxt->input->cur -= 4;
11484                     if ((!terminate) && (term < 0)) {
11485                         ctxt->progressive = XML_PARSER_COMMENT;
11486                         goto done;
11487                     }
11488                     xmlParseComment(ctxt);
11489                     ctxt->instate = XML_PARSER_CONTENT;
11490                     ctxt->progressive = 1;
11491                 } else if ((cur == '<') && (ctxt->input->cur[1] == '!') &&
11492                     (ctxt->input->cur[2] == '[') &&
11493                     (ctxt->input->cur[3] == 'C') &&
11494                     (ctxt->input->cur[4] == 'D') &&
11495                     (ctxt->input->cur[5] == 'A') &&
11496                     (ctxt->input->cur[6] == 'T') &&
11497                     (ctxt->input->cur[7] == 'A') &&
11498                     (ctxt->input->cur[8] == '[')) {
11499                     SKIP(9);
11500                     ctxt->instate = XML_PARSER_CDATA_SECTION;
11501                     break;
11502                 } else if ((cur == '<') && (next == '!') &&
11503                            (avail < 9)) {
11504                     goto done;
11505                 } else if (cur == '&') {
11506                     if ((!terminate) &&
11507                         (xmlParseLookupSequence(ctxt, ';', 0, 0) < 0))
11508                         goto done;
11509                     xmlParseReference(ctxt);
11510                 } else {
11511                     /* TODO Avoid the extra copy, handle directly !!! */
11512                     /*
11513                      * Goal of the following test is:
11514                      *  - minimize calls to the SAX 'character' callback
11515                      *    when they are mergeable
11516                      *  - handle an problem for isBlank when we only parse
11517                      *    a sequence of blank chars and the next one is
11518                      *    not available to check against '<' presence.
11519                      *  - tries to homogenize the differences in SAX
11520                      *    callbacks between the push and pull versions
11521                      *    of the parser.
11522                      */
11523                     if ((ctxt->inputNr == 1) &&
11524                         (avail < XML_PARSER_BIG_BUFFER_SIZE)) {
11525                         if (!terminate) {
11526                             if (ctxt->progressive) {
11527                                 if ((lastlt == NULL) ||
11528                                     (ctxt->input->cur > lastlt))
11529                                     goto done;
11530                             } else if (xmlParseLookupSequence(ctxt,
11531                                                               '<', 0, 0) < 0) {
11532                                 goto done;
11533                             }
11534                         }
11535                     }
11536                     ctxt->checkIndex = 0;
11537                     xmlParseCharData(ctxt, 0);
11538                 }
11539                 /*
11540                  * Pop-up of finished entities.
11541                  */
11542                 while ((RAW == 0) && (ctxt->inputNr > 1))
11543                     xmlPopInput(ctxt);
11544                 if ((cons == ctxt->input->consumed) && (test == CUR_PTR)) {
11545                     xmlFatalErr(ctxt, XML_ERR_INTERNAL_ERROR,
11546                                 "detected an error in element content\n");
11547                     ctxt->instate = XML_PARSER_EOF;
11548                     break;
11549                 }
11550                 break;
11551             }
11552             case XML_PARSER_END_TAG:
11553                 if (avail < 2)
11554                     goto done;
11555                 if (!terminate) {
11556                     if (ctxt->progressive) {
11557                         /* > can be found unescaped in attribute values */
11558                         if ((lastgt == NULL) || (ctxt->input->cur >= lastgt))
11559                             goto done;
11560                     } else if (xmlParseLookupSequence(ctxt, '>', 0, 0) < 0) {
11561                         goto done;
11562                     }
11563                 }
11564                 if (ctxt->sax2) {
11565                     xmlParseEndTag2(ctxt,
11566                            (void *) ctxt->pushTab[ctxt->nameNr * 3 - 3],
11567                            (void *) ctxt->pushTab[ctxt->nameNr * 3 - 2], 0,
11568                        (int) (long) ctxt->pushTab[ctxt->nameNr * 3 - 1], 0);
11569                     nameNsPop(ctxt);
11570                 }
11571 #ifdef LIBXML_SAX1_ENABLED
11572                   else
11573                     xmlParseEndTag1(ctxt, 0);
11574 #endif /* LIBXML_SAX1_ENABLED */
11575                 if (ctxt->instate == XML_PARSER_EOF) {
11576                     /* Nothing */
11577                 } else if (ctxt->nameNr == 0) {
11578                     ctxt->instate = XML_PARSER_EPILOG;
11579                 } else {
11580                     ctxt->instate = XML_PARSER_CONTENT;
11581                 }
11582                 break;
11583             case XML_PARSER_CDATA_SECTION: {
11584                 /*
11585                  * The Push mode need to have the SAX callback for
11586                  * cdataBlock merge back contiguous callbacks.
11587                  */
11588                 int base;
11589
11590                 base = xmlParseLookupSequence(ctxt, ']', ']', '>');
11591                 if (base < 0) {
11592                     if (avail >= XML_PARSER_BIG_BUFFER_SIZE + 2) {
11593                         int tmp;
11594
11595                         tmp = xmlCheckCdataPush(ctxt->input->cur,
11596                                                 XML_PARSER_BIG_BUFFER_SIZE);
11597                         if (tmp < 0) {
11598                             tmp = -tmp;
11599                             ctxt->input->cur += tmp;
11600                             goto encoding_error;
11601                         }
11602                         if ((ctxt->sax != NULL) && (!ctxt->disableSAX)) {
11603                             if (ctxt->sax->cdataBlock != NULL)
11604                                 ctxt->sax->cdataBlock(ctxt->userData,
11605                                                       ctxt->input->cur, tmp);
11606                             else if (ctxt->sax->characters != NULL)
11607                                 ctxt->sax->characters(ctxt->userData,
11608                                                       ctxt->input->cur, tmp);
11609                         }
11610                         if (ctxt->instate == XML_PARSER_EOF)
11611                             goto done;
11612                         SKIPL(tmp);
11613                         ctxt->checkIndex = 0;
11614                     }
11615                     goto done;
11616                 } else {
11617                     int tmp;
11618
11619                     tmp = xmlCheckCdataPush(ctxt->input->cur, base);
11620                     if ((tmp < 0) || (tmp != base)) {
11621                         tmp = -tmp;
11622                         ctxt->input->cur += tmp;
11623                         goto encoding_error;
11624                     }
11625                     if ((ctxt->sax != NULL) && (base == 0) &&
11626                         (ctxt->sax->cdataBlock != NULL) &&
11627                         (!ctxt->disableSAX)) {
11628                         /*
11629                          * Special case to provide identical behaviour
11630                          * between pull and push parsers on enpty CDATA
11631                          * sections
11632                          */
11633                          if ((ctxt->input->cur - ctxt->input->base >= 9) &&
11634                              (!strncmp((const char *)&ctxt->input->cur[-9],
11635                                        "<![CDATA[", 9)))
11636                              ctxt->sax->cdataBlock(ctxt->userData,
11637                                                    BAD_CAST "", 0);
11638                     } else if ((ctxt->sax != NULL) && (base > 0) &&
11639                         (!ctxt->disableSAX)) {
11640                         if (ctxt->sax->cdataBlock != NULL)
11641                             ctxt->sax->cdataBlock(ctxt->userData,
11642                                                   ctxt->input->cur, base);
11643                         else if (ctxt->sax->characters != NULL)
11644                             ctxt->sax->characters(ctxt->userData,
11645                                                   ctxt->input->cur, base);
11646                     }
11647                     if (ctxt->instate == XML_PARSER_EOF)
11648                         goto done;
11649                     SKIPL(base + 3);
11650                     ctxt->checkIndex = 0;
11651                     ctxt->instate = XML_PARSER_CONTENT;
11652 #ifdef DEBUG_PUSH
11653                     xmlGenericError(xmlGenericErrorContext,
11654                             "PP: entering CONTENT\n");
11655 #endif
11656                 }
11657                 break;
11658             }
11659             case XML_PARSER_MISC:
11660                 SKIP_BLANKS;
11661                 if (ctxt->input->buf == NULL)
11662                     avail = ctxt->input->length -
11663                             (ctxt->input->cur - ctxt->input->base);
11664                 else
11665                     avail = xmlBufUse(ctxt->input->buf->buffer) -
11666                             (ctxt->input->cur - ctxt->input->base);
11667                 if (avail < 2)
11668                     goto done;
11669                 cur = ctxt->input->cur[0];
11670                 next = ctxt->input->cur[1];
11671                 if ((cur == '<') && (next == '?')) {
11672                     if ((!terminate) &&
11673                         (xmlParseLookupSequence(ctxt, '?', '>', 0) < 0)) {
11674                         ctxt->progressive = XML_PARSER_PI;
11675                         goto done;
11676                     }
11677 #ifdef DEBUG_PUSH
11678                     xmlGenericError(xmlGenericErrorContext,
11679                             "PP: Parsing PI\n");
11680 #endif
11681                     xmlParsePI(ctxt);
11682                     if (ctxt->instate == XML_PARSER_EOF)
11683                         goto done;
11684                     ctxt->instate = XML_PARSER_MISC;
11685                     ctxt->progressive = 1;
11686                     ctxt->checkIndex = 0;
11687                 } else if ((cur == '<') && (next == '!') &&
11688                     (ctxt->input->cur[2] == '-') &&
11689                     (ctxt->input->cur[3] == '-')) {
11690                     if ((!terminate) &&
11691                         (xmlParseLookupSequence(ctxt, '-', '-', '>') < 0)) {
11692                         ctxt->progressive = XML_PARSER_COMMENT;
11693                         goto done;
11694                     }
11695 #ifdef DEBUG_PUSH
11696                     xmlGenericError(xmlGenericErrorContext,
11697                             "PP: Parsing Comment\n");
11698 #endif
11699                     xmlParseComment(ctxt);
11700                     if (ctxt->instate == XML_PARSER_EOF)
11701                         goto done;
11702                     ctxt->instate = XML_PARSER_MISC;
11703                     ctxt->progressive = 1;
11704                     ctxt->checkIndex = 0;
11705                 } else if ((cur == '<') && (next == '!') &&
11706                     (ctxt->input->cur[2] == 'D') &&
11707                     (ctxt->input->cur[3] == 'O') &&
11708                     (ctxt->input->cur[4] == 'C') &&
11709                     (ctxt->input->cur[5] == 'T') &&
11710                     (ctxt->input->cur[6] == 'Y') &&
11711                     (ctxt->input->cur[7] == 'P') &&
11712                     (ctxt->input->cur[8] == 'E')) {
11713                     if ((!terminate) &&
11714                         (xmlParseLookupSequence(ctxt, '>', 0, 0) < 0)) {
11715                         ctxt->progressive = XML_PARSER_DTD;
11716                         goto done;
11717                     }
11718 #ifdef DEBUG_PUSH
11719                     xmlGenericError(xmlGenericErrorContext,
11720                             "PP: Parsing internal subset\n");
11721 #endif
11722                     ctxt->inSubset = 1;
11723                     ctxt->progressive = 0;
11724                     ctxt->checkIndex = 0;
11725                     xmlParseDocTypeDecl(ctxt);
11726                     if (ctxt->instate == XML_PARSER_EOF)
11727                         goto done;
11728                     if (RAW == '[') {
11729                         ctxt->instate = XML_PARSER_DTD;
11730 #ifdef DEBUG_PUSH
11731                         xmlGenericError(xmlGenericErrorContext,
11732                                 "PP: entering DTD\n");
11733 #endif
11734                     } else {
11735                         /*
11736                          * Create and update the external subset.
11737                          */
11738                         ctxt->inSubset = 2;
11739                         if ((ctxt->sax != NULL) && (!ctxt->disableSAX) &&
11740                             (ctxt->sax->externalSubset != NULL))
11741                             ctxt->sax->externalSubset(ctxt->userData,
11742                                     ctxt->intSubName, ctxt->extSubSystem,
11743                                     ctxt->extSubURI);
11744                         ctxt->inSubset = 0;
11745                         xmlCleanSpecialAttr(ctxt);
11746                         ctxt->instate = XML_PARSER_PROLOG;
11747 #ifdef DEBUG_PUSH
11748                         xmlGenericError(xmlGenericErrorContext,
11749                                 "PP: entering PROLOG\n");
11750 #endif
11751                     }
11752                 } else if ((cur == '<') && (next == '!') &&
11753                            (avail < 9)) {
11754                     goto done;
11755                 } else {
11756                     ctxt->instate = XML_PARSER_START_TAG;
11757                     ctxt->progressive = XML_PARSER_START_TAG;
11758                     xmlParseGetLasts(ctxt, &lastlt, &lastgt);
11759 #ifdef DEBUG_PUSH
11760                     xmlGenericError(xmlGenericErrorContext,
11761                             "PP: entering START_TAG\n");
11762 #endif
11763                 }
11764                 break;
11765             case XML_PARSER_PROLOG:
11766                 SKIP_BLANKS;
11767                 if (ctxt->input->buf == NULL)
11768                     avail = ctxt->input->length - (ctxt->input->cur - ctxt->input->base);
11769                 else
11770                     avail = xmlBufUse(ctxt->input->buf->buffer) -
11771                             (ctxt->input->cur - ctxt->input->base);
11772                 if (avail < 2)
11773                     goto done;
11774                 cur = ctxt->input->cur[0];
11775                 next = ctxt->input->cur[1];
11776                 if ((cur == '<') && (next == '?')) {
11777                     if ((!terminate) &&
11778                         (xmlParseLookupSequence(ctxt, '?', '>', 0) < 0)) {
11779                         ctxt->progressive = XML_PARSER_PI;
11780                         goto done;
11781                     }
11782 #ifdef DEBUG_PUSH
11783                     xmlGenericError(xmlGenericErrorContext,
11784                             "PP: Parsing PI\n");
11785 #endif
11786                     xmlParsePI(ctxt);
11787                     if (ctxt->instate == XML_PARSER_EOF)
11788                         goto done;
11789                     ctxt->instate = XML_PARSER_PROLOG;
11790                     ctxt->progressive = 1;
11791                 } else if ((cur == '<') && (next == '!') &&
11792                     (ctxt->input->cur[2] == '-') && (ctxt->input->cur[3] == '-')) {
11793                     if ((!terminate) &&
11794                         (xmlParseLookupSequence(ctxt, '-', '-', '>') < 0)) {
11795                         ctxt->progressive = XML_PARSER_COMMENT;
11796                         goto done;
11797                     }
11798 #ifdef DEBUG_PUSH
11799                     xmlGenericError(xmlGenericErrorContext,
11800                             "PP: Parsing Comment\n");
11801 #endif
11802                     xmlParseComment(ctxt);
11803                     if (ctxt->instate == XML_PARSER_EOF)
11804                         goto done;
11805                     ctxt->instate = XML_PARSER_PROLOG;
11806                     ctxt->progressive = 1;
11807                 } else if ((cur == '<') && (next == '!') &&
11808                            (avail < 4)) {
11809                     goto done;
11810                 } else {
11811                     ctxt->instate = XML_PARSER_START_TAG;
11812                     if (ctxt->progressive == 0)
11813                         ctxt->progressive = XML_PARSER_START_TAG;
11814                     xmlParseGetLasts(ctxt, &lastlt, &lastgt);
11815 #ifdef DEBUG_PUSH
11816                     xmlGenericError(xmlGenericErrorContext,
11817                             "PP: entering START_TAG\n");
11818 #endif
11819                 }
11820                 break;
11821             case XML_PARSER_EPILOG:
11822                 SKIP_BLANKS;
11823                 if (ctxt->input->buf == NULL)
11824                     avail = ctxt->input->length - (ctxt->input->cur - ctxt->input->base);
11825                 else
11826                     avail = xmlBufUse(ctxt->input->buf->buffer) -
11827                             (ctxt->input->cur - ctxt->input->base);
11828                 if (avail < 2)
11829                     goto done;
11830                 cur = ctxt->input->cur[0];
11831                 next = ctxt->input->cur[1];
11832                 if ((cur == '<') && (next == '?')) {
11833                     if ((!terminate) &&
11834                         (xmlParseLookupSequence(ctxt, '?', '>', 0) < 0)) {
11835                         ctxt->progressive = XML_PARSER_PI;
11836                         goto done;
11837                     }
11838 #ifdef DEBUG_PUSH
11839                     xmlGenericError(xmlGenericErrorContext,
11840                             "PP: Parsing PI\n");
11841 #endif
11842                     xmlParsePI(ctxt);
11843                     if (ctxt->instate == XML_PARSER_EOF)
11844                         goto done;
11845                     ctxt->instate = XML_PARSER_EPILOG;
11846                     ctxt->progressive = 1;
11847                 } else if ((cur == '<') && (next == '!') &&
11848                     (ctxt->input->cur[2] == '-') && (ctxt->input->cur[3] == '-')) {
11849                     if ((!terminate) &&
11850                         (xmlParseLookupSequence(ctxt, '-', '-', '>') < 0)) {
11851                         ctxt->progressive = XML_PARSER_COMMENT;
11852                         goto done;
11853                     }
11854 #ifdef DEBUG_PUSH
11855                     xmlGenericError(xmlGenericErrorContext,
11856                             "PP: Parsing Comment\n");
11857 #endif
11858                     xmlParseComment(ctxt);
11859                     if (ctxt->instate == XML_PARSER_EOF)
11860                         goto done;
11861                     ctxt->instate = XML_PARSER_EPILOG;
11862                     ctxt->progressive = 1;
11863                 } else if ((cur == '<') && (next == '!') &&
11864                            (avail < 4)) {
11865                     goto done;
11866                 } else {
11867                     xmlFatalErr(ctxt, XML_ERR_DOCUMENT_END, NULL);
11868                     ctxt->instate = XML_PARSER_EOF;
11869 #ifdef DEBUG_PUSH
11870                     xmlGenericError(xmlGenericErrorContext,
11871                             "PP: entering EOF\n");
11872 #endif
11873                     if ((ctxt->sax) && (ctxt->sax->endDocument != NULL))
11874                         ctxt->sax->endDocument(ctxt->userData);
11875                     goto done;
11876                 }
11877                 break;
11878             case XML_PARSER_DTD: {
11879                 /*
11880                  * Sorry but progressive parsing of the internal subset
11881                  * is not expected to be supported. We first check that
11882                  * the full content of the internal subset is available and
11883                  * the parsing is launched only at that point.
11884                  * Internal subset ends up with "']' S? '>'" in an unescaped
11885                  * section and not in a ']]>' sequence which are conditional
11886                  * sections (whoever argued to keep that crap in XML deserve
11887                  * a place in hell !).
11888                  */
11889                 int base, i;
11890                 xmlChar *buf;
11891                 xmlChar quote = 0;
11892                 size_t use;
11893
11894                 base = ctxt->input->cur - ctxt->input->base;
11895                 if (base < 0) return(0);
11896                 if (ctxt->checkIndex > base)
11897                     base = ctxt->checkIndex;
11898                 buf = xmlBufContent(ctxt->input->buf->buffer);
11899                 use = xmlBufUse(ctxt->input->buf->buffer);
11900                 for (;(unsigned int) base < use; base++) {
11901                     if (quote != 0) {
11902                         if (buf[base] == quote)
11903                             quote = 0;
11904                         continue;
11905                     }
11906                     if ((quote == 0) && (buf[base] == '<')) {
11907                         int found  = 0;
11908                         /* special handling of comments */
11909                         if (((unsigned int) base + 4 < use) &&
11910                             (buf[base + 1] == '!') &&
11911                             (buf[base + 2] == '-') &&
11912                             (buf[base + 3] == '-')) {
11913                             for (;(unsigned int) base + 3 < use; base++) {
11914                                 if ((buf[base] == '-') &&
11915                                     (buf[base + 1] == '-') &&
11916                                     (buf[base + 2] == '>')) {
11917                                     found = 1;
11918                                     base += 2;
11919                                     break;
11920                                 }
11921                             }
11922                             if (!found) {
11923 #if 0
11924                                 fprintf(stderr, "unfinished comment\n");
11925 #endif
11926                                 break; /* for */
11927                             }
11928                             continue;
11929                         }
11930                     }
11931                     if (buf[base] == '"') {
11932                         quote = '"';
11933                         continue;
11934                     }
11935                     if (buf[base] == '\'') {
11936                         quote = '\'';
11937                         continue;
11938                     }
11939                     if (buf[base] == ']') {
11940 #if 0
11941                         fprintf(stderr, "%c%c%c%c: ", buf[base],
11942                                 buf[base + 1], buf[base + 2], buf[base + 3]);
11943 #endif
11944                         if ((unsigned int) base +1 >= use)
11945                             break;
11946                         if (buf[base + 1] == ']') {
11947                             /* conditional crap, skip both ']' ! */
11948                             base++;
11949                             continue;
11950                         }
11951                         for (i = 1; (unsigned int) base + i < use; i++) {
11952                             if (buf[base + i] == '>') {
11953 #if 0
11954                                 fprintf(stderr, "found\n");
11955 #endif
11956                                 goto found_end_int_subset;
11957                             }
11958                             if (!IS_BLANK_CH(buf[base + i])) {
11959 #if 0
11960                                 fprintf(stderr, "not found\n");
11961 #endif
11962                                 goto not_end_of_int_subset;
11963                             }
11964                         }
11965 #if 0
11966                         fprintf(stderr, "end of stream\n");
11967 #endif
11968                         break;
11969
11970                     }
11971 not_end_of_int_subset:
11972                     continue; /* for */
11973                 }
11974                 /*
11975                  * We didn't found the end of the Internal subset
11976                  */
11977                 if (quote == 0)
11978                     ctxt->checkIndex = base;
11979                 else
11980                     ctxt->checkIndex = 0;
11981 #ifdef DEBUG_PUSH
11982                 if (next == 0)
11983                     xmlGenericError(xmlGenericErrorContext,
11984                             "PP: lookup of int subset end filed\n");
11985 #endif
11986                 goto done;
11987
11988 found_end_int_subset:
11989                 ctxt->checkIndex = 0;
11990                 xmlParseInternalSubset(ctxt);
11991                 if (ctxt->instate == XML_PARSER_EOF)
11992                     goto done;
11993                 ctxt->inSubset = 2;
11994                 if ((ctxt->sax != NULL) && (!ctxt->disableSAX) &&
11995                     (ctxt->sax->externalSubset != NULL))
11996                     ctxt->sax->externalSubset(ctxt->userData, ctxt->intSubName,
11997                             ctxt->extSubSystem, ctxt->extSubURI);
11998                 ctxt->inSubset = 0;
11999                 xmlCleanSpecialAttr(ctxt);
12000                 if (ctxt->instate == XML_PARSER_EOF)
12001                     goto done;
12002                 ctxt->instate = XML_PARSER_PROLOG;
12003                 ctxt->checkIndex = 0;
12004 #ifdef DEBUG_PUSH
12005                 xmlGenericError(xmlGenericErrorContext,
12006                         "PP: entering PROLOG\n");
12007 #endif
12008                 break;
12009             }
12010             case XML_PARSER_COMMENT:
12011                 xmlGenericError(xmlGenericErrorContext,
12012                         "PP: internal error, state == COMMENT\n");
12013                 ctxt->instate = XML_PARSER_CONTENT;
12014 #ifdef DEBUG_PUSH
12015                 xmlGenericError(xmlGenericErrorContext,
12016                         "PP: entering CONTENT\n");
12017 #endif
12018                 break;
12019             case XML_PARSER_IGNORE:
12020                 xmlGenericError(xmlGenericErrorContext,
12021                         "PP: internal error, state == IGNORE");
12022                 ctxt->instate = XML_PARSER_DTD;
12023 #ifdef DEBUG_PUSH
12024                 xmlGenericError(xmlGenericErrorContext,
12025                         "PP: entering DTD\n");
12026 #endif
12027                 break;
12028             case XML_PARSER_PI:
12029                 xmlGenericError(xmlGenericErrorContext,
12030                         "PP: internal error, state == PI\n");
12031                 ctxt->instate = XML_PARSER_CONTENT;
12032 #ifdef DEBUG_PUSH
12033                 xmlGenericError(xmlGenericErrorContext,
12034                         "PP: entering CONTENT\n");
12035 #endif
12036                 break;
12037             case XML_PARSER_ENTITY_DECL:
12038                 xmlGenericError(xmlGenericErrorContext,
12039                         "PP: internal error, state == ENTITY_DECL\n");
12040                 ctxt->instate = XML_PARSER_DTD;
12041 #ifdef DEBUG_PUSH
12042                 xmlGenericError(xmlGenericErrorContext,
12043                         "PP: entering DTD\n");
12044 #endif
12045                 break;
12046             case XML_PARSER_ENTITY_VALUE:
12047                 xmlGenericError(xmlGenericErrorContext,
12048                         "PP: internal error, state == ENTITY_VALUE\n");
12049                 ctxt->instate = XML_PARSER_CONTENT;
12050 #ifdef DEBUG_PUSH
12051                 xmlGenericError(xmlGenericErrorContext,
12052                         "PP: entering DTD\n");
12053 #endif
12054                 break;
12055             case XML_PARSER_ATTRIBUTE_VALUE:
12056                 xmlGenericError(xmlGenericErrorContext,
12057                         "PP: internal error, state == ATTRIBUTE_VALUE\n");
12058                 ctxt->instate = XML_PARSER_START_TAG;
12059 #ifdef DEBUG_PUSH
12060                 xmlGenericError(xmlGenericErrorContext,
12061                         "PP: entering START_TAG\n");
12062 #endif
12063                 break;
12064             case XML_PARSER_SYSTEM_LITERAL:
12065                 xmlGenericError(xmlGenericErrorContext,
12066                         "PP: internal error, state == SYSTEM_LITERAL\n");
12067                 ctxt->instate = XML_PARSER_START_TAG;
12068 #ifdef DEBUG_PUSH
12069                 xmlGenericError(xmlGenericErrorContext,
12070                         "PP: entering START_TAG\n");
12071 #endif
12072                 break;
12073             case XML_PARSER_PUBLIC_LITERAL:
12074                 xmlGenericError(xmlGenericErrorContext,
12075                         "PP: internal error, state == PUBLIC_LITERAL\n");
12076                 ctxt->instate = XML_PARSER_START_TAG;
12077 #ifdef DEBUG_PUSH
12078                 xmlGenericError(xmlGenericErrorContext,
12079                         "PP: entering START_TAG\n");
12080 #endif
12081                 break;
12082         }
12083     }
12084 done:
12085 #ifdef DEBUG_PUSH
12086     xmlGenericError(xmlGenericErrorContext, "PP: done %d\n", ret);
12087 #endif
12088     return(ret);
12089 encoding_error:
12090     {
12091         char buffer[150];
12092
12093         snprintf(buffer, 149, "Bytes: 0x%02X 0x%02X 0x%02X 0x%02X\n",
12094                         ctxt->input->cur[0], ctxt->input->cur[1],
12095                         ctxt->input->cur[2], ctxt->input->cur[3]);
12096         __xmlErrEncoding(ctxt, XML_ERR_INVALID_CHAR,
12097                      "Input is not proper UTF-8, indicate encoding !\n%s",
12098                      BAD_CAST buffer, NULL);
12099     }
12100     return(0);
12101 }
12102
12103 /**
12104  * xmlParseCheckTransition:
12105  * @ctxt:  an XML parser context
12106  * @chunk:  a char array
12107  * @size:  the size in byte of the chunk
12108  *
12109  * Check depending on the current parser state if the chunk given must be
12110  * processed immediately or one need more data to advance on parsing.
12111  *
12112  * Returns -1 in case of error, 0 if the push is not needed and 1 if needed
12113  */
12114 static int
12115 xmlParseCheckTransition(xmlParserCtxtPtr ctxt, const char *chunk, int size) {
12116     if ((ctxt == NULL) || (chunk == NULL) || (size < 0))
12117         return(-1);
12118     if (ctxt->instate == XML_PARSER_START_TAG) {
12119         if (memchr(chunk, '>', size) != NULL)
12120             return(1);
12121         return(0);
12122     }
12123     if (ctxt->progressive == XML_PARSER_COMMENT) {
12124         if (memchr(chunk, '>', size) != NULL)
12125             return(1);
12126         return(0);
12127     }
12128     if (ctxt->instate == XML_PARSER_CDATA_SECTION) {
12129         if (memchr(chunk, '>', size) != NULL)
12130             return(1);
12131         return(0);
12132     }
12133     if (ctxt->progressive == XML_PARSER_PI) {
12134         if (memchr(chunk, '>', size) != NULL)
12135             return(1);
12136         return(0);
12137     }
12138     if (ctxt->instate == XML_PARSER_END_TAG) {
12139         if (memchr(chunk, '>', size) != NULL)
12140             return(1);
12141         return(0);
12142     }
12143     if ((ctxt->progressive == XML_PARSER_DTD) ||
12144         (ctxt->instate == XML_PARSER_DTD)) {
12145         if (memchr(chunk, '>', size) != NULL)
12146             return(1);
12147         return(0);
12148     }
12149     return(1);
12150 }
12151
12152 /**
12153  * xmlParseChunk:
12154  * @ctxt:  an XML parser context
12155  * @chunk:  an char array
12156  * @size:  the size in byte of the chunk
12157  * @terminate:  last chunk indicator
12158  *
12159  * Parse a Chunk of memory
12160  *
12161  * Returns zero if no error, the xmlParserErrors otherwise.
12162  */
12163 int
12164 xmlParseChunk(xmlParserCtxtPtr ctxt, const char *chunk, int size,
12165               int terminate) {
12166     int end_in_lf = 0;
12167     int remain = 0;
12168     size_t old_avail = 0;
12169     size_t avail = 0;
12170
12171     if (ctxt == NULL)
12172         return(XML_ERR_INTERNAL_ERROR);
12173     if ((ctxt->errNo != XML_ERR_OK) && (ctxt->disableSAX == 1))
12174         return(ctxt->errNo);
12175     if (ctxt->instate == XML_PARSER_EOF)
12176         return(-1);
12177     if (ctxt->instate == XML_PARSER_START)
12178         xmlDetectSAX2(ctxt);
12179     if ((size > 0) && (chunk != NULL) && (!terminate) &&
12180         (chunk[size - 1] == '\r')) {
12181         end_in_lf = 1;
12182         size--;
12183     }
12184
12185 xmldecl_done:
12186
12187     if ((size > 0) && (chunk != NULL) && (ctxt->input != NULL) &&
12188         (ctxt->input->buf != NULL) && (ctxt->instate != XML_PARSER_EOF))  {
12189         size_t base = xmlBufGetInputBase(ctxt->input->buf->buffer, ctxt->input);
12190         size_t cur = ctxt->input->cur - ctxt->input->base;
12191         int res;
12192
12193         old_avail = xmlBufUse(ctxt->input->buf->buffer);
12194         /*
12195          * Specific handling if we autodetected an encoding, we should not
12196          * push more than the first line ... which depend on the encoding
12197          * And only push the rest once the final encoding was detected
12198          */
12199         if ((ctxt->instate == XML_PARSER_START) && (ctxt->input != NULL) &&
12200             (ctxt->input->buf != NULL) && (ctxt->input->buf->encoder != NULL)) {
12201             unsigned int len = 45;
12202
12203             if ((xmlStrcasestr(BAD_CAST ctxt->input->buf->encoder->name,
12204                                BAD_CAST "UTF-16")) ||
12205                 (xmlStrcasestr(BAD_CAST ctxt->input->buf->encoder->name,
12206                                BAD_CAST "UTF16")))
12207                 len = 90;
12208             else if ((xmlStrcasestr(BAD_CAST ctxt->input->buf->encoder->name,
12209                                     BAD_CAST "UCS-4")) ||
12210                      (xmlStrcasestr(BAD_CAST ctxt->input->buf->encoder->name,
12211                                     BAD_CAST "UCS4")))
12212                 len = 180;
12213
12214             if (ctxt->input->buf->rawconsumed < len)
12215                 len -= ctxt->input->buf->rawconsumed;
12216
12217             /*
12218              * Change size for reading the initial declaration only
12219              * if size is greater than len. Otherwise, memmove in xmlBufferAdd
12220              * will blindly copy extra bytes from memory.
12221              */
12222             if ((unsigned int) size > len) {
12223                 remain = size - len;
12224                 size = len;
12225             } else {
12226                 remain = 0;
12227             }
12228         }
12229         res = xmlParserInputBufferPush(ctxt->input->buf, size, chunk);
12230         if (res < 0) {
12231             ctxt->errNo = XML_PARSER_EOF;
12232             ctxt->disableSAX = 1;
12233             return (XML_PARSER_EOF);
12234         }
12235         xmlBufSetInputBaseCur(ctxt->input->buf->buffer, ctxt->input, base, cur);
12236 #ifdef DEBUG_PUSH
12237         xmlGenericError(xmlGenericErrorContext, "PP: pushed %d\n", size);
12238 #endif
12239
12240     } else if (ctxt->instate != XML_PARSER_EOF) {
12241         if ((ctxt->input != NULL) && ctxt->input->buf != NULL) {
12242             xmlParserInputBufferPtr in = ctxt->input->buf;
12243             if ((in->encoder != NULL) && (in->buffer != NULL) &&
12244                     (in->raw != NULL)) {
12245                 int nbchars;
12246                 size_t base = xmlBufGetInputBase(in->buffer, ctxt->input);
12247                 size_t current = ctxt->input->cur - ctxt->input->base;
12248
12249                 nbchars = xmlCharEncInput(in, terminate);
12250                 if (nbchars < 0) {
12251                     /* TODO 2.6.0 */
12252                     xmlGenericError(xmlGenericErrorContext,
12253                                     "xmlParseChunk: encoder error\n");
12254                     return(XML_ERR_INVALID_ENCODING);
12255                 }
12256                 xmlBufSetInputBaseCur(in->buffer, ctxt->input, base, current);
12257             }
12258         }
12259     }
12260     if (remain != 0) {
12261         xmlParseTryOrFinish(ctxt, 0);
12262     } else {
12263         if ((ctxt->input != NULL) && (ctxt->input->buf != NULL))
12264             avail = xmlBufUse(ctxt->input->buf->buffer);
12265         /*
12266          * Depending on the current state it may not be such
12267          * a good idea to try parsing if there is nothing in the chunk
12268          * which would be worth doing a parser state transition and we
12269          * need to wait for more data
12270          */
12271         if ((terminate) || (avail > XML_MAX_TEXT_LENGTH) ||
12272             (old_avail == 0) || (avail == 0) ||
12273             (xmlParseCheckTransition(ctxt,
12274                        (const char *)&ctxt->input->base[old_avail],
12275                                      avail - old_avail)))
12276             xmlParseTryOrFinish(ctxt, terminate);
12277     }
12278     if (ctxt->instate == XML_PARSER_EOF)
12279         return(ctxt->errNo);
12280
12281     if ((ctxt->input != NULL) &&
12282          (((ctxt->input->end - ctxt->input->cur) > XML_MAX_LOOKUP_LIMIT) ||
12283          ((ctxt->input->cur - ctxt->input->base) > XML_MAX_LOOKUP_LIMIT)) &&
12284         ((ctxt->options & XML_PARSE_HUGE) == 0)) {
12285         xmlFatalErr(ctxt, XML_ERR_INTERNAL_ERROR, "Huge input lookup");
12286         ctxt->instate = XML_PARSER_EOF;
12287     }
12288     if ((ctxt->errNo != XML_ERR_OK) && (ctxt->disableSAX == 1))
12289         return(ctxt->errNo);
12290
12291     if (remain != 0) {
12292         chunk += size;
12293         size = remain;
12294         remain = 0;
12295         goto xmldecl_done;
12296     }
12297     if ((end_in_lf == 1) && (ctxt->input != NULL) &&
12298         (ctxt->input->buf != NULL)) {
12299         size_t base = xmlBufGetInputBase(ctxt->input->buf->buffer,
12300                                          ctxt->input);
12301         size_t current = ctxt->input->cur - ctxt->input->base;
12302
12303         xmlParserInputBufferPush(ctxt->input->buf, 1, "\r");
12304
12305         xmlBufSetInputBaseCur(ctxt->input->buf->buffer, ctxt->input,
12306                               base, current);
12307     }
12308     if (terminate) {
12309         /*
12310          * Check for termination
12311          */
12312         int cur_avail = 0;
12313
12314         if (ctxt->input != NULL) {
12315             if (ctxt->input->buf == NULL)
12316                 cur_avail = ctxt->input->length -
12317                             (ctxt->input->cur - ctxt->input->base);
12318             else
12319                 cur_avail = xmlBufUse(ctxt->input->buf->buffer) -
12320                                       (ctxt->input->cur - ctxt->input->base);
12321         }
12322
12323         if ((ctxt->instate != XML_PARSER_EOF) &&
12324             (ctxt->instate != XML_PARSER_EPILOG)) {
12325             xmlFatalErr(ctxt, XML_ERR_DOCUMENT_END, NULL);
12326         }
12327         if ((ctxt->instate == XML_PARSER_EPILOG) && (cur_avail > 0)) {
12328             xmlFatalErr(ctxt, XML_ERR_DOCUMENT_END, NULL);
12329         }
12330         if (ctxt->instate != XML_PARSER_EOF) {
12331             if ((ctxt->sax) && (ctxt->sax->endDocument != NULL))
12332                 ctxt->sax->endDocument(ctxt->userData);
12333         }
12334         ctxt->instate = XML_PARSER_EOF;
12335     }
12336     if (ctxt->wellFormed == 0)
12337         return((xmlParserErrors) ctxt->errNo);
12338     else
12339         return(0);
12340 }
12341
12342 /************************************************************************
12343  *                                                                      *
12344  *              I/O front end functions to the parser                   *
12345  *                                                                      *
12346  ************************************************************************/
12347
12348 /**
12349  * xmlCreatePushParserCtxt:
12350  * @sax:  a SAX handler
12351  * @user_data:  The user data returned on SAX callbacks
12352  * @chunk:  a pointer to an array of chars
12353  * @size:  number of chars in the array
12354  * @filename:  an optional file name or URI
12355  *
12356  * Create a parser context for using the XML parser in push mode.
12357  * If @buffer and @size are non-NULL, the data is used to detect
12358  * the encoding.  The remaining characters will be parsed so they
12359  * don't need to be fed in again through xmlParseChunk.
12360  * To allow content encoding detection, @size should be >= 4
12361  * The value of @filename is used for fetching external entities
12362  * and error/warning reports.
12363  *
12364  * Returns the new parser context or NULL
12365  */
12366
12367 xmlParserCtxtPtr
12368 xmlCreatePushParserCtxt(xmlSAXHandlerPtr sax, void *user_data,
12369                         const char *chunk, int size, const char *filename) {
12370     xmlParserCtxtPtr ctxt;
12371     xmlParserInputPtr inputStream;
12372     xmlParserInputBufferPtr buf;
12373     xmlCharEncoding enc = XML_CHAR_ENCODING_NONE;
12374
12375     /*
12376      * plug some encoding conversion routines
12377      */
12378     if ((chunk != NULL) && (size >= 4))
12379         enc = xmlDetectCharEncoding((const xmlChar *) chunk, size);
12380
12381     buf = xmlAllocParserInputBuffer(enc);
12382     if (buf == NULL) return(NULL);
12383
12384     ctxt = xmlNewParserCtxt();
12385     if (ctxt == NULL) {
12386         xmlErrMemory(NULL, "creating parser: out of memory\n");
12387         xmlFreeParserInputBuffer(buf);
12388         return(NULL);
12389     }
12390     ctxt->dictNames = 1;
12391     ctxt->pushTab = (void **) xmlMalloc(ctxt->nameMax * 3 * sizeof(xmlChar *));
12392     if (ctxt->pushTab == NULL) {
12393         xmlErrMemory(ctxt, NULL);
12394         xmlFreeParserInputBuffer(buf);
12395         xmlFreeParserCtxt(ctxt);
12396         return(NULL);
12397     }
12398     if (sax != NULL) {
12399 #ifdef LIBXML_SAX1_ENABLED
12400         if (ctxt->sax != (xmlSAXHandlerPtr) &xmlDefaultSAXHandler)
12401 #endif /* LIBXML_SAX1_ENABLED */
12402             xmlFree(ctxt->sax);
12403         ctxt->sax = (xmlSAXHandlerPtr) xmlMalloc(sizeof(xmlSAXHandler));
12404         if (ctxt->sax == NULL) {
12405             xmlErrMemory(ctxt, NULL);
12406             xmlFreeParserInputBuffer(buf);
12407             xmlFreeParserCtxt(ctxt);
12408             return(NULL);
12409         }
12410         memset(ctxt->sax, 0, sizeof(xmlSAXHandler));
12411         if (sax->initialized == XML_SAX2_MAGIC)
12412             memcpy(ctxt->sax, sax, sizeof(xmlSAXHandler));
12413         else
12414             memcpy(ctxt->sax, sax, sizeof(xmlSAXHandlerV1));
12415         if (user_data != NULL)
12416             ctxt->userData = user_data;
12417     }
12418     if (filename == NULL) {
12419         ctxt->directory = NULL;
12420     } else {
12421         ctxt->directory = xmlParserGetDirectory(filename);
12422     }
12423
12424     inputStream = xmlNewInputStream(ctxt);
12425     if (inputStream == NULL) {
12426         xmlFreeParserCtxt(ctxt);
12427         xmlFreeParserInputBuffer(buf);
12428         return(NULL);
12429     }
12430
12431     if (filename == NULL)
12432         inputStream->filename = NULL;
12433     else {
12434         inputStream->filename = (char *)
12435             xmlCanonicPath((const xmlChar *) filename);
12436         if (inputStream->filename == NULL) {
12437             xmlFreeParserCtxt(ctxt);
12438             xmlFreeParserInputBuffer(buf);
12439             return(NULL);
12440         }
12441     }
12442     inputStream->buf = buf;
12443     xmlBufResetInput(inputStream->buf->buffer, inputStream);
12444     inputPush(ctxt, inputStream);
12445
12446     /*
12447      * If the caller didn't provide an initial 'chunk' for determining
12448      * the encoding, we set the context to XML_CHAR_ENCODING_NONE so
12449      * that it can be automatically determined later
12450      */
12451     if ((size == 0) || (chunk == NULL)) {
12452         ctxt->charset = XML_CHAR_ENCODING_NONE;
12453     } else if ((ctxt->input != NULL) && (ctxt->input->buf != NULL)) {
12454         size_t base = xmlBufGetInputBase(ctxt->input->buf->buffer, ctxt->input);
12455         size_t cur = ctxt->input->cur - ctxt->input->base;
12456
12457         xmlParserInputBufferPush(ctxt->input->buf, size, chunk);
12458
12459         xmlBufSetInputBaseCur(ctxt->input->buf->buffer, ctxt->input, base, cur);
12460 #ifdef DEBUG_PUSH
12461         xmlGenericError(xmlGenericErrorContext, "PP: pushed %d\n", size);
12462 #endif
12463     }
12464
12465     if (enc != XML_CHAR_ENCODING_NONE) {
12466         xmlSwitchEncoding(ctxt, enc);
12467     }
12468
12469     return(ctxt);
12470 }
12471 #endif /* LIBXML_PUSH_ENABLED */
12472
12473 /**
12474  * xmlStopParser:
12475  * @ctxt:  an XML parser context
12476  *
12477  * Blocks further parser processing
12478  */
12479 void
12480 xmlStopParser(xmlParserCtxtPtr ctxt) {
12481     if (ctxt == NULL)
12482         return;
12483     ctxt->instate = XML_PARSER_EOF;
12484     ctxt->errNo = XML_ERR_USER_STOP;
12485     ctxt->disableSAX = 1;
12486     if (ctxt->input != NULL) {
12487         ctxt->input->cur = BAD_CAST"";
12488         ctxt->input->base = ctxt->input->cur;
12489     }
12490 }
12491
12492 /**
12493  * xmlCreateIOParserCtxt:
12494  * @sax:  a SAX handler
12495  * @user_data:  The user data returned on SAX callbacks
12496  * @ioread:  an I/O read function
12497  * @ioclose:  an I/O close function
12498  * @ioctx:  an I/O handler
12499  * @enc:  the charset encoding if known
12500  *
12501  * Create a parser context for using the XML parser with an existing
12502  * I/O stream
12503  *
12504  * Returns the new parser context or NULL
12505  */
12506 xmlParserCtxtPtr
12507 xmlCreateIOParserCtxt(xmlSAXHandlerPtr sax, void *user_data,
12508         xmlInputReadCallback   ioread, xmlInputCloseCallback  ioclose,
12509         void *ioctx, xmlCharEncoding enc) {
12510     xmlParserCtxtPtr ctxt;
12511     xmlParserInputPtr inputStream;
12512     xmlParserInputBufferPtr buf;
12513
12514     if (ioread == NULL) return(NULL);
12515
12516     buf = xmlParserInputBufferCreateIO(ioread, ioclose, ioctx, enc);
12517     if (buf == NULL) {
12518         if (ioclose != NULL)
12519             ioclose(ioctx);
12520         return (NULL);
12521     }
12522
12523     ctxt = xmlNewParserCtxt();
12524     if (ctxt == NULL) {
12525         xmlFreeParserInputBuffer(buf);
12526         return(NULL);
12527     }
12528     if (sax != NULL) {
12529 #ifdef LIBXML_SAX1_ENABLED
12530         if (ctxt->sax != (xmlSAXHandlerPtr) &xmlDefaultSAXHandler)
12531 #endif /* LIBXML_SAX1_ENABLED */
12532             xmlFree(ctxt->sax);
12533         ctxt->sax = (xmlSAXHandlerPtr) xmlMalloc(sizeof(xmlSAXHandler));
12534         if (ctxt->sax == NULL) {
12535             xmlErrMemory(ctxt, NULL);
12536             xmlFreeParserCtxt(ctxt);
12537             return(NULL);
12538         }
12539         memset(ctxt->sax, 0, sizeof(xmlSAXHandler));
12540         if (sax->initialized == XML_SAX2_MAGIC)
12541             memcpy(ctxt->sax, sax, sizeof(xmlSAXHandler));
12542         else
12543             memcpy(ctxt->sax, sax, sizeof(xmlSAXHandlerV1));
12544         if (user_data != NULL)
12545             ctxt->userData = user_data;
12546     }
12547
12548     inputStream = xmlNewIOInputStream(ctxt, buf, enc);
12549     if (inputStream == NULL) {
12550         xmlFreeParserCtxt(ctxt);
12551         return(NULL);
12552     }
12553     inputPush(ctxt, inputStream);
12554
12555     return(ctxt);
12556 }
12557
12558 #ifdef LIBXML_VALID_ENABLED
12559 /************************************************************************
12560  *                                                                      *
12561  *              Front ends when parsing a DTD                           *
12562  *                                                                      *
12563  ************************************************************************/
12564
12565 /**
12566  * xmlIOParseDTD:
12567  * @sax:  the SAX handler block or NULL
12568  * @input:  an Input Buffer
12569  * @enc:  the charset encoding if known
12570  *
12571  * Load and parse a DTD
12572  *
12573  * Returns the resulting xmlDtdPtr or NULL in case of error.
12574  * @input will be freed by the function in any case.
12575  */
12576
12577 xmlDtdPtr
12578 xmlIOParseDTD(xmlSAXHandlerPtr sax, xmlParserInputBufferPtr input,
12579               xmlCharEncoding enc) {
12580     xmlDtdPtr ret = NULL;
12581     xmlParserCtxtPtr ctxt;
12582     xmlParserInputPtr pinput = NULL;
12583     xmlChar start[4];
12584
12585     if (input == NULL)
12586         return(NULL);
12587
12588     ctxt = xmlNewParserCtxt();
12589     if (ctxt == NULL) {
12590         xmlFreeParserInputBuffer(input);
12591         return(NULL);
12592     }
12593
12594     /*
12595      * Set-up the SAX context
12596      */
12597     if (sax != NULL) {
12598         if (ctxt->sax != NULL)
12599             xmlFree(ctxt->sax);
12600         ctxt->sax = sax;
12601         ctxt->userData = ctxt;
12602     }
12603     xmlDetectSAX2(ctxt);
12604
12605     /*
12606      * generate a parser input from the I/O handler
12607      */
12608
12609     pinput = xmlNewIOInputStream(ctxt, input, XML_CHAR_ENCODING_NONE);
12610     if (pinput == NULL) {
12611         if (sax != NULL) ctxt->sax = NULL;
12612         xmlFreeParserInputBuffer(input);
12613         xmlFreeParserCtxt(ctxt);
12614         return(NULL);
12615     }
12616
12617     /*
12618      * plug some encoding conversion routines here.
12619      */
12620     if (xmlPushInput(ctxt, pinput) < 0) {
12621         if (sax != NULL) ctxt->sax = NULL;
12622         xmlFreeParserCtxt(ctxt);
12623         return(NULL);
12624     }
12625     if (enc != XML_CHAR_ENCODING_NONE) {
12626         xmlSwitchEncoding(ctxt, enc);
12627     }
12628
12629     pinput->filename = NULL;
12630     pinput->line = 1;
12631     pinput->col = 1;
12632     pinput->base = ctxt->input->cur;
12633     pinput->cur = ctxt->input->cur;
12634     pinput->free = NULL;
12635
12636     /*
12637      * let's parse that entity knowing it's an external subset.
12638      */
12639     ctxt->inSubset = 2;
12640     ctxt->myDoc = xmlNewDoc(BAD_CAST "1.0");
12641     if (ctxt->myDoc == NULL) {
12642         xmlErrMemory(ctxt, "New Doc failed");
12643         return(NULL);
12644     }
12645     ctxt->myDoc->properties = XML_DOC_INTERNAL;
12646     ctxt->myDoc->extSubset = xmlNewDtd(ctxt->myDoc, BAD_CAST "none",
12647                                        BAD_CAST "none", BAD_CAST "none");
12648
12649     if ((enc == XML_CHAR_ENCODING_NONE) &&
12650         ((ctxt->input->end - ctxt->input->cur) >= 4)) {
12651         /*
12652          * Get the 4 first bytes and decode the charset
12653          * if enc != XML_CHAR_ENCODING_NONE
12654          * plug some encoding conversion routines.
12655          */
12656         start[0] = RAW;
12657         start[1] = NXT(1);
12658         start[2] = NXT(2);
12659         start[3] = NXT(3);
12660         enc = xmlDetectCharEncoding(start, 4);
12661         if (enc != XML_CHAR_ENCODING_NONE) {
12662             xmlSwitchEncoding(ctxt, enc);
12663         }
12664     }
12665
12666     xmlParseExternalSubset(ctxt, BAD_CAST "none", BAD_CAST "none");
12667
12668     if (ctxt->myDoc != NULL) {
12669         if (ctxt->wellFormed) {
12670             ret = ctxt->myDoc->extSubset;
12671             ctxt->myDoc->extSubset = NULL;
12672             if (ret != NULL) {
12673                 xmlNodePtr tmp;
12674
12675                 ret->doc = NULL;
12676                 tmp = ret->children;
12677                 while (tmp != NULL) {
12678                     tmp->doc = NULL;
12679                     tmp = tmp->next;
12680                 }
12681             }
12682         } else {
12683             ret = NULL;
12684         }
12685         xmlFreeDoc(ctxt->myDoc);
12686         ctxt->myDoc = NULL;
12687     }
12688     if (sax != NULL) ctxt->sax = NULL;
12689     xmlFreeParserCtxt(ctxt);
12690
12691     return(ret);
12692 }
12693
12694 /**
12695  * xmlSAXParseDTD:
12696  * @sax:  the SAX handler block
12697  * @ExternalID:  a NAME* containing the External ID of the DTD
12698  * @SystemID:  a NAME* containing the URL to the DTD
12699  *
12700  * Load and parse an external subset.
12701  *
12702  * Returns the resulting xmlDtdPtr or NULL in case of error.
12703  */
12704
12705 xmlDtdPtr
12706 xmlSAXParseDTD(xmlSAXHandlerPtr sax, const xmlChar *ExternalID,
12707                           const xmlChar *SystemID) {
12708     xmlDtdPtr ret = NULL;
12709     xmlParserCtxtPtr ctxt;
12710     xmlParserInputPtr input = NULL;
12711     xmlCharEncoding enc;
12712     xmlChar* systemIdCanonic;
12713
12714     if ((ExternalID == NULL) && (SystemID == NULL)) return(NULL);
12715
12716     ctxt = xmlNewParserCtxt();
12717     if (ctxt == NULL) {
12718         return(NULL);
12719     }
12720
12721     /*
12722      * Set-up the SAX context
12723      */
12724     if (sax != NULL) {
12725         if (ctxt->sax != NULL)
12726             xmlFree(ctxt->sax);
12727         ctxt->sax = sax;
12728         ctxt->userData = ctxt;
12729     }
12730
12731     /*
12732      * Canonicalise the system ID
12733      */
12734     systemIdCanonic = xmlCanonicPath(SystemID);
12735     if ((SystemID != NULL) && (systemIdCanonic == NULL)) {
12736         xmlFreeParserCtxt(ctxt);
12737         return(NULL);
12738     }
12739
12740     /*
12741      * Ask the Entity resolver to load the damn thing
12742      */
12743
12744     if ((ctxt->sax != NULL) && (ctxt->sax->resolveEntity != NULL))
12745         input = ctxt->sax->resolveEntity(ctxt->userData, ExternalID,
12746                                          systemIdCanonic);
12747     if (input == NULL) {
12748         if (sax != NULL) ctxt->sax = NULL;
12749         xmlFreeParserCtxt(ctxt);
12750         if (systemIdCanonic != NULL)
12751             xmlFree(systemIdCanonic);
12752         return(NULL);
12753     }
12754
12755     /*
12756      * plug some encoding conversion routines here.
12757      */
12758     if (xmlPushInput(ctxt, input) < 0) {
12759         if (sax != NULL) ctxt->sax = NULL;
12760         xmlFreeParserCtxt(ctxt);
12761         if (systemIdCanonic != NULL)
12762             xmlFree(systemIdCanonic);
12763         return(NULL);
12764     }
12765     if ((ctxt->input->end - ctxt->input->cur) >= 4) {
12766         enc = xmlDetectCharEncoding(ctxt->input->cur, 4);
12767         xmlSwitchEncoding(ctxt, enc);
12768     }
12769
12770     if (input->filename == NULL)
12771         input->filename = (char *) systemIdCanonic;
12772     else
12773         xmlFree(systemIdCanonic);
12774     input->line = 1;
12775     input->col = 1;
12776     input->base = ctxt->input->cur;
12777     input->cur = ctxt->input->cur;
12778     input->free = NULL;
12779
12780     /*
12781      * let's parse that entity knowing it's an external subset.
12782      */
12783     ctxt->inSubset = 2;
12784     ctxt->myDoc = xmlNewDoc(BAD_CAST "1.0");
12785     if (ctxt->myDoc == NULL) {
12786         xmlErrMemory(ctxt, "New Doc failed");
12787         if (sax != NULL) ctxt->sax = NULL;
12788         xmlFreeParserCtxt(ctxt);
12789         return(NULL);
12790     }
12791     ctxt->myDoc->properties = XML_DOC_INTERNAL;
12792     ctxt->myDoc->extSubset = xmlNewDtd(ctxt->myDoc, BAD_CAST "none",
12793                                        ExternalID, SystemID);
12794     xmlParseExternalSubset(ctxt, ExternalID, SystemID);
12795
12796     if (ctxt->myDoc != NULL) {
12797         if (ctxt->wellFormed) {
12798             ret = ctxt->myDoc->extSubset;
12799             ctxt->myDoc->extSubset = NULL;
12800             if (ret != NULL) {
12801                 xmlNodePtr tmp;
12802
12803                 ret->doc = NULL;
12804                 tmp = ret->children;
12805                 while (tmp != NULL) {
12806                     tmp->doc = NULL;
12807                     tmp = tmp->next;
12808                 }
12809             }
12810         } else {
12811             ret = NULL;
12812         }
12813         xmlFreeDoc(ctxt->myDoc);
12814         ctxt->myDoc = NULL;
12815     }
12816     if (sax != NULL) ctxt->sax = NULL;
12817     xmlFreeParserCtxt(ctxt);
12818
12819     return(ret);
12820 }
12821
12822
12823 /**
12824  * xmlParseDTD:
12825  * @ExternalID:  a NAME* containing the External ID of the DTD
12826  * @SystemID:  a NAME* containing the URL to the DTD
12827  *
12828  * Load and parse an external subset.
12829  *
12830  * Returns the resulting xmlDtdPtr or NULL in case of error.
12831  */
12832
12833 xmlDtdPtr
12834 xmlParseDTD(const xmlChar *ExternalID, const xmlChar *SystemID) {
12835     return(xmlSAXParseDTD(NULL, ExternalID, SystemID));
12836 }
12837 #endif /* LIBXML_VALID_ENABLED */
12838
12839 /************************************************************************
12840  *                                                                      *
12841  *              Front ends when parsing an Entity                       *
12842  *                                                                      *
12843  ************************************************************************/
12844
12845 /**
12846  * xmlParseCtxtExternalEntity:
12847  * @ctx:  the existing parsing context
12848  * @URL:  the URL for the entity to load
12849  * @ID:  the System ID for the entity to load
12850  * @lst:  the return value for the set of parsed nodes
12851  *
12852  * Parse an external general entity within an existing parsing context
12853  * An external general parsed entity is well-formed if it matches the
12854  * production labeled extParsedEnt.
12855  *
12856  * [78] extParsedEnt ::= TextDecl? content
12857  *
12858  * Returns 0 if the entity is well formed, -1 in case of args problem and
12859  *    the parser error code otherwise
12860  */
12861
12862 int
12863 xmlParseCtxtExternalEntity(xmlParserCtxtPtr ctx, const xmlChar *URL,
12864                        const xmlChar *ID, xmlNodePtr *lst) {
12865     xmlParserCtxtPtr ctxt;
12866     xmlDocPtr newDoc;
12867     xmlNodePtr newRoot;
12868     xmlSAXHandlerPtr oldsax = NULL;
12869     int ret = 0;
12870     xmlChar start[4];
12871     xmlCharEncoding enc;
12872
12873     if (ctx == NULL) return(-1);
12874
12875     if (((ctx->depth > 40) && ((ctx->options & XML_PARSE_HUGE) == 0)) ||
12876         (ctx->depth > 1024)) {
12877         return(XML_ERR_ENTITY_LOOP);
12878     }
12879
12880     if (lst != NULL)
12881         *lst = NULL;
12882     if ((URL == NULL) && (ID == NULL))
12883         return(-1);
12884     if (ctx->myDoc == NULL) /* @@ relax but check for dereferences */
12885         return(-1);
12886
12887     ctxt = xmlCreateEntityParserCtxtInternal(URL, ID, NULL, ctx);
12888     if (ctxt == NULL) {
12889         return(-1);
12890     }
12891
12892     oldsax = ctxt->sax;
12893     ctxt->sax = ctx->sax;
12894     xmlDetectSAX2(ctxt);
12895     newDoc = xmlNewDoc(BAD_CAST "1.0");
12896     if (newDoc == NULL) {
12897         xmlFreeParserCtxt(ctxt);
12898         return(-1);
12899     }
12900     newDoc->properties = XML_DOC_INTERNAL;
12901     if (ctx->myDoc->dict) {
12902         newDoc->dict = ctx->myDoc->dict;
12903         xmlDictReference(newDoc->dict);
12904     }
12905     if (ctx->myDoc != NULL) {
12906         newDoc->intSubset = ctx->myDoc->intSubset;
12907         newDoc->extSubset = ctx->myDoc->extSubset;
12908     }
12909     if (ctx->myDoc->URL != NULL) {
12910         newDoc->URL = xmlStrdup(ctx->myDoc->URL);
12911     }
12912     newRoot = xmlNewDocNode(newDoc, NULL, BAD_CAST "pseudoroot", NULL);
12913     if (newRoot == NULL) {
12914         ctxt->sax = oldsax;
12915         xmlFreeParserCtxt(ctxt);
12916         newDoc->intSubset = NULL;
12917         newDoc->extSubset = NULL;
12918         xmlFreeDoc(newDoc);
12919         return(-1);
12920     }
12921     xmlAddChild((xmlNodePtr) newDoc, newRoot);
12922     nodePush(ctxt, newDoc->children);
12923     if (ctx->myDoc == NULL) {
12924         ctxt->myDoc = newDoc;
12925     } else {
12926         ctxt->myDoc = ctx->myDoc;
12927         newDoc->children->doc = ctx->myDoc;
12928     }
12929
12930     /*
12931      * Get the 4 first bytes and decode the charset
12932      * if enc != XML_CHAR_ENCODING_NONE
12933      * plug some encoding conversion routines.
12934      */
12935     GROW
12936     if ((ctxt->input->end - ctxt->input->cur) >= 4) {
12937         start[0] = RAW;
12938         start[1] = NXT(1);
12939         start[2] = NXT(2);
12940         start[3] = NXT(3);
12941         enc = xmlDetectCharEncoding(start, 4);
12942         if (enc != XML_CHAR_ENCODING_NONE) {
12943             xmlSwitchEncoding(ctxt, enc);
12944         }
12945     }
12946
12947     /*
12948      * Parse a possible text declaration first
12949      */
12950     if ((CMP5(CUR_PTR, '<', '?', 'x', 'm', 'l')) && (IS_BLANK_CH(NXT(5)))) {
12951         xmlParseTextDecl(ctxt);
12952         /*
12953          * An XML-1.0 document can't reference an entity not XML-1.0
12954          */
12955         if ((xmlStrEqual(ctx->version, BAD_CAST "1.0")) &&
12956             (!xmlStrEqual(ctxt->input->version, BAD_CAST "1.0"))) {
12957             xmlFatalErrMsg(ctxt, XML_ERR_VERSION_MISMATCH,
12958                            "Version mismatch between document and entity\n");
12959         }
12960     }
12961
12962     /*
12963      * If the user provided its own SAX callbacks then reuse the
12964      * useData callback field, otherwise the expected setup in a
12965      * DOM builder is to have userData == ctxt
12966      */
12967     if (ctx->userData == ctx)
12968         ctxt->userData = ctxt;
12969     else
12970         ctxt->userData = ctx->userData;
12971
12972     /*
12973      * Doing validity checking on chunk doesn't make sense
12974      */
12975     ctxt->instate = XML_PARSER_CONTENT;
12976     ctxt->validate = ctx->validate;
12977     ctxt->valid = ctx->valid;
12978     ctxt->loadsubset = ctx->loadsubset;
12979     ctxt->depth = ctx->depth + 1;
12980     ctxt->replaceEntities = ctx->replaceEntities;
12981     if (ctxt->validate) {
12982         ctxt->vctxt.error = ctx->vctxt.error;
12983         ctxt->vctxt.warning = ctx->vctxt.warning;
12984     } else {
12985         ctxt->vctxt.error = NULL;
12986         ctxt->vctxt.warning = NULL;
12987     }
12988     ctxt->vctxt.nodeTab = NULL;
12989     ctxt->vctxt.nodeNr = 0;
12990     ctxt->vctxt.nodeMax = 0;
12991     ctxt->vctxt.node = NULL;
12992     if (ctxt->dict != NULL) xmlDictFree(ctxt->dict);
12993     ctxt->dict = ctx->dict;
12994     ctxt->str_xml = xmlDictLookup(ctxt->dict, BAD_CAST "xml", 3);
12995     ctxt->str_xmlns = xmlDictLookup(ctxt->dict, BAD_CAST "xmlns", 5);
12996     ctxt->str_xml_ns = xmlDictLookup(ctxt->dict, XML_XML_NAMESPACE, 36);
12997     ctxt->dictNames = ctx->dictNames;
12998     ctxt->attsDefault = ctx->attsDefault;
12999     ctxt->attsSpecial = ctx->attsSpecial;
13000     ctxt->linenumbers = ctx->linenumbers;
13001
13002     xmlParseContent(ctxt);
13003
13004     ctx->validate = ctxt->validate;
13005     ctx->valid = ctxt->valid;
13006     if ((RAW == '<') && (NXT(1) == '/')) {
13007         xmlFatalErr(ctxt, XML_ERR_NOT_WELL_BALANCED, NULL);
13008     } else if (RAW != 0) {
13009         xmlFatalErr(ctxt, XML_ERR_EXTRA_CONTENT, NULL);
13010     }
13011     if (ctxt->node != newDoc->children) {
13012         xmlFatalErr(ctxt, XML_ERR_NOT_WELL_BALANCED, NULL);
13013     }
13014
13015     if (!ctxt->wellFormed) {
13016         if (ctxt->errNo == 0)
13017             ret = 1;
13018         else
13019             ret = ctxt->errNo;
13020     } else {
13021         if (lst != NULL) {
13022             xmlNodePtr cur;
13023
13024             /*
13025              * Return the newly created nodeset after unlinking it from
13026              * they pseudo parent.
13027              */
13028             cur = newDoc->children->children;
13029             *lst = cur;
13030             while (cur != NULL) {
13031                 cur->parent = NULL;
13032                 cur = cur->next;
13033             }
13034             newDoc->children->children = NULL;
13035         }
13036         ret = 0;
13037     }
13038     ctxt->sax = oldsax;
13039     ctxt->dict = NULL;
13040     ctxt->attsDefault = NULL;
13041     ctxt->attsSpecial = NULL;
13042     xmlFreeParserCtxt(ctxt);
13043     newDoc->intSubset = NULL;
13044     newDoc->extSubset = NULL;
13045     xmlFreeDoc(newDoc);
13046
13047     return(ret);
13048 }
13049
13050 /**
13051  * xmlParseExternalEntityPrivate:
13052  * @doc:  the document the chunk pertains to
13053  * @oldctxt:  the previous parser context if available
13054  * @sax:  the SAX handler bloc (possibly NULL)
13055  * @user_data:  The user data returned on SAX callbacks (possibly NULL)
13056  * @depth:  Used for loop detection, use 0
13057  * @URL:  the URL for the entity to load
13058  * @ID:  the System ID for the entity to load
13059  * @list:  the return value for the set of parsed nodes
13060  *
13061  * Private version of xmlParseExternalEntity()
13062  *
13063  * Returns 0 if the entity is well formed, -1 in case of args problem and
13064  *    the parser error code otherwise
13065  */
13066
13067 static xmlParserErrors
13068 xmlParseExternalEntityPrivate(xmlDocPtr doc, xmlParserCtxtPtr oldctxt,
13069                       xmlSAXHandlerPtr sax,
13070                       void *user_data, int depth, const xmlChar *URL,
13071                       const xmlChar *ID, xmlNodePtr *list) {
13072     xmlParserCtxtPtr ctxt;
13073     xmlDocPtr newDoc;
13074     xmlNodePtr newRoot;
13075     xmlSAXHandlerPtr oldsax = NULL;
13076     xmlParserErrors ret = XML_ERR_OK;
13077     xmlChar start[4];
13078     xmlCharEncoding enc;
13079
13080     if (((depth > 40) &&
13081         ((oldctxt == NULL) || (oldctxt->options & XML_PARSE_HUGE) == 0)) ||
13082         (depth > 1024)) {
13083         return(XML_ERR_ENTITY_LOOP);
13084     }
13085
13086     if (list != NULL)
13087         *list = NULL;
13088     if ((URL == NULL) && (ID == NULL))
13089         return(XML_ERR_INTERNAL_ERROR);
13090     if (doc == NULL)
13091         return(XML_ERR_INTERNAL_ERROR);
13092
13093
13094     ctxt = xmlCreateEntityParserCtxtInternal(URL, ID, NULL, oldctxt);
13095     if (ctxt == NULL) return(XML_WAR_UNDECLARED_ENTITY);
13096     ctxt->userData = ctxt;
13097     if (oldctxt != NULL) {
13098         ctxt->_private = oldctxt->_private;
13099         ctxt->loadsubset = oldctxt->loadsubset;
13100         ctxt->validate = oldctxt->validate;
13101         ctxt->external = oldctxt->external;
13102         ctxt->record_info = oldctxt->record_info;
13103         ctxt->node_seq.maximum = oldctxt->node_seq.maximum;
13104         ctxt->node_seq.length = oldctxt->node_seq.length;
13105         ctxt->node_seq.buffer = oldctxt->node_seq.buffer;
13106     } else {
13107         /*
13108          * Doing validity checking on chunk without context
13109          * doesn't make sense
13110          */
13111         ctxt->_private = NULL;
13112         ctxt->validate = 0;
13113         ctxt->external = 2;
13114         ctxt->loadsubset = 0;
13115     }
13116     if (sax != NULL) {
13117         oldsax = ctxt->sax;
13118         ctxt->sax = sax;
13119         if (user_data != NULL)
13120             ctxt->userData = user_data;
13121     }
13122     xmlDetectSAX2(ctxt);
13123     newDoc = xmlNewDoc(BAD_CAST "1.0");
13124     if (newDoc == NULL) {
13125         ctxt->node_seq.maximum = 0;
13126         ctxt->node_seq.length = 0;
13127         ctxt->node_seq.buffer = NULL;
13128         xmlFreeParserCtxt(ctxt);
13129         return(XML_ERR_INTERNAL_ERROR);
13130     }
13131     newDoc->properties = XML_DOC_INTERNAL;
13132     newDoc->intSubset = doc->intSubset;
13133     newDoc->extSubset = doc->extSubset;
13134     newDoc->dict = doc->dict;
13135     xmlDictReference(newDoc->dict);
13136
13137     if (doc->URL != NULL) {
13138         newDoc->URL = xmlStrdup(doc->URL);
13139     }
13140     newRoot = xmlNewDocNode(newDoc, NULL, BAD_CAST "pseudoroot", NULL);
13141     if (newRoot == NULL) {
13142         if (sax != NULL)
13143             ctxt->sax = oldsax;
13144         ctxt->node_seq.maximum = 0;
13145         ctxt->node_seq.length = 0;
13146         ctxt->node_seq.buffer = NULL;
13147         xmlFreeParserCtxt(ctxt);
13148         newDoc->intSubset = NULL;
13149         newDoc->extSubset = NULL;
13150         xmlFreeDoc(newDoc);
13151         return(XML_ERR_INTERNAL_ERROR);
13152     }
13153     xmlAddChild((xmlNodePtr) newDoc, newRoot);
13154     nodePush(ctxt, newDoc->children);
13155     ctxt->myDoc = doc;
13156     newRoot->doc = doc;
13157
13158     /*
13159      * Get the 4 first bytes and decode the charset
13160      * if enc != XML_CHAR_ENCODING_NONE
13161      * plug some encoding conversion routines.
13162      */
13163     GROW;
13164     if ((ctxt->input->end - ctxt->input->cur) >= 4) {
13165         start[0] = RAW;
13166         start[1] = NXT(1);
13167         start[2] = NXT(2);
13168         start[3] = NXT(3);
13169         enc = xmlDetectCharEncoding(start, 4);
13170         if (enc != XML_CHAR_ENCODING_NONE) {
13171             xmlSwitchEncoding(ctxt, enc);
13172         }
13173     }
13174
13175     /*
13176      * Parse a possible text declaration first
13177      */
13178     if ((CMP5(CUR_PTR, '<', '?', 'x', 'm', 'l')) && (IS_BLANK_CH(NXT(5)))) {
13179         xmlParseTextDecl(ctxt);
13180     }
13181
13182     ctxt->instate = XML_PARSER_CONTENT;
13183     ctxt->depth = depth;
13184
13185     xmlParseContent(ctxt);
13186
13187     if ((RAW == '<') && (NXT(1) == '/')) {
13188         xmlFatalErr(ctxt, XML_ERR_NOT_WELL_BALANCED, NULL);
13189     } else if (RAW != 0) {
13190         xmlFatalErr(ctxt, XML_ERR_EXTRA_CONTENT, NULL);
13191     }
13192     if (ctxt->node != newDoc->children) {
13193         xmlFatalErr(ctxt, XML_ERR_NOT_WELL_BALANCED, NULL);
13194     }
13195
13196     if (!ctxt->wellFormed) {
13197         if (ctxt->errNo == 0)
13198             ret = XML_ERR_INTERNAL_ERROR;
13199         else
13200             ret = (xmlParserErrors)ctxt->errNo;
13201     } else {
13202         if (list != NULL) {
13203             xmlNodePtr cur;
13204
13205             /*
13206              * Return the newly created nodeset after unlinking it from
13207              * they pseudo parent.
13208              */
13209             cur = newDoc->children->children;
13210             *list = cur;
13211             while (cur != NULL) {
13212                 cur->parent = NULL;
13213                 cur = cur->next;
13214             }
13215             newDoc->children->children = NULL;
13216         }
13217         ret = XML_ERR_OK;
13218     }
13219
13220     /*
13221      * Record in the parent context the number of entities replacement
13222      * done when parsing that reference.
13223      */
13224     if (oldctxt != NULL)
13225         oldctxt->nbentities += ctxt->nbentities;
13226
13227     /*
13228      * Also record the size of the entity parsed
13229      */
13230     if (ctxt->input != NULL) {
13231         oldctxt->sizeentities += ctxt->input->consumed;
13232         oldctxt->sizeentities += (ctxt->input->cur - ctxt->input->base);
13233     }
13234     /*
13235      * And record the last error if any
13236      */
13237     if (ctxt->lastError.code != XML_ERR_OK)
13238         xmlCopyError(&ctxt->lastError, &oldctxt->lastError);
13239
13240     if (sax != NULL)
13241         ctxt->sax = oldsax;
13242     oldctxt->node_seq.maximum = ctxt->node_seq.maximum;
13243     oldctxt->node_seq.length = ctxt->node_seq.length;
13244     oldctxt->node_seq.buffer = ctxt->node_seq.buffer;
13245     ctxt->node_seq.maximum = 0;
13246     ctxt->node_seq.length = 0;
13247     ctxt->node_seq.buffer = NULL;
13248     xmlFreeParserCtxt(ctxt);
13249     newDoc->intSubset = NULL;
13250     newDoc->extSubset = NULL;
13251     xmlFreeDoc(newDoc);
13252
13253     return(ret);
13254 }
13255
13256 #ifdef LIBXML_SAX1_ENABLED
13257 /**
13258  * xmlParseExternalEntity:
13259  * @doc:  the document the chunk pertains to
13260  * @sax:  the SAX handler bloc (possibly NULL)
13261  * @user_data:  The user data returned on SAX callbacks (possibly NULL)
13262  * @depth:  Used for loop detection, use 0
13263  * @URL:  the URL for the entity to load
13264  * @ID:  the System ID for the entity to load
13265  * @lst:  the return value for the set of parsed nodes
13266  *
13267  * Parse an external general entity
13268  * An external general parsed entity is well-formed if it matches the
13269  * production labeled extParsedEnt.
13270  *
13271  * [78] extParsedEnt ::= TextDecl? content
13272  *
13273  * Returns 0 if the entity is well formed, -1 in case of args problem and
13274  *    the parser error code otherwise
13275  */
13276
13277 int
13278 xmlParseExternalEntity(xmlDocPtr doc, xmlSAXHandlerPtr sax, void *user_data,
13279           int depth, const xmlChar *URL, const xmlChar *ID, xmlNodePtr *lst) {
13280     return(xmlParseExternalEntityPrivate(doc, NULL, sax, user_data, depth, URL,
13281                                        ID, lst));
13282 }
13283
13284 /**
13285  * xmlParseBalancedChunkMemory:
13286  * @doc:  the document the chunk pertains to
13287  * @sax:  the SAX handler bloc (possibly NULL)
13288  * @user_data:  The user data returned on SAX callbacks (possibly NULL)
13289  * @depth:  Used for loop detection, use 0
13290  * @string:  the input string in UTF8 or ISO-Latin (zero terminated)
13291  * @lst:  the return value for the set of parsed nodes
13292  *
13293  * Parse a well-balanced chunk of an XML document
13294  * called by the parser
13295  * The allowed sequence for the Well Balanced Chunk is the one defined by
13296  * the content production in the XML grammar:
13297  *
13298  * [43] content ::= (element | CharData | Reference | CDSect | PI | Comment)*
13299  *
13300  * Returns 0 if the chunk is well balanced, -1 in case of args problem and
13301  *    the parser error code otherwise
13302  */
13303
13304 int
13305 xmlParseBalancedChunkMemory(xmlDocPtr doc, xmlSAXHandlerPtr sax,
13306      void *user_data, int depth, const xmlChar *string, xmlNodePtr *lst) {
13307     return xmlParseBalancedChunkMemoryRecover( doc, sax, user_data,
13308                                                 depth, string, lst, 0 );
13309 }
13310 #endif /* LIBXML_SAX1_ENABLED */
13311
13312 /**
13313  * xmlParseBalancedChunkMemoryInternal:
13314  * @oldctxt:  the existing parsing context
13315  * @string:  the input string in UTF8 or ISO-Latin (zero terminated)
13316  * @user_data:  the user data field for the parser context
13317  * @lst:  the return value for the set of parsed nodes
13318  *
13319  *
13320  * Parse a well-balanced chunk of an XML document
13321  * called by the parser
13322  * The allowed sequence for the Well Balanced Chunk is the one defined by
13323  * the content production in the XML grammar:
13324  *
13325  * [43] content ::= (element | CharData | Reference | CDSect | PI | Comment)*
13326  *
13327  * Returns XML_ERR_OK if the chunk is well balanced, and the parser
13328  * error code otherwise
13329  *
13330  * In case recover is set to 1, the nodelist will not be empty even if
13331  * the parsed chunk is not well balanced.
13332  */
13333 static xmlParserErrors
13334 xmlParseBalancedChunkMemoryInternal(xmlParserCtxtPtr oldctxt,
13335         const xmlChar *string, void *user_data, xmlNodePtr *lst) {
13336     xmlParserCtxtPtr ctxt;
13337     xmlDocPtr newDoc = NULL;
13338     xmlNodePtr newRoot;
13339     xmlSAXHandlerPtr oldsax = NULL;
13340     xmlNodePtr content = NULL;
13341     xmlNodePtr last = NULL;
13342     int size;
13343     xmlParserErrors ret = XML_ERR_OK;
13344 #ifdef SAX2
13345     int i;
13346 #endif
13347
13348     if (((oldctxt->depth > 40) && ((oldctxt->options & XML_PARSE_HUGE) == 0)) ||
13349         (oldctxt->depth >  1024)) {
13350         return(XML_ERR_ENTITY_LOOP);
13351     }
13352
13353
13354     if (lst != NULL)
13355         *lst = NULL;
13356     if (string == NULL)
13357         return(XML_ERR_INTERNAL_ERROR);
13358
13359     size = xmlStrlen(string);
13360
13361     ctxt = xmlCreateMemoryParserCtxt((char *) string, size);
13362     if (ctxt == NULL) return(XML_WAR_UNDECLARED_ENTITY);
13363     if (user_data != NULL)
13364         ctxt->userData = user_data;
13365     else
13366         ctxt->userData = ctxt;
13367     if (ctxt->dict != NULL) xmlDictFree(ctxt->dict);
13368     ctxt->dict = oldctxt->dict;
13369     ctxt->str_xml = xmlDictLookup(ctxt->dict, BAD_CAST "xml", 3);
13370     ctxt->str_xmlns = xmlDictLookup(ctxt->dict, BAD_CAST "xmlns", 5);
13371     ctxt->str_xml_ns = xmlDictLookup(ctxt->dict, XML_XML_NAMESPACE, 36);
13372
13373 #ifdef SAX2
13374     /* propagate namespaces down the entity */
13375     for (i = 0;i < oldctxt->nsNr;i += 2) {
13376         nsPush(ctxt, oldctxt->nsTab[i], oldctxt->nsTab[i+1]);
13377     }
13378 #endif
13379
13380     oldsax = ctxt->sax;
13381     ctxt->sax = oldctxt->sax;
13382     xmlDetectSAX2(ctxt);
13383     ctxt->replaceEntities = oldctxt->replaceEntities;
13384     ctxt->options = oldctxt->options;
13385
13386     ctxt->_private = oldctxt->_private;
13387     if (oldctxt->myDoc == NULL) {
13388         newDoc = xmlNewDoc(BAD_CAST "1.0");
13389         if (newDoc == NULL) {
13390             ctxt->sax = oldsax;
13391             ctxt->dict = NULL;
13392             xmlFreeParserCtxt(ctxt);
13393             return(XML_ERR_INTERNAL_ERROR);
13394         }
13395         newDoc->properties = XML_DOC_INTERNAL;
13396         newDoc->dict = ctxt->dict;
13397         xmlDictReference(newDoc->dict);
13398         ctxt->myDoc = newDoc;
13399     } else {
13400         ctxt->myDoc = oldctxt->myDoc;
13401         content = ctxt->myDoc->children;
13402         last = ctxt->myDoc->last;
13403     }
13404     newRoot = xmlNewDocNode(ctxt->myDoc, NULL, BAD_CAST "pseudoroot", NULL);
13405     if (newRoot == NULL) {
13406         ctxt->sax = oldsax;
13407         ctxt->dict = NULL;
13408         xmlFreeParserCtxt(ctxt);
13409         if (newDoc != NULL) {
13410             xmlFreeDoc(newDoc);
13411         }
13412         return(XML_ERR_INTERNAL_ERROR);
13413     }
13414     ctxt->myDoc->children = NULL;
13415     ctxt->myDoc->last = NULL;
13416     xmlAddChild((xmlNodePtr) ctxt->myDoc, newRoot);
13417     nodePush(ctxt, ctxt->myDoc->children);
13418     ctxt->instate = XML_PARSER_CONTENT;
13419     ctxt->depth = oldctxt->depth + 1;
13420
13421     ctxt->validate = 0;
13422     ctxt->loadsubset = oldctxt->loadsubset;
13423     if ((oldctxt->validate) || (oldctxt->replaceEntities != 0)) {
13424         /*
13425          * ID/IDREF registration will be done in xmlValidateElement below
13426          */
13427         ctxt->loadsubset |= XML_SKIP_IDS;
13428     }
13429     ctxt->dictNames = oldctxt->dictNames;
13430     ctxt->attsDefault = oldctxt->attsDefault;
13431     ctxt->attsSpecial = oldctxt->attsSpecial;
13432
13433     xmlParseContent(ctxt);
13434     if ((RAW == '<') && (NXT(1) == '/')) {
13435         xmlFatalErr(ctxt, XML_ERR_NOT_WELL_BALANCED, NULL);
13436     } else if (RAW != 0) {
13437         xmlFatalErr(ctxt, XML_ERR_EXTRA_CONTENT, NULL);
13438     }
13439     if (ctxt->node != ctxt->myDoc->children) {
13440         xmlFatalErr(ctxt, XML_ERR_NOT_WELL_BALANCED, NULL);
13441     }
13442
13443     if (!ctxt->wellFormed) {
13444         if (ctxt->errNo == 0)
13445             ret = XML_ERR_INTERNAL_ERROR;
13446         else
13447             ret = (xmlParserErrors)ctxt->errNo;
13448     } else {
13449       ret = XML_ERR_OK;
13450     }
13451
13452     if ((lst != NULL) && (ret == XML_ERR_OK)) {
13453         xmlNodePtr cur;
13454
13455         /*
13456          * Return the newly created nodeset after unlinking it from
13457          * they pseudo parent.
13458          */
13459         cur = ctxt->myDoc->children->children;
13460         *lst = cur;
13461         while (cur != NULL) {
13462 #ifdef LIBXML_VALID_ENABLED
13463             if ((oldctxt->validate) && (oldctxt->wellFormed) &&
13464                 (oldctxt->myDoc) && (oldctxt->myDoc->intSubset) &&
13465                 (cur->type == XML_ELEMENT_NODE)) {
13466                 oldctxt->valid &= xmlValidateElement(&oldctxt->vctxt,
13467                         oldctxt->myDoc, cur);
13468             }
13469 #endif /* LIBXML_VALID_ENABLED */
13470             cur->parent = NULL;
13471             cur = cur->next;
13472         }
13473         ctxt->myDoc->children->children = NULL;
13474     }
13475     if (ctxt->myDoc != NULL) {
13476         xmlFreeNode(ctxt->myDoc->children);
13477         ctxt->myDoc->children = content;
13478         ctxt->myDoc->last = last;
13479     }
13480
13481     /*
13482      * Record in the parent context the number of entities replacement
13483      * done when parsing that reference.
13484      */
13485     if (oldctxt != NULL)
13486         oldctxt->nbentities += ctxt->nbentities;
13487
13488     /*
13489      * Also record the last error if any
13490      */
13491     if (ctxt->lastError.code != XML_ERR_OK)
13492         xmlCopyError(&ctxt->lastError, &oldctxt->lastError);
13493
13494     ctxt->sax = oldsax;
13495     ctxt->dict = NULL;
13496     ctxt->attsDefault = NULL;
13497     ctxt->attsSpecial = NULL;
13498     xmlFreeParserCtxt(ctxt);
13499     if (newDoc != NULL) {
13500         xmlFreeDoc(newDoc);
13501     }
13502
13503     return(ret);
13504 }
13505
13506 /**
13507  * xmlParseInNodeContext:
13508  * @node:  the context node
13509  * @data:  the input string
13510  * @datalen:  the input string length in bytes
13511  * @options:  a combination of xmlParserOption
13512  * @lst:  the return value for the set of parsed nodes
13513  *
13514  * Parse a well-balanced chunk of an XML document
13515  * within the context (DTD, namespaces, etc ...) of the given node.
13516  *
13517  * The allowed sequence for the data is a Well Balanced Chunk defined by
13518  * the content production in the XML grammar:
13519  *
13520  * [43] content ::= (element | CharData | Reference | CDSect | PI | Comment)*
13521  *
13522  * Returns XML_ERR_OK if the chunk is well balanced, and the parser
13523  * error code otherwise
13524  */
13525 xmlParserErrors
13526 xmlParseInNodeContext(xmlNodePtr node, const char *data, int datalen,
13527                       int options, xmlNodePtr *lst) {
13528 #ifdef SAX2
13529     xmlParserCtxtPtr ctxt;
13530     xmlDocPtr doc = NULL;
13531     xmlNodePtr fake, cur;
13532     int nsnr = 0;
13533
13534     xmlParserErrors ret = XML_ERR_OK;
13535
13536     /*
13537      * check all input parameters, grab the document
13538      */
13539     if ((lst == NULL) || (node == NULL) || (data == NULL) || (datalen < 0))
13540         return(XML_ERR_INTERNAL_ERROR);
13541     switch (node->type) {
13542         case XML_ELEMENT_NODE:
13543         case XML_ATTRIBUTE_NODE:
13544         case XML_TEXT_NODE:
13545         case XML_CDATA_SECTION_NODE:
13546         case XML_ENTITY_REF_NODE:
13547         case XML_PI_NODE:
13548         case XML_COMMENT_NODE:
13549         case XML_DOCUMENT_NODE:
13550         case XML_HTML_DOCUMENT_NODE:
13551             break;
13552         default:
13553             return(XML_ERR_INTERNAL_ERROR);
13554
13555     }
13556     while ((node != NULL) && (node->type != XML_ELEMENT_NODE) &&
13557            (node->type != XML_DOCUMENT_NODE) &&
13558            (node->type != XML_HTML_DOCUMENT_NODE))
13559         node = node->parent;
13560     if (node == NULL)
13561         return(XML_ERR_INTERNAL_ERROR);
13562     if (node->type == XML_ELEMENT_NODE)
13563         doc = node->doc;
13564     else
13565         doc = (xmlDocPtr) node;
13566     if (doc == NULL)
13567         return(XML_ERR_INTERNAL_ERROR);
13568
13569     /*
13570      * allocate a context and set-up everything not related to the
13571      * node position in the tree
13572      */
13573     if (doc->type == XML_DOCUMENT_NODE)
13574         ctxt = xmlCreateMemoryParserCtxt((char *) data, datalen);
13575 #ifdef LIBXML_HTML_ENABLED
13576     else if (doc->type == XML_HTML_DOCUMENT_NODE) {
13577         ctxt = htmlCreateMemoryParserCtxt((char *) data, datalen);
13578         /*
13579          * When parsing in context, it makes no sense to add implied
13580          * elements like html/body/etc...
13581          */
13582         options |= HTML_PARSE_NOIMPLIED;
13583     }
13584 #endif
13585     else
13586         return(XML_ERR_INTERNAL_ERROR);
13587
13588     if (ctxt == NULL)
13589         return(XML_ERR_NO_MEMORY);
13590
13591     /*
13592      * Use input doc's dict if present, else assure XML_PARSE_NODICT is set.
13593      * We need a dictionary for xmlDetectSAX2, so if there's no doc dict
13594      * we must wait until the last moment to free the original one.
13595      */
13596     if (doc->dict != NULL) {
13597         if (ctxt->dict != NULL)
13598             xmlDictFree(ctxt->dict);
13599         ctxt->dict = doc->dict;
13600     } else
13601         options |= XML_PARSE_NODICT;
13602
13603     if (doc->encoding != NULL) {
13604         xmlCharEncodingHandlerPtr hdlr;
13605
13606         if (ctxt->encoding != NULL)
13607             xmlFree((xmlChar *) ctxt->encoding);
13608         ctxt->encoding = xmlStrdup((const xmlChar *) doc->encoding);
13609
13610         hdlr = xmlFindCharEncodingHandler(doc->encoding);
13611         if (hdlr != NULL) {
13612             xmlSwitchToEncoding(ctxt, hdlr);
13613         } else {
13614             return(XML_ERR_UNSUPPORTED_ENCODING);
13615         }
13616     }
13617
13618     xmlCtxtUseOptionsInternal(ctxt, options, NULL);
13619     xmlDetectSAX2(ctxt);
13620     ctxt->myDoc = doc;
13621
13622     fake = xmlNewComment(NULL);
13623     if (fake == NULL) {
13624         xmlFreeParserCtxt(ctxt);
13625         return(XML_ERR_NO_MEMORY);
13626     }
13627     xmlAddChild(node, fake);
13628
13629     if (node->type == XML_ELEMENT_NODE) {
13630         nodePush(ctxt, node);
13631         /*
13632          * initialize the SAX2 namespaces stack
13633          */
13634         cur = node;
13635         while ((cur != NULL) && (cur->type == XML_ELEMENT_NODE)) {
13636             xmlNsPtr ns = cur->nsDef;
13637             const xmlChar *iprefix, *ihref;
13638
13639             while (ns != NULL) {
13640                 if (ctxt->dict) {
13641                     iprefix = xmlDictLookup(ctxt->dict, ns->prefix, -1);
13642                     ihref = xmlDictLookup(ctxt->dict, ns->href, -1);
13643                 } else {
13644                     iprefix = ns->prefix;
13645                     ihref = ns->href;
13646                 }
13647
13648                 if (xmlGetNamespace(ctxt, iprefix) == NULL) {
13649                     nsPush(ctxt, iprefix, ihref);
13650                     nsnr++;
13651                 }
13652                 ns = ns->next;
13653             }
13654             cur = cur->parent;
13655         }
13656         ctxt->instate = XML_PARSER_CONTENT;
13657     }
13658
13659     if ((ctxt->validate) || (ctxt->replaceEntities != 0)) {
13660         /*
13661          * ID/IDREF registration will be done in xmlValidateElement below
13662          */
13663         ctxt->loadsubset |= XML_SKIP_IDS;
13664     }
13665
13666 #ifdef LIBXML_HTML_ENABLED
13667     if (doc->type == XML_HTML_DOCUMENT_NODE)
13668         __htmlParseContent(ctxt);
13669     else
13670 #endif
13671         xmlParseContent(ctxt);
13672
13673     nsPop(ctxt, nsnr);
13674     if ((RAW == '<') && (NXT(1) == '/')) {
13675         xmlFatalErr(ctxt, XML_ERR_NOT_WELL_BALANCED, NULL);
13676     } else if (RAW != 0) {
13677         xmlFatalErr(ctxt, XML_ERR_EXTRA_CONTENT, NULL);
13678     }
13679     if ((ctxt->node != NULL) && (ctxt->node != node)) {
13680         xmlFatalErr(ctxt, XML_ERR_NOT_WELL_BALANCED, NULL);
13681         ctxt->wellFormed = 0;
13682     }
13683
13684     if (!ctxt->wellFormed) {
13685         if (ctxt->errNo == 0)
13686             ret = XML_ERR_INTERNAL_ERROR;
13687         else
13688             ret = (xmlParserErrors)ctxt->errNo;
13689     } else {
13690         ret = XML_ERR_OK;
13691     }
13692
13693     /*
13694      * Return the newly created nodeset after unlinking it from
13695      * the pseudo sibling.
13696      */
13697
13698     cur = fake->next;
13699     fake->next = NULL;
13700     node->last = fake;
13701
13702     if (cur != NULL) {
13703         cur->prev = NULL;
13704     }
13705
13706     *lst = cur;
13707
13708     while (cur != NULL) {
13709         cur->parent = NULL;
13710         cur = cur->next;
13711     }
13712
13713     xmlUnlinkNode(fake);
13714     xmlFreeNode(fake);
13715
13716
13717     if (ret != XML_ERR_OK) {
13718         xmlFreeNodeList(*lst);
13719         *lst = NULL;
13720     }
13721
13722     if (doc->dict != NULL)
13723         ctxt->dict = NULL;
13724     xmlFreeParserCtxt(ctxt);
13725
13726     return(ret);
13727 #else /* !SAX2 */
13728     return(XML_ERR_INTERNAL_ERROR);
13729 #endif
13730 }
13731
13732 #ifdef LIBXML_SAX1_ENABLED
13733 /**
13734  * xmlParseBalancedChunkMemoryRecover:
13735  * @doc:  the document the chunk pertains to
13736  * @sax:  the SAX handler bloc (possibly NULL)
13737  * @user_data:  The user data returned on SAX callbacks (possibly NULL)
13738  * @depth:  Used for loop detection, use 0
13739  * @string:  the input string in UTF8 or ISO-Latin (zero terminated)
13740  * @lst:  the return value for the set of parsed nodes
13741  * @recover: return nodes even if the data is broken (use 0)
13742  *
13743  *
13744  * Parse a well-balanced chunk of an XML document
13745  * called by the parser
13746  * The allowed sequence for the Well Balanced Chunk is the one defined by
13747  * the content production in the XML grammar:
13748  *
13749  * [43] content ::= (element | CharData | Reference | CDSect | PI | Comment)*
13750  *
13751  * Returns 0 if the chunk is well balanced, -1 in case of args problem and
13752  *    the parser error code otherwise
13753  *
13754  * In case recover is set to 1, the nodelist will not be empty even if
13755  * the parsed chunk is not well balanced, assuming the parsing succeeded to
13756  * some extent.
13757  */
13758 int
13759 xmlParseBalancedChunkMemoryRecover(xmlDocPtr doc, xmlSAXHandlerPtr sax,
13760      void *user_data, int depth, const xmlChar *string, xmlNodePtr *lst,
13761      int recover) {
13762     xmlParserCtxtPtr ctxt;
13763     xmlDocPtr newDoc;
13764     xmlSAXHandlerPtr oldsax = NULL;
13765     xmlNodePtr content, newRoot;
13766     int size;
13767     int ret = 0;
13768
13769     if (depth > 40) {
13770         return(XML_ERR_ENTITY_LOOP);
13771     }
13772
13773
13774     if (lst != NULL)
13775         *lst = NULL;
13776     if (string == NULL)
13777         return(-1);
13778
13779     size = xmlStrlen(string);
13780
13781     ctxt = xmlCreateMemoryParserCtxt((char *) string, size);
13782     if (ctxt == NULL) return(-1);
13783     ctxt->userData = ctxt;
13784     if (sax != NULL) {
13785         oldsax = ctxt->sax;
13786         ctxt->sax = sax;
13787         if (user_data != NULL)
13788             ctxt->userData = user_data;
13789     }
13790     newDoc = xmlNewDoc(BAD_CAST "1.0");
13791     if (newDoc == NULL) {
13792         xmlFreeParserCtxt(ctxt);
13793         return(-1);
13794     }
13795     newDoc->properties = XML_DOC_INTERNAL;
13796     if ((doc != NULL) && (doc->dict != NULL)) {
13797         xmlDictFree(ctxt->dict);
13798         ctxt->dict = doc->dict;
13799         xmlDictReference(ctxt->dict);
13800         ctxt->str_xml = xmlDictLookup(ctxt->dict, BAD_CAST "xml", 3);
13801         ctxt->str_xmlns = xmlDictLookup(ctxt->dict, BAD_CAST "xmlns", 5);
13802         ctxt->str_xml_ns = xmlDictLookup(ctxt->dict, XML_XML_NAMESPACE, 36);
13803         ctxt->dictNames = 1;
13804     } else {
13805         xmlCtxtUseOptionsInternal(ctxt, XML_PARSE_NODICT, NULL);
13806     }
13807     if (doc != NULL) {
13808         newDoc->intSubset = doc->intSubset;
13809         newDoc->extSubset = doc->extSubset;
13810     }
13811     newRoot = xmlNewDocNode(newDoc, NULL, BAD_CAST "pseudoroot", NULL);
13812     if (newRoot == NULL) {
13813         if (sax != NULL)
13814             ctxt->sax = oldsax;
13815         xmlFreeParserCtxt(ctxt);
13816         newDoc->intSubset = NULL;
13817         newDoc->extSubset = NULL;
13818         xmlFreeDoc(newDoc);
13819         return(-1);
13820     }
13821     xmlAddChild((xmlNodePtr) newDoc, newRoot);
13822     nodePush(ctxt, newRoot);
13823     if (doc == NULL) {
13824         ctxt->myDoc = newDoc;
13825     } else {
13826         ctxt->myDoc = newDoc;
13827         newDoc->children->doc = doc;
13828         /* Ensure that doc has XML spec namespace */
13829         xmlSearchNsByHref(doc, (xmlNodePtr)doc, XML_XML_NAMESPACE);
13830         newDoc->oldNs = doc->oldNs;
13831     }
13832     ctxt->instate = XML_PARSER_CONTENT;
13833     ctxt->depth = depth;
13834
13835     /*
13836      * Doing validity checking on chunk doesn't make sense
13837      */
13838     ctxt->validate = 0;
13839     ctxt->loadsubset = 0;
13840     xmlDetectSAX2(ctxt);
13841
13842     if ( doc != NULL ){
13843         content = doc->children;
13844         doc->children = NULL;
13845         xmlParseContent(ctxt);
13846         doc->children = content;
13847     }
13848     else {
13849         xmlParseContent(ctxt);
13850     }
13851     if ((RAW == '<') && (NXT(1) == '/')) {
13852         xmlFatalErr(ctxt, XML_ERR_NOT_WELL_BALANCED, NULL);
13853     } else if (RAW != 0) {
13854         xmlFatalErr(ctxt, XML_ERR_EXTRA_CONTENT, NULL);
13855     }
13856     if (ctxt->node != newDoc->children) {
13857         xmlFatalErr(ctxt, XML_ERR_NOT_WELL_BALANCED, NULL);
13858     }
13859
13860     if (!ctxt->wellFormed) {
13861         if (ctxt->errNo == 0)
13862             ret = 1;
13863         else
13864             ret = ctxt->errNo;
13865     } else {
13866       ret = 0;
13867     }
13868
13869     if ((lst != NULL) && ((ret == 0) || (recover == 1))) {
13870         xmlNodePtr cur;
13871
13872         /*
13873          * Return the newly created nodeset after unlinking it from
13874          * they pseudo parent.
13875          */
13876         cur = newDoc->children->children;
13877         *lst = cur;
13878         while (cur != NULL) {
13879             xmlSetTreeDoc(cur, doc);
13880             cur->parent = NULL;
13881             cur = cur->next;
13882         }
13883         newDoc->children->children = NULL;
13884     }
13885
13886     if (sax != NULL)
13887         ctxt->sax = oldsax;
13888     xmlFreeParserCtxt(ctxt);
13889     newDoc->intSubset = NULL;
13890     newDoc->extSubset = NULL;
13891     newDoc->oldNs = NULL;
13892     xmlFreeDoc(newDoc);
13893
13894     return(ret);
13895 }
13896
13897 /**
13898  * xmlSAXParseEntity:
13899  * @sax:  the SAX handler block
13900  * @filename:  the filename
13901  *
13902  * parse an XML external entity out of context and build a tree.
13903  * It use the given SAX function block to handle the parsing callback.
13904  * If sax is NULL, fallback to the default DOM tree building routines.
13905  *
13906  * [78] extParsedEnt ::= TextDecl? content
13907  *
13908  * This correspond to a "Well Balanced" chunk
13909  *
13910  * Returns the resulting document tree
13911  */
13912
13913 xmlDocPtr
13914 xmlSAXParseEntity(xmlSAXHandlerPtr sax, const char *filename) {
13915     xmlDocPtr ret;
13916     xmlParserCtxtPtr ctxt;
13917
13918     ctxt = xmlCreateFileParserCtxt(filename);
13919     if (ctxt == NULL) {
13920         return(NULL);
13921     }
13922     if (sax != NULL) {
13923         if (ctxt->sax != NULL)
13924             xmlFree(ctxt->sax);
13925         ctxt->sax = sax;
13926         ctxt->userData = NULL;
13927     }
13928
13929     xmlParseExtParsedEnt(ctxt);
13930
13931     if (ctxt->wellFormed)
13932         ret = ctxt->myDoc;
13933     else {
13934         ret = NULL;
13935         xmlFreeDoc(ctxt->myDoc);
13936         ctxt->myDoc = NULL;
13937     }
13938     if (sax != NULL)
13939         ctxt->sax = NULL;
13940     xmlFreeParserCtxt(ctxt);
13941
13942     return(ret);
13943 }
13944
13945 /**
13946  * xmlParseEntity:
13947  * @filename:  the filename
13948  *
13949  * parse an XML external entity out of context and build a tree.
13950  *
13951  * [78] extParsedEnt ::= TextDecl? content
13952  *
13953  * This correspond to a "Well Balanced" chunk
13954  *
13955  * Returns the resulting document tree
13956  */
13957
13958 xmlDocPtr
13959 xmlParseEntity(const char *filename) {
13960     return(xmlSAXParseEntity(NULL, filename));
13961 }
13962 #endif /* LIBXML_SAX1_ENABLED */
13963
13964 /**
13965  * xmlCreateEntityParserCtxtInternal:
13966  * @URL:  the entity URL
13967  * @ID:  the entity PUBLIC ID
13968  * @base:  a possible base for the target URI
13969  * @pctx:  parser context used to set options on new context
13970  *
13971  * Create a parser context for an external entity
13972  * Automatic support for ZLIB/Compress compressed document is provided
13973  * by default if found at compile-time.
13974  *
13975  * Returns the new parser context or NULL
13976  */
13977 static xmlParserCtxtPtr
13978 xmlCreateEntityParserCtxtInternal(const xmlChar *URL, const xmlChar *ID,
13979                           const xmlChar *base, xmlParserCtxtPtr pctx) {
13980     xmlParserCtxtPtr ctxt;
13981     xmlParserInputPtr inputStream;
13982     char *directory = NULL;
13983     xmlChar *uri;
13984
13985     ctxt = xmlNewParserCtxt();
13986     if (ctxt == NULL) {
13987         return(NULL);
13988     }
13989
13990     if (pctx != NULL) {
13991         ctxt->options = pctx->options;
13992         ctxt->_private = pctx->_private;
13993     }
13994
13995     uri = xmlBuildURI(URL, base);
13996
13997     if (uri == NULL) {
13998         inputStream = xmlLoadExternalEntity((char *)URL, (char *)ID, ctxt);
13999         if (inputStream == NULL) {
14000             xmlFreeParserCtxt(ctxt);
14001             return(NULL);
14002         }
14003
14004         inputPush(ctxt, inputStream);
14005
14006         if ((ctxt->directory == NULL) && (directory == NULL))
14007             directory = xmlParserGetDirectory((char *)URL);
14008         if ((ctxt->directory == NULL) && (directory != NULL))
14009             ctxt->directory = directory;
14010     } else {
14011         inputStream = xmlLoadExternalEntity((char *)uri, (char *)ID, ctxt);
14012         if (inputStream == NULL) {
14013             xmlFree(uri);
14014             xmlFreeParserCtxt(ctxt);
14015             return(NULL);
14016         }
14017
14018         inputPush(ctxt, inputStream);
14019
14020         if ((ctxt->directory == NULL) && (directory == NULL))
14021             directory = xmlParserGetDirectory((char *)uri);
14022         if ((ctxt->directory == NULL) && (directory != NULL))
14023             ctxt->directory = directory;
14024         xmlFree(uri);
14025     }
14026     return(ctxt);
14027 }
14028
14029 /**
14030  * xmlCreateEntityParserCtxt:
14031  * @URL:  the entity URL
14032  * @ID:  the entity PUBLIC ID
14033  * @base:  a possible base for the target URI
14034  *
14035  * Create a parser context for an external entity
14036  * Automatic support for ZLIB/Compress compressed document is provided
14037  * by default if found at compile-time.
14038  *
14039  * Returns the new parser context or NULL
14040  */
14041 xmlParserCtxtPtr
14042 xmlCreateEntityParserCtxt(const xmlChar *URL, const xmlChar *ID,
14043                           const xmlChar *base) {
14044     return xmlCreateEntityParserCtxtInternal(URL, ID, base, NULL);
14045
14046 }
14047
14048 /************************************************************************
14049  *                                                                      *
14050  *              Front ends when parsing from a file                     *
14051  *                                                                      *
14052  ************************************************************************/
14053
14054 /**
14055  * xmlCreateURLParserCtxt:
14056  * @filename:  the filename or URL
14057  * @options:  a combination of xmlParserOption
14058  *
14059  * Create a parser context for a file or URL content.
14060  * Automatic support for ZLIB/Compress compressed document is provided
14061  * by default if found at compile-time and for file accesses
14062  *
14063  * Returns the new parser context or NULL
14064  */
14065 xmlParserCtxtPtr
14066 xmlCreateURLParserCtxt(const char *filename, int options)
14067 {
14068     xmlParserCtxtPtr ctxt;
14069     xmlParserInputPtr inputStream;
14070     char *directory = NULL;
14071
14072     ctxt = xmlNewParserCtxt();
14073     if (ctxt == NULL) {
14074         xmlErrMemory(NULL, "cannot allocate parser context");
14075         return(NULL);
14076     }
14077
14078     if (options)
14079         xmlCtxtUseOptionsInternal(ctxt, options, NULL);
14080     ctxt->linenumbers = 1;
14081
14082     inputStream = xmlLoadExternalEntity(filename, NULL, ctxt);
14083     if (inputStream == NULL) {
14084         xmlFreeParserCtxt(ctxt);
14085         return(NULL);
14086     }
14087
14088     inputPush(ctxt, inputStream);
14089     if ((ctxt->directory == NULL) && (directory == NULL))
14090         directory = xmlParserGetDirectory(filename);
14091     if ((ctxt->directory == NULL) && (directory != NULL))
14092         ctxt->directory = directory;
14093
14094     return(ctxt);
14095 }
14096
14097 /**
14098  * xmlCreateFileParserCtxt:
14099  * @filename:  the filename
14100  *
14101  * Create a parser context for a file content.
14102  * Automatic support for ZLIB/Compress compressed document is provided
14103  * by default if found at compile-time.
14104  *
14105  * Returns the new parser context or NULL
14106  */
14107 xmlParserCtxtPtr
14108 xmlCreateFileParserCtxt(const char *filename)
14109 {
14110     return(xmlCreateURLParserCtxt(filename, 0));
14111 }
14112
14113 #ifdef LIBXML_SAX1_ENABLED
14114 /**
14115  * xmlSAXParseFileWithData:
14116  * @sax:  the SAX handler block
14117  * @filename:  the filename
14118  * @recovery:  work in recovery mode, i.e. tries to read no Well Formed
14119  *             documents
14120  * @data:  the userdata
14121  *
14122  * parse an XML file and build a tree. Automatic support for ZLIB/Compress
14123  * compressed document is provided by default if found at compile-time.
14124  * It use the given SAX function block to handle the parsing callback.
14125  * If sax is NULL, fallback to the default DOM tree building routines.
14126  *
14127  * User data (void *) is stored within the parser context in the
14128  * context's _private member, so it is available nearly everywhere in libxml
14129  *
14130  * Returns the resulting document tree
14131  */
14132
14133 xmlDocPtr
14134 xmlSAXParseFileWithData(xmlSAXHandlerPtr sax, const char *filename,
14135                         int recovery, void *data) {
14136     xmlDocPtr ret;
14137     xmlParserCtxtPtr ctxt;
14138
14139     xmlInitParser();
14140
14141     ctxt = xmlCreateFileParserCtxt(filename);
14142     if (ctxt == NULL) {
14143         return(NULL);
14144     }
14145     if (sax != NULL) {
14146         if (ctxt->sax != NULL)
14147             xmlFree(ctxt->sax);
14148         ctxt->sax = sax;
14149     }
14150     xmlDetectSAX2(ctxt);
14151     if (data!=NULL) {
14152         ctxt->_private = data;
14153     }
14154
14155     if (ctxt->directory == NULL)
14156         ctxt->directory = xmlParserGetDirectory(filename);
14157
14158     ctxt->recovery = recovery;
14159
14160     xmlParseDocument(ctxt);
14161
14162     if ((ctxt->wellFormed) || recovery) {
14163         ret = ctxt->myDoc;
14164         if (ret != NULL) {
14165             if (ctxt->input->buf->compressed > 0)
14166                 ret->compression = 9;
14167             else
14168                 ret->compression = ctxt->input->buf->compressed;
14169         }
14170     }
14171     else {
14172        ret = NULL;
14173        xmlFreeDoc(ctxt->myDoc);
14174        ctxt->myDoc = NULL;
14175     }
14176     if (sax != NULL)
14177         ctxt->sax = NULL;
14178     xmlFreeParserCtxt(ctxt);
14179
14180     return(ret);
14181 }
14182
14183 /**
14184  * xmlSAXParseFile:
14185  * @sax:  the SAX handler block
14186  * @filename:  the filename
14187  * @recovery:  work in recovery mode, i.e. tries to read no Well Formed
14188  *             documents
14189  *
14190  * parse an XML file and build a tree. Automatic support for ZLIB/Compress
14191  * compressed document is provided by default if found at compile-time.
14192  * It use the given SAX function block to handle the parsing callback.
14193  * If sax is NULL, fallback to the default DOM tree building routines.
14194  *
14195  * Returns the resulting document tree
14196  */
14197
14198 xmlDocPtr
14199 xmlSAXParseFile(xmlSAXHandlerPtr sax, const char *filename,
14200                           int recovery) {
14201     return(xmlSAXParseFileWithData(sax,filename,recovery,NULL));
14202 }
14203
14204 /**
14205  * xmlRecoverDoc:
14206  * @cur:  a pointer to an array of xmlChar
14207  *
14208  * parse an XML in-memory document and build a tree.
14209  * In the case the document is not Well Formed, a attempt to build a
14210  * tree is tried anyway
14211  *
14212  * Returns the resulting document tree or NULL in case of failure
14213  */
14214
14215 xmlDocPtr
14216 xmlRecoverDoc(const xmlChar *cur) {
14217     return(xmlSAXParseDoc(NULL, cur, 1));
14218 }
14219
14220 /**
14221  * xmlParseFile:
14222  * @filename:  the filename
14223  *
14224  * parse an XML file and build a tree. Automatic support for ZLIB/Compress
14225  * compressed document is provided by default if found at compile-time.
14226  *
14227  * Returns the resulting document tree if the file was wellformed,
14228  * NULL otherwise.
14229  */
14230
14231 xmlDocPtr
14232 xmlParseFile(const char *filename) {
14233     return(xmlSAXParseFile(NULL, filename, 0));
14234 }
14235
14236 /**
14237  * xmlRecoverFile:
14238  * @filename:  the filename
14239  *
14240  * parse an XML file and build a tree. Automatic support for ZLIB/Compress
14241  * compressed document is provided by default if found at compile-time.
14242  * In the case the document is not Well Formed, it attempts to build
14243  * a tree anyway
14244  *
14245  * Returns the resulting document tree or NULL in case of failure
14246  */
14247
14248 xmlDocPtr
14249 xmlRecoverFile(const char *filename) {
14250     return(xmlSAXParseFile(NULL, filename, 1));
14251 }
14252
14253
14254 /**
14255  * xmlSetupParserForBuffer:
14256  * @ctxt:  an XML parser context
14257  * @buffer:  a xmlChar * buffer
14258  * @filename:  a file name
14259  *
14260  * Setup the parser context to parse a new buffer; Clears any prior
14261  * contents from the parser context. The buffer parameter must not be
14262  * NULL, but the filename parameter can be
14263  */
14264 void
14265 xmlSetupParserForBuffer(xmlParserCtxtPtr ctxt, const xmlChar* buffer,
14266                              const char* filename)
14267 {
14268     xmlParserInputPtr input;
14269
14270     if ((ctxt == NULL) || (buffer == NULL))
14271         return;
14272
14273     input = xmlNewInputStream(ctxt);
14274     if (input == NULL) {
14275         xmlErrMemory(NULL, "parsing new buffer: out of memory\n");
14276         xmlClearParserCtxt(ctxt);
14277         return;
14278     }
14279
14280     xmlClearParserCtxt(ctxt);
14281     if (filename != NULL)
14282         input->filename = (char *) xmlCanonicPath((const xmlChar *)filename);
14283     input->base = buffer;
14284     input->cur = buffer;
14285     input->end = &buffer[xmlStrlen(buffer)];
14286     inputPush(ctxt, input);
14287 }
14288
14289 /**
14290  * xmlSAXUserParseFile:
14291  * @sax:  a SAX handler
14292  * @user_data:  The user data returned on SAX callbacks
14293  * @filename:  a file name
14294  *
14295  * parse an XML file and call the given SAX handler routines.
14296  * Automatic support for ZLIB/Compress compressed document is provided
14297  *
14298  * Returns 0 in case of success or a error number otherwise
14299  */
14300 int
14301 xmlSAXUserParseFile(xmlSAXHandlerPtr sax, void *user_data,
14302                     const char *filename) {
14303     int ret = 0;
14304     xmlParserCtxtPtr ctxt;
14305
14306     ctxt = xmlCreateFileParserCtxt(filename);
14307     if (ctxt == NULL) return -1;
14308     if (ctxt->sax != (xmlSAXHandlerPtr) &xmlDefaultSAXHandler)
14309         xmlFree(ctxt->sax);
14310     ctxt->sax = sax;
14311     xmlDetectSAX2(ctxt);
14312
14313     if (user_data != NULL)
14314         ctxt->userData = user_data;
14315
14316     xmlParseDocument(ctxt);
14317
14318     if (ctxt->wellFormed)
14319         ret = 0;
14320     else {
14321         if (ctxt->errNo != 0)
14322             ret = ctxt->errNo;
14323         else
14324             ret = -1;
14325     }
14326     if (sax != NULL)
14327         ctxt->sax = NULL;
14328     if (ctxt->myDoc != NULL) {
14329         xmlFreeDoc(ctxt->myDoc);
14330         ctxt->myDoc = NULL;
14331     }
14332     xmlFreeParserCtxt(ctxt);
14333
14334     return ret;
14335 }
14336 #endif /* LIBXML_SAX1_ENABLED */
14337
14338 /************************************************************************
14339  *                                                                      *
14340  *              Front ends when parsing from memory                     *
14341  *                                                                      *
14342  ************************************************************************/
14343
14344 /**
14345  * xmlCreateMemoryParserCtxt:
14346  * @buffer:  a pointer to a char array
14347  * @size:  the size of the array
14348  *
14349  * Create a parser context for an XML in-memory document.
14350  *
14351  * Returns the new parser context or NULL
14352  */
14353 xmlParserCtxtPtr
14354 xmlCreateMemoryParserCtxt(const char *buffer, int size) {
14355     xmlParserCtxtPtr ctxt;
14356     xmlParserInputPtr input;
14357     xmlParserInputBufferPtr buf;
14358
14359     if (buffer == NULL)
14360         return(NULL);
14361     if (size <= 0)
14362         return(NULL);
14363
14364     ctxt = xmlNewParserCtxt();
14365     if (ctxt == NULL)
14366         return(NULL);
14367
14368     /* TODO: xmlParserInputBufferCreateStatic, requires some serious changes */
14369     buf = xmlParserInputBufferCreateMem(buffer, size, XML_CHAR_ENCODING_NONE);
14370     if (buf == NULL) {
14371         xmlFreeParserCtxt(ctxt);
14372         return(NULL);
14373     }
14374
14375     input = xmlNewInputStream(ctxt);
14376     if (input == NULL) {
14377         xmlFreeParserInputBuffer(buf);
14378         xmlFreeParserCtxt(ctxt);
14379         return(NULL);
14380     }
14381
14382     input->filename = NULL;
14383     input->buf = buf;
14384     xmlBufResetInput(input->buf->buffer, input);
14385
14386     inputPush(ctxt, input);
14387     return(ctxt);
14388 }
14389
14390 #ifdef LIBXML_SAX1_ENABLED
14391 /**
14392  * xmlSAXParseMemoryWithData:
14393  * @sax:  the SAX handler block
14394  * @buffer:  an pointer to a char array
14395  * @size:  the size of the array
14396  * @recovery:  work in recovery mode, i.e. tries to read no Well Formed
14397  *             documents
14398  * @data:  the userdata
14399  *
14400  * parse an XML in-memory block and use the given SAX function block
14401  * to handle the parsing callback. If sax is NULL, fallback to the default
14402  * DOM tree building routines.
14403  *
14404  * User data (void *) is stored within the parser context in the
14405  * context's _private member, so it is available nearly everywhere in libxml
14406  *
14407  * Returns the resulting document tree
14408  */
14409
14410 xmlDocPtr
14411 xmlSAXParseMemoryWithData(xmlSAXHandlerPtr sax, const char *buffer,
14412                   int size, int recovery, void *data) {
14413     xmlDocPtr ret;
14414     xmlParserCtxtPtr ctxt;
14415
14416     xmlInitParser();
14417
14418     ctxt = xmlCreateMemoryParserCtxt(buffer, size);
14419     if (ctxt == NULL) return(NULL);
14420     if (sax != NULL) {
14421         if (ctxt->sax != NULL)
14422             xmlFree(ctxt->sax);
14423         ctxt->sax = sax;
14424     }
14425     xmlDetectSAX2(ctxt);
14426     if (data!=NULL) {
14427         ctxt->_private=data;
14428     }
14429
14430     ctxt->recovery = recovery;
14431
14432     xmlParseDocument(ctxt);
14433
14434     if ((ctxt->wellFormed) || recovery) ret = ctxt->myDoc;
14435     else {
14436        ret = NULL;
14437        xmlFreeDoc(ctxt->myDoc);
14438        ctxt->myDoc = NULL;
14439     }
14440     if (sax != NULL)
14441         ctxt->sax = NULL;
14442     xmlFreeParserCtxt(ctxt);
14443
14444     return(ret);
14445 }
14446
14447 /**
14448  * xmlSAXParseMemory:
14449  * @sax:  the SAX handler block
14450  * @buffer:  an pointer to a char array
14451  * @size:  the size of the array
14452  * @recovery:  work in recovery mode, i.e. tries to read not Well Formed
14453  *             documents
14454  *
14455  * parse an XML in-memory block and use the given SAX function block
14456  * to handle the parsing callback. If sax is NULL, fallback to the default
14457  * DOM tree building routines.
14458  *
14459  * Returns the resulting document tree
14460  */
14461 xmlDocPtr
14462 xmlSAXParseMemory(xmlSAXHandlerPtr sax, const char *buffer,
14463                   int size, int recovery) {
14464     return xmlSAXParseMemoryWithData(sax, buffer, size, recovery, NULL);
14465 }
14466
14467 /**
14468  * xmlParseMemory:
14469  * @buffer:  an pointer to a char array
14470  * @size:  the size of the array
14471  *
14472  * parse an XML in-memory block and build a tree.
14473  *
14474  * Returns the resulting document tree
14475  */
14476
14477 xmlDocPtr xmlParseMemory(const char *buffer, int size) {
14478    return(xmlSAXParseMemory(NULL, buffer, size, 0));
14479 }
14480
14481 /**
14482  * xmlRecoverMemory:
14483  * @buffer:  an pointer to a char array
14484  * @size:  the size of the array
14485  *
14486  * parse an XML in-memory block and build a tree.
14487  * In the case the document is not Well Formed, an attempt to
14488  * build a tree is tried anyway
14489  *
14490  * Returns the resulting document tree or NULL in case of error
14491  */
14492
14493 xmlDocPtr xmlRecoverMemory(const char *buffer, int size) {
14494    return(xmlSAXParseMemory(NULL, buffer, size, 1));
14495 }
14496
14497 /**
14498  * xmlSAXUserParseMemory:
14499  * @sax:  a SAX handler
14500  * @user_data:  The user data returned on SAX callbacks
14501  * @buffer:  an in-memory XML document input
14502  * @size:  the length of the XML document in bytes
14503  *
14504  * A better SAX parsing routine.
14505  * parse an XML in-memory buffer and call the given SAX handler routines.
14506  *
14507  * Returns 0 in case of success or a error number otherwise
14508  */
14509 int xmlSAXUserParseMemory(xmlSAXHandlerPtr sax, void *user_data,
14510                           const char *buffer, int size) {
14511     int ret = 0;
14512     xmlParserCtxtPtr ctxt;
14513
14514     xmlInitParser();
14515
14516     ctxt = xmlCreateMemoryParserCtxt(buffer, size);
14517     if (ctxt == NULL) return -1;
14518     if (ctxt->sax != (xmlSAXHandlerPtr) &xmlDefaultSAXHandler)
14519         xmlFree(ctxt->sax);
14520     ctxt->sax = sax;
14521     xmlDetectSAX2(ctxt);
14522
14523     if (user_data != NULL)
14524         ctxt->userData = user_data;
14525
14526     xmlParseDocument(ctxt);
14527
14528     if (ctxt->wellFormed)
14529         ret = 0;
14530     else {
14531         if (ctxt->errNo != 0)
14532             ret = ctxt->errNo;
14533         else
14534             ret = -1;
14535     }
14536     if (sax != NULL)
14537         ctxt->sax = NULL;
14538     if (ctxt->myDoc != NULL) {
14539         xmlFreeDoc(ctxt->myDoc);
14540         ctxt->myDoc = NULL;
14541     }
14542     xmlFreeParserCtxt(ctxt);
14543
14544     return ret;
14545 }
14546 #endif /* LIBXML_SAX1_ENABLED */
14547
14548 /**
14549  * xmlCreateDocParserCtxt:
14550  * @cur:  a pointer to an array of xmlChar
14551  *
14552  * Creates a parser context for an XML in-memory document.
14553  *
14554  * Returns the new parser context or NULL
14555  */
14556 xmlParserCtxtPtr
14557 xmlCreateDocParserCtxt(const xmlChar *cur) {
14558     int len;
14559
14560     if (cur == NULL)
14561         return(NULL);
14562     len = xmlStrlen(cur);
14563     return(xmlCreateMemoryParserCtxt((const char *)cur, len));
14564 }
14565
14566 #ifdef LIBXML_SAX1_ENABLED
14567 /**
14568  * xmlSAXParseDoc:
14569  * @sax:  the SAX handler block
14570  * @cur:  a pointer to an array of xmlChar
14571  * @recovery:  work in recovery mode, i.e. tries to read no Well Formed
14572  *             documents
14573  *
14574  * parse an XML in-memory document and build a tree.
14575  * It use the given SAX function block to handle the parsing callback.
14576  * If sax is NULL, fallback to the default DOM tree building routines.
14577  *
14578  * Returns the resulting document tree
14579  */
14580
14581 xmlDocPtr
14582 xmlSAXParseDoc(xmlSAXHandlerPtr sax, const xmlChar *cur, int recovery) {
14583     xmlDocPtr ret;
14584     xmlParserCtxtPtr ctxt;
14585     xmlSAXHandlerPtr oldsax = NULL;
14586
14587     if (cur == NULL) return(NULL);
14588
14589
14590     ctxt = xmlCreateDocParserCtxt(cur);
14591     if (ctxt == NULL) return(NULL);
14592     if (sax != NULL) {
14593         oldsax = ctxt->sax;
14594         ctxt->sax = sax;
14595         ctxt->userData = NULL;
14596     }
14597     xmlDetectSAX2(ctxt);
14598
14599     xmlParseDocument(ctxt);
14600     if ((ctxt->wellFormed) || recovery) ret = ctxt->myDoc;
14601     else {
14602        ret = NULL;
14603        xmlFreeDoc(ctxt->myDoc);
14604        ctxt->myDoc = NULL;
14605     }
14606     if (sax != NULL)
14607         ctxt->sax = oldsax;
14608     xmlFreeParserCtxt(ctxt);
14609
14610     return(ret);
14611 }
14612
14613 /**
14614  * xmlParseDoc:
14615  * @cur:  a pointer to an array of xmlChar
14616  *
14617  * parse an XML in-memory document and build a tree.
14618  *
14619  * Returns the resulting document tree
14620  */
14621
14622 xmlDocPtr
14623 xmlParseDoc(const xmlChar *cur) {
14624     return(xmlSAXParseDoc(NULL, cur, 0));
14625 }
14626 #endif /* LIBXML_SAX1_ENABLED */
14627
14628 #ifdef LIBXML_LEGACY_ENABLED
14629 /************************************************************************
14630  *                                                                      *
14631  *      Specific function to keep track of entities references          *
14632  *      and used by the XSLT debugger                                   *
14633  *                                                                      *
14634  ************************************************************************/
14635
14636 static xmlEntityReferenceFunc xmlEntityRefFunc = NULL;
14637
14638 /**
14639  * xmlAddEntityReference:
14640  * @ent : A valid entity
14641  * @firstNode : A valid first node for children of entity
14642  * @lastNode : A valid last node of children entity
14643  *
14644  * Notify of a reference to an entity of type XML_EXTERNAL_GENERAL_PARSED_ENTITY
14645  */
14646 static void
14647 xmlAddEntityReference(xmlEntityPtr ent, xmlNodePtr firstNode,
14648                       xmlNodePtr lastNode)
14649 {
14650     if (xmlEntityRefFunc != NULL) {
14651         (*xmlEntityRefFunc) (ent, firstNode, lastNode);
14652     }
14653 }
14654
14655
14656 /**
14657  * xmlSetEntityReferenceFunc:
14658  * @func: A valid function
14659  *
14660  * Set the function to call call back when a xml reference has been made
14661  */
14662 void
14663 xmlSetEntityReferenceFunc(xmlEntityReferenceFunc func)
14664 {
14665     xmlEntityRefFunc = func;
14666 }
14667 #endif /* LIBXML_LEGACY_ENABLED */
14668
14669 /************************************************************************
14670  *                                                                      *
14671  *                              Miscellaneous                           *
14672  *                                                                      *
14673  ************************************************************************/
14674
14675 #ifdef LIBXML_XPATH_ENABLED
14676 #include <libxml/xpath.h>
14677 #endif
14678
14679 extern void XMLCDECL xmlGenericErrorDefaultFunc(void *ctx, const char *msg, ...);
14680 static int xmlParserInitialized = 0;
14681
14682 /**
14683  * xmlInitParser:
14684  *
14685  * Initialization function for the XML parser.
14686  * This is not reentrant. Call once before processing in case of
14687  * use in multithreaded programs.
14688  */
14689
14690 void
14691 xmlInitParser(void) {
14692     if (xmlParserInitialized != 0)
14693         return;
14694
14695 #ifdef LIBXML_THREAD_ENABLED
14696     __xmlGlobalInitMutexLock();
14697     if (xmlParserInitialized == 0) {
14698 #endif
14699         xmlInitThreads();
14700         xmlInitGlobals();
14701         if ((xmlGenericError == xmlGenericErrorDefaultFunc) ||
14702             (xmlGenericError == NULL))
14703             initGenericErrorDefaultFunc(NULL);
14704         xmlInitMemory();
14705         xmlInitializeDict();
14706         xmlInitCharEncodingHandlers();
14707         xmlDefaultSAXHandlerInit();
14708         xmlRegisterDefaultInputCallbacks();
14709 #ifdef LIBXML_OUTPUT_ENABLED
14710         xmlRegisterDefaultOutputCallbacks();
14711 #endif /* LIBXML_OUTPUT_ENABLED */
14712 #ifdef LIBXML_HTML_ENABLED
14713         htmlInitAutoClose();
14714         htmlDefaultSAXHandlerInit();
14715 #endif
14716 #ifdef LIBXML_XPATH_ENABLED
14717         xmlXPathInit();
14718 #endif
14719         xmlParserInitialized = 1;
14720 #ifdef LIBXML_THREAD_ENABLED
14721     }
14722     __xmlGlobalInitMutexUnlock();
14723 #endif
14724 }
14725
14726 /**
14727  * xmlCleanupParser:
14728  *
14729  * This function name is somewhat misleading. It does not clean up
14730  * parser state, it cleans up memory allocated by the library itself.
14731  * It is a cleanup function for the XML library. It tries to reclaim all
14732  * related global memory allocated for the library processing.
14733  * It doesn't deallocate any document related memory. One should
14734  * call xmlCleanupParser() only when the process has finished using
14735  * the library and all XML/HTML documents built with it.
14736  * See also xmlInitParser() which has the opposite function of preparing
14737  * the library for operations.
14738  *
14739  * WARNING: if your application is multithreaded or has plugin support
14740  *          calling this may crash the application if another thread or
14741  *          a plugin is still using libxml2. It's sometimes very hard to
14742  *          guess if libxml2 is in use in the application, some libraries
14743  *          or plugins may use it without notice. In case of doubt abstain
14744  *          from calling this function or do it just before calling exit()
14745  *          to avoid leak reports from valgrind !
14746  */
14747
14748 void
14749 xmlCleanupParser(void) {
14750     if (!xmlParserInitialized)
14751         return;
14752
14753     xmlCleanupCharEncodingHandlers();
14754 #ifdef LIBXML_CATALOG_ENABLED
14755     xmlCatalogCleanup();
14756 #endif
14757     xmlDictCleanup();
14758     xmlCleanupInputCallbacks();
14759 #ifdef LIBXML_OUTPUT_ENABLED
14760     xmlCleanupOutputCallbacks();
14761 #endif
14762 #ifdef LIBXML_SCHEMAS_ENABLED
14763     xmlSchemaCleanupTypes();
14764     xmlRelaxNGCleanupTypes();
14765 #endif
14766     xmlCleanupGlobals();
14767     xmlResetLastError();
14768     xmlCleanupThreads(); /* must be last if called not from the main thread */
14769     xmlCleanupMemory();
14770     xmlParserInitialized = 0;
14771 }
14772
14773 /************************************************************************
14774  *                                                                      *
14775  *      New set (2.6.0) of simpler and more flexible APIs               *
14776  *                                                                      *
14777  ************************************************************************/
14778
14779 /**
14780  * DICT_FREE:
14781  * @str:  a string
14782  *
14783  * Free a string if it is not owned by the "dict" dictionnary in the
14784  * current scope
14785  */
14786 #define DICT_FREE(str)                                          \
14787         if ((str) && ((!dict) ||                                \
14788             (xmlDictOwns(dict, (const xmlChar *)(str)) == 0)))  \
14789             xmlFree((char *)(str));
14790
14791 /**
14792  * xmlCtxtReset:
14793  * @ctxt: an XML parser context
14794  *
14795  * Reset a parser context
14796  */
14797 void
14798 xmlCtxtReset(xmlParserCtxtPtr ctxt)
14799 {
14800     xmlParserInputPtr input;
14801     xmlDictPtr dict;
14802
14803     if (ctxt == NULL)
14804         return;
14805
14806     dict = ctxt->dict;
14807
14808     while ((input = inputPop(ctxt)) != NULL) { /* Non consuming */
14809         xmlFreeInputStream(input);
14810     }
14811     ctxt->inputNr = 0;
14812     ctxt->input = NULL;
14813
14814     ctxt->spaceNr = 0;
14815     if (ctxt->spaceTab != NULL) {
14816         ctxt->spaceTab[0] = -1;
14817         ctxt->space = &ctxt->spaceTab[0];
14818     } else {
14819         ctxt->space = NULL;
14820     }
14821
14822
14823     ctxt->nodeNr = 0;
14824     ctxt->node = NULL;
14825
14826     ctxt->nameNr = 0;
14827     ctxt->name = NULL;
14828
14829     DICT_FREE(ctxt->version);
14830     ctxt->version = NULL;
14831     DICT_FREE(ctxt->encoding);
14832     ctxt->encoding = NULL;
14833     DICT_FREE(ctxt->directory);
14834     ctxt->directory = NULL;
14835     DICT_FREE(ctxt->extSubURI);
14836     ctxt->extSubURI = NULL;
14837     DICT_FREE(ctxt->extSubSystem);
14838     ctxt->extSubSystem = NULL;
14839     if (ctxt->myDoc != NULL)
14840         xmlFreeDoc(ctxt->myDoc);
14841     ctxt->myDoc = NULL;
14842
14843     ctxt->standalone = -1;
14844     ctxt->hasExternalSubset = 0;
14845     ctxt->hasPErefs = 0;
14846     ctxt->html = 0;
14847     ctxt->external = 0;
14848     ctxt->instate = XML_PARSER_START;
14849     ctxt->token = 0;
14850
14851     ctxt->wellFormed = 1;
14852     ctxt->nsWellFormed = 1;
14853     ctxt->disableSAX = 0;
14854     ctxt->valid = 1;
14855 #if 0
14856     ctxt->vctxt.userData = ctxt;
14857     ctxt->vctxt.error = xmlParserValidityError;
14858     ctxt->vctxt.warning = xmlParserValidityWarning;
14859 #endif
14860     ctxt->record_info = 0;
14861     ctxt->nbChars = 0;
14862     ctxt->checkIndex = 0;
14863     ctxt->inSubset = 0;
14864     ctxt->errNo = XML_ERR_OK;
14865     ctxt->depth = 0;
14866     ctxt->charset = XML_CHAR_ENCODING_UTF8;
14867     ctxt->catalogs = NULL;
14868     ctxt->nbentities = 0;
14869     ctxt->sizeentities = 0;
14870     ctxt->sizeentcopy = 0;
14871     xmlInitNodeInfoSeq(&ctxt->node_seq);
14872
14873     if (ctxt->attsDefault != NULL) {
14874         xmlHashFree(ctxt->attsDefault, (xmlHashDeallocator) xmlFree);
14875         ctxt->attsDefault = NULL;
14876     }
14877     if (ctxt->attsSpecial != NULL) {
14878         xmlHashFree(ctxt->attsSpecial, NULL);
14879         ctxt->attsSpecial = NULL;
14880     }
14881
14882 #ifdef LIBXML_CATALOG_ENABLED
14883     if (ctxt->catalogs != NULL)
14884         xmlCatalogFreeLocal(ctxt->catalogs);
14885 #endif
14886     if (ctxt->lastError.code != XML_ERR_OK)
14887         xmlResetError(&ctxt->lastError);
14888 }
14889
14890 /**
14891  * xmlCtxtResetPush:
14892  * @ctxt: an XML parser context
14893  * @chunk:  a pointer to an array of chars
14894  * @size:  number of chars in the array
14895  * @filename:  an optional file name or URI
14896  * @encoding:  the document encoding, or NULL
14897  *
14898  * Reset a push parser context
14899  *
14900  * Returns 0 in case of success and 1 in case of error
14901  */
14902 int
14903 xmlCtxtResetPush(xmlParserCtxtPtr ctxt, const char *chunk,
14904                  int size, const char *filename, const char *encoding)
14905 {
14906     xmlParserInputPtr inputStream;
14907     xmlParserInputBufferPtr buf;
14908     xmlCharEncoding enc = XML_CHAR_ENCODING_NONE;
14909
14910     if (ctxt == NULL)
14911         return(1);
14912
14913     if ((encoding == NULL) && (chunk != NULL) && (size >= 4))
14914         enc = xmlDetectCharEncoding((const xmlChar *) chunk, size);
14915
14916     buf = xmlAllocParserInputBuffer(enc);
14917     if (buf == NULL)
14918         return(1);
14919
14920     if (ctxt == NULL) {
14921         xmlFreeParserInputBuffer(buf);
14922         return(1);
14923     }
14924
14925     xmlCtxtReset(ctxt);
14926
14927     if (ctxt->pushTab == NULL) {
14928         ctxt->pushTab = (void **) xmlMalloc(ctxt->nameMax * 3 *
14929                                             sizeof(xmlChar *));
14930         if (ctxt->pushTab == NULL) {
14931             xmlErrMemory(ctxt, NULL);
14932             xmlFreeParserInputBuffer(buf);
14933             return(1);
14934         }
14935     }
14936
14937     if (filename == NULL) {
14938         ctxt->directory = NULL;
14939     } else {
14940         ctxt->directory = xmlParserGetDirectory(filename);
14941     }
14942
14943     inputStream = xmlNewInputStream(ctxt);
14944     if (inputStream == NULL) {
14945         xmlFreeParserInputBuffer(buf);
14946         return(1);
14947     }
14948
14949     if (filename == NULL)
14950         inputStream->filename = NULL;
14951     else
14952         inputStream->filename = (char *)
14953             xmlCanonicPath((const xmlChar *) filename);
14954     inputStream->buf = buf;
14955     xmlBufResetInput(buf->buffer, inputStream);
14956
14957     inputPush(ctxt, inputStream);
14958
14959     if ((size > 0) && (chunk != NULL) && (ctxt->input != NULL) &&
14960         (ctxt->input->buf != NULL)) {
14961         size_t base = xmlBufGetInputBase(ctxt->input->buf->buffer, ctxt->input);
14962         size_t cur = ctxt->input->cur - ctxt->input->base;
14963
14964         xmlParserInputBufferPush(ctxt->input->buf, size, chunk);
14965
14966         xmlBufSetInputBaseCur(ctxt->input->buf->buffer, ctxt->input, base, cur);
14967 #ifdef DEBUG_PUSH
14968         xmlGenericError(xmlGenericErrorContext, "PP: pushed %d\n", size);
14969 #endif
14970     }
14971
14972     if (encoding != NULL) {
14973         xmlCharEncodingHandlerPtr hdlr;
14974
14975         if (ctxt->encoding != NULL)
14976             xmlFree((xmlChar *) ctxt->encoding);
14977         ctxt->encoding = xmlStrdup((const xmlChar *) encoding);
14978
14979         hdlr = xmlFindCharEncodingHandler(encoding);
14980         if (hdlr != NULL) {
14981             xmlSwitchToEncoding(ctxt, hdlr);
14982         } else {
14983             xmlFatalErrMsgStr(ctxt, XML_ERR_UNSUPPORTED_ENCODING,
14984                               "Unsupported encoding %s\n", BAD_CAST encoding);
14985         }
14986     } else if (enc != XML_CHAR_ENCODING_NONE) {
14987         xmlSwitchEncoding(ctxt, enc);
14988     }
14989
14990     return(0);
14991 }
14992
14993
14994 /**
14995  * xmlCtxtUseOptionsInternal:
14996  * @ctxt: an XML parser context
14997  * @options:  a combination of xmlParserOption
14998  * @encoding:  the user provided encoding to use
14999  *
15000  * Applies the options to the parser context
15001  *
15002  * Returns 0 in case of success, the set of unknown or unimplemented options
15003  *         in case of error.
15004  */
15005 static int
15006 xmlCtxtUseOptionsInternal(xmlParserCtxtPtr ctxt, int options, const char *encoding)
15007 {
15008     if (ctxt == NULL)
15009         return(-1);
15010     if (encoding != NULL) {
15011         if (ctxt->encoding != NULL)
15012             xmlFree((xmlChar *) ctxt->encoding);
15013         ctxt->encoding = xmlStrdup((const xmlChar *) encoding);
15014     }
15015     if (options & XML_PARSE_RECOVER) {
15016         ctxt->recovery = 1;
15017         options -= XML_PARSE_RECOVER;
15018         ctxt->options |= XML_PARSE_RECOVER;
15019     } else
15020         ctxt->recovery = 0;
15021     if (options & XML_PARSE_DTDLOAD) {
15022         ctxt->loadsubset = XML_DETECT_IDS;
15023         options -= XML_PARSE_DTDLOAD;
15024         ctxt->options |= XML_PARSE_DTDLOAD;
15025     } else
15026         ctxt->loadsubset = 0;
15027     if (options & XML_PARSE_DTDATTR) {
15028         ctxt->loadsubset |= XML_COMPLETE_ATTRS;
15029         options -= XML_PARSE_DTDATTR;
15030         ctxt->options |= XML_PARSE_DTDATTR;
15031     }
15032     if (options & XML_PARSE_NOENT) {
15033         ctxt->replaceEntities = 1;
15034         /* ctxt->loadsubset |= XML_DETECT_IDS; */
15035         options -= XML_PARSE_NOENT;
15036         ctxt->options |= XML_PARSE_NOENT;
15037     } else
15038         ctxt->replaceEntities = 0;
15039     if (options & XML_PARSE_PEDANTIC) {
15040         ctxt->pedantic = 1;
15041         options -= XML_PARSE_PEDANTIC;
15042         ctxt->options |= XML_PARSE_PEDANTIC;
15043     } else
15044         ctxt->pedantic = 0;
15045     if (options & XML_PARSE_NOBLANKS) {
15046         ctxt->keepBlanks = 0;
15047         ctxt->sax->ignorableWhitespace = xmlSAX2IgnorableWhitespace;
15048         options -= XML_PARSE_NOBLANKS;
15049         ctxt->options |= XML_PARSE_NOBLANKS;
15050     } else
15051         ctxt->keepBlanks = 1;
15052     if (options & XML_PARSE_DTDVALID) {
15053         ctxt->validate = 1;
15054         if (options & XML_PARSE_NOWARNING)
15055             ctxt->vctxt.warning = NULL;
15056         if (options & XML_PARSE_NOERROR)
15057             ctxt->vctxt.error = NULL;
15058         options -= XML_PARSE_DTDVALID;
15059         ctxt->options |= XML_PARSE_DTDVALID;
15060     } else
15061         ctxt->validate = 0;
15062     if (options & XML_PARSE_NOWARNING) {
15063         ctxt->sax->warning = NULL;
15064         options -= XML_PARSE_NOWARNING;
15065     }
15066     if (options & XML_PARSE_NOERROR) {
15067         ctxt->sax->error = NULL;
15068         ctxt->sax->fatalError = NULL;
15069         options -= XML_PARSE_NOERROR;
15070     }
15071 #ifdef LIBXML_SAX1_ENABLED
15072     if (options & XML_PARSE_SAX1) {
15073         ctxt->sax->startElement = xmlSAX2StartElement;
15074         ctxt->sax->endElement = xmlSAX2EndElement;
15075         ctxt->sax->startElementNs = NULL;
15076         ctxt->sax->endElementNs = NULL;
15077         ctxt->sax->initialized = 1;
15078         options -= XML_PARSE_SAX1;
15079         ctxt->options |= XML_PARSE_SAX1;
15080     }
15081 #endif /* LIBXML_SAX1_ENABLED */
15082     if (options & XML_PARSE_NODICT) {
15083         ctxt->dictNames = 0;
15084         options -= XML_PARSE_NODICT;
15085         ctxt->options |= XML_PARSE_NODICT;
15086     } else {
15087         ctxt->dictNames = 1;
15088     }
15089     if (options & XML_PARSE_NOCDATA) {
15090         ctxt->sax->cdataBlock = NULL;
15091         options -= XML_PARSE_NOCDATA;
15092         ctxt->options |= XML_PARSE_NOCDATA;
15093     }
15094     if (options & XML_PARSE_NSCLEAN) {
15095         ctxt->options |= XML_PARSE_NSCLEAN;
15096         options -= XML_PARSE_NSCLEAN;
15097     }
15098     if (options & XML_PARSE_NONET) {
15099         ctxt->options |= XML_PARSE_NONET;
15100         options -= XML_PARSE_NONET;
15101     }
15102     if (options & XML_PARSE_COMPACT) {
15103         ctxt->options |= XML_PARSE_COMPACT;
15104         options -= XML_PARSE_COMPACT;
15105     }
15106     if (options & XML_PARSE_OLD10) {
15107         ctxt->options |= XML_PARSE_OLD10;
15108         options -= XML_PARSE_OLD10;
15109     }
15110     if (options & XML_PARSE_NOBASEFIX) {
15111         ctxt->options |= XML_PARSE_NOBASEFIX;
15112         options -= XML_PARSE_NOBASEFIX;
15113     }
15114     if (options & XML_PARSE_HUGE) {
15115         ctxt->options |= XML_PARSE_HUGE;
15116         options -= XML_PARSE_HUGE;
15117         if (ctxt->dict != NULL)
15118             xmlDictSetLimit(ctxt->dict, 0);
15119     }
15120     if (options & XML_PARSE_OLDSAX) {
15121         ctxt->options |= XML_PARSE_OLDSAX;
15122         options -= XML_PARSE_OLDSAX;
15123     }
15124     if (options & XML_PARSE_IGNORE_ENC) {
15125         ctxt->options |= XML_PARSE_IGNORE_ENC;
15126         options -= XML_PARSE_IGNORE_ENC;
15127     }
15128     if (options & XML_PARSE_BIG_LINES) {
15129         ctxt->options |= XML_PARSE_BIG_LINES;
15130         options -= XML_PARSE_BIG_LINES;
15131     }
15132     ctxt->linenumbers = 1;
15133     return (options);
15134 }
15135
15136 /**
15137  * xmlCtxtUseOptions:
15138  * @ctxt: an XML parser context
15139  * @options:  a combination of xmlParserOption
15140  *
15141  * Applies the options to the parser context
15142  *
15143  * Returns 0 in case of success, the set of unknown or unimplemented options
15144  *         in case of error.
15145  */
15146 int
15147 xmlCtxtUseOptions(xmlParserCtxtPtr ctxt, int options)
15148 {
15149    return(xmlCtxtUseOptionsInternal(ctxt, options, NULL));
15150 }
15151
15152 /**
15153  * xmlDoRead:
15154  * @ctxt:  an XML parser context
15155  * @URL:  the base URL to use for the document
15156  * @encoding:  the document encoding, or NULL
15157  * @options:  a combination of xmlParserOption
15158  * @reuse:  keep the context for reuse
15159  *
15160  * Common front-end for the xmlRead functions
15161  *
15162  * Returns the resulting document tree or NULL
15163  */
15164 static xmlDocPtr
15165 xmlDoRead(xmlParserCtxtPtr ctxt, const char *URL, const char *encoding,
15166           int options, int reuse)
15167 {
15168     xmlDocPtr ret;
15169
15170     xmlCtxtUseOptionsInternal(ctxt, options, encoding);
15171     if (encoding != NULL) {
15172         xmlCharEncodingHandlerPtr hdlr;
15173
15174         hdlr = xmlFindCharEncodingHandler(encoding);
15175         if (hdlr != NULL)
15176             xmlSwitchToEncoding(ctxt, hdlr);
15177     }
15178     if ((URL != NULL) && (ctxt->input != NULL) &&
15179         (ctxt->input->filename == NULL))
15180         ctxt->input->filename = (char *) xmlStrdup((const xmlChar *) URL);
15181     xmlParseDocument(ctxt);
15182     if ((ctxt->wellFormed) || ctxt->recovery)
15183         ret = ctxt->myDoc;
15184     else {
15185         ret = NULL;
15186         if (ctxt->myDoc != NULL) {
15187             xmlFreeDoc(ctxt->myDoc);
15188         }
15189     }
15190     ctxt->myDoc = NULL;
15191     if (!reuse) {
15192         xmlFreeParserCtxt(ctxt);
15193     }
15194
15195     return (ret);
15196 }
15197
15198 /**
15199  * xmlReadDoc:
15200  * @cur:  a pointer to a zero terminated string
15201  * @URL:  the base URL to use for the document
15202  * @encoding:  the document encoding, or NULL
15203  * @options:  a combination of xmlParserOption
15204  *
15205  * parse an XML in-memory document and build a tree.
15206  *
15207  * Returns the resulting document tree
15208  */
15209 xmlDocPtr
15210 xmlReadDoc(const xmlChar * cur, const char *URL, const char *encoding, int options)
15211 {
15212     xmlParserCtxtPtr ctxt;
15213
15214     if (cur == NULL)
15215         return (NULL);
15216
15217     ctxt = xmlCreateDocParserCtxt(cur);
15218     if (ctxt == NULL)
15219         return (NULL);
15220     return (xmlDoRead(ctxt, URL, encoding, options, 0));
15221 }
15222
15223 /**
15224  * xmlReadFile:
15225  * @filename:  a file or URL
15226  * @encoding:  the document encoding, or NULL
15227  * @options:  a combination of xmlParserOption
15228  *
15229  * parse an XML file from the filesystem or the network.
15230  *
15231  * Returns the resulting document tree
15232  */
15233 xmlDocPtr
15234 xmlReadFile(const char *filename, const char *encoding, int options)
15235 {
15236     xmlParserCtxtPtr ctxt;
15237
15238     ctxt = xmlCreateURLParserCtxt(filename, options);
15239     if (ctxt == NULL)
15240         return (NULL);
15241     return (xmlDoRead(ctxt, NULL, encoding, options, 0));
15242 }
15243
15244 /**
15245  * xmlReadMemory:
15246  * @buffer:  a pointer to a char array
15247  * @size:  the size of the array
15248  * @URL:  the base URL to use for the document
15249  * @encoding:  the document encoding, or NULL
15250  * @options:  a combination of xmlParserOption
15251  *
15252  * parse an XML in-memory document and build a tree.
15253  *
15254  * Returns the resulting document tree
15255  */
15256 xmlDocPtr
15257 xmlReadMemory(const char *buffer, int size, const char *URL, const char *encoding, int options)
15258 {
15259     xmlParserCtxtPtr ctxt;
15260
15261     ctxt = xmlCreateMemoryParserCtxt(buffer, size);
15262     if (ctxt == NULL)
15263         return (NULL);
15264     return (xmlDoRead(ctxt, URL, encoding, options, 0));
15265 }
15266
15267 /**
15268  * xmlReadFd:
15269  * @fd:  an open file descriptor
15270  * @URL:  the base URL to use for the document
15271  * @encoding:  the document encoding, or NULL
15272  * @options:  a combination of xmlParserOption
15273  *
15274  * parse an XML from a file descriptor and build a tree.
15275  * NOTE that the file descriptor will not be closed when the
15276  *      reader is closed or reset.
15277  *
15278  * Returns the resulting document tree
15279  */
15280 xmlDocPtr
15281 xmlReadFd(int fd, const char *URL, const char *encoding, int options)
15282 {
15283     xmlParserCtxtPtr ctxt;
15284     xmlParserInputBufferPtr input;
15285     xmlParserInputPtr stream;
15286
15287     if (fd < 0)
15288         return (NULL);
15289
15290     input = xmlParserInputBufferCreateFd(fd, XML_CHAR_ENCODING_NONE);
15291     if (input == NULL)
15292         return (NULL);
15293     input->closecallback = NULL;
15294     ctxt = xmlNewParserCtxt();
15295     if (ctxt == NULL) {
15296         xmlFreeParserInputBuffer(input);
15297         return (NULL);
15298     }
15299     stream = xmlNewIOInputStream(ctxt, input, XML_CHAR_ENCODING_NONE);
15300     if (stream == NULL) {
15301         xmlFreeParserInputBuffer(input);
15302         xmlFreeParserCtxt(ctxt);
15303         return (NULL);
15304     }
15305     inputPush(ctxt, stream);
15306     return (xmlDoRead(ctxt, URL, encoding, options, 0));
15307 }
15308
15309 /**
15310  * xmlReadIO:
15311  * @ioread:  an I/O read function
15312  * @ioclose:  an I/O close function
15313  * @ioctx:  an I/O handler
15314  * @URL:  the base URL to use for the document
15315  * @encoding:  the document encoding, or NULL
15316  * @options:  a combination of xmlParserOption
15317  *
15318  * parse an XML document from I/O functions and source and build a tree.
15319  *
15320  * Returns the resulting document tree
15321  */
15322 xmlDocPtr
15323 xmlReadIO(xmlInputReadCallback ioread, xmlInputCloseCallback ioclose,
15324           void *ioctx, const char *URL, const char *encoding, int options)
15325 {
15326     xmlParserCtxtPtr ctxt;
15327     xmlParserInputBufferPtr input;
15328     xmlParserInputPtr stream;
15329
15330     if (ioread == NULL)
15331         return (NULL);
15332
15333     input = xmlParserInputBufferCreateIO(ioread, ioclose, ioctx,
15334                                          XML_CHAR_ENCODING_NONE);
15335     if (input == NULL) {
15336         if (ioclose != NULL)
15337             ioclose(ioctx);
15338         return (NULL);
15339     }
15340     ctxt = xmlNewParserCtxt();
15341     if (ctxt == NULL) {
15342         xmlFreeParserInputBuffer(input);
15343         return (NULL);
15344     }
15345     stream = xmlNewIOInputStream(ctxt, input, XML_CHAR_ENCODING_NONE);
15346     if (stream == NULL) {
15347         xmlFreeParserInputBuffer(input);
15348         xmlFreeParserCtxt(ctxt);
15349         return (NULL);
15350     }
15351     inputPush(ctxt, stream);
15352     return (xmlDoRead(ctxt, URL, encoding, options, 0));
15353 }
15354
15355 /**
15356  * xmlCtxtReadDoc:
15357  * @ctxt:  an XML parser context
15358  * @cur:  a pointer to a zero terminated string
15359  * @URL:  the base URL to use for the document
15360  * @encoding:  the document encoding, or NULL
15361  * @options:  a combination of xmlParserOption
15362  *
15363  * parse an XML in-memory document and build a tree.
15364  * This reuses the existing @ctxt parser context
15365  *
15366  * Returns the resulting document tree
15367  */
15368 xmlDocPtr
15369 xmlCtxtReadDoc(xmlParserCtxtPtr ctxt, const xmlChar * cur,
15370                const char *URL, const char *encoding, int options)
15371 {
15372     xmlParserInputPtr stream;
15373
15374     if (cur == NULL)
15375         return (NULL);
15376     if (ctxt == NULL)
15377         return (NULL);
15378
15379     xmlCtxtReset(ctxt);
15380
15381     stream = xmlNewStringInputStream(ctxt, cur);
15382     if (stream == NULL) {
15383         return (NULL);
15384     }
15385     inputPush(ctxt, stream);
15386     return (xmlDoRead(ctxt, URL, encoding, options, 1));
15387 }
15388
15389 /**
15390  * xmlCtxtReadFile:
15391  * @ctxt:  an XML parser context
15392  * @filename:  a file or URL
15393  * @encoding:  the document encoding, or NULL
15394  * @options:  a combination of xmlParserOption
15395  *
15396  * parse an XML file from the filesystem or the network.
15397  * This reuses the existing @ctxt parser context
15398  *
15399  * Returns the resulting document tree
15400  */
15401 xmlDocPtr
15402 xmlCtxtReadFile(xmlParserCtxtPtr ctxt, const char *filename,
15403                 const char *encoding, int options)
15404 {
15405     xmlParserInputPtr stream;
15406
15407     if (filename == NULL)
15408         return (NULL);
15409     if (ctxt == NULL)
15410         return (NULL);
15411
15412     xmlCtxtReset(ctxt);
15413
15414     stream = xmlLoadExternalEntity(filename, NULL, ctxt);
15415     if (stream == NULL) {
15416         return (NULL);
15417     }
15418     inputPush(ctxt, stream);
15419     return (xmlDoRead(ctxt, NULL, encoding, options, 1));
15420 }
15421
15422 /**
15423  * xmlCtxtReadMemory:
15424  * @ctxt:  an XML parser context
15425  * @buffer:  a pointer to a char array
15426  * @size:  the size of the array
15427  * @URL:  the base URL to use for the document
15428  * @encoding:  the document encoding, or NULL
15429  * @options:  a combination of xmlParserOption
15430  *
15431  * parse an XML in-memory document and build a tree.
15432  * This reuses the existing @ctxt parser context
15433  *
15434  * Returns the resulting document tree
15435  */
15436 xmlDocPtr
15437 xmlCtxtReadMemory(xmlParserCtxtPtr ctxt, const char *buffer, int size,
15438                   const char *URL, const char *encoding, int options)
15439 {
15440     xmlParserInputBufferPtr input;
15441     xmlParserInputPtr stream;
15442
15443     if (ctxt == NULL)
15444         return (NULL);
15445     if (buffer == NULL)
15446         return (NULL);
15447
15448     xmlCtxtReset(ctxt);
15449
15450     input = xmlParserInputBufferCreateMem(buffer, size, XML_CHAR_ENCODING_NONE);
15451     if (input == NULL) {
15452         return(NULL);
15453     }
15454
15455     stream = xmlNewIOInputStream(ctxt, input, XML_CHAR_ENCODING_NONE);
15456     if (stream == NULL) {
15457         xmlFreeParserInputBuffer(input);
15458         return(NULL);
15459     }
15460
15461     inputPush(ctxt, stream);
15462     return (xmlDoRead(ctxt, URL, encoding, options, 1));
15463 }
15464
15465 /**
15466  * xmlCtxtReadFd:
15467  * @ctxt:  an XML parser context
15468  * @fd:  an open file descriptor
15469  * @URL:  the base URL to use for the document
15470  * @encoding:  the document encoding, or NULL
15471  * @options:  a combination of xmlParserOption
15472  *
15473  * parse an XML from a file descriptor and build a tree.
15474  * This reuses the existing @ctxt parser context
15475  * NOTE that the file descriptor will not be closed when the
15476  *      reader is closed or reset.
15477  *
15478  * Returns the resulting document tree
15479  */
15480 xmlDocPtr
15481 xmlCtxtReadFd(xmlParserCtxtPtr ctxt, int fd,
15482               const char *URL, const char *encoding, int options)
15483 {
15484     xmlParserInputBufferPtr input;
15485     xmlParserInputPtr stream;
15486
15487     if (fd < 0)
15488         return (NULL);
15489     if (ctxt == NULL)
15490         return (NULL);
15491
15492     xmlCtxtReset(ctxt);
15493
15494
15495     input = xmlParserInputBufferCreateFd(fd, XML_CHAR_ENCODING_NONE);
15496     if (input == NULL)
15497         return (NULL);
15498     input->closecallback = NULL;
15499     stream = xmlNewIOInputStream(ctxt, input, XML_CHAR_ENCODING_NONE);
15500     if (stream == NULL) {
15501         xmlFreeParserInputBuffer(input);
15502         return (NULL);
15503     }
15504     inputPush(ctxt, stream);
15505     return (xmlDoRead(ctxt, URL, encoding, options, 1));
15506 }
15507
15508 /**
15509  * xmlCtxtReadIO:
15510  * @ctxt:  an XML parser context
15511  * @ioread:  an I/O read function
15512  * @ioclose:  an I/O close function
15513  * @ioctx:  an I/O handler
15514  * @URL:  the base URL to use for the document
15515  * @encoding:  the document encoding, or NULL
15516  * @options:  a combination of xmlParserOption
15517  *
15518  * parse an XML document from I/O functions and source and build a tree.
15519  * This reuses the existing @ctxt parser context
15520  *
15521  * Returns the resulting document tree
15522  */
15523 xmlDocPtr
15524 xmlCtxtReadIO(xmlParserCtxtPtr ctxt, xmlInputReadCallback ioread,
15525               xmlInputCloseCallback ioclose, void *ioctx,
15526               const char *URL,
15527               const char *encoding, int options)
15528 {
15529     xmlParserInputBufferPtr input;
15530     xmlParserInputPtr stream;
15531
15532     if (ioread == NULL)
15533         return (NULL);
15534     if (ctxt == NULL)
15535         return (NULL);
15536
15537     xmlCtxtReset(ctxt);
15538
15539     input = xmlParserInputBufferCreateIO(ioread, ioclose, ioctx,
15540                                          XML_CHAR_ENCODING_NONE);
15541     if (input == NULL) {
15542         if (ioclose != NULL)
15543             ioclose(ioctx);
15544         return (NULL);
15545     }
15546     stream = xmlNewIOInputStream(ctxt, input, XML_CHAR_ENCODING_NONE);
15547     if (stream == NULL) {
15548         xmlFreeParserInputBuffer(input);
15549         return (NULL);
15550     }
15551     inputPush(ctxt, stream);
15552     return (xmlDoRead(ctxt, URL, encoding, options, 1));
15553 }
15554
15555 #define bottom_parser
15556 #include "elfgcchack.h"