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 static void xmlHaltParser(xmlParserCtxtPtr ctxt);
  98
  99 /************************************************************************
 100  *                                                                      *
 101  *      Arbitrary limits set in the parser. See XML_PARSE_HUGE          *
 102  *                                                                      *
 103  ************************************************************************/
 104
 105 #define XML_PARSER_BIG_ENTITY 1000
 106 #define XML_PARSER_LOT_ENTITY 5000
 107
 108 /*
 109  * XML_PARSER_NON_LINEAR is the threshold where the ratio of parsed entity
 110  *    replacement over the size in byte of the input indicates that you have
 111  *    and eponential behaviour. A value of 10 correspond to at least 3 entity
 112  *    replacement per byte of input.
 113  */
 114 #define XML_PARSER_NON_LINEAR 10
 115
 116 /*
 117  * xmlParserEntityCheck
 118  *
 119  * Function to check non-linear entity expansion behaviour
 120  * This is here to detect and stop exponential linear entity expansion
 121  * This is not a limitation of the parser but a safety
 122  * boundary feature. It can be disabled with the XML_PARSE_HUGE
 123  * parser option.
 124  */
 125 static int
 126 xmlParserEntityCheck(xmlParserCtxtPtr ctxt, size_t size,
 127                      xmlEntityPtr ent, size_t replacement)
 128 {
 129     size_t consumed = 0;
 130
 131     if ((ctxt == NULL) || (ctxt->options & XML_PARSE_HUGE))
 132         return (0);
 133     if (ctxt->lastError.code == XML_ERR_ENTITY_LOOP)
 134         return (1);
 135
 136     /*
 137      * This may look absurd but is needed to detect
 138      * entities problems
 139      */
 140     if ((ent != NULL) && (ent->etype != XML_INTERNAL_PREDEFINED_ENTITY) &&
 141         (ent->content != NULL) && (ent->checked == 0) &&
 142         (ctxt->errNo != XML_ERR_ENTITY_LOOP)) {
 143         unsigned long oldnbent = ctxt->nbentities;
 144         xmlChar *rep;
 145
 146         ent->checked = 1;
 147
 148         ++ctxt->depth;
 149         rep = xmlStringDecodeEntities(ctxt, ent->content,
 150                                   XML_SUBSTITUTE_REF, 0, 0, 0);
 151         --ctxt->depth;
 152         if (ctxt->errNo == XML_ERR_ENTITY_LOOP) {
 153             ent->content[0] = 0;
 154         }
 155
 156         ent->checked = (ctxt->nbentities - oldnbent + 1) * 2;
 157         if (rep != NULL) {
 158             if (xmlStrchr(rep, '<'))
 159                 ent->checked |= 1;
 160             xmlFree(rep);
 161             rep = NULL;
 162         }
 163     }
 164     if (replacement != 0) {
 165         if (replacement < XML_MAX_TEXT_LENGTH)
 166             return(0);
 167
 168         /*
 169          * If the volume of entity copy reaches 10 times the
 170          * amount of parsed data and over the large text threshold
 171          * then that's very likely to be an abuse.
 172          */
 173         if (ctxt->input != NULL) {
 174             consumed = ctxt->input->consumed +
 175                        (ctxt->input->cur - ctxt->input->base);
 176         }
 177         consumed += ctxt->sizeentities;
 178
 179         if (replacement < XML_PARSER_NON_LINEAR * consumed)
 180             return(0);
 181     } else if (size != 0) {
 182         /*
 183          * Do the check based on the replacement size of the entity
 184          */
 185         if (size < XML_PARSER_BIG_ENTITY)
 186             return(0);
 187
 188         /*
 189          * A limit on the amount of text data reasonably used
 190          */
 191         if (ctxt->input != NULL) {
 192             consumed = ctxt->input->consumed +
 193                 (ctxt->input->cur - ctxt->input->base);
 194         }
 195         consumed += ctxt->sizeentities;
 196
 197         if ((size < XML_PARSER_NON_LINEAR * consumed) &&
 198             (ctxt->nbentities * 3 < XML_PARSER_NON_LINEAR * consumed))
 199             return (0);
 200     } else if (ent != NULL) {
 201         /*
 202          * use the number of parsed entities in the replacement
 203          */
 204         size = ent->checked / 2;
 205
 206         /*
 207          * The amount of data parsed counting entities size only once
 208          */
 209         if (ctxt->input != NULL) {
 210             consumed = ctxt->input->consumed +
 211                 (ctxt->input->cur - ctxt->input->base);
 212         }
 213         consumed += ctxt->sizeentities;
 214
 215         /*
 216          * Check the density of entities for the amount of data
 217          * knowing an entity reference will take at least 3 bytes
 218          */
 219         if (size * 3 < consumed * XML_PARSER_NON_LINEAR)
 220             return (0);
 221     } else {
 222         /*
 223          * strange we got no data for checking
 224          */
 225         if (((ctxt->lastError.code != XML_ERR_UNDECLARED_ENTITY) &&
 226              (ctxt->lastError.code != XML_WAR_UNDECLARED_ENTITY)) ||
 227             (ctxt->nbentities <= 10000))
 228             return (0);
 229     }
 230     xmlFatalErr(ctxt, XML_ERR_ENTITY_LOOP, NULL);
 231     return (1);
 232 }
 233
 234 /**
 235  * xmlParserMaxDepth:
 236  *
 237  * arbitrary depth limit for the XML documents that we allow to
 238  * process. This is not a limitation of the parser but a safety
 239  * boundary feature. It can be disabled with the XML_PARSE_HUGE
 240  * parser option.
 241  */
 242 unsigned int xmlParserMaxDepth = 256;
 243
 244
 245
 246 #define SAX2 1
 247 #define XML_PARSER_BIG_BUFFER_SIZE 300
 248 #define XML_PARSER_BUFFER_SIZE 100
 249 #define SAX_COMPAT_MODE BAD_CAST "SAX compatibility mode document"
 250
 251 /**
 252  * XML_PARSER_CHUNK_SIZE
 253  *
 254  * When calling GROW that's the minimal amount of data
 255  * the parser expected to have received. It is not a hard
 256  * limit but an optimization when reading strings like Names
 257  * It is not strictly needed as long as inputs available characters
 258  * are followed by 0, which should be provided by the I/O level
 259  */
 260 #define XML_PARSER_CHUNK_SIZE 100
 261
 262 /*
 263  * List of XML prefixed PI allowed by W3C specs
 264  */
 265
 266 static const char *xmlW3CPIs[] = {
 267     "xml-stylesheet",
 268     "xml-model",
 269     NULL
 270 };
 271
 272
 273 /* DEPR void xmlParserHandleReference(xmlParserCtxtPtr ctxt); */
 274 static xmlEntityPtr xmlParseStringPEReference(xmlParserCtxtPtr ctxt,
 275                                               const xmlChar **str);
 276
 277 static xmlParserErrors
 278 xmlParseExternalEntityPrivate(xmlDocPtr doc, xmlParserCtxtPtr oldctxt,
 279                       xmlSAXHandlerPtr sax,
 280                       void *user_data, int depth, const xmlChar *URL,
 281                       const xmlChar *ID, xmlNodePtr *list);
 282
 283 static int
 284 xmlCtxtUseOptionsInternal(xmlParserCtxtPtr ctxt, int options,
 285                           const char *encoding);
 286 #ifdef LIBXML_LEGACY_ENABLED
 287 static void
 288 xmlAddEntityReference(xmlEntityPtr ent, xmlNodePtr firstNode,
 289                       xmlNodePtr lastNode);
 290 #endif /* LIBXML_LEGACY_ENABLED */
 291
 292 static xmlParserErrors
 293 xmlParseBalancedChunkMemoryInternal(xmlParserCtxtPtr oldctxt,
 294                       const xmlChar *string, void *user_data, xmlNodePtr *lst);
 295
 296 static int
 297 xmlLoadEntityContent(xmlParserCtxtPtr ctxt, xmlEntityPtr entity);
 298
 299 /************************************************************************
 300  *                                                                      *
 301  *              Some factorized error routines                          *
 302  *                                                                      *
 303  ************************************************************************/
 304
 305 /**
 306  * xmlErrAttributeDup:
 307  * @ctxt:  an XML parser context
 308  * @prefix:  the attribute prefix
 309  * @localname:  the attribute localname
 310  *
 311  * Handle a redefinition of attribute error
 312  */
 313 static void
 314 xmlErrAttributeDup(xmlParserCtxtPtr ctxt, const xmlChar * prefix,
 315                    const xmlChar * localname)
 316 {
 317     if ((ctxt != NULL) && (ctxt->disableSAX != 0) &&
 318         (ctxt->instate == XML_PARSER_EOF))
 319         return;
 320     if (ctxt != NULL)
 321         ctxt->errNo = XML_ERR_ATTRIBUTE_REDEFINED;
 322
 323     if (prefix == NULL)
 324         __xmlRaiseError(NULL, NULL, NULL, ctxt, NULL, XML_FROM_PARSER,
 325                         XML_ERR_ATTRIBUTE_REDEFINED, XML_ERR_FATAL, NULL, 0,
 326                         (const char *) localname, NULL, NULL, 0, 0,
 327                         "Attribute %s redefined\n", localname);
 328     else
 329         __xmlRaiseError(NULL, NULL, NULL, ctxt, NULL, XML_FROM_PARSER,
 330                         XML_ERR_ATTRIBUTE_REDEFINED, XML_ERR_FATAL, NULL, 0,
 331                         (const char *) prefix, (const char *) localname,
 332                         NULL, 0, 0, "Attribute %s:%s redefined\n", prefix,
 333                         localname);
 334     if (ctxt != NULL) {
 335         ctxt->wellFormed = 0;
 336         if (ctxt->recovery == 0)
 337             ctxt->disableSAX = 1;
 338     }
 339 }
 340
 341 /**
 342  * xmlFatalErr:
 343  * @ctxt:  an XML parser context
 344  * @error:  the error number
 345  * @extra:  extra information string
 346  *
 347  * Handle a fatal parser error, i.e. violating Well-Formedness constraints
 348  */
 349 static void
 350 xmlFatalErr(xmlParserCtxtPtr ctxt, xmlParserErrors error, const char *info)
 351 {
 352     const char *errmsg;
 353
 354     if ((ctxt != NULL) && (ctxt->disableSAX != 0) &&
 355         (ctxt->instate == XML_PARSER_EOF))
 356         return;
 357     switch (error) {
 358         case XML_ERR_INVALID_HEX_CHARREF:
 359             errmsg = "CharRef: invalid hexadecimal value";
 360             break;
 361         case XML_ERR_INVALID_DEC_CHARREF:
 362             errmsg = "CharRef: invalid decimal value";
 363             break;
 364         case XML_ERR_INVALID_CHARREF:
 365             errmsg = "CharRef: invalid value";
 366             break;
 367         case XML_ERR_INTERNAL_ERROR:
 368             errmsg = "internal error";
 369             break;
 370         case XML_ERR_PEREF_AT_EOF:
 371             errmsg = "PEReference at end of document";
 372             break;
 373         case XML_ERR_PEREF_IN_PROLOG:
 374             errmsg = "PEReference in prolog";
 375             break;
 376         case XML_ERR_PEREF_IN_EPILOG:
 377             errmsg = "PEReference in epilog";
 378             break;
 379         case XML_ERR_PEREF_NO_NAME:
 380             errmsg = "PEReference: no name";
 381             break;
 382         case XML_ERR_PEREF_SEMICOL_MISSING:
 383             errmsg = "PEReference: expecting ';'";
 384             break;
 385         case XML_ERR_ENTITY_LOOP:
 386             errmsg = "Detected an entity reference loop";
 387             break;
 388         case XML_ERR_ENTITY_NOT_STARTED:
 389             errmsg = "EntityValue: \" or ' expected";
 390             break;
 391         case XML_ERR_ENTITY_PE_INTERNAL:
 392             errmsg = "PEReferences forbidden in internal subset";
 393             break;
 394         case XML_ERR_ENTITY_NOT_FINISHED:
 395             errmsg = "EntityValue: \" or ' expected";
 396             break;
 397         case XML_ERR_ATTRIBUTE_NOT_STARTED:
 398             errmsg = "AttValue: \" or ' expected";
 399             break;
 400         case XML_ERR_LT_IN_ATTRIBUTE:
 401             errmsg = "Unescaped '<' not allowed in attributes values";
 402             break;
 403         case XML_ERR_LITERAL_NOT_STARTED:
 404             errmsg = "SystemLiteral \" or ' expected";
 405             break;
 406         case XML_ERR_LITERAL_NOT_FINISHED:
 407             errmsg = "Unfinished System or Public ID \" or ' expected";
 408             break;
 409         case XML_ERR_MISPLACED_CDATA_END:
 410             errmsg = "Sequence ']]>' not allowed in content";
 411             break;
 412         case XML_ERR_URI_REQUIRED:
 413             errmsg = "SYSTEM or PUBLIC, the URI is missing";
 414             break;
 415         case XML_ERR_PUBID_REQUIRED:
 416             errmsg = "PUBLIC, the Public Identifier is missing";
 417             break;
 418         case XML_ERR_HYPHEN_IN_COMMENT:
 419             errmsg = "Comment must not contain '--' (double-hyphen)";
 420             break;
 421         case XML_ERR_PI_NOT_STARTED:
 422             errmsg = "xmlParsePI : no target name";
 423             break;
 424         case XML_ERR_RESERVED_XML_NAME:
 425             errmsg = "Invalid PI name";
 426             break;
 427         case XML_ERR_NOTATION_NOT_STARTED:
 428             errmsg = "NOTATION: Name expected here";
 429             break;
 430         case XML_ERR_NOTATION_NOT_FINISHED:
 431             errmsg = "'>' required to close NOTATION declaration";
 432             break;
 433         case XML_ERR_VALUE_REQUIRED:
 434             errmsg = "Entity value required";
 435             break;
 436         case XML_ERR_URI_FRAGMENT:
 437             errmsg = "Fragment not allowed";
 438             break;
 439         case XML_ERR_ATTLIST_NOT_STARTED:
 440             errmsg = "'(' required to start ATTLIST enumeration";
 441             break;
 442         case XML_ERR_NMTOKEN_REQUIRED:
 443             errmsg = "NmToken expected in ATTLIST enumeration";
 444             break;
 445         case XML_ERR_ATTLIST_NOT_FINISHED:
 446             errmsg = "')' required to finish ATTLIST enumeration";
 447             break;
 448         case XML_ERR_MIXED_NOT_STARTED:
 449             errmsg = "MixedContentDecl : '|' or ')*' expected";
 450             break;
 451         case XML_ERR_PCDATA_REQUIRED:
 452             errmsg = "MixedContentDecl : '#PCDATA' expected";
 453             break;
 454         case XML_ERR_ELEMCONTENT_NOT_STARTED:
 455             errmsg = "ContentDecl : Name or '(' expected";
 456             break;
 457         case XML_ERR_ELEMCONTENT_NOT_FINISHED:
 458             errmsg = "ContentDecl : ',' '|' or ')' expected";
 459             break;
 460         case XML_ERR_PEREF_IN_INT_SUBSET:
 461             errmsg =
 462                 "PEReference: forbidden within markup decl in internal subset";
 463             break;
 464         case XML_ERR_GT_REQUIRED:
 465             errmsg = "expected '>'";
 466             break;
 467         case XML_ERR_CONDSEC_INVALID:
 468             errmsg = "XML conditional section '[' expected";
 469             break;
 470         case XML_ERR_EXT_SUBSET_NOT_FINISHED:
 471             errmsg = "Content error in the external subset";
 472             break;
 473         case XML_ERR_CONDSEC_INVALID_KEYWORD:
 474             errmsg =
 475                 "conditional section INCLUDE or IGNORE keyword expected";
 476             break;
 477         case XML_ERR_CONDSEC_NOT_FINISHED:
 478             errmsg = "XML conditional section not closed";
 479             break;
 480         case XML_ERR_XMLDECL_NOT_STARTED:
 481             errmsg = "Text declaration '<?xml' required";
 482             break;
 483         case XML_ERR_XMLDECL_NOT_FINISHED:
 484             errmsg = "parsing XML declaration: '?>' expected";
 485             break;
 486         case XML_ERR_EXT_ENTITY_STANDALONE:
 487             errmsg = "external parsed entities cannot be standalone";
 488             break;
 489         case XML_ERR_ENTITYREF_SEMICOL_MISSING:
 490             errmsg = "EntityRef: expecting ';'";
 491             break;
 492         case XML_ERR_DOCTYPE_NOT_FINISHED:
 493             errmsg = "DOCTYPE improperly terminated";
 494             break;
 495         case XML_ERR_LTSLASH_REQUIRED:
 496             errmsg = "EndTag: '</' not found";
 497             break;
 498         case XML_ERR_EQUAL_REQUIRED:
 499             errmsg = "expected '='";
 500             break;
 501         case XML_ERR_STRING_NOT_CLOSED:
 502             errmsg = "String not closed expecting \" or '";
 503             break;
 504         case XML_ERR_STRING_NOT_STARTED:
 505             errmsg = "String not started expecting ' or \"";
 506             break;
 507         case XML_ERR_ENCODING_NAME:
 508             errmsg = "Invalid XML encoding name";
 509             break;
 510         case XML_ERR_STANDALONE_VALUE:
 511             errmsg = "standalone accepts only 'yes' or 'no'";
 512             break;
 513         case XML_ERR_DOCUMENT_EMPTY:
 514             errmsg = "Document is empty";
 515             break;
 516         case XML_ERR_DOCUMENT_END:
 517             errmsg = "Extra content at the end of the document";
 518             break;
 519         case XML_ERR_NOT_WELL_BALANCED:
 520             errmsg = "chunk is not well balanced";
 521             break;
 522         case XML_ERR_EXTRA_CONTENT:
 523             errmsg = "extra content at the end of well balanced chunk";
 524             break;
 525         case XML_ERR_VERSION_MISSING:
 526             errmsg = "Malformed declaration expecting version";
 527             break;
 528         case XML_ERR_NAME_TOO_LONG:
 529             errmsg = "Name too long use XML_PARSE_HUGE option";
 530             break;
 531 #if 0
 532         case:
 533             errmsg = "";
 534             break;
 535 #endif
 536         default:
 537             errmsg = "Unregistered error message";
 538     }
 539     if (ctxt != NULL)
 540         ctxt->errNo = error;
 541     if (info == NULL) {
 542         __xmlRaiseError(NULL, NULL, NULL, ctxt, NULL, XML_FROM_PARSER, error,
 543                         XML_ERR_FATAL, NULL, 0, info, NULL, NULL, 0, 0, "%s\n",
 544                         errmsg);
 545     } else {
 546         __xmlRaiseError(NULL, NULL, NULL, ctxt, NULL, XML_FROM_PARSER, error,
 547                         XML_ERR_FATAL, NULL, 0, info, NULL, NULL, 0, 0, "%s: %s\n",
 548                         errmsg, info);
 549     }
 550     if (ctxt != NULL) {
 551         ctxt->wellFormed = 0;
 552         if (ctxt->recovery == 0)
 553             ctxt->disableSAX = 1;
 554     }
 555 }
 556
 557 /**
 558  * xmlFatalErrMsg:
 559  * @ctxt:  an XML parser context
 560  * @error:  the error number
 561  * @msg:  the error message
 562  *
 563  * Handle a fatal parser error, i.e. violating Well-Formedness constraints
 564  */
 565 static void LIBXML_ATTR_FORMAT(3,0)
 566 xmlFatalErrMsg(xmlParserCtxtPtr ctxt, xmlParserErrors error,
 567                const char *msg)
 568 {
 569     if ((ctxt != NULL) && (ctxt->disableSAX != 0) &&
 570         (ctxt->instate == XML_PARSER_EOF))
 571         return;
 572     if (ctxt != NULL)
 573         ctxt->errNo = error;
 574     __xmlRaiseError(NULL, NULL, NULL, ctxt, NULL, XML_FROM_PARSER, error,
 575                     XML_ERR_FATAL, NULL, 0, NULL, NULL, NULL, 0, 0, "%s", msg);
 576     if (ctxt != NULL) {
 577         ctxt->wellFormed = 0;
 578         if (ctxt->recovery == 0)
 579             ctxt->disableSAX = 1;
 580     }
 581 }
 582
 583 /**
 584  * xmlWarningMsg:
 585  * @ctxt:  an XML parser context
 586  * @error:  the error number
 587  * @msg:  the error message
 588  * @str1:  extra data
 589  * @str2:  extra data
 590  *
 591  * Handle a warning.
 592  */
 593 static void LIBXML_ATTR_FORMAT(3,0)
 594 xmlWarningMsg(xmlParserCtxtPtr ctxt, xmlParserErrors error,
 595               const char *msg, const xmlChar *str1, const xmlChar *str2)
 596 {
 597     xmlStructuredErrorFunc schannel = NULL;
 598
 599     if ((ctxt != NULL) && (ctxt->disableSAX != 0) &&
 600         (ctxt->instate == XML_PARSER_EOF))
 601         return;
 602     if ((ctxt != NULL) && (ctxt->sax != NULL) &&
 603         (ctxt->sax->initialized == XML_SAX2_MAGIC))
 604         schannel = ctxt->sax->serror;
 605     if (ctxt != NULL) {
 606         __xmlRaiseError(schannel,
 607                     (ctxt->sax) ? ctxt->sax->warning : NULL,
 608                     ctxt->userData,
 609                     ctxt, NULL, XML_FROM_PARSER, error,
 610                     XML_ERR_WARNING, NULL, 0,
 611                     (const char *) str1, (const char *) str2, NULL, 0, 0,
 612                     msg, (const char *) str1, (const char *) str2);
 613     } else {
 614         __xmlRaiseError(schannel, NULL, NULL,
 615                     ctxt, NULL, XML_FROM_PARSER, error,
 616                     XML_ERR_WARNING, NULL, 0,
 617                     (const char *) str1, (const char *) str2, NULL, 0, 0,
 618                     msg, (const char *) str1, (const char *) str2);
 619     }
 620 }
 621
 622 /**
 623  * xmlValidityError:
 624  * @ctxt:  an XML parser context
 625  * @error:  the error number
 626  * @msg:  the error message
 627  * @str1:  extra data
 628  *
 629  * Handle a validity error.
 630  */
 631 static void LIBXML_ATTR_FORMAT(3,0)
 632 xmlValidityError(xmlParserCtxtPtr ctxt, xmlParserErrors error,
 633               const char *msg, const xmlChar *str1, const xmlChar *str2)
 634 {
 635     xmlStructuredErrorFunc schannel = NULL;
 636
 637     if ((ctxt != NULL) && (ctxt->disableSAX != 0) &&
 638         (ctxt->instate == XML_PARSER_EOF))
 639         return;
 640     if (ctxt != NULL) {
 641         ctxt->errNo = error;
 642         if ((ctxt->sax != NULL) && (ctxt->sax->initialized == XML_SAX2_MAGIC))
 643             schannel = ctxt->sax->serror;
 644     }
 645     if (ctxt != NULL) {
 646         __xmlRaiseError(schannel,
 647                     ctxt->vctxt.error, ctxt->vctxt.userData,
 648                     ctxt, NULL, XML_FROM_DTD, error,
 649                     XML_ERR_ERROR, NULL, 0, (const char *) str1,
 650                     (const char *) str2, NULL, 0, 0,
 651                     msg, (const char *) str1, (const char *) str2);
 652         ctxt->valid = 0;
 653     } else {
 654         __xmlRaiseError(schannel, NULL, NULL,
 655                     ctxt, NULL, XML_FROM_DTD, error,
 656                     XML_ERR_ERROR, NULL, 0, (const char *) str1,
 657                     (const char *) str2, NULL, 0, 0,
 658                     msg, (const char *) str1, (const char *) str2);
 659     }
 660 }
 661
 662 /**
 663  * xmlFatalErrMsgInt:
 664  * @ctxt:  an XML parser context
 665  * @error:  the error number
 666  * @msg:  the error message
 667  * @val:  an integer value
 668  *
 669  * Handle a fatal parser error, i.e. violating Well-Formedness constraints
 670  */
 671 static void LIBXML_ATTR_FORMAT(3,0)
 672 xmlFatalErrMsgInt(xmlParserCtxtPtr ctxt, xmlParserErrors error,
 673                   const char *msg, int val)
 674 {
 675     if ((ctxt != NULL) && (ctxt->disableSAX != 0) &&
 676         (ctxt->instate == XML_PARSER_EOF))
 677         return;
 678     if (ctxt != NULL)
 679         ctxt->errNo = error;
 680     __xmlRaiseError(NULL, NULL, NULL,
 681                     ctxt, NULL, XML_FROM_PARSER, error, XML_ERR_FATAL,
 682                     NULL, 0, NULL, NULL, NULL, val, 0, msg, val);
 683     if (ctxt != NULL) {
 684         ctxt->wellFormed = 0;
 685         if (ctxt->recovery == 0)
 686             ctxt->disableSAX = 1;
 687     }
 688 }
 689
 690 /**
 691  * xmlFatalErrMsgStrIntStr:
 692  * @ctxt:  an XML parser context
 693  * @error:  the error number
 694  * @msg:  the error message
 695  * @str1:  an string info
 696  * @val:  an integer value
 697  * @str2:  an string info
 698  *
 699  * Handle a fatal parser error, i.e. violating Well-Formedness constraints
 700  */
 701 static void LIBXML_ATTR_FORMAT(3,0)
 702 xmlFatalErrMsgStrIntStr(xmlParserCtxtPtr ctxt, xmlParserErrors error,
 703                   const char *msg, const xmlChar *str1, int val,
 704                   const xmlChar *str2)
 705 {
 706     if ((ctxt != NULL) && (ctxt->disableSAX != 0) &&
 707         (ctxt->instate == XML_PARSER_EOF))
 708         return;
 709     if (ctxt != NULL)
 710         ctxt->errNo = error;
 711     __xmlRaiseError(NULL, NULL, NULL,
 712                     ctxt, NULL, XML_FROM_PARSER, error, XML_ERR_FATAL,
 713                     NULL, 0, (const char *) str1, (const char *) str2,
 714                     NULL, val, 0, msg, str1, val, str2);
 715     if (ctxt != NULL) {
 716         ctxt->wellFormed = 0;
 717         if (ctxt->recovery == 0)
 718             ctxt->disableSAX = 1;
 719     }
 720 }
 721
 722 /**
 723  * xmlFatalErrMsgStr:
 724  * @ctxt:  an XML parser context
 725  * @error:  the error number
 726  * @msg:  the error message
 727  * @val:  a string value
 728  *
 729  * Handle a fatal parser error, i.e. violating Well-Formedness constraints
 730  */
 731 static void LIBXML_ATTR_FORMAT(3,0)
 732 xmlFatalErrMsgStr(xmlParserCtxtPtr ctxt, xmlParserErrors error,
 733                   const char *msg, const xmlChar * val)
 734 {
 735     if ((ctxt != NULL) && (ctxt->disableSAX != 0) &&
 736         (ctxt->instate == XML_PARSER_EOF))
 737         return;
 738     if (ctxt != NULL)
 739         ctxt->errNo = error;
 740     __xmlRaiseError(NULL, NULL, NULL, ctxt, NULL,
 741                     XML_FROM_PARSER, error, XML_ERR_FATAL,
 742                     NULL, 0, (const char *) val, NULL, NULL, 0, 0, msg,
 743                     val);
 744     if (ctxt != NULL) {
 745         ctxt->wellFormed = 0;
 746         if (ctxt->recovery == 0)
 747             ctxt->disableSAX = 1;
 748     }
 749 }
 750
 751 /**
 752  * xmlErrMsgStr:
 753  * @ctxt:  an XML parser context
 754  * @error:  the error number
 755  * @msg:  the error message
 756  * @val:  a string value
 757  *
 758  * Handle a non fatal parser error
 759  */
 760 static void LIBXML_ATTR_FORMAT(3,0)
 761 xmlErrMsgStr(xmlParserCtxtPtr ctxt, xmlParserErrors error,
 762                   const char *msg, const xmlChar * val)
 763 {
 764     if ((ctxt != NULL) && (ctxt->disableSAX != 0) &&
 765         (ctxt->instate == XML_PARSER_EOF))
 766         return;
 767     if (ctxt != NULL)
 768         ctxt->errNo = error;
 769     __xmlRaiseError(NULL, NULL, NULL, ctxt, NULL,
 770                     XML_FROM_PARSER, error, XML_ERR_ERROR,
 771                     NULL, 0, (const char *) val, NULL, NULL, 0, 0, msg,
 772                     val);
 773 }
 774
 775 /**
 776  * xmlNsErr:
 777  * @ctxt:  an XML parser context
 778  * @error:  the error number
 779  * @msg:  the message
 780  * @info1:  extra information string
 781  * @info2:  extra information string
 782  *
 783  * Handle a fatal parser error, i.e. violating Well-Formedness constraints
 784  */
 785 static void LIBXML_ATTR_FORMAT(3,0)
 786 xmlNsErr(xmlParserCtxtPtr ctxt, xmlParserErrors error,
 787          const char *msg,
 788          const xmlChar * info1, const xmlChar * info2,
 789          const xmlChar * info3)
 790 {
 791     if ((ctxt != NULL) && (ctxt->disableSAX != 0) &&
 792         (ctxt->instate == XML_PARSER_EOF))
 793         return;
 794     if (ctxt != NULL)
 795         ctxt->errNo = error;
 796     __xmlRaiseError(NULL, NULL, NULL, ctxt, NULL, XML_FROM_NAMESPACE, error,
 797                     XML_ERR_ERROR, NULL, 0, (const char *) info1,
 798                     (const char *) info2, (const char *) info3, 0, 0, msg,
 799                     info1, info2, info3);
 800     if (ctxt != NULL)
 801         ctxt->nsWellFormed = 0;
 802 }
 803
 804 /**
 805  * xmlNsWarn
 806  * @ctxt:  an XML parser context
 807  * @error:  the error number
 808  * @msg:  the message
 809  * @info1:  extra information string
 810  * @info2:  extra information string
 811  *
 812  * Handle a namespace warning error
 813  */
 814 static void LIBXML_ATTR_FORMAT(3,0)
 815 xmlNsWarn(xmlParserCtxtPtr ctxt, xmlParserErrors error,
 816          const char *msg,
 817          const xmlChar * info1, const xmlChar * info2,
 818          const xmlChar * info3)
 819 {
 820     if ((ctxt != NULL) && (ctxt->disableSAX != 0) &&
 821         (ctxt->instate == XML_PARSER_EOF))
 822         return;
 823     __xmlRaiseError(NULL, NULL, NULL, ctxt, NULL, XML_FROM_NAMESPACE, error,
 824                     XML_ERR_WARNING, NULL, 0, (const char *) info1,
 825                     (const char *) info2, (const char *) info3, 0, 0, msg,
 826                     info1, info2, info3);
 827 }
 828
 829 /************************************************************************
 830  *                                                                      *
 831  *              Library wide options                                    *
 832  *                                                                      *
 833  ************************************************************************/
 834
 835 /**
 836   * xmlHasFeature:
 837   * @feature: the feature to be examined
 838   *
 839   * Examines if the library has been compiled with a given feature.
 840   *
 841   * Returns a non-zero value if the feature exist, otherwise zero.
 842   * Returns zero (0) if the feature does not exist or an unknown
 843   * unknown feature is requested, non-zero otherwise.
 844   */
 845 int
 846 xmlHasFeature(xmlFeature feature)
 847 {
 848     switch (feature) {
 849         case XML_WITH_THREAD:
 850 #ifdef LIBXML_THREAD_ENABLED
 851             return(1);
 852 #else
 853             return(0);
 854 #endif
 855         case XML_WITH_TREE:
 856 #ifdef LIBXML_TREE_ENABLED
 857             return(1);
 858 #else
 859             return(0);
 860 #endif
 861         case XML_WITH_OUTPUT:
 862 #ifdef LIBXML_OUTPUT_ENABLED
 863             return(1);
 864 #else
 865             return(0);
 866 #endif
 867         case XML_WITH_PUSH:
 868 #ifdef LIBXML_PUSH_ENABLED
 869             return(1);
 870 #else
 871             return(0);
 872 #endif
 873         case XML_WITH_READER:
 874 #ifdef LIBXML_READER_ENABLED
 875             return(1);
 876 #else
 877             return(0);
 878 #endif
 879         case XML_WITH_PATTERN:
 880 #ifdef LIBXML_PATTERN_ENABLED
 881             return(1);
 882 #else
 883             return(0);
 884 #endif
 885         case XML_WITH_WRITER:
 886 #ifdef LIBXML_WRITER_ENABLED
 887             return(1);
 888 #else
 889             return(0);
 890 #endif
 891         case XML_WITH_SAX1:
 892 #ifdef LIBXML_SAX1_ENABLED
 893             return(1);
 894 #else
 895             return(0);
 896 #endif
 897         case XML_WITH_FTP:
 898 #ifdef LIBXML_FTP_ENABLED
 899             return(1);
 900 #else
 901             return(0);
 902 #endif
 903         case XML_WITH_HTTP:
 904 #ifdef LIBXML_HTTP_ENABLED
 905             return(1);
 906 #else
 907             return(0);
 908 #endif
 909         case XML_WITH_VALID:
 910 #ifdef LIBXML_VALID_ENABLED
 911             return(1);
 912 #else
 913             return(0);
 914 #endif
 915         case XML_WITH_HTML:
 916 #ifdef LIBXML_HTML_ENABLED
 917             return(1);
 918 #else
 919             return(0);
 920 #endif
 921         case XML_WITH_LEGACY:
 922 #ifdef LIBXML_LEGACY_ENABLED
 923             return(1);
 924 #else
 925             return(0);
 926 #endif
 927         case XML_WITH_C14N:
 928 #ifdef LIBXML_C14N_ENABLED
 929             return(1);
 930 #else
 931             return(0);
 932 #endif
 933         case XML_WITH_CATALOG:
 934 #ifdef LIBXML_CATALOG_ENABLED
 935             return(1);
 936 #else
 937             return(0);
 938 #endif
 939         case XML_WITH_XPATH:
 940 #ifdef LIBXML_XPATH_ENABLED
 941             return(1);
 942 #else
 943             return(0);
 944 #endif
 945         case XML_WITH_XPTR:
 946 #ifdef LIBXML_XPTR_ENABLED
 947             return(1);
 948 #else
 949             return(0);
 950 #endif
 951         case XML_WITH_XINCLUDE:
 952 #ifdef LIBXML_XINCLUDE_ENABLED
 953             return(1);
 954 #else
 955             return(0);
 956 #endif
 957         case XML_WITH_ICONV:
 958 #ifdef LIBXML_ICONV_ENABLED
 959             return(1);
 960 #else
 961             return(0);
 962 #endif
 963         case XML_WITH_ISO8859X:
 964 #ifdef LIBXML_ISO8859X_ENABLED
 965             return(1);
 966 #else
 967             return(0);
 968 #endif
 969         case XML_WITH_UNICODE:
 970 #ifdef LIBXML_UNICODE_ENABLED
 971             return(1);
 972 #else
 973             return(0);
 974 #endif
 975         case XML_WITH_REGEXP:
 976 #ifdef LIBXML_REGEXP_ENABLED
 977             return(1);
 978 #else
 979             return(0);
 980 #endif
 981         case XML_WITH_AUTOMATA:
 982 #ifdef LIBXML_AUTOMATA_ENABLED
 983             return(1);
 984 #else
 985             return(0);
 986 #endif
 987         case XML_WITH_EXPR:
 988 #ifdef LIBXML_EXPR_ENABLED
 989             return(1);
 990 #else
 991             return(0);
 992 #endif
 993         case XML_WITH_SCHEMAS:
 994 #ifdef LIBXML_SCHEMAS_ENABLED
 995             return(1);
 996 #else
 997             return(0);
 998 #endif
 999         case XML_WITH_SCHEMATRON:
1000 #ifdef LIBXML_SCHEMATRON_ENABLED
1001             return(1);
1002 #else
1003             return(0);
1004 #endif
1005         case XML_WITH_MODULES:
1006 #ifdef LIBXML_MODULES_ENABLED
1007             return(1);
1008 #else
1009             return(0);
1010 #endif
1011         case XML_WITH_DEBUG:
1012 #ifdef LIBXML_DEBUG_ENABLED
1013             return(1);
1014 #else
1015             return(0);
1016 #endif
1017         case XML_WITH_DEBUG_MEM:
1018 #ifdef DEBUG_MEMORY_LOCATION
1019             return(1);
1020 #else
1021             return(0);
1022 #endif
1023         case XML_WITH_DEBUG_RUN:
1024 #ifdef LIBXML_DEBUG_RUNTIME
1025             return(1);
1026 #else
1027             return(0);
1028 #endif
1029         case XML_WITH_ZLIB:
1030 #ifdef LIBXML_ZLIB_ENABLED
1031             return(1);
1032 #else
1033             return(0);
1034 #endif
1035         case XML_WITH_LZMA:
1036 #ifdef LIBXML_LZMA_ENABLED
1037             return(1);
1038 #else
1039             return(0);
1040 #endif
1041         case XML_WITH_ICU:
1042 #ifdef LIBXML_ICU_ENABLED
1043             return(1);
1044 #else
1045             return(0);
1046 #endif
1047         default:
1048             break;
1049      }
1050      return(0);
1051 }
1052
1053 /************************************************************************
1054  *                                                                      *
1055  *              SAX2 defaulted attributes handling                      *
1056  *                                                                      *
1057  ************************************************************************/
1058
1059 /**
1060  * xmlDetectSAX2:
1061  * @ctxt:  an XML parser context
1062  *
1063  * Do the SAX2 detection and specific intialization
1064  */
1065 static void
1066 xmlDetectSAX2(xmlParserCtxtPtr ctxt) {
1067     if (ctxt == NULL) return;
1068 #ifdef LIBXML_SAX1_ENABLED
1069     if ((ctxt->sax) &&  (ctxt->sax->initialized == XML_SAX2_MAGIC) &&
1070         ((ctxt->sax->startElementNs != NULL) ||
1071          (ctxt->sax->endElementNs != NULL))) ctxt->sax2 = 1;
1072 #else
1073     ctxt->sax2 = 1;
1074 #endif /* LIBXML_SAX1_ENABLED */
1075
1076     ctxt->str_xml = xmlDictLookup(ctxt->dict, BAD_CAST "xml", 3);
1077     ctxt->str_xmlns = xmlDictLookup(ctxt->dict, BAD_CAST "xmlns", 5);
1078     ctxt->str_xml_ns = xmlDictLookup(ctxt->dict, XML_XML_NAMESPACE, 36);
1079     if ((ctxt->str_xml==NULL) || (ctxt->str_xmlns==NULL) ||
1080                 (ctxt->str_xml_ns == NULL)) {
1081         xmlErrMemory(ctxt, NULL);
1082     }
1083 }
1084
1085 typedef struct _xmlDefAttrs xmlDefAttrs;
1086 typedef xmlDefAttrs *xmlDefAttrsPtr;
1087 struct _xmlDefAttrs {
1088     int nbAttrs;        /* number of defaulted attributes on that element */
1089     int maxAttrs;       /* the size of the array */
1090     const xmlChar *values[5]; /* array of localname/prefix/values/external */
1091 };
1092
1093 /**
1094  * xmlAttrNormalizeSpace:
1095  * @src: the source string
1096  * @dst: the target string
1097  *
1098  * Normalize the space in non CDATA attribute values:
1099  * If the attribute type is not CDATA, then the XML processor MUST further
1100  * process the normalized attribute value by discarding any leading and
1101  * trailing space (#x20) characters, and by replacing sequences of space
1102  * (#x20) characters by a single space (#x20) character.
1103  * Note that the size of dst need to be at least src, and if one doesn't need
1104  * to preserve dst (and it doesn't come from a dictionary or read-only) then
1105  * passing src as dst is just fine.
1106  *
1107  * Returns a pointer to the normalized value (dst) or NULL if no conversion
1108  *         is needed.
1109  */
1110 static xmlChar *
1111 xmlAttrNormalizeSpace(const xmlChar *src, xmlChar *dst)
1112 {
1113     if ((src == NULL) || (dst == NULL))
1114         return(NULL);
1115
1116     while (*src == 0x20) src++;
1117     while (*src != 0) {
1118         if (*src == 0x20) {
1119             while (*src == 0x20) src++;
1120             if (*src != 0)
1121                 *dst++ = 0x20;
1122         } else {
1123             *dst++ = *src++;
1124         }
1125     }
1126     *dst = 0;
1127     if (dst == src)
1128        return(NULL);
1129     return(dst);
1130 }
1131
1132 /**
1133  * xmlAttrNormalizeSpace2:
1134  * @src: the source string
1135  *
1136  * Normalize the space in non CDATA attribute values, a slightly more complex
1137  * front end to avoid allocation problems when running on attribute values
1138  * coming from the input.
1139  *
1140  * Returns a pointer to the normalized value (dst) or NULL if no conversion
1141  *         is needed.
1142  */
1143 static const xmlChar *
1144 xmlAttrNormalizeSpace2(xmlParserCtxtPtr ctxt, xmlChar *src, int *len)
1145 {
1146     int i;
1147     int remove_head = 0;
1148     int need_realloc = 0;
1149     const xmlChar *cur;
1150
1151     if ((ctxt == NULL) || (src == NULL) || (len == NULL))
1152         return(NULL);
1153     i = *len;
1154     if (i <= 0)
1155         return(NULL);
1156
1157     cur = src;
1158     while (*cur == 0x20) {
1159         cur++;
1160         remove_head++;
1161     }
1162     while (*cur != 0) {
1163         if (*cur == 0x20) {
1164             cur++;
1165             if ((*cur == 0x20) || (*cur == 0)) {
1166                 need_realloc = 1;
1167                 break;
1168             }
1169         } else
1170             cur++;
1171     }
1172     if (need_realloc) {
1173         xmlChar *ret;
1174
1175         ret = xmlStrndup(src + remove_head, i - remove_head + 1);
1176         if (ret == NULL) {
1177             xmlErrMemory(ctxt, NULL);
1178             return(NULL);
1179         }
1180         xmlAttrNormalizeSpace(ret, ret);
1181         *len = (int) strlen((const char *)ret);
1182         return(ret);
1183     } else if (remove_head) {
1184         *len -= remove_head;
1185         memmove(src, src + remove_head, 1 + *len);
1186         return(src);
1187     }
1188     return(NULL);
1189 }
1190
1191 /**
1192  * xmlAddDefAttrs:
1193  * @ctxt:  an XML parser context
1194  * @fullname:  the element fullname
1195  * @fullattr:  the attribute fullname
1196  * @value:  the attribute value
1197  *
1198  * Add a defaulted attribute for an element
1199  */
1200 static void
1201 xmlAddDefAttrs(xmlParserCtxtPtr ctxt,
1202                const xmlChar *fullname,
1203                const xmlChar *fullattr,
1204                const xmlChar *value) {
1205     xmlDefAttrsPtr defaults;
1206     int len;
1207     const xmlChar *name;
1208     const xmlChar *prefix;
1209
1210     /*
1211      * Allows to detect attribute redefinitions
1212      */
1213     if (ctxt->attsSpecial != NULL) {
1214         if (xmlHashLookup2(ctxt->attsSpecial, fullname, fullattr) != NULL)
1215             return;
1216     }
1217
1218     if (ctxt->attsDefault == NULL) {
1219         ctxt->attsDefault = xmlHashCreateDict(10, ctxt->dict);
1220         if (ctxt->attsDefault == NULL)
1221             goto mem_error;
1222     }
1223
1224     /*
1225      * split the element name into prefix:localname , the string found
1226      * are within the DTD and then not associated to namespace names.
1227      */
1228     name = xmlSplitQName3(fullname, &len);
1229     if (name == NULL) {
1230         name = xmlDictLookup(ctxt->dict, fullname, -1);
1231         prefix = NULL;
1232     } else {
1233         name = xmlDictLookup(ctxt->dict, name, -1);
1234         prefix = xmlDictLookup(ctxt->dict, fullname, len);
1235     }
1236
1237     /*
1238      * make sure there is some storage
1239      */
1240     defaults = xmlHashLookup2(ctxt->attsDefault, name, prefix);
1241     if (defaults == NULL) {
1242         defaults = (xmlDefAttrsPtr) xmlMalloc(sizeof(xmlDefAttrs) +
1243                            (4 * 5) * sizeof(const xmlChar *));
1244         if (defaults == NULL)
1245             goto mem_error;
1246         defaults->nbAttrs = 0;
1247         defaults->maxAttrs = 4;
1248         if (xmlHashUpdateEntry2(ctxt->attsDefault, name, prefix,
1249                                 defaults, NULL) < 0) {
1250             xmlFree(defaults);
1251             goto mem_error;
1252         }
1253     } else if (defaults->nbAttrs >= defaults->maxAttrs) {
1254         xmlDefAttrsPtr temp;
1255
1256         temp = (xmlDefAttrsPtr) xmlRealloc(defaults, sizeof(xmlDefAttrs) +
1257                        (2 * defaults->maxAttrs * 5) * sizeof(const xmlChar *));
1258         if (temp == NULL)
1259             goto mem_error;
1260         defaults = temp;
1261         defaults->maxAttrs *= 2;
1262         if (xmlHashUpdateEntry2(ctxt->attsDefault, name, prefix,
1263                                 defaults, NULL) < 0) {
1264             xmlFree(defaults);
1265             goto mem_error;
1266         }
1267     }
1268
1269     /*
1270      * Split the element name into prefix:localname , the string found
1271      * are within the DTD and hen not associated to namespace names.
1272      */
1273     name = xmlSplitQName3(fullattr, &len);
1274     if (name == NULL) {
1275         name = xmlDictLookup(ctxt->dict, fullattr, -1);
1276         prefix = NULL;
1277     } else {
1278         name = xmlDictLookup(ctxt->dict, name, -1);
1279         prefix = xmlDictLookup(ctxt->dict, fullattr, len);
1280     }
1281
1282     defaults->values[5 * defaults->nbAttrs] = name;
1283     defaults->values[5 * defaults->nbAttrs + 1] = prefix;
1284     /* intern the string and precompute the end */
1285     len = xmlStrlen(value);
1286     value = xmlDictLookup(ctxt->dict, value, len);
1287     defaults->values[5 * defaults->nbAttrs + 2] = value;
1288     defaults->values[5 * defaults->nbAttrs + 3] = value + len;
1289     if (ctxt->external)
1290         defaults->values[5 * defaults->nbAttrs + 4] = BAD_CAST "external";
1291     else
1292         defaults->values[5 * defaults->nbAttrs + 4] = NULL;
1293     defaults->nbAttrs++;
1294
1295     return;
1296
1297 mem_error:
1298     xmlErrMemory(ctxt, NULL);
1299     return;
1300 }
1301
1302 /**
1303  * xmlAddSpecialAttr:
1304  * @ctxt:  an XML parser context
1305  * @fullname:  the element fullname
1306  * @fullattr:  the attribute fullname
1307  * @type:  the attribute type
1308  *
1309  * Register this attribute type
1310  */
1311 static void
1312 xmlAddSpecialAttr(xmlParserCtxtPtr ctxt,
1313                   const xmlChar *fullname,
1314                   const xmlChar *fullattr,
1315                   int type)
1316 {
1317     if (ctxt->attsSpecial == NULL) {
1318         ctxt->attsSpecial = xmlHashCreateDict(10, ctxt->dict);
1319         if (ctxt->attsSpecial == NULL)
1320             goto mem_error;
1321     }
1322
1323     if (xmlHashLookup2(ctxt->attsSpecial, fullname, fullattr) != NULL)
1324         return;
1325
1326     xmlHashAddEntry2(ctxt->attsSpecial, fullname, fullattr,
1327                      (void *) (long) type);
1328     return;
1329
1330 mem_error:
1331     xmlErrMemory(ctxt, NULL);
1332     return;
1333 }
1334
1335 /**
1336  * xmlCleanSpecialAttrCallback:
1337  *
1338  * Removes CDATA attributes from the special attribute table
1339  */
1340 static void
1341 xmlCleanSpecialAttrCallback(void *payload, void *data,
1342                             const xmlChar *fullname, const xmlChar *fullattr,
1343                             const xmlChar *unused ATTRIBUTE_UNUSED) {
1344     xmlParserCtxtPtr ctxt = (xmlParserCtxtPtr) data;
1345
1346     if (((long) payload) == XML_ATTRIBUTE_CDATA) {
1347         xmlHashRemoveEntry2(ctxt->attsSpecial, fullname, fullattr, NULL);
1348     }
1349 }
1350
1351 /**
1352  * xmlCleanSpecialAttr:
1353  * @ctxt:  an XML parser context
1354  *
1355  * Trim the list of attributes defined to remove all those of type
1356  * CDATA as they are not special. This call should be done when finishing
1357  * to parse the DTD and before starting to parse the document root.
1358  */
1359 static void
1360 xmlCleanSpecialAttr(xmlParserCtxtPtr ctxt)
1361 {
1362     if (ctxt->attsSpecial == NULL)
1363         return;
1364
1365     xmlHashScanFull(ctxt->attsSpecial, xmlCleanSpecialAttrCallback, ctxt);
1366
1367     if (xmlHashSize(ctxt->attsSpecial) == 0) {
1368         xmlHashFree(ctxt->attsSpecial, NULL);
1369         ctxt->attsSpecial = NULL;
1370     }
1371     return;
1372 }
1373
1374 /**
1375  * xmlCheckLanguageID:
1376  * @lang:  pointer to the string value
1377  *
1378  * Checks that the value conforms to the LanguageID production:
1379  *
1380  * NOTE: this is somewhat deprecated, those productions were removed from
1381  *       the XML Second edition.
1382  *
1383  * [33] LanguageID ::= Langcode ('-' Subcode)*
1384  * [34] Langcode ::= ISO639Code |  IanaCode |  UserCode
1385  * [35] ISO639Code ::= ([a-z] | [A-Z]) ([a-z] | [A-Z])
1386  * [36] IanaCode ::= ('i' | 'I') '-' ([a-z] | [A-Z])+
1387  * [37] UserCode ::= ('x' | 'X') '-' ([a-z] | [A-Z])+
1388  * [38] Subcode ::= ([a-z] | [A-Z])+
1389  *
1390  * The current REC reference the sucessors of RFC 1766, currently 5646
1391  *
1392  * http://www.rfc-editor.org/rfc/rfc5646.txt
1393  * langtag       = language
1394  *                 ["-" script]
1395  *                 ["-" region]
1396  *                 *("-" variant)
1397  *                 *("-" extension)
1398  *                 ["-" privateuse]
1399  * language      = 2*3ALPHA            ; shortest ISO 639 code
1400  *                 ["-" extlang]       ; sometimes followed by
1401  *                                     ; extended language subtags
1402  *               / 4ALPHA              ; or reserved for future use
1403  *               / 5*8ALPHA            ; or registered language subtag
1404  *
1405  * extlang       = 3ALPHA              ; selected ISO 639 codes
1406  *                 *2("-" 3ALPHA)      ; permanently reserved
1407  *
1408  * script        = 4ALPHA              ; ISO 15924 code
1409  *
1410  * region        = 2ALPHA              ; ISO 3166-1 code
1411  *               / 3DIGIT              ; UN M.49 code
1412  *
1413  * variant       = 5*8alphanum         ; registered variants
1414  *               / (DIGIT 3alphanum)
1415  *
1416  * extension     = singleton 1*("-" (2*8alphanum))
1417  *
1418  *                                     ; Single alphanumerics
1419  *                                     ; "x" reserved for private use
1420  * singleton     = DIGIT               ; 0 - 9
1421  *               / %x41-57             ; A - W
1422  *               / %x59-5A             ; Y - Z
1423  *               / %x61-77             ; a - w
1424  *               / %x79-7A             ; y - z
1425  *
1426  * it sounds right to still allow Irregular i-xxx IANA and user codes too
1427  * The parser below doesn't try to cope with extension or privateuse
1428  * that could be added but that's not interoperable anyway
1429  *
1430  * Returns 1 if correct 0 otherwise
1431  **/
1432 int
1433 xmlCheckLanguageID(const xmlChar * lang)
1434 {
1435     const xmlChar *cur = lang, *nxt;
1436
1437     if (cur == NULL)
1438         return (0);
1439     if (((cur[0] == 'i') && (cur[1] == '-')) ||
1440         ((cur[0] == 'I') && (cur[1] == '-')) ||
1441         ((cur[0] == 'x') && (cur[1] == '-')) ||
1442         ((cur[0] == 'X') && (cur[1] == '-'))) {
1443         /*
1444          * Still allow IANA code and user code which were coming
1445          * from the previous version of the XML-1.0 specification
1446          * it's deprecated but we should not fail
1447          */
1448         cur += 2;
1449         while (((cur[0] >= 'A') && (cur[0] <= 'Z')) ||
1450                ((cur[0] >= 'a') && (cur[0] <= 'z')))
1451             cur++;
1452         return(cur[0] == 0);
1453     }
1454     nxt = cur;
1455     while (((nxt[0] >= 'A') && (nxt[0] <= 'Z')) ||
1456            ((nxt[0] >= 'a') && (nxt[0] <= 'z')))
1457            nxt++;
1458     if (nxt - cur >= 4) {
1459         /*
1460          * Reserved
1461          */
1462         if ((nxt - cur > 8) || (nxt[0] != 0))
1463             return(0);
1464         return(1);
1465     }
1466     if (nxt - cur < 2)
1467         return(0);
1468     /* we got an ISO 639 code */
1469     if (nxt[0] == 0)
1470         return(1);
1471     if (nxt[0] != '-')
1472         return(0);
1473
1474     nxt++;
1475     cur = nxt;
1476     /* now we can have extlang or script or region or variant */
1477     if ((nxt[0] >= '0') && (nxt[0] <= '9'))
1478         goto region_m49;
1479
1480     while (((nxt[0] >= 'A') && (nxt[0] <= 'Z')) ||
1481            ((nxt[0] >= 'a') && (nxt[0] <= 'z')))
1482            nxt++;
1483     if (nxt - cur == 4)
1484         goto script;
1485     if (nxt - cur == 2)
1486         goto region;
1487     if ((nxt - cur >= 5) && (nxt - cur <= 8))
1488         goto variant;
1489     if (nxt - cur != 3)
1490         return(0);
1491     /* we parsed an extlang */
1492     if (nxt[0] == 0)
1493         return(1);
1494     if (nxt[0] != '-')
1495         return(0);
1496
1497     nxt++;
1498     cur = nxt;
1499     /* now we can have script or region or variant */
1500     if ((nxt[0] >= '0') && (nxt[0] <= '9'))
1501         goto region_m49;
1502
1503     while (((nxt[0] >= 'A') && (nxt[0] <= 'Z')) ||
1504            ((nxt[0] >= 'a') && (nxt[0] <= 'z')))
1505            nxt++;
1506     if (nxt - cur == 2)
1507         goto region;
1508     if ((nxt - cur >= 5) && (nxt - cur <= 8))
1509         goto variant;
1510     if (nxt - cur != 4)
1511         return(0);
1512     /* we parsed a script */
1513 script:
1514     if (nxt[0] == 0)
1515         return(1);
1516     if (nxt[0] != '-')
1517         return(0);
1518
1519     nxt++;
1520     cur = nxt;
1521     /* now we can have region or variant */
1522     if ((nxt[0] >= '0') && (nxt[0] <= '9'))
1523         goto region_m49;
1524
1525     while (((nxt[0] >= 'A') && (nxt[0] <= 'Z')) ||
1526            ((nxt[0] >= 'a') && (nxt[0] <= 'z')))
1527            nxt++;
1528
1529     if ((nxt - cur >= 5) && (nxt - cur <= 8))
1530         goto variant;
1531     if (nxt - cur != 2)
1532         return(0);
1533     /* we parsed a region */
1534 region:
1535     if (nxt[0] == 0)
1536         return(1);
1537     if (nxt[0] != '-')
1538         return(0);
1539
1540     nxt++;
1541     cur = nxt;
1542     /* now we can just have a variant */
1543     while (((nxt[0] >= 'A') && (nxt[0] <= 'Z')) ||
1544            ((nxt[0] >= 'a') && (nxt[0] <= 'z')))
1545            nxt++;
1546
1547     if ((nxt - cur < 5) || (nxt - cur > 8))
1548         return(0);
1549
1550     /* we parsed a variant */
1551 variant:
1552     if (nxt[0] == 0)
1553         return(1);
1554     if (nxt[0] != '-')
1555         return(0);
1556     /* extensions and private use subtags not checked */
1557     return (1);
1558
1559 region_m49:
1560     if (((nxt[1] >= '0') && (nxt[1] <= '9')) &&
1561         ((nxt[2] >= '0') && (nxt[2] <= '9'))) {
1562         nxt += 3;
1563         goto region;
1564     }
1565     return(0);
1566 }
1567
1568 /************************************************************************
1569  *                                                                      *
1570  *              Parser stacks related functions and macros              *
1571  *                                                                      *
1572  ************************************************************************/
1573
1574 static xmlEntityPtr xmlParseStringEntityRef(xmlParserCtxtPtr ctxt,
1575                                             const xmlChar ** str);
1576
1577 #ifdef SAX2
1578 /**
1579  * nsPush:
1580  * @ctxt:  an XML parser context
1581  * @prefix:  the namespace prefix or NULL
1582  * @URL:  the namespace name
1583  *
1584  * Pushes a new parser namespace on top of the ns stack
1585  *
1586  * Returns -1 in case of error, -2 if the namespace should be discarded
1587  *         and the index in the stack otherwise.
1588  */
1589 static int
1590 nsPush(xmlParserCtxtPtr ctxt, const xmlChar *prefix, const xmlChar *URL)
1591 {
1592     if (ctxt->options & XML_PARSE_NSCLEAN) {
1593         int i;
1594         for (i = ctxt->nsNr - 2;i >= 0;i -= 2) {
1595             if (ctxt->nsTab[i] == prefix) {
1596                 /* in scope */
1597                 if (ctxt->nsTab[i + 1] == URL)
1598                     return(-2);
1599                 /* out of scope keep it */
1600                 break;
1601             }
1602         }
1603     }
1604     if ((ctxt->nsMax == 0) || (ctxt->nsTab == NULL)) {
1605         ctxt->nsMax = 10;
1606         ctxt->nsNr = 0;
1607         ctxt->nsTab = (const xmlChar **)
1608                       xmlMalloc(ctxt->nsMax * sizeof(xmlChar *));
1609         if (ctxt->nsTab == NULL) {
1610             xmlErrMemory(ctxt, NULL);
1611             ctxt->nsMax = 0;
1612             return (-1);
1613         }
1614     } else if (ctxt->nsNr >= ctxt->nsMax) {
1615         const xmlChar ** tmp;
1616         ctxt->nsMax *= 2;
1617         tmp = (const xmlChar **) xmlRealloc((char *) ctxt->nsTab,
1618                                     ctxt->nsMax * sizeof(ctxt->nsTab[0]));
1619         if (tmp == NULL) {
1620             xmlErrMemory(ctxt, NULL);
1621             ctxt->nsMax /= 2;
1622             return (-1);
1623         }
1624         ctxt->nsTab = tmp;
1625     }
1626     ctxt->nsTab[ctxt->nsNr++] = prefix;
1627     ctxt->nsTab[ctxt->nsNr++] = URL;
1628     return (ctxt->nsNr);
1629 }
1630 /**
1631  * nsPop:
1632  * @ctxt: an XML parser context
1633  * @nr:  the number to pop
1634  *
1635  * Pops the top @nr parser prefix/namespace from the ns stack
1636  *
1637  * Returns the number of namespaces removed
1638  */
1639 static int
1640 nsPop(xmlParserCtxtPtr ctxt, int nr)
1641 {
1642     int i;
1643
1644     if (ctxt->nsTab == NULL) return(0);
1645     if (ctxt->nsNr < nr) {
1646         xmlGenericError(xmlGenericErrorContext, "Pbm popping %d NS\n", nr);
1647         nr = ctxt->nsNr;
1648     }
1649     if (ctxt->nsNr <= 0)
1650         return (0);
1651
1652     for (i = 0;i < nr;i++) {
1653          ctxt->nsNr--;
1654          ctxt->nsTab[ctxt->nsNr] = NULL;
1655     }
1656     return(nr);
1657 }
1658 #endif
1659
1660 static int
1661 xmlCtxtGrowAttrs(xmlParserCtxtPtr ctxt, int nr) {
1662     const xmlChar **atts;
1663     int *attallocs;
1664     int maxatts;
1665
1666     if (ctxt->atts == NULL) {
1667         maxatts = 55; /* allow for 10 attrs by default */
1668         atts = (const xmlChar **)
1669                xmlMalloc(maxatts * sizeof(xmlChar *));
1670         if (atts == NULL) goto mem_error;
1671         ctxt->atts = atts;
1672         attallocs = (int *) xmlMalloc((maxatts / 5) * sizeof(int));
1673         if (attallocs == NULL) goto mem_error;
1674         ctxt->attallocs = attallocs;
1675         ctxt->maxatts = maxatts;
1676     } else if (nr + 5 > ctxt->maxatts) {
1677         maxatts = (nr + 5) * 2;
1678         atts = (const xmlChar **) xmlRealloc((void *) ctxt->atts,
1679                                      maxatts * sizeof(const xmlChar *));
1680         if (atts == NULL) goto mem_error;
1681         ctxt->atts = atts;
1682         attallocs = (int *) xmlRealloc((void *) ctxt->attallocs,
1683                                      (maxatts / 5) * sizeof(int));
1684         if (attallocs == NULL) goto mem_error;
1685         ctxt->attallocs = attallocs;
1686         ctxt->maxatts = maxatts;
1687     }
1688     return(ctxt->maxatts);
1689 mem_error:
1690     xmlErrMemory(ctxt, NULL);
1691     return(-1);
1692 }
1693
1694 /**
1695  * inputPush:
1696  * @ctxt:  an XML parser context
1697  * @value:  the parser input
1698  *
1699  * Pushes a new parser input on top of the input stack
1700  *
1701  * Returns -1 in case of error, the index in the stack otherwise
1702  */
1703 int
1704 inputPush(xmlParserCtxtPtr ctxt, xmlParserInputPtr value)
1705 {
1706     if ((ctxt == NULL) || (value == NULL))
1707         return(-1);
1708     if (ctxt->inputNr >= ctxt->inputMax) {
1709         ctxt->inputMax *= 2;
1710         ctxt->inputTab =
1711             (xmlParserInputPtr *) xmlRealloc(ctxt->inputTab,
1712                                              ctxt->inputMax *
1713                                              sizeof(ctxt->inputTab[0]));
1714         if (ctxt->inputTab == NULL) {
1715             xmlErrMemory(ctxt, NULL);
1716             xmlFreeInputStream(value);
1717             ctxt->inputMax /= 2;
1718             value = NULL;
1719             return (-1);
1720         }
1721     }
1722     ctxt->inputTab[ctxt->inputNr] = value;
1723     ctxt->input = value;
1724     return (ctxt->inputNr++);
1725 }
1726 /**
1727  * inputPop:
1728  * @ctxt: an XML parser context
1729  *
1730  * Pops the top parser input from the input stack
1731  *
1732  * Returns the input just removed
1733  */
1734 xmlParserInputPtr
1735 inputPop(xmlParserCtxtPtr ctxt)
1736 {
1737     xmlParserInputPtr ret;
1738
1739     if (ctxt == NULL)
1740         return(NULL);
1741     if (ctxt->inputNr <= 0)
1742         return (NULL);
1743     ctxt->inputNr--;
1744     if (ctxt->inputNr > 0)
1745         ctxt->input = ctxt->inputTab[ctxt->inputNr - 1];
1746     else
1747         ctxt->input = NULL;
1748     ret = ctxt->inputTab[ctxt->inputNr];
1749     ctxt->inputTab[ctxt->inputNr] = NULL;
1750     return (ret);
1751 }
1752 /**
1753  * nodePush:
1754  * @ctxt:  an XML parser context
1755  * @value:  the element node
1756  *
1757  * Pushes a new element node on top of the node stack
1758  *
1759  * Returns -1 in case of error, the index in the stack otherwise
1760  */
1761 int
1762 nodePush(xmlParserCtxtPtr ctxt, xmlNodePtr value)
1763 {
1764     if (ctxt == NULL) return(0);
1765     if (ctxt->nodeNr >= ctxt->nodeMax) {
1766         xmlNodePtr *tmp;
1767
1768         tmp = (xmlNodePtr *) xmlRealloc(ctxt->nodeTab,
1769                                       ctxt->nodeMax * 2 *
1770                                       sizeof(ctxt->nodeTab[0]));
1771         if (tmp == NULL) {
1772             xmlErrMemory(ctxt, NULL);
1773             return (-1);
1774         }
1775         ctxt->nodeTab = tmp;
1776         ctxt->nodeMax *= 2;
1777     }
1778     if ((((unsigned int) ctxt->nodeNr) > xmlParserMaxDepth) &&
1779         ((ctxt->options & XML_PARSE_HUGE) == 0)) {
1780         xmlFatalErrMsgInt(ctxt, XML_ERR_INTERNAL_ERROR,
1781                  "Excessive depth in document: %d use XML_PARSE_HUGE option\n",
1782                           xmlParserMaxDepth);
1783         xmlHaltParser(ctxt);
1784         return(-1);
1785     }
1786     ctxt->nodeTab[ctxt->nodeNr] = value;
1787     ctxt->node = value;
1788     return (ctxt->nodeNr++);
1789 }
1790
1791 /**
1792  * nodePop:
1793  * @ctxt: an XML parser context
1794  *
1795  * Pops the top element node from the node stack
1796  *
1797  * Returns the node just removed
1798  */
1799 xmlNodePtr
1800 nodePop(xmlParserCtxtPtr ctxt)
1801 {
1802     xmlNodePtr ret;
1803
1804     if (ctxt == NULL) return(NULL);
1805     if (ctxt->nodeNr <= 0)
1806         return (NULL);
1807     ctxt->nodeNr--;
1808     if (ctxt->nodeNr > 0)
1809         ctxt->node = ctxt->nodeTab[ctxt->nodeNr - 1];
1810     else
1811         ctxt->node = NULL;
1812     ret = ctxt->nodeTab[ctxt->nodeNr];
1813     ctxt->nodeTab[ctxt->nodeNr] = NULL;
1814     return (ret);
1815 }
1816
1817 #ifdef LIBXML_PUSH_ENABLED
1818 /**
1819  * nameNsPush:
1820  * @ctxt:  an XML parser context
1821  * @value:  the element name
1822  * @prefix:  the element prefix
1823  * @URI:  the element namespace name
1824  *
1825  * Pushes a new element name/prefix/URL on top of the name stack
1826  *
1827  * Returns -1 in case of error, the index in the stack otherwise
1828  */
1829 static int
1830 nameNsPush(xmlParserCtxtPtr ctxt, const xmlChar * value,
1831            const xmlChar *prefix, const xmlChar *URI, int nsNr)
1832 {
1833     if (ctxt->nameNr >= ctxt->nameMax) {
1834         const xmlChar * *tmp;
1835         void **tmp2;
1836         ctxt->nameMax *= 2;
1837         tmp = (const xmlChar * *) xmlRealloc((xmlChar * *)ctxt->nameTab,
1838                                     ctxt->nameMax *
1839                                     sizeof(ctxt->nameTab[0]));
1840         if (tmp == NULL) {
1841             ctxt->nameMax /= 2;
1842             goto mem_error;
1843         }
1844         ctxt->nameTab = tmp;
1845         tmp2 = (void **) xmlRealloc((void * *)ctxt->pushTab,
1846                                     ctxt->nameMax * 3 *
1847                                     sizeof(ctxt->pushTab[0]));
1848         if (tmp2 == NULL) {
1849             ctxt->nameMax /= 2;
1850             goto mem_error;
1851         }
1852         ctxt->pushTab = tmp2;
1853     }
1854     ctxt->nameTab[ctxt->nameNr] = value;
1855     ctxt->name = value;
1856     ctxt->pushTab[ctxt->nameNr * 3] = (void *) prefix;
1857     ctxt->pushTab[ctxt->nameNr * 3 + 1] = (void *) URI;
1858     ctxt->pushTab[ctxt->nameNr * 3 + 2] = (void *) (long) nsNr;
1859     return (ctxt->nameNr++);
1860 mem_error:
1861     xmlErrMemory(ctxt, NULL);
1862     return (-1);
1863 }
1864 /**
1865  * nameNsPop:
1866  * @ctxt: an XML parser context
1867  *
1868  * Pops the top element/prefix/URI name from the name stack
1869  *
1870  * Returns the name just removed
1871  */
1872 static const xmlChar *
1873 nameNsPop(xmlParserCtxtPtr ctxt)
1874 {
1875     const xmlChar *ret;
1876
1877     if (ctxt->nameNr <= 0)
1878         return (NULL);
1879     ctxt->nameNr--;
1880     if (ctxt->nameNr > 0)
1881         ctxt->name = ctxt->nameTab[ctxt->nameNr - 1];
1882     else
1883         ctxt->name = NULL;
1884     ret = ctxt->nameTab[ctxt->nameNr];
1885     ctxt->nameTab[ctxt->nameNr] = NULL;
1886     return (ret);
1887 }
1888 #endif /* LIBXML_PUSH_ENABLED */
1889
1890 /**
1891  * namePush:
1892  * @ctxt:  an XML parser context
1893  * @value:  the element name
1894  *
1895  * Pushes a new element name on top of the name stack
1896  *
1897  * Returns -1 in case of error, the index in the stack otherwise
1898  */
1899 int
1900 namePush(xmlParserCtxtPtr ctxt, const xmlChar * value)
1901 {
1902     if (ctxt == NULL) return (-1);
1903
1904     if (ctxt->nameNr >= ctxt->nameMax) {
1905         const xmlChar * *tmp;
1906         tmp = (const xmlChar * *) xmlRealloc((xmlChar * *)ctxt->nameTab,
1907                                     ctxt->nameMax * 2 *
1908                                     sizeof(ctxt->nameTab[0]));
1909         if (tmp == NULL) {
1910             goto mem_error;
1911         }
1912         ctxt->nameTab = tmp;
1913         ctxt->nameMax *= 2;
1914     }
1915     ctxt->nameTab[ctxt->nameNr] = value;
1916     ctxt->name = value;
1917     return (ctxt->nameNr++);
1918 mem_error:
1919     xmlErrMemory(ctxt, NULL);
1920     return (-1);
1921 }
1922 /**
1923  * namePop:
1924  * @ctxt: an XML parser context
1925  *
1926  * Pops the top element name from the name stack
1927  *
1928  * Returns the name just removed
1929  */
1930 const xmlChar *
1931 namePop(xmlParserCtxtPtr ctxt)
1932 {
1933     const xmlChar *ret;
1934
1935     if ((ctxt == NULL) || (ctxt->nameNr <= 0))
1936         return (NULL);
1937     ctxt->nameNr--;
1938     if (ctxt->nameNr > 0)
1939         ctxt->name = ctxt->nameTab[ctxt->nameNr - 1];
1940     else
1941         ctxt->name = NULL;
1942     ret = ctxt->nameTab[ctxt->nameNr];
1943     ctxt->nameTab[ctxt->nameNr] = NULL;
1944     return (ret);
1945 }
1946
1947 static int spacePush(xmlParserCtxtPtr ctxt, int val) {
1948     if (ctxt->spaceNr >= ctxt->spaceMax) {
1949         int *tmp;
1950
1951         ctxt->spaceMax *= 2;
1952         tmp = (int *) xmlRealloc(ctxt->spaceTab,
1953                                  ctxt->spaceMax * sizeof(ctxt->spaceTab[0]));
1954         if (tmp == NULL) {
1955             xmlErrMemory(ctxt, NULL);
1956             ctxt->spaceMax /=2;
1957             return(-1);
1958         }
1959         ctxt->spaceTab = tmp;
1960     }
1961     ctxt->spaceTab[ctxt->spaceNr] = val;
1962     ctxt->space = &ctxt->spaceTab[ctxt->spaceNr];
1963     return(ctxt->spaceNr++);
1964 }
1965
1966 static int spacePop(xmlParserCtxtPtr ctxt) {
1967     int ret;
1968     if (ctxt->spaceNr <= 0) return(0);
1969     ctxt->spaceNr--;
1970     if (ctxt->spaceNr > 0)
1971         ctxt->space = &ctxt->spaceTab[ctxt->spaceNr - 1];
1972     else
1973         ctxt->space = &ctxt->spaceTab[0];
1974     ret = ctxt->spaceTab[ctxt->spaceNr];
1975     ctxt->spaceTab[ctxt->spaceNr] = -1;
1976     return(ret);
1977 }
1978
1979 /*
1980  * Macros for accessing the content. Those should be used only by the parser,
1981  * and not exported.
1982  *
1983  * Dirty macros, i.e. one often need to make assumption on the context to
1984  * use them
1985  *
1986  *   CUR_PTR return the current pointer to the xmlChar to be parsed.
1987  *           To be used with extreme caution since operations consuming
1988  *           characters may move the input buffer to a different location !
1989  *   CUR     returns the current xmlChar value, i.e. a 8 bit value if compiled
1990  *           This should be used internally by the parser
1991  *           only to compare to ASCII values otherwise it would break when
1992  *           running with UTF-8 encoding.
1993  *   RAW     same as CUR but in the input buffer, bypass any token
1994  *           extraction that may have been done
1995  *   NXT(n)  returns the n'th next xmlChar. Same as CUR is should be used only
1996  *           to compare on ASCII based substring.
1997  *   SKIP(n) Skip n xmlChar, and must also be used only to skip ASCII defined
1998  *           strings without newlines within the parser.
1999  *   NEXT1(l) Skip 1 xmlChar, and must also be used only to skip 1 non-newline ASCII
2000  *           defined char within the parser.
2001  * Clean macros, not dependent of an ASCII context, expect UTF-8 encoding
2002  *
2003  *   NEXT    Skip to the next character, this does the proper decoding
2004  *           in UTF-8 mode. It also pop-up unfinished entities on the fly.
2005  *   NEXTL(l) Skip the current unicode character of l xmlChars long.
2006  *   CUR_CHAR(l) returns the current unicode character (int), set l
2007  *           to the number of xmlChars used for the encoding [0-5].
2008  *   CUR_SCHAR  same but operate on a string instead of the context
2009  *   COPY_BUF  copy the current unicode char to the target buffer, increment
2010  *            the index
2011  *   GROW, SHRINK  handling of input buffers
2012  */
2013
2014 #define RAW (*ctxt->input->cur)
2015 #define CUR (*ctxt->input->cur)
2016 #define NXT(val) ctxt->input->cur[(val)]
2017 #define CUR_PTR ctxt->input->cur
2018 #define BASE_PTR ctxt->input->base
2019
2020 #define CMP4( s, c1, c2, c3, c4 ) \
2021   ( ((unsigned char *) s)[ 0 ] == c1 && ((unsigned char *) s)[ 1 ] == c2 && \
2022     ((unsigned char *) s)[ 2 ] == c3 && ((unsigned char *) s)[ 3 ] == c4 )
2023 #define CMP5( s, c1, c2, c3, c4, c5 ) \
2024   ( CMP4( s, c1, c2, c3, c4 ) && ((unsigned char *) s)[ 4 ] == c5 )
2025 #define CMP6( s, c1, c2, c3, c4, c5, c6 ) \
2026   ( CMP5( s, c1, c2, c3, c4, c5 ) && ((unsigned char *) s)[ 5 ] == c6 )
2027 #define CMP7( s, c1, c2, c3, c4, c5, c6, c7 ) \
2028   ( CMP6( s, c1, c2, c3, c4, c5, c6 ) && ((unsigned char *) s)[ 6 ] == c7 )
2029 #define CMP8( s, c1, c2, c3, c4, c5, c6, c7, c8 ) \
2030   ( CMP7( s, c1, c2, c3, c4, c5, c6, c7 ) && ((unsigned char *) s)[ 7 ] == c8 )
2031 #define CMP9( s, c1, c2, c3, c4, c5, c6, c7, c8, c9 ) \
2032   ( CMP8( s, c1, c2, c3, c4, c5, c6, c7, c8 ) && \
2033     ((unsigned char *) s)[ 8 ] == c9 )
2034 #define CMP10( s, c1, c2, c3, c4, c5, c6, c7, c8, c9, c10 ) \
2035   ( CMP9( s, c1, c2, c3, c4, c5, c6, c7, c8, c9 ) && \
2036     ((unsigned char *) s)[ 9 ] == c10 )
2037
2038 #define SKIP(val) do {                                                  \
2039     ctxt->nbChars += (val),ctxt->input->cur += (val),ctxt->input->col+=(val);                   \
2040     if (*ctxt->input->cur == '%') xmlParserHandlePEReference(ctxt);     \
2041     if ((*ctxt->input->cur == 0) &&                                     \
2042         (xmlParserInputGrow(ctxt->input, INPUT_CHUNK) <= 0))            \
2043             xmlPopInput(ctxt);                                          \
2044   } while (0)
2045
2046 #define SKIPL(val) do {                                                 \
2047     int skipl;                                                          \
2048     for(skipl=0; skipl<val; skipl++) {                                  \
2049         if (*(ctxt->input->cur) == '\n') {                              \
2050         ctxt->input->line++; ctxt->input->col = 1;                      \
2051         } else ctxt->input->col++;                                      \
2052         ctxt->nbChars++;                                                \
2053         ctxt->input->cur++;                                             \
2054     }                                                                   \
2055     if (*ctxt->input->cur == '%') xmlParserHandlePEReference(ctxt);     \
2056     if ((*ctxt->input->cur == 0) &&                                     \
2057         (xmlParserInputGrow(ctxt->input, INPUT_CHUNK) <= 0))            \
2058             xmlPopInput(ctxt);                                          \
2059   } while (0)
2060
2061 #define SHRINK if ((ctxt->progressive == 0) &&                          \
2062                    (ctxt->input->cur - ctxt->input->base > 2 * INPUT_CHUNK) && \
2063                    (ctxt->input->end - ctxt->input->cur < 2 * INPUT_CHUNK)) \
2064         xmlSHRINK (ctxt);
2065
2066 static void xmlSHRINK (xmlParserCtxtPtr ctxt) {
2067     xmlParserInputShrink(ctxt->input);
2068     if ((*ctxt->input->cur == 0) &&
2069         (xmlParserInputGrow(ctxt->input, INPUT_CHUNK) <= 0))
2070             xmlPopInput(ctxt);
2071   }
2072
2073 #define GROW if ((ctxt->progressive == 0) &&                            \
2074                  (ctxt->input->end - ctxt->input->cur < INPUT_CHUNK))   \
2075         xmlGROW (ctxt);
2076
2077 static void xmlGROW (xmlParserCtxtPtr ctxt) {
2078     unsigned long curEnd = ctxt->input->end - ctxt->input->cur;
2079     unsigned long curBase = ctxt->input->cur - ctxt->input->base;
2080
2081     if (((curEnd > (unsigned long) XML_MAX_LOOKUP_LIMIT) ||
2082          (curBase > (unsigned long) XML_MAX_LOOKUP_LIMIT)) &&
2083          ((ctxt->input->buf) && (ctxt->input->buf->readcallback != (xmlInputReadCallback) xmlNop)) &&
2084         ((ctxt->options & XML_PARSE_HUGE) == 0)) {
2085         xmlFatalErr(ctxt, XML_ERR_INTERNAL_ERROR, "Huge input lookup");
2086         xmlHaltParser(ctxt);
2087         return;
2088     }
2089     xmlParserInputGrow(ctxt->input, INPUT_CHUNK);
2090     if ((ctxt->input->cur > ctxt->input->end) ||
2091         (ctxt->input->cur < ctxt->input->base)) {
2092         xmlHaltParser(ctxt);
2093         xmlFatalErr(ctxt, XML_ERR_INTERNAL_ERROR, "cur index out of bound");
2094         return;
2095     }
2096     if ((ctxt->input->cur != NULL) && (*ctxt->input->cur == 0) &&
2097         (xmlParserInputGrow(ctxt->input, INPUT_CHUNK) <= 0))
2098             xmlPopInput(ctxt);
2099 }
2100
2101 #define SKIP_BLANKS xmlSkipBlankChars(ctxt)
2102
2103 #define NEXT xmlNextChar(ctxt)
2104
2105 #define NEXT1 {                                                         \
2106         ctxt->input->col++;                                             \
2107         ctxt->input->cur++;                                             \
2108         ctxt->nbChars++;                                                \
2109         if (*ctxt->input->cur == 0)                                     \
2110             xmlParserInputGrow(ctxt->input, INPUT_CHUNK);               \
2111     }
2112
2113 #define NEXTL(l) do {                                                   \
2114     if (*(ctxt->input->cur) == '\n') {                                  \
2115         ctxt->input->line++; ctxt->input->col = 1;                      \
2116     } else ctxt->input->col++;                                          \
2117     ctxt->input->cur += l;                              \
2118     if (*ctxt->input->cur == '%') xmlParserHandlePEReference(ctxt);     \
2119   } while (0)
2120
2121 #define CUR_CHAR(l) xmlCurrentChar(ctxt, &l)
2122 #define CUR_SCHAR(s, l) xmlStringCurrentChar(ctxt, s, &l)
2123
2124 #define COPY_BUF(l,b,i,v)                                               \
2125     if (l == 1) b[i++] = (xmlChar) v;                                   \
2126     else i += xmlCopyCharMultiByte(&b[i],v)
2127
2128 /**
2129  * xmlSkipBlankChars:
2130  * @ctxt:  the XML parser context
2131  *
2132  * skip all blanks character found at that point in the input streams.
2133  * It pops up finished entities in the process if allowable at that point.
2134  *
2135  * Returns the number of space chars skipped
2136  */
2137
2138 int
2139 xmlSkipBlankChars(xmlParserCtxtPtr ctxt) {
2140     int res = 0;
2141
2142     /*
2143      * It's Okay to use CUR/NEXT here since all the blanks are on
2144      * the ASCII range.
2145      */
2146     if ((ctxt->inputNr == 1) && (ctxt->instate != XML_PARSER_DTD)) {
2147         const xmlChar *cur;
2148         /*
2149          * if we are in the document content, go really fast
2150          */
2151         cur = ctxt->input->cur;
2152         while (IS_BLANK_CH(*cur)) {
2153             if (*cur == '\n') {
2154                 ctxt->input->line++; ctxt->input->col = 1;
2155             } else {
2156                 ctxt->input->col++;
2157             }
2158             cur++;
2159             res++;
2160             if (*cur == 0) {
2161                 ctxt->input->cur = cur;
2162                 xmlParserInputGrow(ctxt->input, INPUT_CHUNK);
2163                 cur = ctxt->input->cur;
2164             }
2165         }
2166         ctxt->input->cur = cur;
2167     } else {
2168         int cur;
2169         do {
2170             cur = CUR;
2171             while ((IS_BLANK_CH(cur) && /* CHECKED tstblanks.xml */
2172                    (ctxt->instate != XML_PARSER_EOF))) {
2173                 NEXT;
2174                 cur = CUR;
2175                 res++;
2176             }
2177             while ((cur == 0) && (ctxt->inputNr > 1) &&
2178                    (ctxt->instate != XML_PARSER_COMMENT)) {
2179                 xmlPopInput(ctxt);
2180                 cur = CUR;
2181             }
2182             /*
2183              * Need to handle support of entities branching here
2184              */
2185             if (*ctxt->input->cur == '%') xmlParserHandlePEReference(ctxt);
2186         } while ((IS_BLANK(cur)) && /* CHECKED tstblanks.xml */
2187                  (ctxt->instate != XML_PARSER_EOF));
2188     }
2189     return(res);
2190 }
2191
2192 /************************************************************************
2193  *                                                                      *
2194  *              Commodity functions to handle entities                  *
2195  *                                                                      *
2196  ************************************************************************/
2197
2198 /**
2199  * xmlPopInput:
2200  * @ctxt:  an XML parser context
2201  *
2202  * xmlPopInput: the current input pointed by ctxt->input came to an end
2203  *          pop it and return the next char.
2204  *
2205  * Returns the current xmlChar in the parser context
2206  */
2207 xmlChar
2208 xmlPopInput(xmlParserCtxtPtr ctxt) {
2209     if ((ctxt == NULL) || (ctxt->inputNr <= 1)) return(0);
2210     if (xmlParserDebugEntities)
2211         xmlGenericError(xmlGenericErrorContext,
2212                 "Popping input %d\n", ctxt->inputNr);
2213     xmlFreeInputStream(inputPop(ctxt));
2214     if ((*ctxt->input->cur == 0) &&
2215         (xmlParserInputGrow(ctxt->input, INPUT_CHUNK) <= 0))
2216             return(xmlPopInput(ctxt));
2217     return(CUR);
2218 }
2219
2220 /**
2221  * xmlPushInput:
2222  * @ctxt:  an XML parser context
2223  * @input:  an XML parser input fragment (entity, XML fragment ...).
2224  *
2225  * xmlPushInput: switch to a new input stream which is stacked on top
2226  *               of the previous one(s).
2227  * Returns -1 in case of error or the index in the input stack
2228  */
2229 int
2230 xmlPushInput(xmlParserCtxtPtr ctxt, xmlParserInputPtr input) {
2231     int ret;
2232     if (input == NULL) return(-1);
2233
2234     if (xmlParserDebugEntities) {
2235         if ((ctxt->input != NULL) && (ctxt->input->filename))
2236             xmlGenericError(xmlGenericErrorContext,
2237                     "%s(%d): ", ctxt->input->filename,
2238                     ctxt->input->line);
2239         xmlGenericError(xmlGenericErrorContext,
2240                 "Pushing input %d : %.30s\n", ctxt->inputNr+1, input->cur);
2241     }
2242     ret = inputPush(ctxt, input);
2243     if (ctxt->instate == XML_PARSER_EOF)
2244         return(-1);
2245     GROW;
2246     return(ret);
2247 }
2248
2249 /**
2250  * xmlParseCharRef:
2251  * @ctxt:  an XML parser context
2252  *
2253  * parse Reference declarations
2254  *
2255  * [66] CharRef ::= '&#' [0-9]+ ';' |
2256  *                  '&#x' [0-9a-fA-F]+ ';'
2257  *
2258  * [ WFC: Legal Character ]
2259  * Characters referred to using character references must match the
2260  * production for Char.
2261  *
2262  * Returns the value parsed (as an int), 0 in case of error
2263  */
2264 int
2265 xmlParseCharRef(xmlParserCtxtPtr ctxt) {
2266     unsigned int val = 0;
2267     int count = 0;
2268     unsigned int outofrange = 0;
2269
2270     /*
2271      * Using RAW/CUR/NEXT is okay since we are working on ASCII range here
2272      */
2273     if ((RAW == '&') && (NXT(1) == '#') &&
2274         (NXT(2) == 'x')) {
2275         SKIP(3);
2276         GROW;
2277         while (RAW != ';') { /* loop blocked by count */
2278             if (count++ > 20) {
2279                 count = 0;
2280                 GROW;
2281                 if (ctxt->instate == XML_PARSER_EOF)
2282                     return(0);
2283             }
2284             if ((RAW >= '0') && (RAW <= '9'))
2285                 val = val * 16 + (CUR - '0');
2286             else if ((RAW >= 'a') && (RAW <= 'f') && (count < 20))
2287                 val = val * 16 + (CUR - 'a') + 10;
2288             else if ((RAW >= 'A') && (RAW <= 'F') && (count < 20))
2289                 val = val * 16 + (CUR - 'A') + 10;
2290             else {
2291                 xmlFatalErr(ctxt, XML_ERR_INVALID_HEX_CHARREF, NULL);
2292                 val = 0;
2293                 break;
2294             }
2295             if (val > 0x10FFFF)
2296                 outofrange = val;
2297
2298             NEXT;
2299             count++;
2300         }
2301         if (RAW == ';') {
2302             /* on purpose to avoid reentrancy problems with NEXT and SKIP */
2303             ctxt->input->col++;
2304             ctxt->nbChars ++;
2305             ctxt->input->cur++;
2306         }
2307     } else if  ((RAW == '&') && (NXT(1) == '#')) {
2308         SKIP(2);
2309         GROW;
2310         while (RAW != ';') { /* loop blocked by count */
2311             if (count++ > 20) {
2312                 count = 0;
2313                 GROW;
2314                 if (ctxt->instate == XML_PARSER_EOF)
2315                     return(0);
2316             }
2317             if ((RAW >= '0') && (RAW <= '9'))
2318                 val = val * 10 + (CUR - '0');
2319             else {
2320                 xmlFatalErr(ctxt, XML_ERR_INVALID_DEC_CHARREF, NULL);
2321                 val = 0;
2322                 break;
2323             }
2324             if (val > 0x10FFFF)
2325                 outofrange = val;
2326
2327             NEXT;
2328             count++;
2329         }
2330         if (RAW == ';') {
2331             /* on purpose to avoid reentrancy problems with NEXT and SKIP */
2332             ctxt->input->col++;
2333             ctxt->nbChars ++;
2334             ctxt->input->cur++;
2335         }
2336     } else {
2337         xmlFatalErr(ctxt, XML_ERR_INVALID_CHARREF, NULL);
2338     }
2339
2340     /*
2341      * [ WFC: Legal Character ]
2342      * Characters referred to using character references must match the
2343      * production for Char.
2344      */
2345     if ((IS_CHAR(val) && (outofrange == 0))) {
2346         return(val);
2347     } else {
2348         xmlFatalErrMsgInt(ctxt, XML_ERR_INVALID_CHAR,
2349                           "xmlParseCharRef: invalid xmlChar value %d\n",
2350                           val);
2351     }
2352     return(0);
2353 }
2354
2355 /**
2356  * xmlParseStringCharRef:
2357  * @ctxt:  an XML parser context
2358  * @str:  a pointer to an index in the string
2359  *
2360  * parse Reference declarations, variant parsing from a string rather
2361  * than an an input flow.
2362  *
2363  * [66] CharRef ::= '&#' [0-9]+ ';' |
2364  *                  '&#x' [0-9a-fA-F]+ ';'
2365  *
2366  * [ WFC: Legal Character ]
2367  * Characters referred to using character references must match the
2368  * production for Char.
2369  *
2370  * Returns the value parsed (as an int), 0 in case of error, str will be
2371  *         updated to the current value of the index
2372  */
2373 static int
2374 xmlParseStringCharRef(xmlParserCtxtPtr ctxt, const xmlChar **str) {
2375     const xmlChar *ptr;
2376     xmlChar cur;
2377     unsigned int val = 0;
2378     unsigned int outofrange = 0;
2379
2380     if ((str == NULL) || (*str == NULL)) return(0);
2381     ptr = *str;
2382     cur = *ptr;
2383     if ((cur == '&') && (ptr[1] == '#') && (ptr[2] == 'x')) {
2384         ptr += 3;
2385         cur = *ptr;
2386         while (cur != ';') { /* Non input consuming loop */
2387             if ((cur >= '0') && (cur <= '9'))
2388                 val = val * 16 + (cur - '0');
2389             else if ((cur >= 'a') && (cur <= 'f'))
2390                 val = val * 16 + (cur - 'a') + 10;
2391             else if ((cur >= 'A') && (cur <= 'F'))
2392                 val = val * 16 + (cur - 'A') + 10;
2393             else {
2394                 xmlFatalErr(ctxt, XML_ERR_INVALID_HEX_CHARREF, NULL);
2395                 val = 0;
2396                 break;
2397             }
2398             if (val > 0x10FFFF)
2399                 outofrange = val;
2400
2401             ptr++;
2402             cur = *ptr;
2403         }
2404         if (cur == ';')
2405             ptr++;
2406     } else if  ((cur == '&') && (ptr[1] == '#')){
2407         ptr += 2;
2408         cur = *ptr;
2409         while (cur != ';') { /* Non input consuming loops */
2410             if ((cur >= '0') && (cur <= '9'))
2411                 val = val * 10 + (cur - '0');
2412             else {
2413                 xmlFatalErr(ctxt, XML_ERR_INVALID_DEC_CHARREF, NULL);
2414                 val = 0;
2415                 break;
2416             }
2417             if (val > 0x10FFFF)
2418                 outofrange = val;
2419
2420             ptr++;
2421             cur = *ptr;
2422         }
2423         if (cur == ';')
2424             ptr++;
2425     } else {
2426         xmlFatalErr(ctxt, XML_ERR_INVALID_CHARREF, NULL);
2427         return(0);
2428     }
2429     *str = ptr;
2430
2431     /*
2432      * [ WFC: Legal Character ]
2433      * Characters referred to using character references must match the
2434      * production for Char.
2435      */
2436     if ((IS_CHAR(val) && (outofrange == 0))) {
2437         return(val);
2438     } else {
2439         xmlFatalErrMsgInt(ctxt, XML_ERR_INVALID_CHAR,
2440                           "xmlParseStringCharRef: invalid xmlChar value %d\n",
2441                           val);
2442     }
2443     return(0);
2444 }
2445
2446 /**
2447  * xmlNewBlanksWrapperInputStream:
2448  * @ctxt:  an XML parser context
2449  * @entity:  an Entity pointer
2450  *
2451  * Create a new input stream for wrapping
2452  * blanks around a PEReference
2453  *
2454  * Returns the new input stream or NULL
2455  */
2456
2457 static void deallocblankswrapper (xmlChar *str) {xmlFree(str);}
2458
2459 static xmlParserInputPtr
2460 xmlNewBlanksWrapperInputStream(xmlParserCtxtPtr ctxt, xmlEntityPtr entity) {
2461     xmlParserInputPtr input;
2462     xmlChar *buffer;
2463     size_t length;
2464     if (entity == NULL) {
2465         xmlFatalErr(ctxt, XML_ERR_INTERNAL_ERROR,
2466                     "xmlNewBlanksWrapperInputStream entity\n");
2467         return(NULL);
2468     }
2469     if (xmlParserDebugEntities)
2470         xmlGenericError(xmlGenericErrorContext,
2471                 "new blanks wrapper for entity: %s\n", entity->name);
2472     input = xmlNewInputStream(ctxt);
2473     if (input == NULL) {
2474         return(NULL);
2475     }
2476     length = xmlStrlen(entity->name) + 5;
2477     buffer = xmlMallocAtomic(length);
2478     if (buffer == NULL) {
2479         xmlErrMemory(ctxt, NULL);
2480         xmlFree(input);
2481         return(NULL);
2482     }
2483     buffer [0] = ' ';
2484     buffer [1] = '%';
2485     buffer [length-3] = ';';
2486     buffer [length-2] = ' ';
2487     buffer [length-1] = 0;
2488     memcpy(buffer + 2, entity->name, length - 5);
2489     input->free = deallocblankswrapper;
2490     input->base = buffer;
2491     input->cur = buffer;
2492     input->length = length;
2493     input->end = &buffer[length];
2494     return(input);
2495 }
2496
2497 /**
2498  * xmlParserHandlePEReference:
2499  * @ctxt:  the parser context
2500  *
2501  * [69] PEReference ::= '%' Name ';'
2502  *
2503  * [ WFC: No Recursion ]
2504  * A parsed entity must not contain a recursive
2505  * reference to itself, either directly or indirectly.
2506  *
2507  * [ WFC: Entity Declared ]
2508  * In a document without any DTD, a document with only an internal DTD
2509  * subset which contains no parameter entity references, or a document
2510  * with "standalone='yes'", ...  ... The declaration of a parameter
2511  * entity must precede any reference to it...
2512  *
2513  * [ VC: Entity Declared ]
2514  * In a document with an external subset or external parameter entities
2515  * with "standalone='no'", ...  ... The declaration of a parameter entity
2516  * must precede any reference to it...
2517  *
2518  * [ WFC: In DTD ]
2519  * Parameter-entity references may only appear in the DTD.
2520  * NOTE: misleading but this is handled.
2521  *
2522  * A PEReference may have been detected in the current input stream
2523  * the handling is done accordingly to
2524  *      http://www.w3.org/TR/REC-xml#entproc
2525  * i.e.
2526  *   - Included in literal in entity values
2527  *   - Included as Parameter Entity reference within DTDs
2528  */
2529 void
2530 xmlParserHandlePEReference(xmlParserCtxtPtr ctxt) {
2531     const xmlChar *name;
2532     xmlEntityPtr entity = NULL;
2533     xmlParserInputPtr input;
2534
2535     if (RAW != '%') return;
2536     switch(ctxt->instate) {
2537         case XML_PARSER_CDATA_SECTION:
2538             return;
2539         case XML_PARSER_COMMENT:
2540             return;
2541         case XML_PARSER_START_TAG:
2542             return;
2543         case XML_PARSER_END_TAG:
2544             return;
2545         case XML_PARSER_EOF:
2546             xmlFatalErr(ctxt, XML_ERR_PEREF_AT_EOF, NULL);
2547             return;
2548         case XML_PARSER_PROLOG:
2549         case XML_PARSER_START:
2550         case XML_PARSER_MISC:
2551             xmlFatalErr(ctxt, XML_ERR_PEREF_IN_PROLOG, NULL);
2552             return;
2553         case XML_PARSER_ENTITY_DECL:
2554         case XML_PARSER_CONTENT:
2555         case XML_PARSER_ATTRIBUTE_VALUE:
2556         case XML_PARSER_PI:
2557         case XML_PARSER_SYSTEM_LITERAL:
2558         case XML_PARSER_PUBLIC_LITERAL:
2559             /* we just ignore it there */
2560             return;
2561         case XML_PARSER_EPILOG:
2562             xmlFatalErr(ctxt, XML_ERR_PEREF_IN_EPILOG, NULL);
2563             return;
2564         case XML_PARSER_ENTITY_VALUE:
2565             /*
2566              * NOTE: in the case of entity values, we don't do the
2567              *       substitution here since we need the literal
2568              *       entity value to be able to save the internal
2569              *       subset of the document.
2570              *       This will be handled by xmlStringDecodeEntities
2571              */
2572             return;
2573         case XML_PARSER_DTD:
2574             /*
2575              * [WFC: Well-Formedness Constraint: PEs in Internal Subset]
2576              * In the internal DTD subset, parameter-entity references
2577              * can occur only where markup declarations can occur, not
2578              * within markup declarations.
2579              * In that case this is handled in xmlParseMarkupDecl
2580              */
2581             if ((ctxt->external == 0) && (ctxt->inputNr == 1))
2582                 return;
2583             if (IS_BLANK_CH(NXT(1)) || NXT(1) == 0)
2584                 return;
2585             break;
2586         case XML_PARSER_IGNORE:
2587             return;
2588     }
2589
2590     NEXT;
2591     name = xmlParseName(ctxt);
2592     if (xmlParserDebugEntities)
2593         xmlGenericError(xmlGenericErrorContext,
2594                 "PEReference: %s\n", name);
2595     if (name == NULL) {
2596         xmlFatalErr(ctxt, XML_ERR_PEREF_NO_NAME, NULL);
2597     } else {
2598         if (RAW == ';') {
2599             NEXT;
2600             if ((ctxt->sax != NULL) && (ctxt->sax->getParameterEntity != NULL))
2601                 entity = ctxt->sax->getParameterEntity(ctxt->userData, name);
2602             if (ctxt->instate == XML_PARSER_EOF)
2603                 return;
2604             if (entity == NULL) {
2605
2606                 /*
2607                  * [ WFC: Entity Declared ]
2608                  * In a document without any DTD, a document with only an
2609                  * internal DTD subset which contains no parameter entity
2610                  * references, or a document with "standalone='yes'", ...
2611                  * ... The declaration of a parameter entity must precede
2612                  * any reference to it...
2613                  */
2614                 if ((ctxt->standalone == 1) ||
2615                     ((ctxt->hasExternalSubset == 0) &&
2616                      (ctxt->hasPErefs == 0))) {
2617                     xmlFatalErrMsgStr(ctxt, XML_ERR_UNDECLARED_ENTITY,
2618                          "PEReference: %%%s; not found\n", name);
2619                 } else {
2620                     /*
2621                      * [ VC: Entity Declared ]
2622                      * In a document with an external subset or external
2623                      * parameter entities with "standalone='no'", ...
2624                      * ... The declaration of a parameter entity must precede
2625                      * any reference to it...
2626                      */
2627                     if ((ctxt->validate) && (ctxt->vctxt.error != NULL)) {
2628                         xmlValidityError(ctxt, XML_WAR_UNDECLARED_ENTITY,
2629                                          "PEReference: %%%s; not found\n",
2630                                          name, NULL);
2631                     } else
2632                         xmlWarningMsg(ctxt, XML_WAR_UNDECLARED_ENTITY,
2633                                       "PEReference: %%%s; not found\n",
2634                                       name, NULL);
2635                     ctxt->valid = 0;
2636                 }
2637                 xmlParserEntityCheck(ctxt, 0, NULL, 0);
2638             } else if (ctxt->input->free != deallocblankswrapper) {
2639                     input = xmlNewBlanksWrapperInputStream(ctxt, entity);
2640                     if (xmlPushInput(ctxt, input) < 0)
2641                         return;
2642             } else {
2643                 if ((entity->etype == XML_INTERNAL_PARAMETER_ENTITY) ||
2644                     (entity->etype == XML_EXTERNAL_PARAMETER_ENTITY)) {
2645                     xmlChar start[4];
2646                     xmlCharEncoding enc;
2647
2648                     /*
2649                      * Note: external parameter entities will not be loaded, it
2650                      * is not required for a non-validating parser, unless the
2651                      * option of validating, or substituting entities were
2652                      * given. Doing so is far more secure as the parser will
2653                      * only process data coming from the document entity by
2654                      * default.
2655                      */
2656                     if ((entity->etype == XML_EXTERNAL_PARAMETER_ENTITY) &&
2657                         ((ctxt->options & XML_PARSE_NOENT) == 0) &&
2658                         ((ctxt->options & XML_PARSE_DTDVALID) == 0) &&
2659                         ((ctxt->options & XML_PARSE_DTDLOAD) == 0) &&
2660                         ((ctxt->options & XML_PARSE_DTDATTR) == 0) &&
2661                         (ctxt->replaceEntities == 0) &&
2662                         (ctxt->validate == 0))
2663                         return;
2664
2665                     /*
2666                      * handle the extra spaces added before and after
2667                      * c.f. http://www.w3.org/TR/REC-xml#as-PE
2668                      * this is done independently.
2669                      */
2670                     input = xmlNewEntityInputStream(ctxt, entity);
2671                     if (xmlPushInput(ctxt, input) < 0)
2672                         return;
2673
2674                     /*
2675                      * Get the 4 first bytes and decode the charset
2676                      * if enc != XML_CHAR_ENCODING_NONE
2677                      * plug some encoding conversion routines.
2678                      * Note that, since we may have some non-UTF8
2679                      * encoding (like UTF16, bug 135229), the 'length'
2680                      * is not known, but we can calculate based upon
2681                      * the amount of data in the buffer.
2682                      */
2683                     GROW
2684                     if (ctxt->instate == XML_PARSER_EOF)
2685                         return;
2686                     if ((ctxt->input->end - ctxt->input->cur)>=4) {
2687                         start[0] = RAW;
2688                         start[1] = NXT(1);
2689                         start[2] = NXT(2);
2690                         start[3] = NXT(3);
2691                         enc = xmlDetectCharEncoding(start, 4);
2692                         if (enc != XML_CHAR_ENCODING_NONE) {
2693                             xmlSwitchEncoding(ctxt, enc);
2694                         }
2695                     }
2696
2697                     if ((entity->etype == XML_EXTERNAL_PARAMETER_ENTITY) &&
2698                         (CMP5(CUR_PTR, '<', '?', 'x', 'm', 'l' )) &&
2699                         (IS_BLANK_CH(NXT(5)))) {
2700                         xmlParseTextDecl(ctxt);
2701                     }
2702                 } else {
2703                     xmlFatalErrMsgStr(ctxt, XML_ERR_ENTITY_IS_PARAMETER,
2704                              "PEReference: %s is not a parameter entity\n",
2705                                       name);
2706                 }
2707             }
2708         } else {
2709             xmlFatalErr(ctxt, XML_ERR_PEREF_SEMICOL_MISSING, NULL);
2710         }
2711     }
2712 }
2713
2714 /*
2715  * Macro used to grow the current buffer.
2716  * buffer##_size is expected to be a size_t
2717  * mem_error: is expected to handle memory allocation failures
2718  */
2719 #define growBuffer(buffer, n) {                                         \
2720     xmlChar *tmp;                                                       \
2721     size_t new_size = buffer##_size * 2 + n;                            \
2722     if (new_size < buffer##_size) goto mem_error;                       \
2723     tmp = (xmlChar *) xmlRealloc(buffer, new_size);                     \
2724     if (tmp == NULL) goto mem_error;                                    \
2725     buffer = tmp;                                                       \
2726     buffer##_size = new_size;                                           \
2727 }
2728
2729 /**
2730  * xmlStringLenDecodeEntities:
2731  * @ctxt:  the parser context
2732  * @str:  the input string
2733  * @len: the string length
2734  * @what:  combination of XML_SUBSTITUTE_REF and XML_SUBSTITUTE_PEREF
2735  * @end:  an end marker xmlChar, 0 if none
2736  * @end2:  an end marker xmlChar, 0 if none
2737  * @end3:  an end marker xmlChar, 0 if none
2738  *
2739  * Takes a entity string content and process to do the adequate substitutions.
2740  *
2741  * [67] Reference ::= EntityRef | CharRef
2742  *
2743  * [69] PEReference ::= '%' Name ';'
2744  *
2745  * Returns A newly allocated string with the substitution done. The caller
2746  *      must deallocate it !
2747  */
2748 xmlChar *
2749 xmlStringLenDecodeEntities(xmlParserCtxtPtr ctxt, const xmlChar *str, int len,
2750                       int what, xmlChar end, xmlChar  end2, xmlChar end3) {
2751     xmlChar *buffer = NULL;
2752     size_t buffer_size = 0;
2753     size_t nbchars = 0;
2754
2755     xmlChar *current = NULL;
2756     xmlChar *rep = NULL;
2757     const xmlChar *last;
2758     xmlEntityPtr ent;
2759     int c,l;
2760
2761     if ((ctxt == NULL) || (str == NULL) || (len < 0))
2762         return(NULL);
2763     last = str + len;
2764
2765     if (((ctxt->depth > 40) &&
2766          ((ctxt->options & XML_PARSE_HUGE) == 0)) ||
2767         (ctxt->depth > 1024)) {
2768         xmlFatalErr(ctxt, XML_ERR_ENTITY_LOOP, NULL);
2769         return(NULL);
2770     }
2771
2772     /*
2773      * allocate a translation buffer.
2774      */
2775     buffer_size = XML_PARSER_BIG_BUFFER_SIZE;
2776     buffer = (xmlChar *) xmlMallocAtomic(buffer_size);
2777     if (buffer == NULL) goto mem_error;
2778
2779     /*
2780      * OK loop until we reach one of the ending char or a size limit.
2781      * we are operating on already parsed values.
2782      */
2783     if (str < last)
2784         c = CUR_SCHAR(str, l);
2785     else
2786         c = 0;
2787     while ((c != 0) && (c != end) && /* non input consuming loop */
2788            (c != end2) && (c != end3)) {
2789
2790         if (c == 0) break;
2791         if ((c == '&') && (str[1] == '#')) {
2792             int val = xmlParseStringCharRef(ctxt, &str);
2793             if (val != 0) {
2794                 COPY_BUF(0,buffer,nbchars,val);
2795             }
2796             if (nbchars + XML_PARSER_BUFFER_SIZE > buffer_size) {
2797                 growBuffer(buffer, XML_PARSER_BUFFER_SIZE);
2798             }
2799         } else if ((c == '&') && (what & XML_SUBSTITUTE_REF)) {
2800             if (xmlParserDebugEntities)
2801                 xmlGenericError(xmlGenericErrorContext,
2802                         "String decoding Entity Reference: %.30s\n",
2803                         str);
2804             ent = xmlParseStringEntityRef(ctxt, &str);
2805             if ((ctxt->lastError.code == XML_ERR_ENTITY_LOOP) ||
2806                 (ctxt->lastError.code == XML_ERR_INTERNAL_ERROR))
2807                 goto int_error;
2808             xmlParserEntityCheck(ctxt, 0, ent, 0);
2809             if (ent != NULL)
2810                 ctxt->nbentities += ent->checked / 2;
2811             if ((ent != NULL) &&
2812                 (ent->etype == XML_INTERNAL_PREDEFINED_ENTITY)) {
2813                 if (ent->content != NULL) {
2814                     COPY_BUF(0,buffer,nbchars,ent->content[0]);
2815                     if (nbchars + XML_PARSER_BUFFER_SIZE > buffer_size) {
2816                         growBuffer(buffer, XML_PARSER_BUFFER_SIZE);
2817                     }
2818                 } else {
2819                     xmlFatalErrMsg(ctxt, XML_ERR_INTERNAL_ERROR,
2820                             "predefined entity has no content\n");
2821                 }
2822             } else if ((ent != NULL) && (ent->content != NULL)) {
2823                 ctxt->depth++;
2824                 rep = xmlStringDecodeEntities(ctxt, ent->content, what,
2825                                               0, 0, 0);
2826                 ctxt->depth--;
2827
2828                 if ((ctxt->lastError.code == XML_ERR_ENTITY_LOOP) ||
2829                     (ctxt->lastError.code == XML_ERR_INTERNAL_ERROR))
2830                     goto int_error;
2831
2832                 if (rep != NULL) {
2833                     current = rep;
2834                     while (*current != 0) { /* non input consuming loop */
2835                         buffer[nbchars++] = *current++;
2836                         if (nbchars + XML_PARSER_BUFFER_SIZE > buffer_size) {
2837                             if (xmlParserEntityCheck(ctxt, nbchars, ent, 0))
2838                                 goto int_error;
2839                             growBuffer(buffer, XML_PARSER_BUFFER_SIZE);
2840                         }
2841                     }
2842                     xmlFree(rep);
2843                     rep = NULL;
2844                 }
2845             } else if (ent != NULL) {
2846                 int i = xmlStrlen(ent->name);
2847                 const xmlChar *cur = ent->name;
2848
2849                 buffer[nbchars++] = '&';
2850                 if (nbchars + i + XML_PARSER_BUFFER_SIZE > buffer_size) {
2851                     growBuffer(buffer, i + XML_PARSER_BUFFER_SIZE);
2852                 }
2853                 for (;i > 0;i--)
2854                     buffer[nbchars++] = *cur++;
2855                 buffer[nbchars++] = ';';
2856             }
2857         } else if (c == '%' && (what & XML_SUBSTITUTE_PEREF)) {
2858             if (xmlParserDebugEntities)
2859                 xmlGenericError(xmlGenericErrorContext,
2860                         "String decoding PE Reference: %.30s\n", str);
2861             ent = xmlParseStringPEReference(ctxt, &str);
2862             if (ctxt->lastError.code == XML_ERR_ENTITY_LOOP)
2863                 goto int_error;
2864             xmlParserEntityCheck(ctxt, 0, ent, 0);
2865             if (ent != NULL)
2866                 ctxt->nbentities += ent->checked / 2;
2867             if (ent != NULL) {
2868                 if (ent->content == NULL) {
2869                     /*
2870                      * Note: external parsed entities will not be loaded,
2871                      * it is not required for a non-validating parser to
2872                      * complete external PEreferences coming from the
2873                      * internal subset
2874                      */
2875                     if (((ctxt->options & XML_PARSE_NOENT) != 0) ||
2876                         ((ctxt->options & XML_PARSE_DTDVALID) != 0) ||
2877                         (ctxt->validate != 0)) {
2878                         xmlLoadEntityContent(ctxt, ent);
2879                     } else {
2880                         xmlWarningMsg(ctxt, XML_ERR_ENTITY_PROCESSING,
2881                   "not validating will not read content for PE entity %s\n",
2882                                       ent->name, NULL);
2883                     }
2884                 }
2885                 ctxt->depth++;
2886                 rep = xmlStringDecodeEntities(ctxt, ent->content, what,
2887                                               0, 0, 0);
2888                 ctxt->depth--;
2889                 if (rep != NULL) {
2890                     current = rep;
2891                     while (*current != 0) { /* non input consuming loop */
2892                         buffer[nbchars++] = *current++;
2893                         if (nbchars + XML_PARSER_BUFFER_SIZE > buffer_size) {
2894                             if (xmlParserEntityCheck(ctxt, nbchars, ent, 0))
2895                                 goto int_error;
2896                             growBuffer(buffer, XML_PARSER_BUFFER_SIZE);
2897                         }
2898                     }
2899                     xmlFree(rep);
2900                     rep = NULL;
2901                 }
2902             }
2903         } else {
2904             COPY_BUF(l,buffer,nbchars,c);
2905             str += l;
2906             if (nbchars + XML_PARSER_BUFFER_SIZE > buffer_size) {
2907                 growBuffer(buffer, XML_PARSER_BUFFER_SIZE);
2908             }
2909         }
2910         if (str < last)
2911             c = CUR_SCHAR(str, l);
2912         else
2913             c = 0;
2914     }
2915     buffer[nbchars] = 0;
2916     return(buffer);
2917
2918 mem_error:
2919     xmlErrMemory(ctxt, NULL);
2920 int_error:
2921     if (rep != NULL)
2922         xmlFree(rep);
2923     if (buffer != NULL)
2924         xmlFree(buffer);
2925     return(NULL);
2926 }
2927
2928 /**
2929  * xmlStringDecodeEntities:
2930  * @ctxt:  the parser context
2931  * @str:  the input string
2932  * @what:  combination of XML_SUBSTITUTE_REF and XML_SUBSTITUTE_PEREF
2933  * @end:  an end marker xmlChar, 0 if none
2934  * @end2:  an end marker xmlChar, 0 if none
2935  * @end3:  an end marker xmlChar, 0 if none
2936  *
2937  * Takes a entity string content and process to do the adequate substitutions.
2938  *
2939  * [67] Reference ::= EntityRef | CharRef
2940  *
2941  * [69] PEReference ::= '%' Name ';'
2942  *
2943  * Returns A newly allocated string with the substitution done. The caller
2944  *      must deallocate it !
2945  */
2946 xmlChar *
2947 xmlStringDecodeEntities(xmlParserCtxtPtr ctxt, const xmlChar *str, int what,
2948                         xmlChar end, xmlChar  end2, xmlChar end3) {
2949     if ((ctxt == NULL) || (str == NULL)) return(NULL);
2950     return(xmlStringLenDecodeEntities(ctxt, str, xmlStrlen(str), what,
2951            end, end2, end3));
2952 }
2953
2954 /************************************************************************
2955  *                                                                      *
2956  *              Commodity functions, cleanup needed ?                   *
2957  *                                                                      *
2958  ************************************************************************/
2959
2960 /**
2961  * areBlanks:
2962  * @ctxt:  an XML parser context
2963  * @str:  a xmlChar *
2964  * @len:  the size of @str
2965  * @blank_chars: we know the chars are blanks
2966  *
2967  * Is this a sequence of blank chars that one can ignore ?
2968  *
2969  * Returns 1 if ignorable 0 otherwise.
2970  */
2971
2972 static int areBlanks(xmlParserCtxtPtr ctxt, const xmlChar *str, int len,
2973                      int blank_chars) {
2974     int i, ret;
2975     xmlNodePtr lastChild;
2976
2977     /*
2978      * Don't spend time trying to differentiate them, the same callback is
2979      * used !
2980      */
2981     if (ctxt->sax->ignorableWhitespace == ctxt->sax->characters)
2982         return(0);
2983
2984     /*
2985      * Check for xml:space value.
2986      */
2987     if ((ctxt->space == NULL) || (*(ctxt->space) == 1) ||
2988         (*(ctxt->space) == -2))
2989         return(0);
2990
2991     /*
2992      * Check that the string is made of blanks
2993      */
2994     if (blank_chars == 0) {
2995         for (i = 0;i < len;i++)
2996             if (!(IS_BLANK_CH(str[i]))) return(0);
2997     }
2998
2999     /*
3000      * Look if the element is mixed content in the DTD if available
3001      */
3002     if (ctxt->node == NULL) return(0);
3003     if (ctxt->myDoc != NULL) {
3004         ret = xmlIsMixedElement(ctxt->myDoc, ctxt->node->name);
3005         if (ret == 0) return(1);
3006         if (ret == 1) return(0);
3007     }
3008
3009     /*
3010      * Otherwise, heuristic :-\
3011      */
3012     if ((RAW != '<') && (RAW != 0xD)) return(0);
3013     if ((ctxt->node->children == NULL) &&
3014         (RAW == '<') && (NXT(1) == '/')) return(0);
3015
3016     lastChild = xmlGetLastChild(ctxt->node);
3017     if (lastChild == NULL) {
3018         if ((ctxt->node->type != XML_ELEMENT_NODE) &&
3019             (ctxt->node->content != NULL)) return(0);
3020     } else if (xmlNodeIsText(lastChild))
3021         return(0);
3022     else if ((ctxt->node->children != NULL) &&
3023              (xmlNodeIsText(ctxt->node->children)))
3024         return(0);
3025     return(1);
3026 }
3027
3028 /************************************************************************
3029  *                                                                      *
3030  *              Extra stuff for namespace support                       *
3031  *      Relates to http://www.w3.org/TR/WD-xml-names                    *
3032  *                                                                      *
3033  ************************************************************************/
3034
3035 /**
3036  * xmlSplitQName:
3037  * @ctxt:  an XML parser context
3038  * @name:  an XML parser context
3039  * @prefix:  a xmlChar **
3040  *
3041  * parse an UTF8 encoded XML qualified name string
3042  *
3043  * [NS 5] QName ::= (Prefix ':')? LocalPart
3044  *
3045  * [NS 6] Prefix ::= NCName
3046  *
3047  * [NS 7] LocalPart ::= NCName
3048  *
3049  * Returns the local part, and prefix is updated
3050  *   to get the Prefix if any.
3051  */
3052
3053 xmlChar *
3054 xmlSplitQName(xmlParserCtxtPtr ctxt, const xmlChar *name, xmlChar **prefix) {
3055     xmlChar buf[XML_MAX_NAMELEN + 5];
3056     xmlChar *buffer = NULL;
3057     int len = 0;
3058     int max = XML_MAX_NAMELEN;
3059     xmlChar *ret = NULL;
3060     const xmlChar *cur = name;
3061     int c;
3062
3063     if (prefix == NULL) return(NULL);
3064     *prefix = NULL;
3065
3066     if (cur == NULL) return(NULL);
3067
3068 #ifndef XML_XML_NAMESPACE
3069     /* xml: prefix is not really a namespace */
3070     if ((cur[0] == 'x') && (cur[1] == 'm') &&
3071         (cur[2] == 'l') && (cur[3] == ':'))
3072         return(xmlStrdup(name));
3073 #endif
3074
3075     /* nasty but well=formed */
3076     if (cur[0] == ':')
3077         return(xmlStrdup(name));
3078
3079     c = *cur++;
3080     while ((c != 0) && (c != ':') && (len < max)) { /* tested bigname.xml */
3081         buf[len++] = c;
3082         c = *cur++;
3083     }
3084     if (len >= max) {
3085         /*
3086          * Okay someone managed to make a huge name, so he's ready to pay
3087          * for the processing speed.
3088          */
3089         max = len * 2;
3090
3091         buffer = (xmlChar *) xmlMallocAtomic(max * sizeof(xmlChar));
3092         if (buffer == NULL) {
3093             xmlErrMemory(ctxt, NULL);
3094             return(NULL);
3095         }
3096         memcpy(buffer, buf, len);
3097         while ((c != 0) && (c != ':')) { /* tested bigname.xml */
3098             if (len + 10 > max) {
3099                 xmlChar *tmp;
3100
3101                 max *= 2;
3102                 tmp = (xmlChar *) xmlRealloc(buffer,
3103                                                 max * sizeof(xmlChar));
3104                 if (tmp == NULL) {
3105                     xmlFree(buffer);
3106                     xmlErrMemory(ctxt, NULL);
3107                     return(NULL);
3108                 }
3109                 buffer = tmp;
3110             }
3111             buffer[len++] = c;
3112             c = *cur++;
3113         }
3114         buffer[len] = 0;
3115     }
3116
3117     if ((c == ':') && (*cur == 0)) {
3118         if (buffer != NULL)
3119             xmlFree(buffer);
3120         *prefix = NULL;
3121         return(xmlStrdup(name));
3122     }
3123
3124     if (buffer == NULL)
3125         ret = xmlStrndup(buf, len);
3126     else {
3127         ret = buffer;
3128         buffer = NULL;
3129         max = XML_MAX_NAMELEN;
3130     }
3131
3132
3133     if (c == ':') {
3134         c = *cur;
3135         *prefix = ret;
3136         if (c == 0) {
3137             return(xmlStrndup(BAD_CAST "", 0));
3138         }
3139         len = 0;
3140
3141         /*
3142          * Check that the first character is proper to start
3143          * a new name
3144          */
3145         if (!(((c >= 0x61) && (c <= 0x7A)) ||
3146               ((c >= 0x41) && (c <= 0x5A)) ||
3147               (c == '_') || (c == ':'))) {
3148             int l;
3149             int first = CUR_SCHAR(cur, l);
3150
3151             if (!IS_LETTER(first) && (first != '_')) {
3152                 xmlFatalErrMsgStr(ctxt, XML_NS_ERR_QNAME,
3153                             "Name %s is not XML Namespace compliant\n",
3154                                   name);
3155             }
3156         }
3157         cur++;
3158
3159         while ((c != 0) && (len < max)) { /* tested bigname2.xml */
3160             buf[len++] = c;
3161             c = *cur++;
3162         }
3163         if (len >= max) {
3164             /*
3165              * Okay someone managed to make a huge name, so he's ready to pay
3166              * for the processing speed.
3167              */
3168             max = len * 2;
3169
3170             buffer = (xmlChar *) xmlMallocAtomic(max * sizeof(xmlChar));
3171             if (buffer == NULL) {
3172                 xmlErrMemory(ctxt, NULL);
3173                 return(NULL);
3174             }
3175             memcpy(buffer, buf, len);
3176             while (c != 0) { /* tested bigname2.xml */
3177                 if (len + 10 > max) {
3178                     xmlChar *tmp;
3179
3180                     max *= 2;
3181                     tmp = (xmlChar *) xmlRealloc(buffer,
3182                                                     max * sizeof(xmlChar));
3183                     if (tmp == NULL) {
3184                         xmlErrMemory(ctxt, NULL);
3185                         xmlFree(buffer);
3186                         return(NULL);
3187                     }
3188                     buffer = tmp;
3189                 }
3190                 buffer[len++] = c;
3191                 c = *cur++;
3192             }
3193             buffer[len] = 0;
3194         }
3195
3196         if (buffer == NULL)
3197             ret = xmlStrndup(buf, len);
3198         else {
3199             ret = buffer;
3200         }
3201     }
3202
3203     return(ret);
3204 }
3205
3206 /************************************************************************
3207  *                                                                      *
3208  *                      The parser itself                               *
3209  *      Relates to http://www.w3.org/TR/REC-xml                         *
3210  *                                                                      *
3211  ************************************************************************/
3212
3213 /************************************************************************
3214  *                                                                      *
3215  *      Routines to parse Name, NCName and NmToken                      *
3216  *                                                                      *
3217  ************************************************************************/
3218 #ifdef DEBUG
3219 static unsigned long nbParseName = 0;
3220 static unsigned long nbParseNmToken = 0;
3221 static unsigned long nbParseNCName = 0;
3222 static unsigned long nbParseNCNameComplex = 0;
3223 static unsigned long nbParseNameComplex = 0;
3224 static unsigned long nbParseStringName = 0;
3225 #endif
3226
3227 /*
3228  * The two following functions are related to the change of accepted
3229  * characters for Name and NmToken in the Revision 5 of XML-1.0
3230  * They correspond to the modified production [4] and the new production [4a]
3231  * changes in that revision. Also note that the macros used for the
3232  * productions Letter, Digit, CombiningChar and Extender are not needed
3233  * anymore.
3234  * We still keep compatibility to pre-revision5 parsing semantic if the
3235  * new XML_PARSE_OLD10 option is given to the parser.
3236  */
3237 static int
3238 xmlIsNameStartChar(xmlParserCtxtPtr ctxt, int c) {
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(1);
3261     } else {
3262         if (IS_LETTER(c) || (c == '_') || (c == ':'))
3263             return(1);
3264     }
3265     return(0);
3266 }
3267
3268 static int
3269 xmlIsNameChar(xmlParserCtxtPtr ctxt, int c) {
3270     if ((ctxt->options & XML_PARSE_OLD10) == 0) {
3271         /*
3272          * Use the new checks of production [4] [4a] amd [5] of the
3273          * Update 5 of XML-1.0
3274          */
3275         if ((c != ' ') && (c != '>') && (c != '/') && /* accelerators */
3276             (((c >= 'a') && (c <= 'z')) ||
3277              ((c >= 'A') && (c <= 'Z')) ||
3278              ((c >= '0') && (c <= '9')) || /* !start */
3279              (c == '_') || (c == ':') ||
3280              (c == '-') || (c == '.') || (c == 0xB7) || /* !start */
3281              ((c >= 0xC0) && (c <= 0xD6)) ||
3282              ((c >= 0xD8) && (c <= 0xF6)) ||
3283              ((c >= 0xF8) && (c <= 0x2FF)) ||
3284              ((c >= 0x300) && (c <= 0x36F)) || /* !start */
3285              ((c >= 0x370) && (c <= 0x37D)) ||
3286              ((c >= 0x37F) && (c <= 0x1FFF)) ||
3287              ((c >= 0x200C) && (c <= 0x200D)) ||
3288              ((c >= 0x203F) && (c <= 0x2040)) || /* !start */
3289              ((c >= 0x2070) && (c <= 0x218F)) ||
3290              ((c >= 0x2C00) && (c <= 0x2FEF)) ||
3291              ((c >= 0x3001) && (c <= 0xD7FF)) ||
3292              ((c >= 0xF900) && (c <= 0xFDCF)) ||
3293              ((c >= 0xFDF0) && (c <= 0xFFFD)) ||
3294              ((c >= 0x10000) && (c <= 0xEFFFF))))
3295              return(1);
3296     } else {
3297         if ((IS_LETTER(c)) || (IS_DIGIT(c)) ||
3298             (c == '.') || (c == '-') ||
3299             (c == '_') || (c == ':') ||
3300             (IS_COMBINING(c)) ||
3301             (IS_EXTENDER(c)))
3302             return(1);
3303     }
3304     return(0);
3305 }
3306
3307 static xmlChar * xmlParseAttValueInternal(xmlParserCtxtPtr ctxt,
3308                                           int *len, int *alloc, int normalize);
3309
3310 static const xmlChar *
3311 xmlParseNameComplex(xmlParserCtxtPtr ctxt) {
3312     int len = 0, l;
3313     int c;
3314     int count = 0;
3315
3316 #ifdef DEBUG
3317     nbParseNameComplex++;
3318 #endif
3319
3320     /*
3321      * Handler for more complex cases
3322      */
3323     GROW;
3324     if (ctxt->instate == XML_PARSER_EOF)
3325         return(NULL);
3326     c = CUR_CHAR(l);
3327     if ((ctxt->options & XML_PARSE_OLD10) == 0) {
3328         /*
3329          * Use the new checks of production [4] [4a] amd [5] of the
3330          * Update 5 of XML-1.0
3331          */
3332         if ((c == ' ') || (c == '>') || (c == '/') || /* accelerators */
3333             (!(((c >= 'a') && (c <= 'z')) ||
3334                ((c >= 'A') && (c <= 'Z')) ||
3335                (c == '_') || (c == ':') ||
3336                ((c >= 0xC0) && (c <= 0xD6)) ||
3337                ((c >= 0xD8) && (c <= 0xF6)) ||
3338                ((c >= 0xF8) && (c <= 0x2FF)) ||
3339                ((c >= 0x370) && (c <= 0x37D)) ||
3340                ((c >= 0x37F) && (c <= 0x1FFF)) ||
3341                ((c >= 0x200C) && (c <= 0x200D)) ||
3342                ((c >= 0x2070) && (c <= 0x218F)) ||
3343                ((c >= 0x2C00) && (c <= 0x2FEF)) ||
3344                ((c >= 0x3001) && (c <= 0xD7FF)) ||
3345                ((c >= 0xF900) && (c <= 0xFDCF)) ||
3346                ((c >= 0xFDF0) && (c <= 0xFFFD)) ||
3347                ((c >= 0x10000) && (c <= 0xEFFFF))))) {
3348             return(NULL);
3349         }
3350         len += l;
3351         NEXTL(l);
3352         c = CUR_CHAR(l);
3353         while ((c != ' ') && (c != '>') && (c != '/') && /* accelerators */
3354                (((c >= 'a') && (c <= 'z')) ||
3355                 ((c >= 'A') && (c <= 'Z')) ||
3356                 ((c >= '0') && (c <= '9')) || /* !start */
3357                 (c == '_') || (c == ':') ||
3358                 (c == '-') || (c == '.') || (c == 0xB7) || /* !start */
3359                 ((c >= 0xC0) && (c <= 0xD6)) ||
3360                 ((c >= 0xD8) && (c <= 0xF6)) ||
3361                 ((c >= 0xF8) && (c <= 0x2FF)) ||
3362                 ((c >= 0x300) && (c <= 0x36F)) || /* !start */
3363                 ((c >= 0x370) && (c <= 0x37D)) ||
3364                 ((c >= 0x37F) && (c <= 0x1FFF)) ||
3365                 ((c >= 0x200C) && (c <= 0x200D)) ||
3366                 ((c >= 0x203F) && (c <= 0x2040)) || /* !start */
3367                 ((c >= 0x2070) && (c <= 0x218F)) ||
3368                 ((c >= 0x2C00) && (c <= 0x2FEF)) ||
3369                 ((c >= 0x3001) && (c <= 0xD7FF)) ||
3370                 ((c >= 0xF900) && (c <= 0xFDCF)) ||
3371                 ((c >= 0xFDF0) && (c <= 0xFFFD)) ||
3372                 ((c >= 0x10000) && (c <= 0xEFFFF))
3373                 )) {
3374             if (count++ > XML_PARSER_CHUNK_SIZE) {
3375                 count = 0;
3376                 GROW;
3377                 if (ctxt->instate == XML_PARSER_EOF)
3378                     return(NULL);
3379             }
3380             len += l;
3381             NEXTL(l);
3382             c = CUR_CHAR(l);
3383         }
3384     } else {
3385         if ((c == ' ') || (c == '>') || (c == '/') || /* accelerators */
3386             (!IS_LETTER(c) && (c != '_') &&
3387              (c != ':'))) {
3388             return(NULL);
3389         }
3390         len += l;
3391         NEXTL(l);
3392         c = CUR_CHAR(l);
3393
3394         while ((c != ' ') && (c != '>') && (c != '/') && /* test bigname.xml */
3395                ((IS_LETTER(c)) || (IS_DIGIT(c)) ||
3396                 (c == '.') || (c == '-') ||
3397                 (c == '_') || (c == ':') ||
3398                 (IS_COMBINING(c)) ||
3399                 (IS_EXTENDER(c)))) {
3400             if (count++ > XML_PARSER_CHUNK_SIZE) {
3401                 count = 0;
3402                 GROW;
3403                 if (ctxt->instate == XML_PARSER_EOF)
3404                     return(NULL);
3405             }
3406             len += l;
3407             NEXTL(l);
3408             c = CUR_CHAR(l);
3409             if (c == 0) {
3410                 count = 0;
3411                 GROW;
3412                 if (ctxt->instate == XML_PARSER_EOF)
3413                     return(NULL);
3414                 c = CUR_CHAR(l);
3415             }
3416         }
3417     }
3418     if ((len > XML_MAX_NAME_LENGTH) &&
3419         ((ctxt->options & XML_PARSE_HUGE) == 0)) {
3420         xmlFatalErr(ctxt, XML_ERR_NAME_TOO_LONG, "Name");
3421         return(NULL);
3422     }
3423     if ((*ctxt->input->cur == '\n') && (ctxt->input->cur[-1] == '\r'))
3424         return(xmlDictLookup(ctxt->dict, ctxt->input->cur - (len + 1), len));
3425     return(xmlDictLookup(ctxt->dict, ctxt->input->cur - len, len));
3426 }
3427
3428 /**
3429  * xmlParseName:
3430  * @ctxt:  an XML parser context
3431  *
3432  * parse an XML name.
3433  *
3434  * [4] NameChar ::= Letter | Digit | '.' | '-' | '_' | ':' |
3435  *                  CombiningChar | Extender
3436  *
3437  * [5] Name ::= (Letter | '_' | ':') (NameChar)*
3438  *
3439  * [6] Names ::= Name (#x20 Name)*
3440  *
3441  * Returns the Name parsed or NULL
3442  */
3443
3444 const xmlChar *
3445 xmlParseName(xmlParserCtxtPtr ctxt) {
3446     const xmlChar *in;
3447     const xmlChar *ret;
3448     int count = 0;
3449
3450     GROW;
3451
3452 #ifdef DEBUG
3453     nbParseName++;
3454 #endif
3455
3456     /*
3457      * Accelerator for simple ASCII names
3458      */
3459     in = ctxt->input->cur;
3460     if (((*in >= 0x61) && (*in <= 0x7A)) ||
3461         ((*in >= 0x41) && (*in <= 0x5A)) ||
3462         (*in == '_') || (*in == ':')) {
3463         in++;
3464         while (((*in >= 0x61) && (*in <= 0x7A)) ||
3465                ((*in >= 0x41) && (*in <= 0x5A)) ||
3466                ((*in >= 0x30) && (*in <= 0x39)) ||
3467                (*in == '_') || (*in == '-') ||
3468                (*in == ':') || (*in == '.'))
3469             in++;
3470         if ((*in > 0) && (*in < 0x80)) {
3471             count = in - ctxt->input->cur;
3472             if ((count > XML_MAX_NAME_LENGTH) &&
3473                 ((ctxt->options & XML_PARSE_HUGE) == 0)) {
3474                 xmlFatalErr(ctxt, XML_ERR_NAME_TOO_LONG, "Name");
3475                 return(NULL);
3476             }
3477             ret = xmlDictLookup(ctxt->dict, ctxt->input->cur, count);
3478             ctxt->input->cur = in;
3479             ctxt->nbChars += count;
3480             ctxt->input->col += count;
3481             if (ret == NULL)
3482                 xmlErrMemory(ctxt, NULL);
3483             return(ret);
3484         }
3485     }
3486     /* accelerator for special cases */
3487     return(xmlParseNameComplex(ctxt));
3488 }
3489
3490 static const xmlChar *
3491 xmlParseNCNameComplex(xmlParserCtxtPtr ctxt) {
3492     int len = 0, l;
3493     int c;
3494     int count = 0;
3495     size_t startPosition = 0;
3496
3497 #ifdef DEBUG
3498     nbParseNCNameComplex++;
3499 #endif
3500
3501     /*
3502      * Handler for more complex cases
3503      */
3504     GROW;
3505     startPosition = CUR_PTR - BASE_PTR;
3506     c = CUR_CHAR(l);
3507     if ((c == ' ') || (c == '>') || (c == '/') || /* accelerators */
3508         (!xmlIsNameStartChar(ctxt, c) || (c == ':'))) {
3509         return(NULL);
3510     }
3511
3512     while ((c != ' ') && (c != '>') && (c != '/') && /* test bigname.xml */
3513            (xmlIsNameChar(ctxt, c) && (c != ':'))) {
3514         if (count++ > XML_PARSER_CHUNK_SIZE) {
3515             if ((len > XML_MAX_NAME_LENGTH) &&
3516                 ((ctxt->options & XML_PARSE_HUGE) == 0)) {
3517                 xmlFatalErr(ctxt, XML_ERR_NAME_TOO_LONG, "NCName");
3518                 return(NULL);
3519             }
3520             count = 0;
3521             GROW;
3522             if (ctxt->instate == XML_PARSER_EOF)
3523                 return(NULL);
3524         }
3525         len += l;
3526         NEXTL(l);
3527         c = CUR_CHAR(l);
3528         if (c == 0) {
3529             count = 0;
3530             /*
3531              * when shrinking to extend the buffer we really need to preserve
3532              * the part of the name we already parsed. Hence rolling back
3533              * by current lenght.
3534              */
3535             ctxt->input->cur -= l;
3536             GROW;
3537             ctxt->input->cur += l;
3538             if (ctxt->instate == XML_PARSER_EOF)
3539                 return(NULL);
3540             c = CUR_CHAR(l);
3541         }
3542     }
3543     if ((len > XML_MAX_NAME_LENGTH) &&
3544         ((ctxt->options & XML_PARSE_HUGE) == 0)) {
3545         xmlFatalErr(ctxt, XML_ERR_NAME_TOO_LONG, "NCName");
3546         return(NULL);
3547     }
3548     return(xmlDictLookup(ctxt->dict, (BASE_PTR + startPosition), len));
3549 }
3550
3551 /**
3552  * xmlParseNCName:
3553  * @ctxt:  an XML parser context
3554  * @len:  length of the string parsed
3555  *
3556  * parse an XML name.
3557  *
3558  * [4NS] NCNameChar ::= Letter | Digit | '.' | '-' | '_' |
3559  *                      CombiningChar | Extender
3560  *
3561  * [5NS] NCName ::= (Letter | '_') (NCNameChar)*
3562  *
3563  * Returns the Name parsed or NULL
3564  */
3565
3566 static const xmlChar *
3567 xmlParseNCName(xmlParserCtxtPtr ctxt) {
3568     const xmlChar *in, *e;
3569     const xmlChar *ret;
3570     int count = 0;
3571
3572 #ifdef DEBUG
3573     nbParseNCName++;
3574 #endif
3575
3576     /*
3577      * Accelerator for simple ASCII names
3578      */
3579     in = ctxt->input->cur;
3580     e = ctxt->input->end;
3581     if ((((*in >= 0x61) && (*in <= 0x7A)) ||
3582          ((*in >= 0x41) && (*in <= 0x5A)) ||
3583          (*in == '_')) && (in < e)) {
3584         in++;
3585         while ((((*in >= 0x61) && (*in <= 0x7A)) ||
3586                 ((*in >= 0x41) && (*in <= 0x5A)) ||
3587                 ((*in >= 0x30) && (*in <= 0x39)) ||
3588                 (*in == '_') || (*in == '-') ||
3589                 (*in == '.')) && (in < e))
3590             in++;
3591         if (in >= e)
3592             goto complex;
3593         if ((*in > 0) && (*in < 0x80)) {
3594             count = in - ctxt->input->cur;
3595             if ((count > XML_MAX_NAME_LENGTH) &&
3596                 ((ctxt->options & XML_PARSE_HUGE) == 0)) {
3597                 xmlFatalErr(ctxt, XML_ERR_NAME_TOO_LONG, "NCName");
3598                 return(NULL);
3599             }
3600             ret = xmlDictLookup(ctxt->dict, ctxt->input->cur, count);
3601             ctxt->input->cur = in;
3602             ctxt->nbChars += count;
3603             ctxt->input->col += count;
3604             if (ret == NULL) {
3605                 xmlErrMemory(ctxt, NULL);
3606             }
3607             return(ret);
3608         }
3609     }
3610 complex:
3611     return(xmlParseNCNameComplex(ctxt));
3612 }
3613
3614 /**
3615  * xmlParseNameAndCompare:
3616  * @ctxt:  an XML parser context
3617  *
3618  * parse an XML name and compares for match
3619  * (specialized for endtag parsing)
3620  *
3621  * Returns NULL for an illegal name, (xmlChar*) 1 for success
3622  * and the name for mismatch
3623  */
3624
3625 static const xmlChar *
3626 xmlParseNameAndCompare(xmlParserCtxtPtr ctxt, xmlChar const *other) {
3627     register const xmlChar *cmp = other;
3628     register const xmlChar *in;
3629     const xmlChar *ret;
3630
3631     GROW;
3632     if (ctxt->instate == XML_PARSER_EOF)
3633         return(NULL);
3634
3635     in = ctxt->input->cur;
3636     while (*in != 0 && *in == *cmp) {
3637         ++in;
3638         ++cmp;
3639         ctxt->input->col++;
3640     }
3641     if (*cmp == 0 && (*in == '>' || IS_BLANK_CH (*in))) {
3642         /* success */
3643         ctxt->input->cur = in;
3644         return (const xmlChar*) 1;
3645     }
3646     /* failure (or end of input buffer), check with full function */
3647     ret = xmlParseName (ctxt);
3648     /* strings coming from the dictionary direct compare possible */
3649     if (ret == other) {
3650         return (const xmlChar*) 1;
3651     }
3652     return ret;
3653 }
3654
3655 /**
3656  * xmlParseStringName:
3657  * @ctxt:  an XML parser context
3658  * @str:  a pointer to the string pointer (IN/OUT)
3659  *
3660  * parse an XML name.
3661  *
3662  * [4] NameChar ::= Letter | Digit | '.' | '-' | '_' | ':' |
3663  *                  CombiningChar | Extender
3664  *
3665  * [5] Name ::= (Letter | '_' | ':') (NameChar)*
3666  *
3667  * [6] Names ::= Name (#x20 Name)*
3668  *
3669  * Returns the Name parsed or NULL. The @str pointer
3670  * is updated to the current location in the string.
3671  */
3672
3673 static xmlChar *
3674 xmlParseStringName(xmlParserCtxtPtr ctxt, const xmlChar** str) {
3675     xmlChar buf[XML_MAX_NAMELEN + 5];
3676     const xmlChar *cur = *str;
3677     int len = 0, l;
3678     int c;
3679
3680 #ifdef DEBUG
3681     nbParseStringName++;
3682 #endif
3683
3684     c = CUR_SCHAR(cur, l);
3685     if (!xmlIsNameStartChar(ctxt, c)) {
3686         return(NULL);
3687     }
3688
3689     COPY_BUF(l,buf,len,c);
3690     cur += l;
3691     c = CUR_SCHAR(cur, l);
3692     while (xmlIsNameChar(ctxt, c)) {
3693         COPY_BUF(l,buf,len,c);
3694         cur += l;
3695         c = CUR_SCHAR(cur, l);
3696         if (len >= XML_MAX_NAMELEN) { /* test bigentname.xml */
3697             /*
3698              * Okay someone managed to make a huge name, so he's ready to pay
3699              * for the processing speed.
3700              */
3701             xmlChar *buffer;
3702             int max = len * 2;
3703
3704             buffer = (xmlChar *) xmlMallocAtomic(max * sizeof(xmlChar));
3705             if (buffer == NULL) {
3706                 xmlErrMemory(ctxt, NULL);
3707                 return(NULL);
3708             }
3709             memcpy(buffer, buf, len);
3710             while (xmlIsNameChar(ctxt, c)) {
3711                 if (len + 10 > max) {
3712                     xmlChar *tmp;
3713
3714                     if ((len > XML_MAX_NAME_LENGTH) &&
3715                         ((ctxt->options & XML_PARSE_HUGE) == 0)) {
3716                         xmlFatalErr(ctxt, XML_ERR_NAME_TOO_LONG, "NCName");
3717                         xmlFree(buffer);
3718                         return(NULL);
3719                     }
3720                     max *= 2;
3721                     tmp = (xmlChar *) xmlRealloc(buffer,
3722                                                     max * sizeof(xmlChar));
3723                     if (tmp == NULL) {
3724                         xmlErrMemory(ctxt, NULL);
3725                         xmlFree(buffer);
3726                         return(NULL);
3727                     }
3728                     buffer = tmp;
3729                 }
3730                 COPY_BUF(l,buffer,len,c);
3731                 cur += l;
3732                 c = CUR_SCHAR(cur, l);
3733             }
3734             buffer[len] = 0;
3735             *str = cur;
3736             return(buffer);
3737         }
3738     }
3739     if ((len > XML_MAX_NAME_LENGTH) &&
3740         ((ctxt->options & XML_PARSE_HUGE) == 0)) {
3741         xmlFatalErr(ctxt, XML_ERR_NAME_TOO_LONG, "NCName");
3742         return(NULL);
3743     }
3744     *str = cur;
3745     return(xmlStrndup(buf, len));
3746 }
3747
3748 /**
3749  * xmlParseNmtoken:
3750  * @ctxt:  an XML parser context
3751  *
3752  * parse an XML Nmtoken.
3753  *
3754  * [7] Nmtoken ::= (NameChar)+
3755  *
3756  * [8] Nmtokens ::= Nmtoken (#x20 Nmtoken)*
3757  *
3758  * Returns the Nmtoken parsed or NULL
3759  */
3760
3761 xmlChar *
3762 xmlParseNmtoken(xmlParserCtxtPtr ctxt) {
3763     xmlChar buf[XML_MAX_NAMELEN + 5];
3764     int len = 0, l;
3765     int c;
3766     int count = 0;
3767
3768 #ifdef DEBUG
3769     nbParseNmToken++;
3770 #endif
3771
3772     GROW;
3773     if (ctxt->instate == XML_PARSER_EOF)
3774         return(NULL);
3775     c = CUR_CHAR(l);
3776
3777     while (xmlIsNameChar(ctxt, c)) {
3778         if (count++ > XML_PARSER_CHUNK_SIZE) {
3779             count = 0;
3780             GROW;
3781         }
3782         COPY_BUF(l,buf,len,c);
3783         NEXTL(l);
3784         c = CUR_CHAR(l);
3785         if (c == 0) {
3786             count = 0;
3787             GROW;
3788             if (ctxt->instate == XML_PARSER_EOF)
3789                 return(NULL);
3790             c = CUR_CHAR(l);
3791         }
3792         if (len >= XML_MAX_NAMELEN) {
3793             /*
3794              * Okay someone managed to make a huge token, so he's ready to pay
3795              * for the processing speed.
3796              */
3797             xmlChar *buffer;
3798             int max = len * 2;
3799
3800             buffer = (xmlChar *) xmlMallocAtomic(max * sizeof(xmlChar));
3801             if (buffer == NULL) {
3802                 xmlErrMemory(ctxt, NULL);
3803                 return(NULL);
3804             }
3805             memcpy(buffer, buf, len);
3806             while (xmlIsNameChar(ctxt, c)) {
3807                 if (count++ > XML_PARSER_CHUNK_SIZE) {
3808                     count = 0;
3809                     GROW;
3810                     if (ctxt->instate == XML_PARSER_EOF) {
3811                         xmlFree(buffer);
3812                         return(NULL);
3813                     }
3814                 }
3815                 if (len + 10 > max) {
3816                     xmlChar *tmp;
3817
3818                     if ((max > XML_MAX_NAME_LENGTH) &&
3819                         ((ctxt->options & XML_PARSE_HUGE) == 0)) {
3820                         xmlFatalErr(ctxt, XML_ERR_NAME_TOO_LONG, "NmToken");
3821                         xmlFree(buffer);
3822                         return(NULL);
3823                     }
3824                     max *= 2;
3825                     tmp = (xmlChar *) xmlRealloc(buffer,
3826                                                     max * sizeof(xmlChar));
3827                     if (tmp == NULL) {
3828                         xmlErrMemory(ctxt, NULL);
3829                         xmlFree(buffer);
3830                         return(NULL);
3831                     }
3832                     buffer = tmp;
3833                 }
3834                 COPY_BUF(l,buffer,len,c);
3835                 NEXTL(l);
3836                 c = CUR_CHAR(l);
3837             }
3838             buffer[len] = 0;
3839             return(buffer);
3840         }
3841     }
3842     if (len == 0)
3843         return(NULL);
3844     if ((len > XML_MAX_NAME_LENGTH) &&
3845         ((ctxt->options & XML_PARSE_HUGE) == 0)) {
3846         xmlFatalErr(ctxt, XML_ERR_NAME_TOO_LONG, "NmToken");
3847         return(NULL);
3848     }
3849     return(xmlStrndup(buf, len));
3850 }
3851
3852 /**
3853  * xmlParseEntityValue:
3854  * @ctxt:  an XML parser context
3855  * @orig:  if non-NULL store a copy of the original entity value
3856  *
3857  * parse a value for ENTITY declarations
3858  *
3859  * [9] EntityValue ::= '"' ([^%&"] | PEReference | Reference)* '"' |
3860  *                     "'" ([^%&'] | PEReference | Reference)* "'"
3861  *
3862  * Returns the EntityValue parsed with reference substituted or NULL
3863  */
3864
3865 xmlChar *
3866 xmlParseEntityValue(xmlParserCtxtPtr ctxt, xmlChar **orig) {
3867     xmlChar *buf = NULL;
3868     int len = 0;
3869     int size = XML_PARSER_BUFFER_SIZE;
3870     int c, l;
3871     xmlChar stop;
3872     xmlChar *ret = NULL;
3873     const xmlChar *cur = NULL;
3874     xmlParserInputPtr input;
3875
3876     if (RAW == '"') stop = '"';
3877     else if (RAW == '\'') stop = '\'';
3878     else {
3879         xmlFatalErr(ctxt, XML_ERR_ENTITY_NOT_STARTED, NULL);
3880         return(NULL);
3881     }
3882     buf = (xmlChar *) xmlMallocAtomic(size * sizeof(xmlChar));
3883     if (buf == NULL) {
3884         xmlErrMemory(ctxt, NULL);
3885         return(NULL);
3886     }
3887
3888     /*
3889      * The content of the entity definition is copied in a buffer.
3890      */
3891
3892     ctxt->instate = XML_PARSER_ENTITY_VALUE;
3893     input = ctxt->input;
3894     GROW;
3895     if (ctxt->instate == XML_PARSER_EOF) {
3896         xmlFree(buf);
3897         return(NULL);
3898     }
3899     NEXT;
3900     c = CUR_CHAR(l);
3901     /*
3902      * NOTE: 4.4.5 Included in Literal
3903      * When a parameter entity reference appears in a literal entity
3904      * value, ... a single or double quote character in the replacement
3905      * text is always treated as a normal data character and will not
3906      * terminate the literal.
3907      * In practice it means we stop the loop only when back at parsing
3908      * the initial entity and the quote is found
3909      */
3910     while (((IS_CHAR(c)) && ((c != stop) || /* checked */
3911             (ctxt->input != input))) && (ctxt->instate != XML_PARSER_EOF)) {
3912         if (len + 5 >= size) {
3913             xmlChar *tmp;
3914
3915             size *= 2;
3916             tmp = (xmlChar *) xmlRealloc(buf, size * sizeof(xmlChar));
3917             if (tmp == NULL) {
3918                 xmlErrMemory(ctxt, NULL);
3919                 xmlFree(buf);
3920                 return(NULL);
3921             }
3922             buf = tmp;
3923         }
3924         COPY_BUF(l,buf,len,c);
3925         NEXTL(l);
3926         /*
3927          * Pop-up of finished entities.
3928          */
3929         while ((RAW == 0) && (ctxt->inputNr > 1)) /* non input consuming */
3930             xmlPopInput(ctxt);
3931
3932         GROW;
3933         c = CUR_CHAR(l);
3934         if (c == 0) {
3935             GROW;
3936             c = CUR_CHAR(l);
3937         }
3938     }
3939     buf[len] = 0;
3940     if (ctxt->instate == XML_PARSER_EOF) {
3941         xmlFree(buf);
3942         return(NULL);
3943     }
3944
3945     /*
3946      * Raise problem w.r.t. '&' and '%' being used in non-entities
3947      * reference constructs. Note Charref will be handled in
3948      * xmlStringDecodeEntities()
3949      */
3950     cur = buf;
3951     while (*cur != 0) { /* non input consuming */
3952         if ((*cur == '%') || ((*cur == '&') && (cur[1] != '#'))) {
3953             xmlChar *name;
3954             xmlChar tmp = *cur;
3955
3956             cur++;
3957             name = xmlParseStringName(ctxt, &cur);
3958             if ((name == NULL) || (*cur != ';')) {
3959                 xmlFatalErrMsgInt(ctxt, XML_ERR_ENTITY_CHAR_ERROR,
3960             "EntityValue: '%c' forbidden except for entities references\n",
3961                                   tmp);
3962             }
3963             if ((tmp == '%') && (ctxt->inSubset == 1) &&
3964                 (ctxt->inputNr == 1)) {
3965                 xmlFatalErr(ctxt, XML_ERR_ENTITY_PE_INTERNAL, NULL);
3966             }
3967             if (name != NULL)
3968                 xmlFree(name);
3969             if (*cur == 0)
3970                 break;
3971         }
3972         cur++;
3973     }
3974
3975     /*
3976      * Then PEReference entities are substituted.
3977      */
3978     if (c != stop) {
3979         xmlFatalErr(ctxt, XML_ERR_ENTITY_NOT_FINISHED, NULL);
3980         xmlFree(buf);
3981     } else {
3982         NEXT;
3983         /*
3984          * NOTE: 4.4.7 Bypassed
3985          * When a general entity reference appears in the EntityValue in
3986          * an entity declaration, it is bypassed and left as is.
3987          * so XML_SUBSTITUTE_REF is not set here.
3988          */
3989         ++ctxt->depth;
3990         ret = xmlStringDecodeEntities(ctxt, buf, XML_SUBSTITUTE_PEREF,
3991                                       0, 0, 0);
3992         --ctxt->depth;
3993         if (orig != NULL)
3994             *orig = buf;
3995         else
3996             xmlFree(buf);
3997     }
3998
3999     return(ret);
4000 }
4001
4002 /**
4003  * xmlParseAttValueComplex:
4004  * @ctxt:  an XML parser context
4005  * @len:   the resulting attribute len
4006  * @normalize:  wether to apply the inner normalization
4007  *
4008  * parse a value for an attribute, this is the fallback function
4009  * of xmlParseAttValue() when the attribute parsing requires handling
4010  * of non-ASCII characters, or normalization compaction.
4011  *
4012  * Returns the AttValue parsed or NULL. The value has to be freed by the caller.
4013  */
4014 static xmlChar *
4015 xmlParseAttValueComplex(xmlParserCtxtPtr ctxt, int *attlen, int normalize) {
4016     xmlChar limit = 0;
4017     xmlChar *buf = NULL;
4018     xmlChar *rep = NULL;
4019     size_t len = 0;
4020     size_t buf_size = 0;
4021     int c, l, in_space = 0;
4022     xmlChar *current = NULL;
4023     xmlEntityPtr ent;
4024
4025     if (NXT(0) == '"') {
4026         ctxt->instate = XML_PARSER_ATTRIBUTE_VALUE;
4027         limit = '"';
4028         NEXT;
4029     } else if (NXT(0) == '\'') {
4030         limit = '\'';
4031         ctxt->instate = XML_PARSER_ATTRIBUTE_VALUE;
4032         NEXT;
4033     } else {
4034         xmlFatalErr(ctxt, XML_ERR_ATTRIBUTE_NOT_STARTED, NULL);
4035         return(NULL);
4036     }
4037
4038     /*
4039      * allocate a translation buffer.
4040      */
4041     buf_size = XML_PARSER_BUFFER_SIZE;
4042     buf = (xmlChar *) xmlMallocAtomic(buf_size);
4043     if (buf == NULL) goto mem_error;
4044
4045     /*
4046      * OK loop until we reach one of the ending char or a size limit.
4047      */
4048     c = CUR_CHAR(l);
4049     while (((NXT(0) != limit) && /* checked */
4050             (IS_CHAR(c)) && (c != '<')) &&
4051             (ctxt->instate != XML_PARSER_EOF)) {
4052         /*
4053          * Impose a reasonable limit on attribute size, unless XML_PARSE_HUGE
4054          * special option is given
4055          */
4056         if ((len > XML_MAX_TEXT_LENGTH) &&
4057             ((ctxt->options & XML_PARSE_HUGE) == 0)) {
4058             xmlFatalErrMsg(ctxt, XML_ERR_ATTRIBUTE_NOT_FINISHED,
4059                            "AttValue length too long\n");
4060             goto mem_error;
4061         }
4062         if (c == 0) break;
4063         if (c == '&') {
4064             in_space = 0;
4065             if (NXT(1) == '#') {
4066                 int val = xmlParseCharRef(ctxt);
4067
4068                 if (val == '&') {
4069                     if (ctxt->replaceEntities) {
4070                         if (len + 10 > buf_size) {
4071                             growBuffer(buf, 10);
4072                         }
4073                         buf[len++] = '&';
4074                     } else {
4075                         /*
4076                          * The reparsing will be done in xmlStringGetNodeList()
4077                          * called by the attribute() function in SAX.c
4078                          */
4079                         if (len + 10 > buf_size) {
4080                             growBuffer(buf, 10);
4081                         }
4082                         buf[len++] = '&';
4083                         buf[len++] = '#';
4084                         buf[len++] = '3';
4085                         buf[len++] = '8';
4086                         buf[len++] = ';';
4087                     }
4088                 } else if (val != 0) {
4089                     if (len + 10 > buf_size) {
4090                         growBuffer(buf, 10);
4091                     }
4092                     len += xmlCopyChar(0, &buf[len], val);
4093                 }
4094             } else {
4095                 ent = xmlParseEntityRef(ctxt);
4096                 ctxt->nbentities++;
4097                 if (ent != NULL)
4098                     ctxt->nbentities += ent->owner;
4099                 if ((ent != NULL) &&
4100                     (ent->etype == XML_INTERNAL_PREDEFINED_ENTITY)) {
4101                     if (len + 10 > buf_size) {
4102                         growBuffer(buf, 10);
4103                     }
4104                     if ((ctxt->replaceEntities == 0) &&
4105                         (ent->content[0] == '&')) {
4106                         buf[len++] = '&';
4107                         buf[len++] = '#';
4108                         buf[len++] = '3';
4109                         buf[len++] = '8';
4110                         buf[len++] = ';';
4111                     } else {
4112                         buf[len++] = ent->content[0];
4113                     }
4114                 } else if ((ent != NULL) &&
4115                            (ctxt->replaceEntities != 0)) {
4116                     if (ent->etype != XML_INTERNAL_PREDEFINED_ENTITY) {
4117                         ++ctxt->depth;
4118                         rep = xmlStringDecodeEntities(ctxt, ent->content,
4119                                                       XML_SUBSTITUTE_REF,
4120                                                       0, 0, 0);
4121                         --ctxt->depth;
4122                         if (rep != NULL) {
4123                             current = rep;
4124                             while (*current != 0) { /* non input consuming */
4125                                 if ((*current == 0xD) || (*current == 0xA) ||
4126                                     (*current == 0x9)) {
4127                                     buf[len++] = 0x20;
4128                                     current++;
4129                                 } else
4130                                     buf[len++] = *current++;
4131                                 if (len + 10 > buf_size) {
4132                                     growBuffer(buf, 10);
4133                                 }
4134                             }
4135                             xmlFree(rep);
4136                             rep = NULL;
4137                         }
4138                     } else {
4139                         if (len + 10 > buf_size) {
4140                             growBuffer(buf, 10);
4141                         }
4142                         if (ent->content != NULL)
4143                             buf[len++] = ent->content[0];
4144                     }
4145                 } else if (ent != NULL) {
4146                     int i = xmlStrlen(ent->name);
4147                     const xmlChar *cur = ent->name;
4148
4149                     /*
4150                      * This may look absurd but is needed to detect
4151                      * entities problems
4152                      */
4153                     if ((ent->etype != XML_INTERNAL_PREDEFINED_ENTITY) &&
4154                         (ent->content != NULL) && (ent->checked == 0)) {
4155                         unsigned long oldnbent = ctxt->nbentities;
4156
4157                         ++ctxt->depth;
4158                         rep = xmlStringDecodeEntities(ctxt, ent->content,
4159                                                   XML_SUBSTITUTE_REF, 0, 0, 0);
4160                         --ctxt->depth;
4161
4162                         ent->checked = (ctxt->nbentities - oldnbent + 1) * 2;
4163                         if (rep != NULL) {
4164                             if (xmlStrchr(rep, '<'))
4165                                 ent->checked |= 1;
4166                             xmlFree(rep);
4167                             rep = NULL;
4168                         }
4169                     }
4170
4171                     /*
4172                      * Just output the reference
4173                      */
4174                     buf[len++] = '&';
4175                     while (len + i + 10 > buf_size) {
4176                         growBuffer(buf, i + 10);
4177                     }
4178                     for (;i > 0;i--)
4179                         buf[len++] = *cur++;
4180                     buf[len++] = ';';
4181                 }
4182             }
4183         } else {
4184             if ((c == 0x20) || (c == 0xD) || (c == 0xA) || (c == 0x9)) {
4185                 if ((len != 0) || (!normalize)) {
4186                     if ((!normalize) || (!in_space)) {
4187                         COPY_BUF(l,buf,len,0x20);
4188                         while (len + 10 > buf_size) {
4189                             growBuffer(buf, 10);
4190                         }
4191                     }
4192                     in_space = 1;
4193                 }
4194             } else {
4195                 in_space = 0;
4196                 COPY_BUF(l,buf,len,c);
4197                 if (len + 10 > buf_size) {
4198                     growBuffer(buf, 10);
4199                 }
4200             }
4201             NEXTL(l);
4202         }
4203         GROW;
4204         c = CUR_CHAR(l);
4205     }
4206     if (ctxt->instate == XML_PARSER_EOF)
4207         goto error;
4208
4209     if ((in_space) && (normalize)) {
4210         while ((len > 0) && (buf[len - 1] == 0x20)) len--;
4211     }
4212     buf[len] = 0;
4213     if (RAW == '<') {
4214         xmlFatalErr(ctxt, XML_ERR_LT_IN_ATTRIBUTE, NULL);
4215     } else if (RAW != limit) {
4216         if ((c != 0) && (!IS_CHAR(c))) {
4217             xmlFatalErrMsg(ctxt, XML_ERR_INVALID_CHAR,
4218                            "invalid character in attribute value\n");
4219         } else {
4220             xmlFatalErrMsg(ctxt, XML_ERR_ATTRIBUTE_NOT_FINISHED,
4221                            "AttValue: ' expected\n");
4222         }
4223     } else
4224         NEXT;
4225
4226     /*
4227      * There we potentially risk an overflow, don't allow attribute value of
4228      * length more than INT_MAX it is a very reasonnable assumption !
4229      */
4230     if (len >= INT_MAX) {
4231         xmlFatalErrMsg(ctxt, XML_ERR_ATTRIBUTE_NOT_FINISHED,
4232                        "AttValue length too long\n");
4233         goto mem_error;
4234     }
4235
4236     if (attlen != NULL) *attlen = (int) len;
4237     return(buf);
4238
4239 mem_error:
4240     xmlErrMemory(ctxt, NULL);
4241 error:
4242     if (buf != NULL)
4243         xmlFree(buf);
4244     if (rep != NULL)
4245         xmlFree(rep);
4246     return(NULL);
4247 }
4248
4249 /**
4250  * xmlParseAttValue:
4251  * @ctxt:  an XML parser context
4252  *
4253  * parse a value for an attribute
4254  * Note: the parser won't do substitution of entities here, this
4255  * will be handled later in xmlStringGetNodeList
4256  *
4257  * [10] AttValue ::= '"' ([^<&"] | Reference)* '"' |
4258  *                   "'" ([^<&'] | Reference)* "'"
4259  *
4260  * 3.3.3 Attribute-Value Normalization:
4261  * Before the value of an attribute is passed to the application or
4262  * checked for validity, the XML processor must normalize it as follows:
4263  * - a character reference is processed by appending the referenced
4264  *   character to the attribute value
4265  * - an entity reference is processed by recursively processing the
4266  *   replacement text of the entity
4267  * - a whitespace character (#x20, #xD, #xA, #x9) is processed by
4268  *   appending #x20 to the normalized value, except that only a single
4269  *   #x20 is appended for a "#xD#xA" sequence that is part of an external
4270  *   parsed entity or the literal entity value of an internal parsed entity
4271  * - other characters are processed by appending them to the normalized value
4272  * If the declared value is not CDATA, then the XML processor must further
4273  * process the normalized attribute value by discarding any leading and
4274  * trailing space (#x20) characters, and by replacing sequences of space
4275  * (#x20) characters by a single space (#x20) character.
4276  * All attributes for which no declaration has been read should be treated
4277  * by a non-validating parser as if declared CDATA.
4278  *
4279  * Returns the AttValue parsed or NULL. The value has to be freed by the caller.
4280  */
4281
4282
4283 xmlChar *
4284 xmlParseAttValue(xmlParserCtxtPtr ctxt) {
4285     if ((ctxt == NULL) || (ctxt->input == NULL)) return(NULL);
4286     return(xmlParseAttValueInternal(ctxt, NULL, NULL, 0));
4287 }
4288
4289 /**
4290  * xmlParseSystemLiteral:
4291  * @ctxt:  an XML parser context
4292  *
4293  * parse an XML Literal
4294  *
4295  * [11] SystemLiteral ::= ('"' [^"]* '"') | ("'" [^']* "'")
4296  *
4297  * Returns the SystemLiteral parsed or NULL
4298  */
4299
4300 xmlChar *
4301 xmlParseSystemLiteral(xmlParserCtxtPtr ctxt) {
4302     xmlChar *buf = NULL;
4303     int len = 0;
4304     int size = XML_PARSER_BUFFER_SIZE;
4305     int cur, l;
4306     xmlChar stop;
4307     int state = ctxt->instate;
4308     int count = 0;
4309
4310     SHRINK;
4311     if (RAW == '"') {
4312         NEXT;
4313         stop = '"';
4314     } else if (RAW == '\'') {
4315         NEXT;
4316         stop = '\'';
4317     } else {
4318         xmlFatalErr(ctxt, XML_ERR_LITERAL_NOT_STARTED, NULL);
4319         return(NULL);
4320     }
4321
4322     buf = (xmlChar *) xmlMallocAtomic(size * sizeof(xmlChar));
4323     if (buf == NULL) {
4324         xmlErrMemory(ctxt, NULL);
4325         return(NULL);
4326     }
4327     ctxt->instate = XML_PARSER_SYSTEM_LITERAL;
4328     cur = CUR_CHAR(l);
4329     while ((IS_CHAR(cur)) && (cur != stop)) { /* checked */
4330         if (len + 5 >= size) {
4331             xmlChar *tmp;
4332
4333             if ((size > XML_MAX_NAME_LENGTH) &&
4334                 ((ctxt->options & XML_PARSE_HUGE) == 0)) {
4335                 xmlFatalErr(ctxt, XML_ERR_NAME_TOO_LONG, "SystemLiteral");
4336                 xmlFree(buf);
4337                 ctxt->instate = (xmlParserInputState) state;
4338                 return(NULL);
4339             }
4340             size *= 2;
4341             tmp = (xmlChar *) xmlRealloc(buf, size * sizeof(xmlChar));
4342             if (tmp == NULL) {
4343                 xmlFree(buf);
4344                 xmlErrMemory(ctxt, NULL);
4345                 ctxt->instate = (xmlParserInputState) state;
4346                 return(NULL);
4347             }
4348             buf = tmp;
4349         }
4350         count++;
4351         if (count > 50) {
4352             GROW;
4353             count = 0;
4354             if (ctxt->instate == XML_PARSER_EOF) {
4355                 xmlFree(buf);
4356                 return(NULL);
4357             }
4358         }
4359         COPY_BUF(l,buf,len,cur);
4360         NEXTL(l);
4361         cur = CUR_CHAR(l);
4362         if (cur == 0) {
4363             GROW;
4364             SHRINK;
4365             cur = CUR_CHAR(l);
4366         }
4367     }
4368     buf[len] = 0;
4369     ctxt->instate = (xmlParserInputState) state;
4370     if (!IS_CHAR(cur)) {
4371         xmlFatalErr(ctxt, XML_ERR_LITERAL_NOT_FINISHED, NULL);
4372     } else {
4373         NEXT;
4374     }
4375     return(buf);
4376 }
4377
4378 /**
4379  * xmlParsePubidLiteral:
4380  * @ctxt:  an XML parser context
4381  *
4382  * parse an XML public literal
4383  *
4384  * [12] PubidLiteral ::= '"' PubidChar* '"' | "'" (PubidChar - "'")* "'"
4385  *
4386  * Returns the PubidLiteral parsed or NULL.
4387  */
4388
4389 xmlChar *
4390 xmlParsePubidLiteral(xmlParserCtxtPtr ctxt) {
4391     xmlChar *buf = NULL;
4392     int len = 0;
4393     int size = XML_PARSER_BUFFER_SIZE;
4394     xmlChar cur;
4395     xmlChar stop;
4396     int count = 0;
4397     xmlParserInputState oldstate = ctxt->instate;
4398
4399     SHRINK;
4400     if (RAW == '"') {
4401         NEXT;
4402         stop = '"';
4403     } else if (RAW == '\'') {
4404         NEXT;
4405         stop = '\'';
4406     } else {
4407         xmlFatalErr(ctxt, XML_ERR_LITERAL_NOT_STARTED, NULL);
4408         return(NULL);
4409     }
4410     buf = (xmlChar *) xmlMallocAtomic(size * sizeof(xmlChar));
4411     if (buf == NULL) {
4412         xmlErrMemory(ctxt, NULL);
4413         return(NULL);
4414     }
4415     ctxt->instate = XML_PARSER_PUBLIC_LITERAL;
4416     cur = CUR;
4417     while ((IS_PUBIDCHAR_CH(cur)) && (cur != stop)) { /* checked */
4418         if (len + 1 >= size) {
4419             xmlChar *tmp;
4420
4421             if ((size > XML_MAX_NAME_LENGTH) &&
4422                 ((ctxt->options & XML_PARSE_HUGE) == 0)) {
4423                 xmlFatalErr(ctxt, XML_ERR_NAME_TOO_LONG, "Public ID");
4424                 xmlFree(buf);
4425                 return(NULL);
4426             }
4427             size *= 2;
4428             tmp = (xmlChar *) xmlRealloc(buf, size * sizeof(xmlChar));
4429             if (tmp == NULL) {
4430                 xmlErrMemory(ctxt, NULL);
4431                 xmlFree(buf);
4432                 return(NULL);
4433             }
4434             buf = tmp;
4435         }
4436         buf[len++] = cur;
4437         count++;
4438         if (count > 50) {
4439             GROW;
4440             count = 0;
4441             if (ctxt->instate == XML_PARSER_EOF) {
4442                 xmlFree(buf);
4443                 return(NULL);
4444             }
4445         }
4446         NEXT;
4447         cur = CUR;
4448         if (cur == 0) {
4449             GROW;
4450             SHRINK;
4451             cur = CUR;
4452         }
4453     }
4454     buf[len] = 0;
4455     if (cur != stop) {
4456         xmlFatalErr(ctxt, XML_ERR_LITERAL_NOT_FINISHED, NULL);
4457     } else {
4458         NEXT;
4459     }
4460     ctxt->instate = oldstate;
4461     return(buf);
4462 }
4463
4464 static void xmlParseCharDataComplex(xmlParserCtxtPtr ctxt, int cdata);
4465
4466 /*
4467  * used for the test in the inner loop of the char data testing
4468  */
4469 static const unsigned char test_char_data[256] = {
4470     0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
4471     0x00, 0x09, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, /* 0x9, CR/LF separated */
4472     0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
4473     0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
4474     0x20, 0x21, 0x22, 0x23, 0x24, 0x25, 0x00, 0x27, /* & */
4475     0x28, 0x29, 0x2A, 0x2B, 0x2C, 0x2D, 0x2E, 0x2F,
4476     0x30, 0x31, 0x32, 0x33, 0x34, 0x35, 0x36, 0x37,
4477     0x38, 0x39, 0x3A, 0x3B, 0x00, 0x3D, 0x3E, 0x3F, /* < */
4478     0x40, 0x41, 0x42, 0x43, 0x44, 0x45, 0x46, 0x47,
4479     0x48, 0x49, 0x4A, 0x4B, 0x4C, 0x4D, 0x4E, 0x4F,
4480     0x50, 0x51, 0x52, 0x53, 0x54, 0x55, 0x56, 0x57,
4481     0x58, 0x59, 0x5A, 0x5B, 0x5C, 0x00, 0x5E, 0x5F, /* ] */
4482     0x60, 0x61, 0x62, 0x63, 0x64, 0x65, 0x66, 0x67,
4483     0x68, 0x69, 0x6A, 0x6B, 0x6C, 0x6D, 0x6E, 0x6F,
4484     0x70, 0x71, 0x72, 0x73, 0x74, 0x75, 0x76, 0x77,
4485     0x78, 0x79, 0x7A, 0x7B, 0x7C, 0x7D, 0x7E, 0x7F,
4486     0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, /* non-ascii */
4487     0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
4488     0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
4489     0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
4490     0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
4491     0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
4492     0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
4493     0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
4494     0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
4495     0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
4496     0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
4497     0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
4498     0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
4499     0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
4500     0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
4501     0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00
4502 };
4503
4504 /**
4505  * xmlParseCharData:
4506  * @ctxt:  an XML parser context
4507  * @cdata:  int indicating whether we are within a CDATA section
4508  *
4509  * parse a CharData section.
4510  * if we are within a CDATA section ']]>' marks an end of section.
4511  *
4512  * The right angle bracket (>) may be represented using the string "&gt;",
4513  * and must, for compatibility, be escaped using "&gt;" or a character
4514  * reference when it appears in the string "]]>" in content, when that
4515  * string is not marking the end of a CDATA section.
4516  *
4517  * [14] CharData ::= [^<&]* - ([^<&]* ']]>' [^<&]*)
4518  */
4519
4520 void
4521 xmlParseCharData(xmlParserCtxtPtr ctxt, int cdata) {
4522     const xmlChar *in;
4523     int nbchar = 0;
4524     int line = ctxt->input->line;
4525     int col = ctxt->input->col;
4526     int ccol;
4527
4528     SHRINK;
4529     GROW;
4530     /*
4531      * Accelerated common case where input don't need to be
4532      * modified before passing it to the handler.
4533      */
4534     if (!cdata) {
4535         in = ctxt->input->cur;
4536         do {
4537 get_more_space:
4538             while (*in == 0x20) { in++; ctxt->input->col++; }
4539             if (*in == 0xA) {
4540                 do {
4541                     ctxt->input->line++; ctxt->input->col = 1;
4542                     in++;
4543                 } while (*in == 0xA);
4544                 goto get_more_space;
4545             }
4546             if (*in == '<') {
4547                 nbchar = in - ctxt->input->cur;
4548                 if (nbchar > 0) {
4549                     const xmlChar *tmp = ctxt->input->cur;
4550                     ctxt->input->cur = in;
4551
4552                     if ((ctxt->sax != NULL) &&
4553                         (ctxt->sax->ignorableWhitespace !=
4554                          ctxt->sax->characters)) {
4555                         if (areBlanks(ctxt, tmp, nbchar, 1)) {
4556                             if (ctxt->sax->ignorableWhitespace != NULL)
4557                                 ctxt->sax->ignorableWhitespace(ctxt->userData,
4558                                                        tmp, nbchar);
4559                         } else {
4560                             if (ctxt->sax->characters != NULL)
4561                                 ctxt->sax->characters(ctxt->userData,
4562                                                       tmp, nbchar);
4563                             if (*ctxt->space == -1)
4564                                 *ctxt->space = -2;
4565                         }
4566                     } else if ((ctxt->sax != NULL) &&
4567                                (ctxt->sax->characters != NULL)) {
4568                         ctxt->sax->characters(ctxt->userData,
4569                                               tmp, nbchar);
4570                     }
4571                 }
4572                 return;
4573             }
4574
4575 get_more:
4576             ccol = ctxt->input->col;
4577             while (test_char_data[*in]) {
4578                 in++;
4579                 ccol++;
4580             }
4581             ctxt->input->col = ccol;
4582             if (*in == 0xA) {
4583                 do {
4584                     ctxt->input->line++; ctxt->input->col = 1;
4585                     in++;
4586                 } while (*in == 0xA);
4587                 goto get_more;
4588             }
4589             if (*in == ']') {
4590                 if ((in[1] == ']') && (in[2] == '>')) {
4591                     xmlFatalErr(ctxt, XML_ERR_MISPLACED_CDATA_END, NULL);
4592                     ctxt->input->cur = in;
4593                     return;
4594                 }
4595                 in++;
4596                 ctxt->input->col++;
4597                 goto get_more;
4598             }
4599             nbchar = in - ctxt->input->cur;
4600             if (nbchar > 0) {
4601                 if ((ctxt->sax != NULL) &&
4602                     (ctxt->sax->ignorableWhitespace !=
4603                      ctxt->sax->characters) &&
4604                     (IS_BLANK_CH(*ctxt->input->cur))) {
4605                     const xmlChar *tmp = ctxt->input->cur;
4606                     ctxt->input->cur = in;
4607
4608                     if (areBlanks(ctxt, tmp, nbchar, 0)) {
4609                         if (ctxt->sax->ignorableWhitespace != NULL)
4610                             ctxt->sax->ignorableWhitespace(ctxt->userData,
4611                                                            tmp, nbchar);
4612                     } else {
4613                         if (ctxt->sax->characters != NULL)
4614                             ctxt->sax->characters(ctxt->userData,
4615                                                   tmp, nbchar);
4616                         if (*ctxt->space == -1)
4617                             *ctxt->space = -2;
4618                     }
4619                     line = ctxt->input->line;
4620                     col = ctxt->input->col;
4621                 } else if (ctxt->sax != NULL) {
4622                     if (ctxt->sax->characters != NULL)
4623                         ctxt->sax->characters(ctxt->userData,
4624                                               ctxt->input->cur, nbchar);
4625                     line = ctxt->input->line;
4626                     col = ctxt->input->col;
4627                 }
4628                 /* something really bad happened in the SAX callback */
4629                 if (ctxt->instate != XML_PARSER_CONTENT)
4630                     return;
4631             }
4632             ctxt->input->cur = in;
4633             if (*in == 0xD) {
4634                 in++;
4635                 if (*in == 0xA) {
4636                     ctxt->input->cur = in;
4637                     in++;
4638                     ctxt->input->line++; ctxt->input->col = 1;
4639                     continue; /* while */
4640                 }
4641                 in--;
4642             }
4643             if (*in == '<') {
4644                 return;
4645             }
4646             if (*in == '&') {
4647                 return;
4648             }
4649             SHRINK;
4650             GROW;
4651             if (ctxt->instate == XML_PARSER_EOF)
4652                 return;
4653             in = ctxt->input->cur;
4654         } while (((*in >= 0x20) && (*in <= 0x7F)) || (*in == 0x09));
4655         nbchar = 0;
4656     }
4657     ctxt->input->line = line;
4658     ctxt->input->col = col;
4659     xmlParseCharDataComplex(ctxt, cdata);
4660 }
4661
4662 /**
4663  * xmlParseCharDataComplex:
4664  * @ctxt:  an XML parser context
4665  * @cdata:  int indicating whether we are within a CDATA section
4666  *
4667  * parse a CharData section.this is the fallback function
4668  * of xmlParseCharData() when the parsing requires handling
4669  * of non-ASCII characters.
4670  */
4671 static void
4672 xmlParseCharDataComplex(xmlParserCtxtPtr ctxt, int cdata) {
4673     xmlChar buf[XML_PARSER_BIG_BUFFER_SIZE + 5];
4674     int nbchar = 0;
4675     int cur, l;
4676     int count = 0;
4677
4678     SHRINK;
4679     GROW;
4680     cur = CUR_CHAR(l);
4681     while ((cur != '<') && /* checked */
4682            (cur != '&') &&
4683            (IS_CHAR(cur))) /* test also done in xmlCurrentChar() */ {
4684         if ((cur == ']') && (NXT(1) == ']') &&
4685             (NXT(2) == '>')) {
4686             if (cdata) break;
4687             else {
4688                 xmlFatalErr(ctxt, XML_ERR_MISPLACED_CDATA_END, NULL);
4689             }
4690         }
4691         COPY_BUF(l,buf,nbchar,cur);
4692         if (nbchar >= XML_PARSER_BIG_BUFFER_SIZE) {
4693             buf[nbchar] = 0;
4694
4695             /*
4696              * OK the segment is to be consumed as chars.
4697              */
4698             if ((ctxt->sax != NULL) && (!ctxt->disableSAX)) {
4699                 if (areBlanks(ctxt, buf, nbchar, 0)) {
4700                     if (ctxt->sax->ignorableWhitespace != NULL)
4701                         ctxt->sax->ignorableWhitespace(ctxt->userData,
4702                                                        buf, nbchar);
4703                 } else {
4704                     if (ctxt->sax->characters != NULL)
4705                         ctxt->sax->characters(ctxt->userData, buf, nbchar);
4706                     if ((ctxt->sax->characters !=
4707                          ctxt->sax->ignorableWhitespace) &&
4708                         (*ctxt->space == -1))
4709                         *ctxt->space = -2;
4710                 }
4711             }
4712             nbchar = 0;
4713             /* something really bad happened in the SAX callback */
4714             if (ctxt->instate != XML_PARSER_CONTENT)
4715                 return;
4716         }
4717         count++;
4718         if (count > 50) {
4719             GROW;
4720             count = 0;
4721             if (ctxt->instate == XML_PARSER_EOF)
4722                 return;
4723         }
4724         NEXTL(l);
4725         cur = CUR_CHAR(l);
4726     }
4727     if (nbchar != 0) {
4728         buf[nbchar] = 0;
4729         /*
4730          * OK the segment is to be consumed as chars.
4731          */
4732         if ((ctxt->sax != NULL) && (!ctxt->disableSAX)) {
4733             if (areBlanks(ctxt, buf, nbchar, 0)) {
4734                 if (ctxt->sax->ignorableWhitespace != NULL)
4735                     ctxt->sax->ignorableWhitespace(ctxt->userData, buf, nbchar);
4736             } else {
4737                 if (ctxt->sax->characters != NULL)
4738                     ctxt->sax->characters(ctxt->userData, buf, nbchar);
4739                 if ((ctxt->sax->characters != ctxt->sax->ignorableWhitespace) &&
4740                     (*ctxt->space == -1))
4741                     *ctxt->space = -2;
4742             }
4743         }
4744     }
4745     if ((cur != 0) && (!IS_CHAR(cur))) {
4746         /* Generate the error and skip the offending character */
4747         xmlFatalErrMsgInt(ctxt, XML_ERR_INVALID_CHAR,
4748                           "PCDATA invalid Char value %d\n",
4749                           cur);
4750         NEXTL(l);
4751     }
4752 }
4753
4754 /**
4755  * xmlParseExternalID:
4756  * @ctxt:  an XML parser context
4757  * @publicID:  a xmlChar** receiving PubidLiteral
4758  * @strict: indicate whether we should restrict parsing to only
4759  *          production [75], see NOTE below
4760  *
4761  * Parse an External ID or a Public ID
4762  *
4763  * NOTE: Productions [75] and [83] interact badly since [75] can generate
4764  *       'PUBLIC' S PubidLiteral S SystemLiteral
4765  *
4766  * [75] ExternalID ::= 'SYSTEM' S SystemLiteral
4767  *                   | 'PUBLIC' S PubidLiteral S SystemLiteral
4768  *
4769  * [83] PublicID ::= 'PUBLIC' S PubidLiteral
4770  *
4771  * Returns the function returns SystemLiteral and in the second
4772  *                case publicID receives PubidLiteral, is strict is off
4773  *                it is possible to return NULL and have publicID set.
4774  */
4775
4776 xmlChar *
4777 xmlParseExternalID(xmlParserCtxtPtr ctxt, xmlChar **publicID, int strict) {
4778     xmlChar *URI = NULL;
4779
4780     SHRINK;
4781
4782     *publicID = NULL;
4783     if (CMP6(CUR_PTR, 'S', 'Y', 'S', 'T', 'E', 'M')) {
4784         SKIP(6);
4785         if (!IS_BLANK_CH(CUR)) {
4786             xmlFatalErrMsg(ctxt, XML_ERR_SPACE_REQUIRED,
4787                            "Space required after 'SYSTEM'\n");
4788         }
4789         SKIP_BLANKS;
4790         URI = xmlParseSystemLiteral(ctxt);
4791         if (URI == NULL) {
4792             xmlFatalErr(ctxt, XML_ERR_URI_REQUIRED, NULL);
4793         }
4794     } else if (CMP6(CUR_PTR, 'P', 'U', 'B', 'L', 'I', 'C')) {
4795         SKIP(6);
4796         if (!IS_BLANK_CH(CUR)) {
4797             xmlFatalErrMsg(ctxt, XML_ERR_SPACE_REQUIRED,
4798                     "Space required after 'PUBLIC'\n");
4799         }
4800         SKIP_BLANKS;
4801         *publicID = xmlParsePubidLiteral(ctxt);
4802         if (*publicID == NULL) {
4803             xmlFatalErr(ctxt, XML_ERR_PUBID_REQUIRED, NULL);
4804         }
4805         if (strict) {
4806             /*
4807              * We don't handle [83] so "S SystemLiteral" is required.
4808              */
4809             if (!IS_BLANK_CH(CUR)) {
4810                 xmlFatalErrMsg(ctxt, XML_ERR_SPACE_REQUIRED,
4811                         "Space required after the Public Identifier\n");
4812             }
4813         } else {
4814             /*
4815              * We handle [83] so we return immediately, if
4816              * "S SystemLiteral" is not detected. From a purely parsing
4817              * point of view that's a nice mess.
4818              */
4819             const xmlChar *ptr;
4820             GROW;
4821
4822             ptr = CUR_PTR;
4823             if (!IS_BLANK_CH(*ptr)) return(NULL);
4824
4825             while (IS_BLANK_CH(*ptr)) ptr++; /* TODO: dangerous, fix ! */
4826             if ((*ptr != '\'') && (*ptr != '"')) return(NULL);
4827         }
4828         SKIP_BLANKS;
4829         URI = xmlParseSystemLiteral(ctxt);
4830         if (URI == NULL) {
4831             xmlFatalErr(ctxt, XML_ERR_URI_REQUIRED, NULL);
4832         }
4833     }
4834     return(URI);
4835 }
4836
4837 /**
4838  * xmlParseCommentComplex:
4839  * @ctxt:  an XML parser context
4840  * @buf:  the already parsed part of the buffer
4841  * @len:  number of bytes filles in the buffer
4842  * @size:  allocated size of the buffer
4843  *
4844  * Skip an XML (SGML) comment <!-- .... -->
4845  *  The spec says that "For compatibility, the string "--" (double-hyphen)
4846  *  must not occur within comments. "
4847  * This is the slow routine in case the accelerator for ascii didn't work
4848  *
4849  * [15] Comment ::= '<!--' ((Char - '-') | ('-' (Char - '-')))* '-->'
4850  */
4851 static void
4852 xmlParseCommentComplex(xmlParserCtxtPtr ctxt, xmlChar *buf,
4853                        size_t len, size_t size) {
4854     int q, ql;
4855     int r, rl;
4856     int cur, l;
4857     size_t count = 0;
4858     int inputid;
4859
4860     inputid = ctxt->input->id;
4861
4862     if (buf == NULL) {
4863         len = 0;
4864         size = XML_PARSER_BUFFER_SIZE;
4865         buf = (xmlChar *) xmlMallocAtomic(size * sizeof(xmlChar));
4866         if (buf == NULL) {
4867             xmlErrMemory(ctxt, NULL);
4868             return;
4869         }
4870     }
4871     GROW;       /* Assure there's enough input data */
4872     q = CUR_CHAR(ql);
4873     if (q == 0)
4874         goto not_terminated;
4875     if (!IS_CHAR(q)) {
4876         xmlFatalErrMsgInt(ctxt, XML_ERR_INVALID_CHAR,
4877                           "xmlParseComment: invalid xmlChar value %d\n",
4878                           q);
4879         xmlFree (buf);
4880         return;
4881     }
4882     NEXTL(ql);
4883     r = CUR_CHAR(rl);
4884     if (r == 0)
4885         goto not_terminated;
4886     if (!IS_CHAR(r)) {
4887         xmlFatalErrMsgInt(ctxt, XML_ERR_INVALID_CHAR,
4888                           "xmlParseComment: invalid xmlChar value %d\n",
4889                           q);
4890         xmlFree (buf);
4891         return;
4892     }
4893     NEXTL(rl);
4894     cur = CUR_CHAR(l);
4895     if (cur == 0)
4896         goto not_terminated;
4897     while (IS_CHAR(cur) && /* checked */
4898            ((cur != '>') ||
4899             (r != '-') || (q != '-'))) {
4900         if ((r == '-') && (q == '-')) {
4901             xmlFatalErr(ctxt, XML_ERR_HYPHEN_IN_COMMENT, NULL);
4902         }
4903         if ((len > XML_MAX_TEXT_LENGTH) &&
4904             ((ctxt->options & XML_PARSE_HUGE) == 0)) {
4905             xmlFatalErrMsgStr(ctxt, XML_ERR_COMMENT_NOT_FINISHED,
4906                          "Comment too big found", NULL);
4907             xmlFree (buf);
4908             return;
4909         }
4910         if (len + 5 >= size) {
4911             xmlChar *new_buf;
4912             size_t new_size;
4913
4914             new_size = size * 2;
4915             new_buf = (xmlChar *) xmlRealloc(buf, new_size);
4916             if (new_buf == NULL) {
4917                 xmlFree (buf);
4918                 xmlErrMemory(ctxt, NULL);
4919                 return;
4920             }
4921             buf = new_buf;
4922             size = new_size;
4923         }
4924         COPY_BUF(ql,buf,len,q);
4925         q = r;
4926         ql = rl;
4927         r = cur;
4928         rl = l;
4929
4930         count++;
4931         if (count > 50) {
4932             GROW;
4933             count = 0;
4934             if (ctxt->instate == XML_PARSER_EOF) {
4935                 xmlFree(buf);
4936                 return;
4937             }
4938         }
4939         NEXTL(l);
4940         cur = CUR_CHAR(l);
4941         if (cur == 0) {
4942             SHRINK;
4943             GROW;
4944             cur = CUR_CHAR(l);
4945         }
4946     }
4947     buf[len] = 0;
4948     if (cur == 0) {
4949         xmlFatalErrMsgStr(ctxt, XML_ERR_COMMENT_NOT_FINISHED,
4950                              "Comment not terminated \n<!--%.50s\n", buf);
4951     } else if (!IS_CHAR(cur)) {
4952         xmlFatalErrMsgInt(ctxt, XML_ERR_INVALID_CHAR,
4953                           "xmlParseComment: invalid xmlChar value %d\n",
4954                           cur);
4955     } else {
4956         if (inputid != ctxt->input->id) {
4957             xmlFatalErrMsg(ctxt, XML_ERR_ENTITY_BOUNDARY,
4958                 "Comment doesn't start and stop in the same entity\n");
4959         }
4960         NEXT;
4961         if ((ctxt->sax != NULL) && (ctxt->sax->comment != NULL) &&
4962             (!ctxt->disableSAX))
4963             ctxt->sax->comment(ctxt->userData, buf);
4964     }
4965     xmlFree(buf);
4966     return;
4967 not_terminated:
4968     xmlFatalErrMsgStr(ctxt, XML_ERR_COMMENT_NOT_FINISHED,
4969                          "Comment not terminated\n", NULL);
4970     xmlFree(buf);
4971     return;
4972 }
4973
4974 /**
4975  * xmlParseComment:
4976  * @ctxt:  an XML parser context
4977  *
4978  * Skip an XML (SGML) comment <!-- .... -->
4979  *  The spec says that "For compatibility, the string "--" (double-hyphen)
4980  *  must not occur within comments. "
4981  *
4982  * [15] Comment ::= '<!--' ((Char - '-') | ('-' (Char - '-')))* '-->'
4983  */
4984 void
4985 xmlParseComment(xmlParserCtxtPtr ctxt) {
4986     xmlChar *buf = NULL;
4987     size_t size = XML_PARSER_BUFFER_SIZE;
4988     size_t len = 0;
4989     xmlParserInputState state;
4990     const xmlChar *in;
4991     size_t nbchar = 0;
4992     int ccol;
4993     int inputid;
4994
4995     /*
4996      * Check that there is a comment right here.
4997      */
4998     if ((RAW != '<') || (NXT(1) != '!') ||
4999         (NXT(2) != '-') || (NXT(3) != '-')) return;
5000     state = ctxt->instate;
5001     ctxt->instate = XML_PARSER_COMMENT;
5002     inputid = ctxt->input->id;
5003     SKIP(4);
5004     SHRINK;
5005     GROW;
5006
5007     /*
5008      * Accelerated common case where input don't need to be
5009      * modified before passing it to the handler.
5010      */
5011     in = ctxt->input->cur;
5012     do {
5013         if (*in == 0xA) {
5014             do {
5015                 ctxt->input->line++; ctxt->input->col = 1;
5016                 in++;
5017             } while (*in == 0xA);
5018         }
5019 get_more:
5020         ccol = ctxt->input->col;
5021         while (((*in > '-') && (*in <= 0x7F)) ||
5022                ((*in >= 0x20) && (*in < '-')) ||
5023                (*in == 0x09)) {
5024                     in++;
5025                     ccol++;
5026         }
5027         ctxt->input->col = ccol;
5028         if (*in == 0xA) {
5029             do {
5030                 ctxt->input->line++; ctxt->input->col = 1;
5031                 in++;
5032             } while (*in == 0xA);
5033             goto get_more;
5034         }
5035         nbchar = in - ctxt->input->cur;
5036         /*
5037          * save current set of data
5038          */
5039         if (nbchar > 0) {
5040             if ((ctxt->sax != NULL) &&
5041                 (ctxt->sax->comment != NULL)) {
5042                 if (buf == NULL) {
5043                     if ((*in == '-') && (in[1] == '-'))
5044                         size = nbchar + 1;
5045                     else
5046                         size = XML_PARSER_BUFFER_SIZE + nbchar;
5047                     buf = (xmlChar *) xmlMallocAtomic(size * sizeof(xmlChar));
5048                     if (buf == NULL) {
5049                         xmlErrMemory(ctxt, NULL);
5050                         ctxt->instate = state;
5051                         return;
5052                     }
5053                     len = 0;
5054                 } else if (len + nbchar + 1 >= size) {
5055                     xmlChar *new_buf;
5056                     size  += len + nbchar + XML_PARSER_BUFFER_SIZE;
5057                     new_buf = (xmlChar *) xmlRealloc(buf,
5058                                                      size * sizeof(xmlChar));
5059                     if (new_buf == NULL) {
5060                         xmlFree (buf);
5061                         xmlErrMemory(ctxt, NULL);
5062                         ctxt->instate = state;
5063                         return;
5064                     }
5065                     buf = new_buf;
5066                 }
5067                 memcpy(&buf[len], ctxt->input->cur, nbchar);
5068                 len += nbchar;
5069                 buf[len] = 0;
5070             }
5071         }
5072         if ((len > XML_MAX_TEXT_LENGTH) &&
5073             ((ctxt->options & XML_PARSE_HUGE) == 0)) {
5074             xmlFatalErrMsgStr(ctxt, XML_ERR_COMMENT_NOT_FINISHED,
5075                          "Comment too big found", NULL);
5076             xmlFree (buf);
5077             return;
5078         }
5079         ctxt->input->cur = in;
5080         if (*in == 0xA) {
5081             in++;
5082             ctxt->input->line++; ctxt->input->col = 1;
5083         }
5084         if (*in == 0xD) {
5085             in++;
5086             if (*in == 0xA) {
5087                 ctxt->input->cur = in;
5088                 in++;
5089                 ctxt->input->line++; ctxt->input->col = 1;
5090                 continue; /* while */
5091             }
5092             in--;
5093         }
5094         SHRINK;
5095         GROW;
5096         if (ctxt->instate == XML_PARSER_EOF) {
5097             xmlFree(buf);
5098             return;
5099         }
5100         in = ctxt->input->cur;
5101         if (*in == '-') {
5102             if (in[1] == '-') {
5103                 if (in[2] == '>') {
5104                     if (ctxt->input->id != inputid) {
5105                         xmlFatalErrMsg(ctxt, XML_ERR_ENTITY_BOUNDARY,
5106                         "comment doesn't start and stop in the same entity\n");
5107                     }
5108                     SKIP(3);
5109                     if ((ctxt->sax != NULL) && (ctxt->sax->comment != NULL) &&
5110                         (!ctxt->disableSAX)) {
5111                         if (buf != NULL)
5112                             ctxt->sax->comment(ctxt->userData, buf);
5113                         else
5114                             ctxt->sax->comment(ctxt->userData, BAD_CAST "");
5115                     }
5116                     if (buf != NULL)
5117                         xmlFree(buf);
5118                     if (ctxt->instate != XML_PARSER_EOF)
5119                         ctxt->instate = state;
5120                     return;
5121                 }
5122                 if (buf != NULL) {
5123                     xmlFatalErrMsgStr(ctxt, XML_ERR_HYPHEN_IN_COMMENT,
5124                                       "Double hyphen within comment: "
5125                                       "<!--%.50s\n",
5126                                       buf);
5127                 } else
5128                     xmlFatalErrMsgStr(ctxt, XML_ERR_HYPHEN_IN_COMMENT,
5129                                       "Double hyphen within comment\n", NULL);
5130                 in++;
5131                 ctxt->input->col++;
5132             }
5133             in++;
5134             ctxt->input->col++;
5135             goto get_more;
5136         }
5137     } while (((*in >= 0x20) && (*in <= 0x7F)) || (*in == 0x09));
5138     xmlParseCommentComplex(ctxt, buf, len, size);
5139     ctxt->instate = state;
5140     return;
5141 }
5142
5143
5144 /**
5145  * xmlParsePITarget:
5146  * @ctxt:  an XML parser context
5147  *
5148  * parse the name of a PI
5149  *
5150  * [17] PITarget ::= Name - (('X' | 'x') ('M' | 'm') ('L' | 'l'))
5151  *
5152  * Returns the PITarget name or NULL
5153  */
5154
5155 const xmlChar *
5156 xmlParsePITarget(xmlParserCtxtPtr ctxt) {
5157     const xmlChar *name;
5158
5159     name = xmlParseName(ctxt);
5160     if ((name != NULL) &&
5161         ((name[0] == 'x') || (name[0] == 'X')) &&
5162         ((name[1] == 'm') || (name[1] == 'M')) &&
5163         ((name[2] == 'l') || (name[2] == 'L'))) {
5164         int i;
5165         if ((name[0] == 'x') && (name[1] == 'm') &&
5166             (name[2] == 'l') && (name[3] == 0)) {
5167             xmlFatalErrMsg(ctxt, XML_ERR_RESERVED_XML_NAME,
5168                  "XML declaration allowed only at the start of the document\n");
5169             return(name);
5170         } else if (name[3] == 0) {
5171             xmlFatalErr(ctxt, XML_ERR_RESERVED_XML_NAME, NULL);
5172             return(name);
5173         }
5174         for (i = 0;;i++) {
5175             if (xmlW3CPIs[i] == NULL) break;
5176             if (xmlStrEqual(name, (const xmlChar *)xmlW3CPIs[i]))
5177                 return(name);
5178         }
5179         xmlWarningMsg(ctxt, XML_ERR_RESERVED_XML_NAME,
5180                       "xmlParsePITarget: invalid name prefix 'xml'\n",
5181                       NULL, NULL);
5182     }
5183     if ((name != NULL) && (xmlStrchr(name, ':') != NULL)) {
5184         xmlNsErr(ctxt, XML_NS_ERR_COLON,
5185                  "colons are forbidden from PI names '%s'\n", name, NULL, NULL);
5186     }
5187     return(name);
5188 }
5189
5190 #ifdef LIBXML_CATALOG_ENABLED
5191 /**
5192  * xmlParseCatalogPI:
5193  * @ctxt:  an XML parser context
5194  * @catalog:  the PI value string
5195  *
5196  * parse an XML Catalog Processing Instruction.
5197  *
5198  * <?oasis-xml-catalog catalog="http://example.com/catalog.xml"?>
5199  *
5200  * Occurs only if allowed by the user and if happening in the Misc
5201  * part of the document before any doctype informations
5202  * This will add the given catalog to the parsing context in order
5203  * to be used if there is a resolution need further down in the document
5204  */
5205
5206 static void
5207 xmlParseCatalogPI(xmlParserCtxtPtr ctxt, const xmlChar *catalog) {
5208     xmlChar *URL = NULL;
5209     const xmlChar *tmp, *base;
5210     xmlChar marker;
5211
5212     tmp = catalog;
5213     while (IS_BLANK_CH(*tmp)) tmp++;
5214     if (xmlStrncmp(tmp, BAD_CAST"catalog", 7))
5215         goto error;
5216     tmp += 7;
5217     while (IS_BLANK_CH(*tmp)) tmp++;
5218     if (*tmp != '=') {
5219         return;
5220     }
5221     tmp++;
5222     while (IS_BLANK_CH(*tmp)) tmp++;
5223     marker = *tmp;
5224     if ((marker != '\'') && (marker != '"'))
5225         goto error;
5226     tmp++;
5227     base = tmp;
5228     while ((*tmp != 0) && (*tmp != marker)) tmp++;
5229     if (*tmp == 0)
5230         goto error;
5231     URL = xmlStrndup(base, tmp - base);
5232     tmp++;
5233     while (IS_BLANK_CH(*tmp)) tmp++;
5234     if (*tmp != 0)
5235         goto error;
5236
5237     if (URL != NULL) {
5238         ctxt->catalogs = xmlCatalogAddLocal(ctxt->catalogs, URL);
5239         xmlFree(URL);
5240     }
5241     return;
5242
5243 error:
5244     xmlWarningMsg(ctxt, XML_WAR_CATALOG_PI,
5245                   "Catalog PI syntax error: %s\n",
5246                   catalog, NULL);
5247     if (URL != NULL)
5248         xmlFree(URL);
5249 }
5250 #endif
5251
5252 /**
5253  * xmlParsePI:
5254  * @ctxt:  an XML parser context
5255  *
5256  * parse an XML Processing Instruction.
5257  *
5258  * [16] PI ::= '<?' PITarget (S (Char* - (Char* '?>' Char*)))? '?>'
5259  *
5260  * The processing is transfered to SAX once parsed.
5261  */
5262
5263 void
5264 xmlParsePI(xmlParserCtxtPtr ctxt) {
5265     xmlChar *buf = NULL;
5266     size_t len = 0;
5267     size_t size = XML_PARSER_BUFFER_SIZE;
5268     int cur, l;
5269     const xmlChar *target;
5270     xmlParserInputState state;
5271     int count = 0;
5272
5273     if ((RAW == '<') && (NXT(1) == '?')) {
5274         xmlParserInputPtr input = ctxt->input;
5275         state = ctxt->instate;
5276         ctxt->instate = XML_PARSER_PI;
5277         /*
5278          * this is a Processing Instruction.
5279          */
5280         SKIP(2);
5281         SHRINK;
5282
5283         /*
5284          * Parse the target name and check for special support like
5285          * namespace.
5286          */
5287         target = xmlParsePITarget(ctxt);
5288         if (target != NULL) {
5289             if ((RAW == '?') && (NXT(1) == '>')) {
5290                 if (input != ctxt->input) {
5291                     xmlFatalErrMsg(ctxt, XML_ERR_ENTITY_BOUNDARY,
5292             "PI declaration doesn't start and stop in the same entity\n");
5293                 }
5294                 SKIP(2);
5295
5296                 /*
5297                  * SAX: PI detected.
5298                  */
5299                 if ((ctxt->sax) && (!ctxt->disableSAX) &&
5300                     (ctxt->sax->processingInstruction != NULL))
5301                     ctxt->sax->processingInstruction(ctxt->userData,
5302                                                      target, NULL);
5303                 if (ctxt->instate != XML_PARSER_EOF)
5304                     ctxt->instate = state;
5305                 return;
5306             }
5307             buf = (xmlChar *) xmlMallocAtomic(size * sizeof(xmlChar));
5308             if (buf == NULL) {
5309                 xmlErrMemory(ctxt, NULL);
5310                 ctxt->instate = state;
5311                 return;
5312             }
5313             cur = CUR;
5314             if (!IS_BLANK(cur)) {
5315                 xmlFatalErrMsgStr(ctxt, XML_ERR_SPACE_REQUIRED,
5316                           "ParsePI: PI %s space expected\n", target);
5317             }
5318             SKIP_BLANKS;
5319             cur = CUR_CHAR(l);
5320             while (IS_CHAR(cur) && /* checked */
5321                    ((cur != '?') || (NXT(1) != '>'))) {
5322                 if (len + 5 >= size) {
5323                     xmlChar *tmp;
5324                     size_t new_size = size * 2;
5325                     tmp = (xmlChar *) xmlRealloc(buf, new_size);
5326                     if (tmp == NULL) {
5327                         xmlErrMemory(ctxt, NULL);
5328                         xmlFree(buf);
5329                         ctxt->instate = state;
5330                         return;
5331                     }
5332                     buf = tmp;
5333                     size = new_size;
5334                 }
5335                 count++;
5336                 if (count > 50) {
5337                     GROW;
5338                     if (ctxt->instate == XML_PARSER_EOF) {
5339                         xmlFree(buf);
5340                         return;
5341                     }
5342                     count = 0;
5343                     if ((len > XML_MAX_TEXT_LENGTH) &&
5344                         ((ctxt->options & XML_PARSE_HUGE) == 0)) {
5345                         xmlFatalErrMsgStr(ctxt, XML_ERR_PI_NOT_FINISHED,
5346                                           "PI %s too big found", target);
5347                         xmlFree(buf);
5348                         ctxt->instate = state;
5349                         return;
5350                     }
5351                 }
5352                 COPY_BUF(l,buf,len,cur);
5353                 NEXTL(l);
5354                 cur = CUR_CHAR(l);
5355                 if (cur == 0) {
5356                     SHRINK;
5357                     GROW;
5358                     cur = CUR_CHAR(l);
5359                 }
5360             }
5361             if ((len > XML_MAX_TEXT_LENGTH) &&
5362                 ((ctxt->options & XML_PARSE_HUGE) == 0)) {
5363                 xmlFatalErrMsgStr(ctxt, XML_ERR_PI_NOT_FINISHED,
5364                                   "PI %s too big found", target);
5365                 xmlFree(buf);
5366                 ctxt->instate = state;
5367                 return;
5368             }
5369             buf[len] = 0;
5370             if (cur != '?') {
5371                 xmlFatalErrMsgStr(ctxt, XML_ERR_PI_NOT_FINISHED,
5372                       "ParsePI: PI %s never end ...\n", target);
5373             } else {
5374                 if (input != ctxt->input) {
5375                     xmlFatalErrMsg(ctxt, XML_ERR_SPACE_REQUIRED,
5376             "PI declaration doesn't start and stop in the same entity\n");
5377                 }
5378                 SKIP(2);
5379
5380 #ifdef LIBXML_CATALOG_ENABLED
5381                 if (((state == XML_PARSER_MISC) ||
5382                      (state == XML_PARSER_START)) &&
5383                     (xmlStrEqual(target, XML_CATALOG_PI))) {
5384                     xmlCatalogAllow allow = xmlCatalogGetDefaults();
5385                     if ((allow == XML_CATA_ALLOW_DOCUMENT) ||
5386                         (allow == XML_CATA_ALLOW_ALL))
5387                         xmlParseCatalogPI(ctxt, buf);
5388                 }
5389 #endif
5390
5391
5392                 /*
5393                  * SAX: PI detected.
5394                  */
5395                 if ((ctxt->sax) && (!ctxt->disableSAX) &&
5396                     (ctxt->sax->processingInstruction != NULL))
5397                     ctxt->sax->processingInstruction(ctxt->userData,
5398                                                      target, buf);
5399             }
5400             xmlFree(buf);
5401         } else {
5402             xmlFatalErr(ctxt, XML_ERR_PI_NOT_STARTED, NULL);
5403         }
5404         if (ctxt->instate != XML_PARSER_EOF)
5405             ctxt->instate = state;
5406     }
5407 }
5408
5409 /**
5410  * xmlParseNotationDecl:
5411  * @ctxt:  an XML parser context
5412  *
5413  * parse a notation declaration
5414  *
5415  * [82] NotationDecl ::= '<!NOTATION' S Name S (ExternalID |  PublicID) S? '>'
5416  *
5417  * Hence there is actually 3 choices:
5418  *     'PUBLIC' S PubidLiteral
5419  *     'PUBLIC' S PubidLiteral S SystemLiteral
5420  * and 'SYSTEM' S SystemLiteral
5421  *
5422  * See the NOTE on xmlParseExternalID().
5423  */
5424
5425 void
5426 xmlParseNotationDecl(xmlParserCtxtPtr ctxt) {
5427     const xmlChar *name;
5428     xmlChar *Pubid;
5429     xmlChar *Systemid;
5430
5431     if (CMP10(CUR_PTR, '<', '!', 'N', 'O', 'T', 'A', 'T', 'I', 'O', 'N')) {
5432         xmlParserInputPtr input = ctxt->input;
5433         SHRINK;
5434         SKIP(10);
5435         if (!IS_BLANK_CH(CUR)) {
5436             xmlFatalErrMsg(ctxt, XML_ERR_SPACE_REQUIRED,
5437                            "Space required after '<!NOTATION'\n");
5438             return;
5439         }
5440         SKIP_BLANKS;
5441
5442         name = xmlParseName(ctxt);
5443         if (name == NULL) {
5444             xmlFatalErr(ctxt, XML_ERR_NOTATION_NOT_STARTED, NULL);
5445             return;
5446         }
5447         if (!IS_BLANK_CH(CUR)) {
5448             xmlFatalErrMsg(ctxt, XML_ERR_SPACE_REQUIRED,
5449                      "Space required after the NOTATION name'\n");
5450             return;
5451         }
5452         if (xmlStrchr(name, ':') != NULL) {
5453             xmlNsErr(ctxt, XML_NS_ERR_COLON,
5454                      "colons are forbidden from notation names '%s'\n",
5455                      name, NULL, NULL);
5456         }
5457         SKIP_BLANKS;
5458
5459         /*
5460          * Parse the IDs.
5461          */
5462         Systemid = xmlParseExternalID(ctxt, &Pubid, 0);
5463         SKIP_BLANKS;
5464
5465         if (RAW == '>') {
5466             if (input != ctxt->input) {
5467                 xmlFatalErrMsg(ctxt, XML_ERR_SPACE_REQUIRED,
5468         "Notation declaration doesn't start and stop in the same entity\n");
5469             }
5470             NEXT;
5471             if ((ctxt->sax != NULL) && (!ctxt->disableSAX) &&
5472                 (ctxt->sax->notationDecl != NULL))
5473                 ctxt->sax->notationDecl(ctxt->userData, name, Pubid, Systemid);
5474         } else {
5475             xmlFatalErr(ctxt, XML_ERR_NOTATION_NOT_FINISHED, NULL);
5476         }
5477         if (Systemid != NULL) xmlFree(Systemid);
5478         if (Pubid != NULL) xmlFree(Pubid);
5479     }
5480 }
5481
5482 /**
5483  * xmlParseEntityDecl:
5484  * @ctxt:  an XML parser context
5485  *
5486  * parse <!ENTITY declarations
5487  *
5488  * [70] EntityDecl ::= GEDecl | PEDecl
5489  *
5490  * [71] GEDecl ::= '<!ENTITY' S Name S EntityDef S? '>'
5491  *
5492  * [72] PEDecl ::= '<!ENTITY' S '%' S Name S PEDef S? '>'
5493  *
5494  * [73] EntityDef ::= EntityValue | (ExternalID NDataDecl?)
5495  *
5496  * [74] PEDef ::= EntityValue | ExternalID
5497  *
5498  * [76] NDataDecl ::= S 'NDATA' S Name
5499  *
5500  * [ VC: Notation Declared ]
5501  * The Name must match the declared name of a notation.
5502  */
5503
5504 void
5505 xmlParseEntityDecl(xmlParserCtxtPtr ctxt) {
5506     const xmlChar *name = NULL;
5507     xmlChar *value = NULL;
5508     xmlChar *URI = NULL, *literal = NULL;
5509     const xmlChar *ndata = NULL;
5510     int isParameter = 0;
5511     xmlChar *orig = NULL;
5512     int skipped;
5513
5514     /* GROW; done in the caller */
5515     if (CMP8(CUR_PTR, '<', '!', 'E', 'N', 'T', 'I', 'T', 'Y')) {
5516         xmlParserInputPtr input = ctxt->input;
5517         SHRINK;
5518         SKIP(8);
5519         skipped = SKIP_BLANKS;
5520         if (skipped == 0) {
5521             xmlFatalErrMsg(ctxt, XML_ERR_SPACE_REQUIRED,
5522                            "Space required after '<!ENTITY'\n");
5523         }
5524
5525         if (RAW == '%') {
5526             NEXT;
5527             skipped = SKIP_BLANKS;
5528             if (skipped == 0) {
5529                 xmlFatalErrMsg(ctxt, XML_ERR_SPACE_REQUIRED,
5530                                "Space required after '%%'\n");
5531             }
5532             isParameter = 1;
5533         }
5534
5535         name = xmlParseName(ctxt);
5536         if (name == NULL) {
5537             xmlFatalErrMsg(ctxt, XML_ERR_NAME_REQUIRED,
5538                            "xmlParseEntityDecl: no name\n");
5539             return;
5540         }
5541         if (xmlStrchr(name, ':') != NULL) {
5542             xmlNsErr(ctxt, XML_NS_ERR_COLON,
5543                      "colons are forbidden from entities names '%s'\n",
5544                      name, NULL, NULL);
5545         }
5546         skipped = SKIP_BLANKS;
5547         if (skipped == 0) {
5548             xmlFatalErrMsg(ctxt, XML_ERR_SPACE_REQUIRED,
5549                            "Space required after the entity name\n");
5550         }
5551
5552         ctxt->instate = XML_PARSER_ENTITY_DECL;
5553         /*
5554          * handle the various case of definitions...
5555          */
5556         if (isParameter) {
5557             if ((RAW == '"') || (RAW == '\'')) {
5558                 value = xmlParseEntityValue(ctxt, &orig);
5559                 if (value) {
5560                     if ((ctxt->sax != NULL) &&
5561                         (!ctxt->disableSAX) && (ctxt->sax->entityDecl != NULL))
5562                         ctxt->sax->entityDecl(ctxt->userData, name,
5563                                     XML_INTERNAL_PARAMETER_ENTITY,
5564                                     NULL, NULL, value);
5565                 }
5566             } else {
5567                 URI = xmlParseExternalID(ctxt, &literal, 1);
5568                 if ((URI == NULL) && (literal == NULL)) {
5569                     xmlFatalErr(ctxt, XML_ERR_VALUE_REQUIRED, NULL);
5570                 }
5571                 if (URI) {
5572                     xmlURIPtr uri;
5573
5574                     uri = xmlParseURI((const char *) URI);
5575                     if (uri == NULL) {
5576                         xmlErrMsgStr(ctxt, XML_ERR_INVALID_URI,
5577                                      "Invalid URI: %s\n", URI);
5578                         /*
5579                          * This really ought to be a well formedness error
5580                          * but the XML Core WG decided otherwise c.f. issue
5581                          * E26 of the XML erratas.
5582                          */
5583                     } else {
5584                         if (uri->fragment != NULL) {
5585                             /*
5586                              * Okay this is foolish to block those but not
5587                              * invalid URIs.
5588                              */
5589                             xmlFatalErr(ctxt, XML_ERR_URI_FRAGMENT, NULL);
5590                         } else {
5591                             if ((ctxt->sax != NULL) &&
5592                                 (!ctxt->disableSAX) &&
5593                                 (ctxt->sax->entityDecl != NULL))
5594                                 ctxt->sax->entityDecl(ctxt->userData, name,
5595                                             XML_EXTERNAL_PARAMETER_ENTITY,
5596                                             literal, URI, NULL);
5597                         }
5598                         xmlFreeURI(uri);
5599                     }
5600                 }
5601             }
5602         } else {
5603             if ((RAW == '"') || (RAW == '\'')) {
5604                 value = xmlParseEntityValue(ctxt, &orig);
5605                 if ((ctxt->sax != NULL) &&
5606                     (!ctxt->disableSAX) && (ctxt->sax->entityDecl != NULL))
5607                     ctxt->sax->entityDecl(ctxt->userData, name,
5608                                 XML_INTERNAL_GENERAL_ENTITY,
5609                                 NULL, NULL, value);
5610                 /*
5611                  * For expat compatibility in SAX mode.
5612                  */
5613                 if ((ctxt->myDoc == NULL) ||
5614                     (xmlStrEqual(ctxt->myDoc->version, SAX_COMPAT_MODE))) {
5615                     if (ctxt->myDoc == NULL) {
5616                         ctxt->myDoc = xmlNewDoc(SAX_COMPAT_MODE);
5617                         if (ctxt->myDoc == NULL) {
5618                             xmlErrMemory(ctxt, "New Doc failed");
5619                             return;
5620                         }
5621                         ctxt->myDoc->properties = XML_DOC_INTERNAL;
5622                     }
5623                     if (ctxt->myDoc->intSubset == NULL)
5624                         ctxt->myDoc->intSubset = xmlNewDtd(ctxt->myDoc,
5625                                             BAD_CAST "fake", NULL, NULL);
5626
5627                     xmlSAX2EntityDecl(ctxt, name, XML_INTERNAL_GENERAL_ENTITY,
5628                                       NULL, NULL, value);
5629                 }
5630             } else {
5631                 URI = xmlParseExternalID(ctxt, &literal, 1);
5632                 if ((URI == NULL) && (literal == NULL)) {
5633                     xmlFatalErr(ctxt, XML_ERR_VALUE_REQUIRED, NULL);
5634                 }
5635                 if (URI) {
5636                     xmlURIPtr uri;
5637
5638                     uri = xmlParseURI((const char *)URI);
5639                     if (uri == NULL) {
5640                         xmlErrMsgStr(ctxt, XML_ERR_INVALID_URI,
5641                                      "Invalid URI: %s\n", URI);
5642                         /*
5643                          * This really ought to be a well formedness error
5644                          * but the XML Core WG decided otherwise c.f. issue
5645                          * E26 of the XML erratas.
5646                          */
5647                     } else {
5648                         if (uri->fragment != NULL) {
5649                             /*
5650                              * Okay this is foolish to block those but not
5651                              * invalid URIs.
5652                              */
5653                             xmlFatalErr(ctxt, XML_ERR_URI_FRAGMENT, NULL);
5654                         }
5655                         xmlFreeURI(uri);
5656                     }
5657                 }
5658                 if ((RAW != '>') && (!IS_BLANK_CH(CUR))) {
5659                     xmlFatalErrMsg(ctxt, XML_ERR_SPACE_REQUIRED,
5660                                    "Space required before 'NDATA'\n");
5661                 }
5662                 SKIP_BLANKS;
5663                 if (CMP5(CUR_PTR, 'N', 'D', 'A', 'T', 'A')) {
5664                     SKIP(5);
5665                     if (!IS_BLANK_CH(CUR)) {
5666                         xmlFatalErrMsg(ctxt, XML_ERR_SPACE_REQUIRED,
5667                                        "Space required after 'NDATA'\n");
5668                     }
5669                     SKIP_BLANKS;
5670                     ndata = xmlParseName(ctxt);
5671                     if ((ctxt->sax != NULL) && (!ctxt->disableSAX) &&
5672                         (ctxt->sax->unparsedEntityDecl != NULL))
5673                         ctxt->sax->unparsedEntityDecl(ctxt->userData, name,
5674                                     literal, URI, ndata);
5675                 } else {
5676                     if ((ctxt->sax != NULL) &&
5677                         (!ctxt->disableSAX) && (ctxt->sax->entityDecl != NULL))
5678                         ctxt->sax->entityDecl(ctxt->userData, name,
5679                                     XML_EXTERNAL_GENERAL_PARSED_ENTITY,
5680                                     literal, URI, NULL);
5681                     /*
5682                      * For expat compatibility in SAX mode.
5683                      * assuming the entity repalcement was asked for
5684                      */
5685                     if ((ctxt->replaceEntities != 0) &&
5686                         ((ctxt->myDoc == NULL) ||
5687                         (xmlStrEqual(ctxt->myDoc->version, SAX_COMPAT_MODE)))) {
5688                         if (ctxt->myDoc == NULL) {
5689                             ctxt->myDoc = xmlNewDoc(SAX_COMPAT_MODE);
5690                             if (ctxt->myDoc == NULL) {
5691                                 xmlErrMemory(ctxt, "New Doc failed");
5692                                 return;
5693                             }
5694                             ctxt->myDoc->properties = XML_DOC_INTERNAL;
5695                         }
5696
5697                         if (ctxt->myDoc->intSubset == NULL)
5698                             ctxt->myDoc->intSubset = xmlNewDtd(ctxt->myDoc,
5699                                                 BAD_CAST "fake", NULL, NULL);
5700                         xmlSAX2EntityDecl(ctxt, name,
5701                                           XML_EXTERNAL_GENERAL_PARSED_ENTITY,
5702                                           literal, URI, NULL);
5703                     }
5704                 }
5705             }
5706         }
5707         if (ctxt->instate == XML_PARSER_EOF)
5708             return;
5709         SKIP_BLANKS;
5710         if (RAW != '>') {
5711             xmlFatalErrMsgStr(ctxt, XML_ERR_ENTITY_NOT_FINISHED,
5712                     "xmlParseEntityDecl: entity %s not terminated\n", name);
5713             xmlHaltParser(ctxt);
5714         } else {
5715             if (input != ctxt->input) {
5716                 xmlFatalErrMsg(ctxt, XML_ERR_ENTITY_BOUNDARY,
5717         "Entity declaration doesn't start and stop in the same entity\n");
5718             }
5719             NEXT;
5720         }
5721         if (orig != NULL) {
5722             /*
5723              * Ugly mechanism to save the raw entity value.
5724              */
5725             xmlEntityPtr cur = NULL;
5726
5727             if (isParameter) {
5728                 if ((ctxt->sax != NULL) &&
5729                     (ctxt->sax->getParameterEntity != NULL))
5730                     cur = ctxt->sax->getParameterEntity(ctxt->userData, name);
5731             } else {
5732                 if ((ctxt->sax != NULL) &&
5733                     (ctxt->sax->getEntity != NULL))
5734                     cur = ctxt->sax->getEntity(ctxt->userData, name);
5735                 if ((cur == NULL) && (ctxt->userData==ctxt)) {
5736                     cur = xmlSAX2GetEntity(ctxt, name);
5737                 }
5738             }
5739             if (cur != NULL) {
5740                 if (cur->orig != NULL)
5741                     xmlFree(orig);
5742                 else
5743                     cur->orig = orig;
5744             } else
5745                 xmlFree(orig);
5746         }
5747         if (value != NULL) xmlFree(value);
5748         if (URI != NULL) xmlFree(URI);
5749         if (literal != NULL) xmlFree(literal);
5750     }
5751 }
5752
5753 /**
5754  * xmlParseDefaultDecl:
5755  * @ctxt:  an XML parser context
5756  * @value:  Receive a possible fixed default value for the attribute
5757  *
5758  * Parse an attribute default declaration
5759  *
5760  * [60] DefaultDecl ::= '#REQUIRED' | '#IMPLIED' | (('#FIXED' S)? AttValue)
5761  *
5762  * [ VC: Required Attribute ]
5763  * if the default declaration is the keyword #REQUIRED, then the
5764  * attribute must be specified for all elements of the type in the
5765  * attribute-list declaration.
5766  *
5767  * [ VC: Attribute Default Legal ]
5768  * The declared default value must meet the lexical constraints of
5769  * the declared attribute type c.f. xmlValidateAttributeDecl()
5770  *
5771  * [ VC: Fixed Attribute Default ]
5772  * if an attribute has a default value declared with the #FIXED
5773  * keyword, instances of that attribute must match the default value.
5774  *
5775  * [ WFC: No < in Attribute Values ]
5776  * handled in xmlParseAttValue()
5777  *
5778  * returns: XML_ATTRIBUTE_NONE, XML_ATTRIBUTE_REQUIRED, XML_ATTRIBUTE_IMPLIED
5779  *          or XML_ATTRIBUTE_FIXED.
5780  */
5781
5782 int
5783 xmlParseDefaultDecl(xmlParserCtxtPtr ctxt, xmlChar **value) {
5784     int val;
5785     xmlChar *ret;
5786
5787     *value = NULL;
5788     if (CMP9(CUR_PTR, '#', 'R', 'E', 'Q', 'U', 'I', 'R', 'E', 'D')) {
5789         SKIP(9);
5790         return(XML_ATTRIBUTE_REQUIRED);
5791     }
5792     if (CMP8(CUR_PTR, '#', 'I', 'M', 'P', 'L', 'I', 'E', 'D')) {
5793         SKIP(8);
5794         return(XML_ATTRIBUTE_IMPLIED);
5795     }
5796     val = XML_ATTRIBUTE_NONE;
5797     if (CMP6(CUR_PTR, '#', 'F', 'I', 'X', 'E', 'D')) {
5798         SKIP(6);
5799         val = XML_ATTRIBUTE_FIXED;
5800         if (!IS_BLANK_CH(CUR)) {
5801             xmlFatalErrMsg(ctxt, XML_ERR_SPACE_REQUIRED,
5802                            "Space required after '#FIXED'\n");
5803         }
5804         SKIP_BLANKS;
5805     }
5806     ret = xmlParseAttValue(ctxt);
5807     ctxt->instate = XML_PARSER_DTD;
5808     if (ret == NULL) {
5809         xmlFatalErrMsg(ctxt, (xmlParserErrors)ctxt->errNo,
5810                        "Attribute default value declaration error\n");
5811     } else
5812         *value = ret;
5813     return(val);
5814 }
5815
5816 /**
5817  * xmlParseNotationType:
5818  * @ctxt:  an XML parser context
5819  *
5820  * parse an Notation attribute type.
5821  *
5822  * Note: the leading 'NOTATION' S part has already being parsed...
5823  *
5824  * [58] NotationType ::= 'NOTATION' S '(' S? Name (S? '|' S? Name)* S? ')'
5825  *
5826  * [ VC: Notation Attributes ]
5827  * Values of this type must match one of the notation names included
5828  * in the declaration; all notation names in the declaration must be declared.
5829  *
5830  * Returns: the notation attribute tree built while parsing
5831  */
5832
5833 xmlEnumerationPtr
5834 xmlParseNotationType(xmlParserCtxtPtr ctxt) {
5835     const xmlChar *name;
5836     xmlEnumerationPtr ret = NULL, last = NULL, cur, tmp;
5837
5838     if (RAW != '(') {
5839         xmlFatalErr(ctxt, XML_ERR_NOTATION_NOT_STARTED, NULL);
5840         return(NULL);
5841     }
5842     SHRINK;
5843     do {
5844         NEXT;
5845         SKIP_BLANKS;
5846         name = xmlParseName(ctxt);
5847         if (name == NULL) {
5848             xmlFatalErrMsg(ctxt, XML_ERR_NAME_REQUIRED,
5849                            "Name expected in NOTATION declaration\n");
5850             xmlFreeEnumeration(ret);
5851             return(NULL);
5852         }
5853         tmp = ret;
5854         while (tmp != NULL) {
5855             if (xmlStrEqual(name, tmp->name)) {
5856                 xmlValidityError(ctxt, XML_DTD_DUP_TOKEN,
5857           "standalone: attribute notation value token %s duplicated\n",
5858                                  name, NULL);
5859                 if (!xmlDictOwns(ctxt->dict, name))
5860                     xmlFree((xmlChar *) name);
5861                 break;
5862             }
5863             tmp = tmp->next;
5864         }
5865         if (tmp == NULL) {
5866             cur = xmlCreateEnumeration(name);
5867             if (cur == NULL) {
5868                 xmlFreeEnumeration(ret);
5869                 return(NULL);
5870             }
5871             if (last == NULL) ret = last = cur;
5872             else {
5873                 last->next = cur;
5874                 last = cur;
5875             }
5876         }
5877         SKIP_BLANKS;
5878     } while (RAW == '|');
5879     if (RAW != ')') {
5880         xmlFatalErr(ctxt, XML_ERR_NOTATION_NOT_FINISHED, NULL);
5881         xmlFreeEnumeration(ret);
5882         return(NULL);
5883     }
5884     NEXT;
5885     return(ret);
5886 }
5887
5888 /**
5889  * xmlParseEnumerationType:
5890  * @ctxt:  an XML parser context
5891  *
5892  * parse an Enumeration attribute type.
5893  *
5894  * [59] Enumeration ::= '(' S? Nmtoken (S? '|' S? Nmtoken)* S? ')'
5895  *
5896  * [ VC: Enumeration ]
5897  * Values of this type must match one of the Nmtoken tokens in
5898  * the declaration
5899  *
5900  * Returns: the enumeration attribute tree built while parsing
5901  */
5902
5903 xmlEnumerationPtr
5904 xmlParseEnumerationType(xmlParserCtxtPtr ctxt) {
5905     xmlChar *name;
5906     xmlEnumerationPtr ret = NULL, last = NULL, cur, tmp;
5907
5908     if (RAW != '(') {
5909         xmlFatalErr(ctxt, XML_ERR_ATTLIST_NOT_STARTED, NULL);
5910         return(NULL);
5911     }
5912     SHRINK;
5913     do {
5914         NEXT;
5915         SKIP_BLANKS;
5916         name = xmlParseNmtoken(ctxt);
5917         if (name == NULL) {
5918             xmlFatalErr(ctxt, XML_ERR_NMTOKEN_REQUIRED, NULL);
5919             return(ret);
5920         }
5921         tmp = ret;
5922         while (tmp != NULL) {
5923             if (xmlStrEqual(name, tmp->name)) {
5924                 xmlValidityError(ctxt, XML_DTD_DUP_TOKEN,
5925           "standalone: attribute enumeration value token %s duplicated\n",
5926                                  name, NULL);
5927                 if (!xmlDictOwns(ctxt->dict, name))
5928                     xmlFree(name);
5929                 break;
5930             }
5931             tmp = tmp->next;
5932         }
5933         if (tmp == NULL) {
5934             cur = xmlCreateEnumeration(name);
5935             if (!xmlDictOwns(ctxt->dict, name))
5936                 xmlFree(name);
5937             if (cur == NULL) {
5938                 xmlFreeEnumeration(ret);
5939                 return(NULL);
5940             }
5941             if (last == NULL) ret = last = cur;
5942             else {
5943                 last->next = cur;
5944                 last = cur;
5945             }
5946         }
5947         SKIP_BLANKS;
5948     } while (RAW == '|');
5949     if (RAW != ')') {
5950         xmlFatalErr(ctxt, XML_ERR_ATTLIST_NOT_FINISHED, NULL);
5951         return(ret);
5952     }
5953     NEXT;
5954     return(ret);
5955 }
5956
5957 /**
5958  * xmlParseEnumeratedType:
5959  * @ctxt:  an XML parser context
5960  * @tree:  the enumeration tree built while parsing
5961  *
5962  * parse an Enumerated attribute type.
5963  *
5964  * [57] EnumeratedType ::= NotationType | Enumeration
5965  *
5966  * [58] NotationType ::= 'NOTATION' S '(' S? Name (S? '|' S? Name)* S? ')'
5967  *
5968  *
5969  * Returns: XML_ATTRIBUTE_ENUMERATION or XML_ATTRIBUTE_NOTATION
5970  */
5971
5972 int
5973 xmlParseEnumeratedType(xmlParserCtxtPtr ctxt, xmlEnumerationPtr *tree) {
5974     if (CMP8(CUR_PTR, 'N', 'O', 'T', 'A', 'T', 'I', 'O', 'N')) {
5975         SKIP(8);
5976         if (!IS_BLANK_CH(CUR)) {
5977             xmlFatalErrMsg(ctxt, XML_ERR_SPACE_REQUIRED,
5978                            "Space required after 'NOTATION'\n");
5979             return(0);
5980         }
5981         SKIP_BLANKS;
5982         *tree = xmlParseNotationType(ctxt);
5983         if (*tree == NULL) return(0);
5984         return(XML_ATTRIBUTE_NOTATION);
5985     }
5986     *tree = xmlParseEnumerationType(ctxt);
5987     if (*tree == NULL) return(0);
5988     return(XML_ATTRIBUTE_ENUMERATION);
5989 }
5990
5991 /**
5992  * xmlParseAttributeType:
5993  * @ctxt:  an XML parser context
5994  * @tree:  the enumeration tree built while parsing
5995  *
5996  * parse the Attribute list def for an element
5997  *
5998  * [54] AttType ::= StringType | TokenizedType | EnumeratedType
5999  *
6000  * [55] StringType ::= 'CDATA'
6001  *
6002  * [56] TokenizedType ::= 'ID' | 'IDREF' | 'IDREFS' | 'ENTITY' |
6003  *                        'ENTITIES' | 'NMTOKEN' | 'NMTOKENS'
6004  *
6005  * Validity constraints for attribute values syntax are checked in
6006  * xmlValidateAttributeValue()
6007  *
6008  * [ VC: ID ]
6009  * Values of type ID must match the Name production. A name must not
6010  * appear more than once in an XML document as a value of this type;
6011  * i.e., ID values must uniquely identify the elements which bear them.
6012  *
6013  * [ VC: One ID per Element Type ]
6014  * No element type may have more than one ID attribute specified.
6015  *
6016  * [ VC: ID Attribute Default ]
6017  * An ID attribute must have a declared default of #IMPLIED or #REQUIRED.
6018  *
6019  * [ VC: IDREF ]
6020  * Values of type IDREF must match the Name production, and values
6021  * of type IDREFS must match Names; each IDREF Name must match the value
6022  * of an ID attribute on some element in the XML document; i.e. IDREF
6023  * values must match the value of some ID attribute.
6024  *
6025  * [ VC: Entity Name ]
6026  * Values of type ENTITY must match the Name production, values
6027  * of type ENTITIES must match Names; each Entity Name must match the
6028  * name of an unparsed entity declared in the DTD.
6029  *
6030  * [ VC: Name Token ]
6031  * Values of type NMTOKEN must match the Nmtoken production; values
6032  * of type NMTOKENS must match Nmtokens.
6033  *
6034  * Returns the attribute type
6035  */
6036 int
6037 xmlParseAttributeType(xmlParserCtxtPtr ctxt, xmlEnumerationPtr *tree) {
6038     SHRINK;
6039     if (CMP5(CUR_PTR, 'C', 'D', 'A', 'T', 'A')) {
6040         SKIP(5);
6041         return(XML_ATTRIBUTE_CDATA);
6042      } else if (CMP6(CUR_PTR, 'I', 'D', 'R', 'E', 'F', 'S')) {
6043         SKIP(6);
6044         return(XML_ATTRIBUTE_IDREFS);
6045      } else if (CMP5(CUR_PTR, 'I', 'D', 'R', 'E', 'F')) {
6046         SKIP(5);
6047         return(XML_ATTRIBUTE_IDREF);
6048      } else if ((RAW == 'I') && (NXT(1) == 'D')) {
6049         SKIP(2);
6050         return(XML_ATTRIBUTE_ID);
6051      } else if (CMP6(CUR_PTR, 'E', 'N', 'T', 'I', 'T', 'Y')) {
6052         SKIP(6);
6053         return(XML_ATTRIBUTE_ENTITY);
6054      } else if (CMP8(CUR_PTR, 'E', 'N', 'T', 'I', 'T', 'I', 'E', 'S')) {
6055         SKIP(8);
6056         return(XML_ATTRIBUTE_ENTITIES);
6057      } else if (CMP8(CUR_PTR, 'N', 'M', 'T', 'O', 'K', 'E', 'N', 'S')) {
6058         SKIP(8);
6059         return(XML_ATTRIBUTE_NMTOKENS);
6060      } else if (CMP7(CUR_PTR, 'N', 'M', 'T', 'O', 'K', 'E', 'N')) {
6061         SKIP(7);
6062         return(XML_ATTRIBUTE_NMTOKEN);
6063      }
6064      return(xmlParseEnumeratedType(ctxt, tree));
6065 }
6066
6067 /**
6068  * xmlParseAttributeListDecl:
6069  * @ctxt:  an XML parser context
6070  *
6071  * : parse the Attribute list def for an element
6072  *
6073  * [52] AttlistDecl ::= '<!ATTLIST' S Name AttDef* S? '>'
6074  *
6075  * [53] AttDef ::= S Name S AttType S DefaultDecl
6076  *
6077  */
6078 void
6079 xmlParseAttributeListDecl(xmlParserCtxtPtr ctxt) {
6080     const xmlChar *elemName;
6081     const xmlChar *attrName;
6082     xmlEnumerationPtr tree;
6083
6084     if (CMP9(CUR_PTR, '<', '!', 'A', 'T', 'T', 'L', 'I', 'S', 'T')) {
6085         xmlParserInputPtr input = ctxt->input;
6086
6087         SKIP(9);
6088         if (!IS_BLANK_CH(CUR)) {
6089             xmlFatalErrMsg(ctxt, XML_ERR_SPACE_REQUIRED,
6090                                  "Space required after '<!ATTLIST'\n");
6091         }
6092         SKIP_BLANKS;
6093         elemName = xmlParseName(ctxt);
6094         if (elemName == NULL) {
6095             xmlFatalErrMsg(ctxt, XML_ERR_NAME_REQUIRED,
6096                            "ATTLIST: no name for Element\n");
6097             return;
6098         }
6099         SKIP_BLANKS;
6100         GROW;
6101         while ((RAW != '>') && (ctxt->instate != XML_PARSER_EOF)) {
6102             const xmlChar *check = CUR_PTR;
6103             int type;
6104             int def;
6105             xmlChar *defaultValue = NULL;
6106
6107             GROW;
6108             tree = NULL;
6109             attrName = xmlParseName(ctxt);
6110             if (attrName == NULL) {
6111                 xmlFatalErrMsg(ctxt, XML_ERR_NAME_REQUIRED,
6112                                "ATTLIST: no name for Attribute\n");
6113                 break;
6114             }
6115             GROW;
6116             if (!IS_BLANK_CH(CUR)) {
6117                 xmlFatalErrMsg(ctxt, XML_ERR_SPACE_REQUIRED,
6118                         "Space required after the attribute name\n");
6119                 break;
6120             }
6121             SKIP_BLANKS;
6122
6123             type = xmlParseAttributeType(ctxt, &tree);
6124             if (type <= 0) {
6125                 break;
6126             }
6127
6128             GROW;
6129             if (!IS_BLANK_CH(CUR)) {
6130                 xmlFatalErrMsg(ctxt, XML_ERR_SPACE_REQUIRED,
6131                                "Space required after the attribute type\n");
6132                 if (tree != NULL)
6133                     xmlFreeEnumeration(tree);
6134                 break;
6135             }
6136             SKIP_BLANKS;
6137
6138             def = xmlParseDefaultDecl(ctxt, &defaultValue);
6139             if (def <= 0) {
6140                 if (defaultValue != NULL)
6141                     xmlFree(defaultValue);
6142                 if (tree != NULL)
6143                     xmlFreeEnumeration(tree);
6144                 break;
6145             }
6146             if ((type != XML_ATTRIBUTE_CDATA) && (defaultValue != NULL))
6147                 xmlAttrNormalizeSpace(defaultValue, defaultValue);
6148
6149             GROW;
6150             if (RAW != '>') {
6151                 if (!IS_BLANK_CH(CUR)) {
6152                     xmlFatalErrMsg(ctxt, XML_ERR_SPACE_REQUIRED,
6153                         "Space required after the attribute default value\n");
6154                     if (defaultValue != NULL)
6155                         xmlFree(defaultValue);
6156                     if (tree != NULL)
6157                         xmlFreeEnumeration(tree);
6158                     break;
6159                 }
6160                 SKIP_BLANKS;
6161             }
6162             if (check == CUR_PTR) {
6163                 xmlFatalErr(ctxt, XML_ERR_INTERNAL_ERROR,
6164                             "in xmlParseAttributeListDecl\n");
6165                 if (defaultValue != NULL)
6166                     xmlFree(defaultValue);
6167                 if (tree != NULL)
6168                     xmlFreeEnumeration(tree);
6169                 break;
6170             }
6171             if ((ctxt->sax != NULL) && (!ctxt->disableSAX) &&
6172                 (ctxt->sax->attributeDecl != NULL))
6173                 ctxt->sax->attributeDecl(ctxt->userData, elemName, attrName,
6174                                 type, def, defaultValue, tree);
6175             else if (tree != NULL)
6176                 xmlFreeEnumeration(tree);
6177
6178             if ((ctxt->sax2) && (defaultValue != NULL) &&
6179                 (def != XML_ATTRIBUTE_IMPLIED) &&
6180                 (def != XML_ATTRIBUTE_REQUIRED)) {
6181                 xmlAddDefAttrs(ctxt, elemName, attrName, defaultValue);
6182             }
6183             if (ctxt->sax2) {
6184                 xmlAddSpecialAttr(ctxt, elemName, attrName, type);
6185             }
6186             if (defaultValue != NULL)
6187                 xmlFree(defaultValue);
6188             GROW;
6189         }
6190         if (RAW == '>') {
6191             if (input != ctxt->input) {
6192                 xmlValidityError(ctxt, XML_ERR_ENTITY_BOUNDARY,
6193     "Attribute list declaration doesn't start and stop in the same entity\n",
6194                                  NULL, NULL);
6195             }
6196             NEXT;
6197         }
6198     }
6199 }
6200
6201 /**
6202  * xmlParseElementMixedContentDecl:
6203  * @ctxt:  an XML parser context
6204  * @inputchk:  the input used for the current entity, needed for boundary checks
6205  *
6206  * parse the declaration for a Mixed Element content
6207  * The leading '(' and spaces have been skipped in xmlParseElementContentDecl
6208  *
6209  * [51] Mixed ::= '(' S? '#PCDATA' (S? '|' S? Name)* S? ')*' |
6210  *                '(' S? '#PCDATA' S? ')'
6211  *
6212  * [ VC: Proper Group/PE Nesting ] applies to [51] too (see [49])
6213  *
6214  * [ VC: No Duplicate Types ]
6215  * The same name must not appear more than once in a single
6216  * mixed-content declaration.
6217  *
6218  * returns: the list of the xmlElementContentPtr describing the element choices
6219  */
6220 xmlElementContentPtr
6221 xmlParseElementMixedContentDecl(xmlParserCtxtPtr ctxt, int inputchk) {
6222     xmlElementContentPtr ret = NULL, cur = NULL, n;
6223     const xmlChar *elem = NULL;
6224
6225     GROW;
6226     if (CMP7(CUR_PTR, '#', 'P', 'C', 'D', 'A', 'T', 'A')) {
6227         SKIP(7);
6228         SKIP_BLANKS;
6229         SHRINK;
6230         if (RAW == ')') {
6231             if ((ctxt->validate) && (ctxt->input->id != inputchk)) {
6232                 xmlValidityError(ctxt, XML_ERR_ENTITY_BOUNDARY,
6233 "Element content declaration doesn't start and stop in the same entity\n",
6234                                  NULL, NULL);
6235             }
6236             NEXT;
6237             ret = xmlNewDocElementContent(ctxt->myDoc, NULL, XML_ELEMENT_CONTENT_PCDATA);
6238             if (ret == NULL)
6239                 return(NULL);
6240             if (RAW == '*') {
6241                 ret->ocur = XML_ELEMENT_CONTENT_MULT;
6242                 NEXT;
6243             }
6244             return(ret);
6245         }
6246         if ((RAW == '(') || (RAW == '|')) {
6247             ret = cur = xmlNewDocElementContent(ctxt->myDoc, NULL, XML_ELEMENT_CONTENT_PCDATA);
6248             if (ret == NULL) return(NULL);
6249         }
6250         while ((RAW == '|') && (ctxt->instate != XML_PARSER_EOF)) {
6251             NEXT;
6252             if (elem == NULL) {
6253                 ret = xmlNewDocElementContent(ctxt->myDoc, NULL, XML_ELEMENT_CONTENT_OR);
6254                 if (ret == NULL) return(NULL);
6255                 ret->c1 = cur;
6256                 if (cur != NULL)
6257                     cur->parent = ret;
6258                 cur = ret;
6259             } else {
6260                 n = xmlNewDocElementContent(ctxt->myDoc, NULL, XML_ELEMENT_CONTENT_OR);
6261                 if (n == NULL) return(NULL);
6262                 n->c1 = xmlNewDocElementContent(ctxt->myDoc, elem, XML_ELEMENT_CONTENT_ELEMENT);
6263                 if (n->c1 != NULL)
6264                     n->c1->parent = n;
6265                 cur->c2 = n;
6266                 if (n != NULL)
6267                     n->parent = cur;
6268                 cur = n;
6269             }
6270             SKIP_BLANKS;
6271             elem = xmlParseName(ctxt);
6272             if (elem == NULL) {
6273                 xmlFatalErrMsg(ctxt, XML_ERR_NAME_REQUIRED,
6274                         "xmlParseElementMixedContentDecl : Name expected\n");
6275                 xmlFreeDocElementContent(ctxt->myDoc, cur);
6276                 return(NULL);
6277             }
6278             SKIP_BLANKS;
6279             GROW;
6280         }
6281         if ((RAW == ')') && (NXT(1) == '*')) {
6282             if (elem != NULL) {
6283                 cur->c2 = xmlNewDocElementContent(ctxt->myDoc, elem,
6284                                                XML_ELEMENT_CONTENT_ELEMENT);
6285                 if (cur->c2 != NULL)
6286                     cur->c2->parent = cur;
6287             }
6288             if (ret != NULL)
6289                 ret->ocur = XML_ELEMENT_CONTENT_MULT;
6290             if ((ctxt->validate) && (ctxt->input->id != inputchk)) {
6291                 xmlValidityError(ctxt, XML_ERR_ENTITY_BOUNDARY,
6292 "Element content declaration doesn't start and stop in the same entity\n",
6293                                  NULL, NULL);
6294             }
6295             SKIP(2);
6296         } else {
6297             xmlFreeDocElementContent(ctxt->myDoc, ret);
6298             xmlFatalErr(ctxt, XML_ERR_MIXED_NOT_STARTED, NULL);
6299             return(NULL);
6300         }
6301
6302     } else {
6303         xmlFatalErr(ctxt, XML_ERR_PCDATA_REQUIRED, NULL);
6304     }
6305     return(ret);
6306 }
6307
6308 /**
6309  * xmlParseElementChildrenContentDeclPriv:
6310  * @ctxt:  an XML parser context
6311  * @inputchk:  the input used for the current entity, needed for boundary checks
6312  * @depth: the level of recursion
6313  *
6314  * parse the declaration for a Mixed Element content
6315  * The leading '(' and spaces have been skipped in xmlParseElementContentDecl
6316  *
6317  *
6318  * [47] children ::= (choice | seq) ('?' | '*' | '+')?
6319  *
6320  * [48] cp ::= (Name | choice | seq) ('?' | '*' | '+')?
6321  *
6322  * [49] choice ::= '(' S? cp ( S? '|' S? cp )* S? ')'
6323  *
6324  * [50] seq ::= '(' S? cp ( S? ',' S? cp )* S? ')'
6325  *
6326  * [ VC: Proper Group/PE Nesting ] applies to [49] and [50]
6327  * TODO Parameter-entity replacement text must be properly nested
6328  *      with parenthesized groups. That is to say, if either of the
6329  *      opening or closing parentheses in a choice, seq, or Mixed
6330  *      construct is contained in the replacement text for a parameter
6331  *      entity, both must be contained in the same replacement text. For
6332  *      interoperability, if a parameter-entity reference appears in a
6333  *      choice, seq, or Mixed construct, its replacement text should not
6334  *      be empty, and neither the first nor last non-blank character of
6335  *      the replacement text should be a connector (| or ,).
6336  *
6337  * Returns the tree of xmlElementContentPtr describing the element
6338  *          hierarchy.
6339  */
6340 static xmlElementContentPtr
6341 xmlParseElementChildrenContentDeclPriv(xmlParserCtxtPtr ctxt, int inputchk,
6342                                        int depth) {
6343     xmlElementContentPtr ret = NULL, cur = NULL, last = NULL, op = NULL;
6344     const xmlChar *elem;
6345     xmlChar type = 0;
6346
6347     if (((depth > 128) && ((ctxt->options & XML_PARSE_HUGE) == 0)) ||
6348         (depth >  2048)) {
6349         xmlFatalErrMsgInt(ctxt, XML_ERR_ELEMCONTENT_NOT_FINISHED,
6350 "xmlParseElementChildrenContentDecl : depth %d too deep, use XML_PARSE_HUGE\n",
6351                           depth);
6352         return(NULL);
6353     }
6354     SKIP_BLANKS;
6355     GROW;
6356     if (RAW == '(') {
6357         int inputid = ctxt->input->id;
6358
6359         /* Recurse on first child */
6360         NEXT;
6361         SKIP_BLANKS;
6362         cur = ret = xmlParseElementChildrenContentDeclPriv(ctxt, inputid,
6363                                                            depth + 1);
6364         SKIP_BLANKS;
6365         GROW;
6366     } else {
6367         elem = xmlParseName(ctxt);
6368         if (elem == NULL) {
6369             xmlFatalErr(ctxt, XML_ERR_ELEMCONTENT_NOT_STARTED, NULL);
6370             return(NULL);
6371         }
6372         cur = ret = xmlNewDocElementContent(ctxt->myDoc, elem, XML_ELEMENT_CONTENT_ELEMENT);
6373         if (cur == NULL) {
6374             xmlErrMemory(ctxt, NULL);
6375             return(NULL);
6376         }
6377         GROW;
6378         if (RAW == '?') {
6379             cur->ocur = XML_ELEMENT_CONTENT_OPT;
6380             NEXT;
6381         } else if (RAW == '*') {
6382             cur->ocur = XML_ELEMENT_CONTENT_MULT;
6383             NEXT;
6384         } else if (RAW == '+') {
6385             cur->ocur = XML_ELEMENT_CONTENT_PLUS;
6386             NEXT;
6387         } else {
6388             cur->ocur = XML_ELEMENT_CONTENT_ONCE;
6389         }
6390         GROW;
6391     }
6392     SKIP_BLANKS;
6393     SHRINK;
6394     while ((RAW != ')') && (ctxt->instate != XML_PARSER_EOF)) {
6395         /*
6396          * Each loop we parse one separator and one element.
6397          */
6398         if (RAW == ',') {
6399             if (type == 0) type = CUR;
6400
6401             /*
6402              * Detect "Name | Name , Name" error
6403              */
6404             else if (type != CUR) {
6405                 xmlFatalErrMsgInt(ctxt, XML_ERR_SEPARATOR_REQUIRED,
6406                     "xmlParseElementChildrenContentDecl : '%c' expected\n",
6407                                   type);
6408                 if ((last != NULL) && (last != ret))
6409                     xmlFreeDocElementContent(ctxt->myDoc, last);
6410                 if (ret != NULL)
6411                     xmlFreeDocElementContent(ctxt->myDoc, ret);
6412                 return(NULL);
6413             }
6414             NEXT;
6415
6416             op = xmlNewDocElementContent(ctxt->myDoc, NULL, XML_ELEMENT_CONTENT_SEQ);
6417             if (op == NULL) {
6418                 if ((last != NULL) && (last != ret))
6419                     xmlFreeDocElementContent(ctxt->myDoc, last);
6420                 xmlFreeDocElementContent(ctxt->myDoc, ret);
6421                 return(NULL);
6422             }
6423             if (last == NULL) {
6424                 op->c1 = ret;
6425                 if (ret != NULL)
6426                     ret->parent = op;
6427                 ret = cur = op;
6428             } else {
6429                 cur->c2 = op;
6430                 if (op != NULL)
6431                     op->parent = cur;
6432                 op->c1 = last;
6433                 if (last != NULL)
6434                     last->parent = op;
6435                 cur =op;
6436                 last = NULL;
6437             }
6438         } else if (RAW == '|') {
6439             if (type == 0) type = CUR;
6440
6441             /*
6442              * Detect "Name , Name | Name" error
6443              */
6444             else if (type != CUR) {
6445                 xmlFatalErrMsgInt(ctxt, XML_ERR_SEPARATOR_REQUIRED,
6446                     "xmlParseElementChildrenContentDecl : '%c' expected\n",
6447                                   type);
6448                 if ((last != NULL) && (last != ret))
6449                     xmlFreeDocElementContent(ctxt->myDoc, last);
6450                 if (ret != NULL)
6451                     xmlFreeDocElementContent(ctxt->myDoc, ret);
6452                 return(NULL);
6453             }
6454             NEXT;
6455
6456             op = xmlNewDocElementContent(ctxt->myDoc, NULL, XML_ELEMENT_CONTENT_OR);
6457             if (op == NULL) {
6458                 if ((last != NULL) && (last != ret))
6459                     xmlFreeDocElementContent(ctxt->myDoc, last);
6460                 if (ret != NULL)
6461                     xmlFreeDocElementContent(ctxt->myDoc, ret);
6462                 return(NULL);
6463             }
6464             if (last == NULL) {
6465                 op->c1 = ret;
6466                 if (ret != NULL)
6467                     ret->parent = op;
6468                 ret = cur = op;
6469             } else {
6470                 cur->c2 = op;
6471                 if (op != NULL)
6472                     op->parent = cur;
6473                 op->c1 = last;
6474                 if (last != NULL)
6475                     last->parent = op;
6476                 cur =op;
6477                 last = NULL;
6478             }
6479         } else {
6480             xmlFatalErr(ctxt, XML_ERR_ELEMCONTENT_NOT_FINISHED, NULL);
6481             if ((last != NULL) && (last != ret))
6482                 xmlFreeDocElementContent(ctxt->myDoc, last);
6483             if (ret != NULL)
6484                 xmlFreeDocElementContent(ctxt->myDoc, ret);
6485             return(NULL);
6486         }
6487         GROW;
6488         SKIP_BLANKS;
6489         GROW;
6490         if (RAW == '(') {
6491             int inputid = ctxt->input->id;
6492             /* Recurse on second child */
6493             NEXT;
6494             SKIP_BLANKS;
6495             last = xmlParseElementChildrenContentDeclPriv(ctxt, inputid,
6496                                                           depth + 1);
6497             SKIP_BLANKS;
6498         } else {
6499             elem = xmlParseName(ctxt);
6500             if (elem == NULL) {
6501                 xmlFatalErr(ctxt, XML_ERR_ELEMCONTENT_NOT_STARTED, NULL);
6502                 if (ret != NULL)
6503                     xmlFreeDocElementContent(ctxt->myDoc, ret);
6504                 return(NULL);
6505             }
6506             last = xmlNewDocElementContent(ctxt->myDoc, elem, XML_ELEMENT_CONTENT_ELEMENT);
6507             if (last == NULL) {
6508                 if (ret != NULL)
6509                     xmlFreeDocElementContent(ctxt->myDoc, ret);
6510                 return(NULL);
6511             }
6512             if (RAW == '?') {
6513                 last->ocur = XML_ELEMENT_CONTENT_OPT;
6514                 NEXT;
6515             } else if (RAW == '*') {
6516                 last->ocur = XML_ELEMENT_CONTENT_MULT;
6517                 NEXT;
6518             } else if (RAW == '+') {
6519                 last->ocur = XML_ELEMENT_CONTENT_PLUS;
6520                 NEXT;
6521             } else {
6522                 last->ocur = XML_ELEMENT_CONTENT_ONCE;
6523             }
6524         }
6525         SKIP_BLANKS;
6526         GROW;
6527     }
6528     if ((cur != NULL) && (last != NULL)) {
6529         cur->c2 = last;
6530         if (last != NULL)
6531             last->parent = cur;
6532     }
6533     if ((ctxt->validate) && (ctxt->input->id != inputchk)) {
6534         xmlValidityError(ctxt, XML_ERR_ENTITY_BOUNDARY,
6535 "Element content declaration doesn't start and stop in the same entity\n",
6536                          NULL, NULL);
6537     }
6538     NEXT;
6539     if (RAW == '?') {
6540         if (ret != NULL) {
6541             if ((ret->ocur == XML_ELEMENT_CONTENT_PLUS) ||
6542                 (ret->ocur == XML_ELEMENT_CONTENT_MULT))
6543                 ret->ocur = XML_ELEMENT_CONTENT_MULT;
6544             else
6545                 ret->ocur = XML_ELEMENT_CONTENT_OPT;
6546         }
6547         NEXT;
6548     } else if (RAW == '*') {
6549         if (ret != NULL) {
6550             ret->ocur = XML_ELEMENT_CONTENT_MULT;
6551             cur = ret;
6552             /*
6553              * Some normalization:
6554              * (a | b* | c?)* == (a | b | c)*
6555              */
6556             while ((cur != NULL) && (cur->type == XML_ELEMENT_CONTENT_OR)) {
6557                 if ((cur->c1 != NULL) &&
6558                     ((cur->c1->ocur == XML_ELEMENT_CONTENT_OPT) ||
6559                      (cur->c1->ocur == XML_ELEMENT_CONTENT_MULT)))
6560                     cur->c1->ocur = XML_ELEMENT_CONTENT_ONCE;
6561                 if ((cur->c2 != NULL) &&
6562                     ((cur->c2->ocur == XML_ELEMENT_CONTENT_OPT) ||
6563                      (cur->c2->ocur == XML_ELEMENT_CONTENT_MULT)))
6564                     cur->c2->ocur = XML_ELEMENT_CONTENT_ONCE;
6565                 cur = cur->c2;
6566             }
6567         }
6568         NEXT;
6569     } else if (RAW == '+') {
6570         if (ret != NULL) {
6571             int found = 0;
6572
6573             if ((ret->ocur == XML_ELEMENT_CONTENT_OPT) ||
6574                 (ret->ocur == XML_ELEMENT_CONTENT_MULT))
6575                 ret->ocur = XML_ELEMENT_CONTENT_MULT;
6576             else
6577                 ret->ocur = XML_ELEMENT_CONTENT_PLUS;
6578             /*
6579              * Some normalization:
6580              * (a | b*)+ == (a | b)*
6581              * (a | b?)+ == (a | b)*
6582              */
6583             while ((cur != NULL) && (cur->type == XML_ELEMENT_CONTENT_OR)) {
6584                 if ((cur->c1 != NULL) &&
6585                     ((cur->c1->ocur == XML_ELEMENT_CONTENT_OPT) ||
6586                      (cur->c1->ocur == XML_ELEMENT_CONTENT_MULT))) {
6587                     cur->c1->ocur = XML_ELEMENT_CONTENT_ONCE;
6588                     found = 1;
6589                 }
6590                 if ((cur->c2 != NULL) &&
6591                     ((cur->c2->ocur == XML_ELEMENT_CONTENT_OPT) ||
6592                      (cur->c2->ocur == XML_ELEMENT_CONTENT_MULT))) {
6593                     cur->c2->ocur = XML_ELEMENT_CONTENT_ONCE;
6594                     found = 1;
6595                 }
6596                 cur = cur->c2;
6597             }
6598             if (found)
6599                 ret->ocur = XML_ELEMENT_CONTENT_MULT;
6600         }
6601         NEXT;
6602     }
6603     return(ret);
6604 }
6605
6606 /**
6607  * xmlParseElementChildrenContentDecl:
6608  * @ctxt:  an XML parser context
6609  * @inputchk:  the input used for the current entity, needed for boundary checks
6610  *
6611  * parse the declaration for a Mixed Element content
6612  * The leading '(' and spaces have been skipped in xmlParseElementContentDecl
6613  *
6614  * [47] children ::= (choice | seq) ('?' | '*' | '+')?
6615  *
6616  * [48] cp ::= (Name | choice | seq) ('?' | '*' | '+')?
6617  *
6618  * [49] choice ::= '(' S? cp ( S? '|' S? cp )* S? ')'
6619  *
6620  * [50] seq ::= '(' S? cp ( S? ',' S? cp )* S? ')'
6621  *
6622  * [ VC: Proper Group/PE Nesting ] applies to [49] and [50]
6623  * TODO Parameter-entity replacement text must be properly nested
6624  *      with parenthesized groups. That is to say, if either of the
6625  *      opening or closing parentheses in a choice, seq, or Mixed
6626  *      construct is contained in the replacement text for a parameter
6627  *      entity, both must be contained in the same replacement text. For
6628  *      interoperability, if a parameter-entity reference appears in a
6629  *      choice, seq, or Mixed construct, its replacement text should not
6630  *      be empty, and neither the first nor last non-blank character of
6631  *      the replacement text should be a connector (| or ,).
6632  *
6633  * Returns the tree of xmlElementContentPtr describing the element
6634  *          hierarchy.
6635  */
6636 xmlElementContentPtr
6637 xmlParseElementChildrenContentDecl(xmlParserCtxtPtr ctxt, int inputchk) {
6638     /* stub left for API/ABI compat */
6639     return(xmlParseElementChildrenContentDeclPriv(ctxt, inputchk, 1));
6640 }
6641
6642 /**
6643  * xmlParseElementContentDecl:
6644  * @ctxt:  an XML parser context
6645  * @name:  the name of the element being defined.
6646  * @result:  the Element Content pointer will be stored here if any
6647  *
6648  * parse the declaration for an Element content either Mixed or Children,
6649  * the cases EMPTY and ANY are handled directly in xmlParseElementDecl
6650  *
6651  * [46] contentspec ::= 'EMPTY' | 'ANY' | Mixed | children
6652  *
6653  * returns: the type of element content XML_ELEMENT_TYPE_xxx
6654  */
6655
6656 int
6657 xmlParseElementContentDecl(xmlParserCtxtPtr ctxt, const xmlChar *name,
6658                            xmlElementContentPtr *result) {
6659
6660     xmlElementContentPtr tree = NULL;
6661     int inputid = ctxt->input->id;
6662     int res;
6663
6664     *result = NULL;
6665
6666     if (RAW != '(') {
6667         xmlFatalErrMsgStr(ctxt, XML_ERR_ELEMCONTENT_NOT_STARTED,
6668                 "xmlParseElementContentDecl : %s '(' expected\n", name);
6669         return(-1);
6670     }
6671     NEXT;
6672     GROW;
6673     if (ctxt->instate == XML_PARSER_EOF)
6674         return(-1);
6675     SKIP_BLANKS;
6676     if (CMP7(CUR_PTR, '#', 'P', 'C', 'D', 'A', 'T', 'A')) {
6677         tree = xmlParseElementMixedContentDecl(ctxt, inputid);
6678         res = XML_ELEMENT_TYPE_MIXED;
6679     } else {
6680         tree = xmlParseElementChildrenContentDeclPriv(ctxt, inputid, 1);
6681         res = XML_ELEMENT_TYPE_ELEMENT;
6682     }
6683     SKIP_BLANKS;
6684     *result = tree;
6685     return(res);
6686 }
6687
6688 /**
6689  * xmlParseElementDecl:
6690  * @ctxt:  an XML parser context
6691  *
6692  * parse an Element declaration.
6693  *
6694  * [45] elementdecl ::= '<!ELEMENT' S Name S contentspec S? '>'
6695  *
6696  * [ VC: Unique Element Type Declaration ]
6697  * No element type may be declared more than once
6698  *
6699  * Returns the type of the element, or -1 in case of error
6700  */
6701 int
6702 xmlParseElementDecl(xmlParserCtxtPtr ctxt) {
6703     const xmlChar *name;
6704     int ret = -1;
6705     xmlElementContentPtr content  = NULL;
6706
6707     /* GROW; done in the caller */
6708     if (CMP9(CUR_PTR, '<', '!', 'E', 'L', 'E', 'M', 'E', 'N', 'T')) {
6709         xmlParserInputPtr input = ctxt->input;
6710
6711         SKIP(9);
6712         if (!IS_BLANK_CH(CUR)) {
6713             xmlFatalErrMsg(ctxt, XML_ERR_SPACE_REQUIRED,
6714                            "Space required after 'ELEMENT'\n");
6715             return(-1);
6716         }
6717         SKIP_BLANKS;
6718         name = xmlParseName(ctxt);
6719         if (name == NULL) {
6720             xmlFatalErrMsg(ctxt, XML_ERR_NAME_REQUIRED,
6721                            "xmlParseElementDecl: no name for Element\n");
6722             return(-1);
6723         }
6724         while ((RAW == 0) && (ctxt->inputNr > 1))
6725             xmlPopInput(ctxt);
6726         if (!IS_BLANK_CH(CUR)) {
6727             xmlFatalErrMsg(ctxt, XML_ERR_SPACE_REQUIRED,
6728                            "Space required after the element name\n");
6729         }
6730         SKIP_BLANKS;
6731         if (CMP5(CUR_PTR, 'E', 'M', 'P', 'T', 'Y')) {
6732             SKIP(5);
6733             /*
6734              * Element must always be empty.
6735              */
6736             ret = XML_ELEMENT_TYPE_EMPTY;
6737         } else if ((RAW == 'A') && (NXT(1) == 'N') &&
6738                    (NXT(2) == 'Y')) {
6739             SKIP(3);
6740             /*
6741              * Element is a generic container.
6742              */
6743             ret = XML_ELEMENT_TYPE_ANY;
6744         } else if (RAW == '(') {
6745             ret = xmlParseElementContentDecl(ctxt, name, &content);
6746         } else {
6747             /*
6748              * [ WFC: PEs in Internal Subset ] error handling.
6749              */
6750             if ((RAW == '%') && (ctxt->external == 0) &&
6751                 (ctxt->inputNr == 1)) {
6752                 xmlFatalErrMsg(ctxt, XML_ERR_PEREF_IN_INT_SUBSET,
6753           "PEReference: forbidden within markup decl in internal subset\n");
6754             } else {
6755                 xmlFatalErrMsg(ctxt, XML_ERR_ELEMCONTENT_NOT_STARTED,
6756                       "xmlParseElementDecl: 'EMPTY', 'ANY' or '(' expected\n");
6757             }
6758             return(-1);
6759         }
6760
6761         SKIP_BLANKS;
6762         /*
6763          * Pop-up of finished entities.
6764          */
6765         while ((RAW == 0) && (ctxt->inputNr > 1))
6766             xmlPopInput(ctxt);
6767         SKIP_BLANKS;
6768
6769         if (RAW != '>') {
6770             xmlFatalErr(ctxt, XML_ERR_GT_REQUIRED, NULL);
6771             if (content != NULL) {
6772                 xmlFreeDocElementContent(ctxt->myDoc, content);
6773             }
6774         } else {
6775             if (input != ctxt->input) {
6776                 xmlFatalErrMsg(ctxt, XML_ERR_ENTITY_BOUNDARY,
6777     "Element declaration doesn't start and stop in the same entity\n");
6778             }
6779
6780             NEXT;
6781             if ((ctxt->sax != NULL) && (!ctxt->disableSAX) &&
6782                 (ctxt->sax->elementDecl != NULL)) {
6783                 if (content != NULL)
6784                     content->parent = NULL;
6785                 ctxt->sax->elementDecl(ctxt->userData, name, ret,
6786                                        content);
6787                 if ((content != NULL) && (content->parent == NULL)) {
6788                     /*
6789                      * this is a trick: if xmlAddElementDecl is called,
6790                      * instead of copying the full tree it is plugged directly
6791                      * if called from the parser. Avoid duplicating the
6792                      * interfaces or change the API/ABI
6793                      */
6794                     xmlFreeDocElementContent(ctxt->myDoc, content);
6795                 }
6796             } else if (content != NULL) {
6797                 xmlFreeDocElementContent(ctxt->myDoc, content);
6798             }
6799         }
6800     }
6801     return(ret);
6802 }
6803
6804 /**
6805  * xmlParseConditionalSections
6806  * @ctxt:  an XML parser context
6807  *
6808  * [61] conditionalSect ::= includeSect | ignoreSect
6809  * [62] includeSect ::= '<![' S? 'INCLUDE' S? '[' extSubsetDecl ']]>'
6810  * [63] ignoreSect ::= '<![' S? 'IGNORE' S? '[' ignoreSectContents* ']]>'
6811  * [64] ignoreSectContents ::= Ignore ('<![' ignoreSectContents ']]>' Ignore)*
6812  * [65] Ignore ::= Char* - (Char* ('<![' | ']]>') Char*)
6813  */
6814
6815 static void
6816 xmlParseConditionalSections(xmlParserCtxtPtr ctxt) {
6817     int id = ctxt->input->id;
6818
6819     SKIP(3);
6820     SKIP_BLANKS;
6821     if (CMP7(CUR_PTR, 'I', 'N', 'C', 'L', 'U', 'D', 'E')) {
6822         SKIP(7);
6823         SKIP_BLANKS;
6824         if (RAW != '[') {
6825             xmlFatalErr(ctxt, XML_ERR_CONDSEC_INVALID, NULL);
6826             xmlHaltParser(ctxt);
6827             return;
6828         } else {
6829             if (ctxt->input->id != id) {
6830                 xmlValidityError(ctxt, XML_ERR_ENTITY_BOUNDARY,
6831             "All markup of the conditional section is not in the same entity\n",
6832                                      NULL, NULL);
6833             }
6834             NEXT;
6835         }
6836         if (xmlParserDebugEntities) {
6837             if ((ctxt->input != NULL) && (ctxt->input->filename))
6838                 xmlGenericError(xmlGenericErrorContext,
6839                         "%s(%d): ", ctxt->input->filename,
6840                         ctxt->input->line);
6841             xmlGenericError(xmlGenericErrorContext,
6842                     "Entering INCLUDE Conditional Section\n");
6843         }
6844
6845         while (((RAW != 0) && ((RAW != ']') || (NXT(1) != ']') ||
6846                 (NXT(2) != '>'))) && (ctxt->instate != XML_PARSER_EOF)) {
6847             const xmlChar *check = CUR_PTR;
6848             unsigned int cons = ctxt->input->consumed;
6849
6850             if ((RAW == '<') && (NXT(1) == '!') && (NXT(2) == '[')) {
6851                 xmlParseConditionalSections(ctxt);
6852             } else if (IS_BLANK_CH(CUR)) {
6853                 NEXT;
6854             } else if (RAW == '%') {
6855                 xmlParsePEReference(ctxt);
6856             } else
6857                 xmlParseMarkupDecl(ctxt);
6858
6859             /*
6860              * Pop-up of finished entities.
6861              */
6862             while ((RAW == 0) && (ctxt->inputNr > 1))
6863                 xmlPopInput(ctxt);
6864
6865             if ((CUR_PTR == check) && (cons == ctxt->input->consumed)) {
6866                 xmlFatalErr(ctxt, XML_ERR_EXT_SUBSET_NOT_FINISHED, NULL);
6867                 xmlHaltParser(ctxt);
6868                 break;
6869             }
6870         }
6871         if (xmlParserDebugEntities) {
6872             if ((ctxt->input != NULL) && (ctxt->input->filename))
6873                 xmlGenericError(xmlGenericErrorContext,
6874                         "%s(%d): ", ctxt->input->filename,
6875                         ctxt->input->line);
6876             xmlGenericError(xmlGenericErrorContext,
6877                     "Leaving INCLUDE Conditional Section\n");
6878         }
6879
6880     } else if (CMP6(CUR_PTR, 'I', 'G', 'N', 'O', 'R', 'E')) {
6881         int state;
6882         xmlParserInputState instate;
6883         int depth = 0;
6884
6885         SKIP(6);
6886         SKIP_BLANKS;
6887         if (RAW != '[') {
6888             xmlFatalErr(ctxt, XML_ERR_CONDSEC_INVALID, NULL);
6889             xmlHaltParser(ctxt);
6890             return;
6891         } else {
6892             if (ctxt->input->id != id) {
6893                 xmlValidityError(ctxt, XML_ERR_ENTITY_BOUNDARY,
6894             "All markup of the conditional section is not in the same entity\n",
6895                                      NULL, NULL);
6896             }
6897             NEXT;
6898         }
6899         if (xmlParserDebugEntities) {
6900             if ((ctxt->input != NULL) && (ctxt->input->filename))
6901                 xmlGenericError(xmlGenericErrorContext,
6902                         "%s(%d): ", ctxt->input->filename,
6903                         ctxt->input->line);
6904             xmlGenericError(xmlGenericErrorContext,
6905                     "Entering IGNORE Conditional Section\n");
6906         }
6907
6908         /*
6909          * Parse up to the end of the conditional section
6910          * But disable SAX event generating DTD building in the meantime
6911          */
6912         state = ctxt->disableSAX;
6913         instate = ctxt->instate;
6914         if (ctxt->recovery == 0) ctxt->disableSAX = 1;
6915         ctxt->instate = XML_PARSER_IGNORE;
6916
6917         while (((depth >= 0) && (RAW != 0)) &&
6918                (ctxt->instate != XML_PARSER_EOF)) {
6919           if ((RAW == '<') && (NXT(1) == '!') && (NXT(2) == '[')) {
6920             depth++;
6921             SKIP(3);
6922             continue;
6923           }
6924           if ((RAW == ']') && (NXT(1) == ']') && (NXT(2) == '>')) {
6925             if (--depth >= 0) SKIP(3);
6926             continue;
6927           }
6928           NEXT;
6929           continue;
6930         }
6931
6932         ctxt->disableSAX = state;
6933         ctxt->instate = instate;
6934
6935         if (xmlParserDebugEntities) {
6936             if ((ctxt->input != NULL) && (ctxt->input->filename))
6937                 xmlGenericError(xmlGenericErrorContext,
6938                         "%s(%d): ", ctxt->input->filename,
6939                         ctxt->input->line);
6940             xmlGenericError(xmlGenericErrorContext,
6941                     "Leaving IGNORE Conditional Section\n");
6942         }
6943
6944     } else {
6945         xmlFatalErr(ctxt, XML_ERR_CONDSEC_INVALID_KEYWORD, NULL);
6946         xmlHaltParser(ctxt);
6947         return;
6948     }
6949
6950     if (RAW == 0)
6951         SHRINK;
6952
6953     if (RAW == 0) {
6954         xmlFatalErr(ctxt, XML_ERR_CONDSEC_NOT_FINISHED, NULL);
6955     } else {
6956         if (ctxt->input->id != id) {
6957             xmlValidityError(ctxt, XML_ERR_ENTITY_BOUNDARY,
6958         "All markup of the conditional section is not in the same entity\n",
6959                                  NULL, NULL);
6960         }
6961         if ((ctxt-> instate != XML_PARSER_EOF) &&
6962             ((ctxt->input->cur + 3) <= ctxt->input->end))
6963             SKIP(3);
6964     }
6965 }
6966
6967 /**
6968  * xmlParseMarkupDecl:
6969  * @ctxt:  an XML parser context
6970  *
6971  * parse Markup declarations
6972  *
6973  * [29] markupdecl ::= elementdecl | AttlistDecl | EntityDecl |
6974  *                     NotationDecl | PI | Comment
6975  *
6976  * [ VC: Proper Declaration/PE Nesting ]
6977  * Parameter-entity replacement text must be properly nested with
6978  * markup declarations. That is to say, if either the first character
6979  * or the last character of a markup declaration (markupdecl above) is
6980  * contained in the replacement text for a parameter-entity reference,
6981  * both must be contained in the same replacement text.
6982  *
6983  * [ WFC: PEs in Internal Subset ]
6984  * In the internal DTD subset, parameter-entity references can occur
6985  * only where markup declarations can occur, not within markup declarations.
6986  * (This does not apply to references that occur in external parameter
6987  * entities or to the external subset.)
6988  */
6989 void
6990 xmlParseMarkupDecl(xmlParserCtxtPtr ctxt) {
6991     GROW;
6992     if (CUR == '<') {
6993         if (NXT(1) == '!') {
6994             switch (NXT(2)) {
6995                 case 'E':
6996                     if (NXT(3) == 'L')
6997                         xmlParseElementDecl(ctxt);
6998                     else if (NXT(3) == 'N')
6999                         xmlParseEntityDecl(ctxt);
7000                     break;
7001                 case 'A':
7002                     xmlParseAttributeListDecl(ctxt);
7003                     break;
7004                 case 'N':
7005                     xmlParseNotationDecl(ctxt);
7006                     break;
7007                 case '-':
7008                     xmlParseComment(ctxt);
7009                     break;
7010                 default:
7011                     /* there is an error but it will be detected later */
7012                     break;
7013             }
7014         } else if (NXT(1) == '?') {
7015             xmlParsePI(ctxt);
7016         }
7017     }
7018
7019     /*
7020      * detect requirement to exit there and act accordingly
7021      * and avoid having instate overriden later on
7022      */
7023     if (ctxt->instate == XML_PARSER_EOF)
7024         return;
7025
7026     /*
7027      * This is only for internal subset. On external entities,
7028      * the replacement is done before parsing stage
7029      */
7030     if ((ctxt->external == 0) && (ctxt->inputNr == 1))
7031         xmlParsePEReference(ctxt);
7032
7033     /*
7034      * Conditional sections are allowed from entities included
7035      * by PE References in the internal subset.
7036      */
7037     if ((ctxt->external == 0) && (ctxt->inputNr > 1)) {
7038         if ((RAW == '<') && (NXT(1) == '!') && (NXT(2) == '[')) {
7039             xmlParseConditionalSections(ctxt);
7040         }
7041     }
7042
7043     ctxt->instate = XML_PARSER_DTD;
7044 }
7045
7046 /**
7047  * xmlParseTextDecl:
7048  * @ctxt:  an XML parser context
7049  *
7050  * parse an XML declaration header for external entities
7051  *
7052  * [77] TextDecl ::= '<?xml' VersionInfo? EncodingDecl S? '?>'
7053  */
7054
7055 void
7056 xmlParseTextDecl(xmlParserCtxtPtr ctxt) {
7057     xmlChar *version;
7058     const xmlChar *encoding;
7059
7060     /*
7061      * We know that '<?xml' is here.
7062      */
7063     if ((CMP5(CUR_PTR, '<', '?', 'x', 'm', 'l')) && (IS_BLANK_CH(NXT(5)))) {
7064         SKIP(5);
7065     } else {
7066         xmlFatalErr(ctxt, XML_ERR_XMLDECL_NOT_STARTED, NULL);
7067         return;
7068     }
7069
7070     if (!IS_BLANK_CH(CUR)) {
7071         xmlFatalErrMsg(ctxt, XML_ERR_SPACE_REQUIRED,
7072                        "Space needed after '<?xml'\n");
7073     }
7074     SKIP_BLANKS;
7075
7076     /*
7077      * We may have the VersionInfo here.
7078      */
7079     version = xmlParseVersionInfo(ctxt);
7080     if (version == NULL)
7081         version = xmlCharStrdup(XML_DEFAULT_VERSION);
7082     else {
7083         if (!IS_BLANK_CH(CUR)) {
7084             xmlFatalErrMsg(ctxt, XML_ERR_SPACE_REQUIRED,
7085                            "Space needed here\n");
7086         }
7087     }
7088     ctxt->input->version = version;
7089
7090     /*
7091      * We must have the encoding declaration
7092      */
7093     encoding = xmlParseEncodingDecl(ctxt);
7094     if (ctxt->errNo == XML_ERR_UNSUPPORTED_ENCODING) {
7095         /*
7096          * The XML REC instructs us to stop parsing right here
7097          */
7098         return;
7099     }
7100     if ((encoding == NULL) && (ctxt->errNo == XML_ERR_OK)) {
7101         xmlFatalErrMsg(ctxt, XML_ERR_MISSING_ENCODING,
7102                        "Missing encoding in text declaration\n");
7103     }
7104
7105     SKIP_BLANKS;
7106     if ((RAW == '?') && (NXT(1) == '>')) {
7107         SKIP(2);
7108     } else if (RAW == '>') {
7109         /* Deprecated old WD ... */
7110         xmlFatalErr(ctxt, XML_ERR_XMLDECL_NOT_FINISHED, NULL);
7111         NEXT;
7112     } else {
7113         xmlFatalErr(ctxt, XML_ERR_XMLDECL_NOT_FINISHED, NULL);
7114         MOVETO_ENDTAG(CUR_PTR);
7115         NEXT;
7116     }
7117 }
7118
7119 /**
7120  * xmlParseExternalSubset:
7121  * @ctxt:  an XML parser context
7122  * @ExternalID: the external identifier
7123  * @SystemID: the system identifier (or URL)
7124  *
7125  * parse Markup declarations from an external subset
7126  *
7127  * [30] extSubset ::= textDecl? extSubsetDecl
7128  *
7129  * [31] extSubsetDecl ::= (markupdecl | conditionalSect | PEReference | S) *
7130  */
7131 void
7132 xmlParseExternalSubset(xmlParserCtxtPtr ctxt, const xmlChar *ExternalID,
7133                        const xmlChar *SystemID) {
7134     xmlDetectSAX2(ctxt);
7135     GROW;
7136
7137     if ((ctxt->encoding == NULL) &&
7138         (ctxt->input->end - ctxt->input->cur >= 4)) {
7139         xmlChar start[4];
7140         xmlCharEncoding enc;
7141
7142         start[0] = RAW;
7143         start[1] = NXT(1);
7144         start[2] = NXT(2);
7145         start[3] = NXT(3);
7146         enc = xmlDetectCharEncoding(start, 4);
7147         if (enc != XML_CHAR_ENCODING_NONE)
7148             xmlSwitchEncoding(ctxt, enc);
7149     }
7150
7151     if (CMP5(CUR_PTR, '<', '?', 'x', 'm', 'l')) {
7152         xmlParseTextDecl(ctxt);
7153         if (ctxt->errNo == XML_ERR_UNSUPPORTED_ENCODING) {
7154             /*
7155              * The XML REC instructs us to stop parsing right here
7156              */
7157             xmlHaltParser(ctxt);
7158             return;
7159         }
7160     }
7161     if (ctxt->myDoc == NULL) {
7162         ctxt->myDoc = xmlNewDoc(BAD_CAST "1.0");
7163         if (ctxt->myDoc == NULL) {
7164             xmlErrMemory(ctxt, "New Doc failed");
7165             return;
7166         }
7167         ctxt->myDoc->properties = XML_DOC_INTERNAL;
7168     }
7169     if ((ctxt->myDoc != NULL) && (ctxt->myDoc->intSubset == NULL))
7170         xmlCreateIntSubset(ctxt->myDoc, NULL, ExternalID, SystemID);
7171
7172     ctxt->instate = XML_PARSER_DTD;
7173     ctxt->external = 1;
7174     while (((RAW == '<') && (NXT(1) == '?')) ||
7175            ((RAW == '<') && (NXT(1) == '!')) ||
7176            (RAW == '%') || IS_BLANK_CH(CUR)) {
7177         const xmlChar *check = CUR_PTR;
7178         unsigned int cons = ctxt->input->consumed;
7179
7180         GROW;
7181         if ((RAW == '<') && (NXT(1) == '!') && (NXT(2) == '[')) {
7182             xmlParseConditionalSections(ctxt);
7183         } else if (IS_BLANK_CH(CUR)) {
7184             NEXT;
7185         } else if (RAW == '%') {
7186             xmlParsePEReference(ctxt);
7187         } else
7188             xmlParseMarkupDecl(ctxt);
7189
7190         /*
7191          * Pop-up of finished entities.
7192          */
7193         while ((RAW == 0) && (ctxt->inputNr > 1))
7194             xmlPopInput(ctxt);
7195
7196         if ((CUR_PTR == check) && (cons == ctxt->input->consumed)) {
7197             xmlFatalErr(ctxt, XML_ERR_EXT_SUBSET_NOT_FINISHED, NULL);
7198             break;
7199         }
7200     }
7201
7202     if (RAW != 0) {
7203         xmlFatalErr(ctxt, XML_ERR_EXT_SUBSET_NOT_FINISHED, NULL);
7204     }
7205
7206 }
7207
7208 /**
7209  * xmlParseReference:
7210  * @ctxt:  an XML parser context
7211  *
7212  * parse and handle entity references in content, depending on the SAX
7213  * interface, this may end-up in a call to character() if this is a
7214  * CharRef, a predefined entity, if there is no reference() callback.
7215  * or if the parser was asked to switch to that mode.
7216  *
7217  * [67] Reference ::= EntityRef | CharRef
7218  */
7219 void
7220 xmlParseReference(xmlParserCtxtPtr ctxt) {
7221     xmlEntityPtr ent;
7222     xmlChar *val;
7223     int was_checked;
7224     xmlNodePtr list = NULL;
7225     xmlParserErrors ret = XML_ERR_OK;
7226
7227
7228     if (RAW != '&')
7229         return;
7230
7231     /*
7232      * Simple case of a CharRef
7233      */
7234     if (NXT(1) == '#') {
7235         int i = 0;
7236         xmlChar out[10];
7237         int hex = NXT(2);
7238         int value = xmlParseCharRef(ctxt);
7239
7240         if (value == 0)
7241             return;
7242         if (ctxt->charset != XML_CHAR_ENCODING_UTF8) {
7243             /*
7244              * So we are using non-UTF-8 buffers
7245              * Check that the char fit on 8bits, if not
7246              * generate a CharRef.
7247              */
7248             if (value <= 0xFF) {
7249                 out[0] = value;
7250                 out[1] = 0;
7251                 if ((ctxt->sax != NULL) && (ctxt->sax->characters != NULL) &&
7252                     (!ctxt->disableSAX))
7253                     ctxt->sax->characters(ctxt->userData, out, 1);
7254             } else {
7255                 if ((hex == 'x') || (hex == 'X'))
7256                     snprintf((char *)out, sizeof(out), "#x%X", value);
7257                 else
7258                     snprintf((char *)out, sizeof(out), "#%d", value);
7259                 if ((ctxt->sax != NULL) && (ctxt->sax->reference != NULL) &&
7260                     (!ctxt->disableSAX))
7261                     ctxt->sax->reference(ctxt->userData, out);
7262             }
7263         } else {
7264             /*
7265              * Just encode the value in UTF-8
7266              */
7267             COPY_BUF(0 ,out, i, value);
7268             out[i] = 0;
7269             if ((ctxt->sax != NULL) && (ctxt->sax->characters != NULL) &&
7270                 (!ctxt->disableSAX))
7271                 ctxt->sax->characters(ctxt->userData, out, i);
7272         }
7273         return;
7274     }
7275
7276     /*
7277      * We are seeing an entity reference
7278      */
7279     ent = xmlParseEntityRef(ctxt);
7280     if (ent == NULL) return;
7281     if (!ctxt->wellFormed)
7282         return;
7283     was_checked = ent->checked;
7284
7285     /* special case of predefined entities */
7286     if ((ent->name == NULL) ||
7287         (ent->etype == XML_INTERNAL_PREDEFINED_ENTITY)) {
7288         val = ent->content;
7289         if (val == NULL) return;
7290         /*
7291          * inline the entity.
7292          */
7293         if ((ctxt->sax != NULL) && (ctxt->sax->characters != NULL) &&
7294             (!ctxt->disableSAX))
7295             ctxt->sax->characters(ctxt->userData, val, xmlStrlen(val));
7296         return;
7297     }
7298
7299     /*
7300      * The first reference to the entity trigger a parsing phase
7301      * where the ent->children is filled with the result from
7302      * the parsing.
7303      * Note: external parsed entities will not be loaded, it is not
7304      * required for a non-validating parser, unless the parsing option
7305      * of validating, or substituting entities were given. Doing so is
7306      * far more secure as the parser will only process data coming from
7307      * the document entity by default.
7308      */
7309     if (((ent->checked == 0) ||
7310          ((ent->children == NULL) && (ctxt->options & XML_PARSE_NOENT))) &&
7311         ((ent->etype != XML_EXTERNAL_GENERAL_PARSED_ENTITY) ||
7312          (ctxt->options & (XML_PARSE_NOENT | XML_PARSE_DTDVALID)))) {
7313         unsigned long oldnbent = ctxt->nbentities;
7314
7315         /*
7316          * This is a bit hackish but this seems the best
7317          * way to make sure both SAX and DOM entity support
7318          * behaves okay.
7319          */
7320         void *user_data;
7321         if (ctxt->userData == ctxt)
7322             user_data = NULL;
7323         else
7324             user_data = ctxt->userData;
7325
7326         /*
7327          * Check that this entity is well formed
7328          * 4.3.2: An internal general parsed entity is well-formed
7329          * if its replacement text matches the production labeled
7330          * content.
7331          */
7332         if (ent->etype == XML_INTERNAL_GENERAL_ENTITY) {
7333             ctxt->depth++;
7334             ret = xmlParseBalancedChunkMemoryInternal(ctxt, ent->content,
7335                                                       user_data, &list);
7336             ctxt->depth--;
7337
7338         } else if (ent->etype == XML_EXTERNAL_GENERAL_PARSED_ENTITY) {
7339             ctxt->depth++;
7340             ret = xmlParseExternalEntityPrivate(ctxt->myDoc, ctxt, ctxt->sax,
7341                                            user_data, ctxt->depth, ent->URI,
7342                                            ent->ExternalID, &list);
7343             ctxt->depth--;
7344         } else {
7345             ret = XML_ERR_ENTITY_PE_INTERNAL;
7346             xmlErrMsgStr(ctxt, XML_ERR_INTERNAL_ERROR,
7347                          "invalid entity type found\n", NULL);
7348         }
7349
7350         /*
7351          * Store the number of entities needing parsing for this entity
7352          * content and do checkings
7353          */
7354         ent->checked = (ctxt->nbentities - oldnbent + 1) * 2;
7355         if ((ent->content != NULL) && (xmlStrchr(ent->content, '<')))
7356             ent->checked |= 1;
7357         if (ret == XML_ERR_ENTITY_LOOP) {
7358             xmlFatalErr(ctxt, XML_ERR_ENTITY_LOOP, NULL);
7359             xmlFreeNodeList(list);
7360             return;
7361         }
7362         if (xmlParserEntityCheck(ctxt, 0, ent, 0)) {
7363             xmlFreeNodeList(list);
7364             return;
7365         }
7366
7367         if ((ret == XML_ERR_OK) && (list != NULL)) {
7368             if (((ent->etype == XML_INTERNAL_GENERAL_ENTITY) ||
7369              (ent->etype == XML_EXTERNAL_GENERAL_PARSED_ENTITY))&&
7370                 (ent->children == NULL)) {
7371                 ent->children = list;
7372                 if (ctxt->replaceEntities) {
7373                     /*
7374                      * Prune it directly in the generated document
7375                      * except for single text nodes.
7376                      */
7377                     if (((list->type == XML_TEXT_NODE) &&
7378                          (list->next == NULL)) ||
7379                         (ctxt->parseMode == XML_PARSE_READER)) {
7380                         list->parent = (xmlNodePtr) ent;
7381                         list = NULL;
7382                         ent->owner = 1;
7383                     } else {
7384                         ent->owner = 0;
7385                         while (list != NULL) {
7386                             list->parent = (xmlNodePtr) ctxt->node;
7387                             list->doc = ctxt->myDoc;
7388                             if (list->next == NULL)
7389                                 ent->last = list;
7390                             list = list->next;
7391                         }
7392                         list = ent->children;
7393 #ifdef LIBXML_LEGACY_ENABLED
7394                         if (ent->etype == XML_EXTERNAL_GENERAL_PARSED_ENTITY)
7395                           xmlAddEntityReference(ent, list, NULL);
7396 #endif /* LIBXML_LEGACY_ENABLED */
7397                     }
7398                 } else {
7399                     ent->owner = 1;
7400                     while (list != NULL) {
7401                         list->parent = (xmlNodePtr) ent;
7402                         xmlSetTreeDoc(list, ent->doc);
7403                         if (list->next == NULL)
7404                             ent->last = list;
7405                         list = list->next;
7406                     }
7407                 }
7408             } else {
7409                 xmlFreeNodeList(list);
7410                 list = NULL;
7411             }
7412         } else if ((ret != XML_ERR_OK) &&
7413                    (ret != XML_WAR_UNDECLARED_ENTITY)) {
7414             xmlFatalErrMsgStr(ctxt, XML_ERR_UNDECLARED_ENTITY,
7415                      "Entity '%s' failed to parse\n", ent->name);
7416             xmlParserEntityCheck(ctxt, 0, ent, 0);
7417         } else if (list != NULL) {
7418             xmlFreeNodeList(list);
7419             list = NULL;
7420         }
7421         if (ent->checked == 0)
7422             ent->checked = 2;
7423     } else if (ent->checked != 1) {
7424         ctxt->nbentities += ent->checked / 2;
7425     }
7426
7427     /*
7428      * Now that the entity content has been gathered
7429      * provide it to the application, this can take different forms based
7430      * on the parsing modes.
7431      */
7432     if (ent->children == NULL) {
7433         /*
7434          * Probably running in SAX mode and the callbacks don't
7435          * build the entity content. So unless we already went
7436          * though parsing for first checking go though the entity
7437          * content to generate callbacks associated to the entity
7438          */
7439         if (was_checked != 0) {
7440             void *user_data;
7441             /*
7442              * This is a bit hackish but this seems the best
7443              * way to make sure both SAX and DOM entity support
7444              * behaves okay.
7445              */
7446             if (ctxt->userData == ctxt)
7447                 user_data = NULL;
7448             else
7449                 user_data = ctxt->userData;
7450
7451             if (ent->etype == XML_INTERNAL_GENERAL_ENTITY) {
7452                 ctxt->depth++;
7453                 ret = xmlParseBalancedChunkMemoryInternal(ctxt,
7454                                    ent->content, user_data, NULL);
7455                 ctxt->depth--;
7456             } else if (ent->etype ==
7457                        XML_EXTERNAL_GENERAL_PARSED_ENTITY) {
7458                 ctxt->depth++;
7459                 ret = xmlParseExternalEntityPrivate(ctxt->myDoc, ctxt,
7460                            ctxt->sax, user_data, ctxt->depth,
7461                            ent->URI, ent->ExternalID, NULL);
7462                 ctxt->depth--;
7463             } else {
7464                 ret = XML_ERR_ENTITY_PE_INTERNAL;
7465                 xmlErrMsgStr(ctxt, XML_ERR_INTERNAL_ERROR,
7466                              "invalid entity type found\n", NULL);
7467             }
7468             if (ret == XML_ERR_ENTITY_LOOP) {
7469                 xmlFatalErr(ctxt, XML_ERR_ENTITY_LOOP, NULL);
7470                 return;
7471             }
7472         }
7473         if ((ctxt->sax != NULL) && (ctxt->sax->reference != NULL) &&
7474             (ctxt->replaceEntities == 0) && (!ctxt->disableSAX)) {
7475             /*
7476              * Entity reference callback comes second, it's somewhat
7477              * superfluous but a compatibility to historical behaviour
7478              */
7479             ctxt->sax->reference(ctxt->userData, ent->name);
7480         }
7481         return;
7482     }
7483
7484     /*
7485      * If we didn't get any children for the entity being built
7486      */
7487     if ((ctxt->sax != NULL) && (ctxt->sax->reference != NULL) &&
7488         (ctxt->replaceEntities == 0) && (!ctxt->disableSAX)) {
7489         /*
7490          * Create a node.
7491          */
7492         ctxt->sax->reference(ctxt->userData, ent->name);
7493         return;
7494     }
7495
7496     if ((ctxt->replaceEntities) || (ent->children == NULL))  {
7497         /*
7498          * There is a problem on the handling of _private for entities
7499          * (bug 155816): Should we copy the content of the field from
7500          * the entity (possibly overwriting some value set by the user
7501          * when a copy is created), should we leave it alone, or should
7502          * we try to take care of different situations?  The problem
7503          * is exacerbated by the usage of this field by the xmlReader.
7504          * To fix this bug, we look at _private on the created node
7505          * and, if it's NULL, we copy in whatever was in the entity.
7506          * If it's not NULL we leave it alone.  This is somewhat of a
7507          * hack - maybe we should have further tests to determine
7508          * what to do.
7509          */
7510         if ((ctxt->node != NULL) && (ent->children != NULL)) {
7511             /*
7512              * Seems we are generating the DOM content, do
7513              * a simple tree copy for all references except the first
7514              * In the first occurrence list contains the replacement.
7515              */
7516             if (((list == NULL) && (ent->owner == 0)) ||
7517                 (ctxt->parseMode == XML_PARSE_READER)) {
7518                 xmlNodePtr nw = NULL, cur, firstChild = NULL;
7519
7520                 /*
7521                  * We are copying here, make sure there is no abuse
7522                  */
7523                 ctxt->sizeentcopy += ent->length + 5;
7524                 if (xmlParserEntityCheck(ctxt, 0, ent, ctxt->sizeentcopy))
7525                     return;
7526
7527                 /*
7528                  * when operating on a reader, the entities definitions
7529                  * are always owning the entities subtree.
7530                 if (ctxt->parseMode == XML_PARSE_READER)
7531                     ent->owner = 1;
7532                  */
7533
7534                 cur = ent->children;
7535                 while (cur != NULL) {
7536                     nw = xmlDocCopyNode(cur, ctxt->myDoc, 1);
7537                     if (nw != NULL) {
7538                         if (nw->_private == NULL)
7539                             nw->_private = cur->_private;
7540                         if (firstChild == NULL){
7541                             firstChild = nw;
7542                         }
7543                         nw = xmlAddChild(ctxt->node, nw);
7544                     }
7545                     if (cur == ent->last) {
7546                         /*
7547                          * needed to detect some strange empty
7548                          * node cases in the reader tests
7549                          */
7550                         if ((ctxt->parseMode == XML_PARSE_READER) &&
7551                             (nw != NULL) &&
7552                             (nw->type == XML_ELEMENT_NODE) &&
7553                             (nw->children == NULL))
7554                             nw->extra = 1;
7555
7556                         break;
7557                     }
7558                     cur = cur->next;
7559                 }
7560 #ifdef LIBXML_LEGACY_ENABLED
7561                 if (ent->etype == XML_EXTERNAL_GENERAL_PARSED_ENTITY)
7562                   xmlAddEntityReference(ent, firstChild, nw);
7563 #endif /* LIBXML_LEGACY_ENABLED */
7564             } else if ((list == NULL) || (ctxt->inputNr > 0)) {
7565                 xmlNodePtr nw = NULL, cur, next, last,
7566                            firstChild = NULL;
7567
7568                 /*
7569                  * We are copying here, make sure there is no abuse
7570                  */
7571                 ctxt->sizeentcopy += ent->length + 5;
7572                 if (xmlParserEntityCheck(ctxt, 0, ent, ctxt->sizeentcopy))
7573                     return;
7574
7575                 /*
7576                  * Copy the entity child list and make it the new
7577                  * entity child list. The goal is to make sure any
7578                  * ID or REF referenced will be the one from the
7579                  * document content and not the entity copy.
7580                  */
7581                 cur = ent->children;
7582                 ent->children = NULL;
7583                 last = ent->last;
7584                 ent->last = NULL;
7585                 while (cur != NULL) {
7586                     next = cur->next;
7587                     cur->next = NULL;
7588                     cur->parent = NULL;
7589                     nw = xmlDocCopyNode(cur, ctxt->myDoc, 1);
7590                     if (nw != NULL) {
7591                         if (nw->_private == NULL)
7592                             nw->_private = cur->_private;
7593                         if (firstChild == NULL){
7594                             firstChild = cur;
7595                         }
7596                         xmlAddChild((xmlNodePtr) ent, nw);
7597                         xmlAddChild(ctxt->node, cur);
7598                     }
7599                     if (cur == last)
7600                         break;
7601                     cur = next;
7602                 }
7603                 if (ent->owner == 0)
7604                     ent->owner = 1;
7605 #ifdef LIBXML_LEGACY_ENABLED
7606                 if (ent->etype == XML_EXTERNAL_GENERAL_PARSED_ENTITY)
7607                   xmlAddEntityReference(ent, firstChild, nw);
7608 #endif /* LIBXML_LEGACY_ENABLED */
7609             } else {
7610                 const xmlChar *nbktext;
7611
7612                 /*
7613                  * the name change is to avoid coalescing of the
7614                  * node with a possible previous text one which
7615                  * would make ent->children a dangling pointer
7616                  */
7617                 nbktext = xmlDictLookup(ctxt->dict, BAD_CAST "nbktext",
7618                                         -1);
7619                 if (ent->children->type == XML_TEXT_NODE)
7620                     ent->children->name = nbktext;
7621                 if ((ent->last != ent->children) &&
7622                     (ent->last->type == XML_TEXT_NODE))
7623                     ent->last->name = nbktext;
7624                 xmlAddChildList(ctxt->node, ent->children);
7625             }
7626
7627             /*
7628              * This is to avoid a nasty side effect, see
7629              * characters() in SAX.c
7630              */
7631             ctxt->nodemem = 0;
7632             ctxt->nodelen = 0;
7633             return;
7634         }
7635     }
7636 }
7637
7638 /**
7639  * xmlParseEntityRef:
7640  * @ctxt:  an XML parser context
7641  *
7642  * parse ENTITY references declarations
7643  *
7644  * [68] EntityRef ::= '&' Name ';'
7645  *
7646  * [ WFC: Entity Declared ]
7647  * In a document without any DTD, a document with only an internal DTD
7648  * subset which contains no parameter entity references, or a document
7649  * with "standalone='yes'", the Name given in the entity reference
7650  * must match that in an entity declaration, except that well-formed
7651  * documents need not declare any of the following entities: amp, lt,
7652  * gt, apos, quot.  The declaration of a parameter entity must precede
7653  * any reference to it.  Similarly, the declaration of a general entity
7654  * must precede any reference to it which appears in a default value in an
7655  * attribute-list declaration. Note that if entities are declared in the
7656  * external subset or in external parameter entities, a non-validating
7657  * processor is not obligated to read and process their declarations;
7658  * for such documents, the rule that an entity must be declared is a
7659  * well-formedness constraint only if standalone='yes'.
7660  *
7661  * [ WFC: Parsed Entity ]
7662  * An entity reference must not contain the name of an unparsed entity
7663  *
7664  * Returns the xmlEntityPtr if found, or NULL otherwise.
7665  */
7666 xmlEntityPtr
7667 xmlParseEntityRef(xmlParserCtxtPtr ctxt) {
7668     const xmlChar *name;
7669     xmlEntityPtr ent = NULL;
7670
7671     GROW;
7672     if (ctxt->instate == XML_PARSER_EOF)
7673         return(NULL);
7674
7675     if (RAW != '&')
7676         return(NULL);
7677     NEXT;
7678     name = xmlParseName(ctxt);
7679     if (name == NULL) {
7680         xmlFatalErrMsg(ctxt, XML_ERR_NAME_REQUIRED,
7681                        "xmlParseEntityRef: no name\n");
7682         return(NULL);
7683     }
7684     if (RAW != ';') {
7685         xmlFatalErr(ctxt, XML_ERR_ENTITYREF_SEMICOL_MISSING, NULL);
7686         return(NULL);
7687     }
7688     NEXT;
7689
7690     /*
7691      * Predefined entities override any extra definition
7692      */
7693     if ((ctxt->options & XML_PARSE_OLDSAX) == 0) {
7694         ent = xmlGetPredefinedEntity(name);
7695         if (ent != NULL)
7696             return(ent);
7697     }
7698
7699     /*
7700      * Increase the number of entity references parsed
7701      */
7702     ctxt->nbentities++;
7703
7704     /*
7705      * Ask first SAX for entity resolution, otherwise try the
7706      * entities which may have stored in the parser context.
7707      */
7708     if (ctxt->sax != NULL) {
7709         if (ctxt->sax->getEntity != NULL)
7710             ent = ctxt->sax->getEntity(ctxt->userData, name);
7711         if ((ctxt->wellFormed == 1 ) && (ent == NULL) &&
7712             (ctxt->options & XML_PARSE_OLDSAX))
7713             ent = xmlGetPredefinedEntity(name);
7714         if ((ctxt->wellFormed == 1 ) && (ent == NULL) &&
7715             (ctxt->userData==ctxt)) {
7716             ent = xmlSAX2GetEntity(ctxt, name);
7717         }
7718     }
7719     if (ctxt->instate == XML_PARSER_EOF)
7720         return(NULL);
7721     /*
7722      * [ WFC: Entity Declared ]
7723      * In a document without any DTD, a document with only an
7724      * internal DTD subset which contains no parameter entity
7725      * references, or a document with "standalone='yes'", the
7726      * Name given in the entity reference must match that in an
7727      * entity declaration, except that well-formed documents
7728      * need not declare any of the following entities: amp, lt,
7729      * gt, apos, quot.
7730      * The declaration of a parameter entity must precede any
7731      * reference to it.
7732      * Similarly, the declaration of a general entity must
7733      * precede any reference to it which appears in a default
7734      * value in an attribute-list declaration. Note that if
7735      * entities are declared in the external subset or in
7736      * external parameter entities, a non-validating processor
7737      * is not obligated to read and process their declarations;
7738      * for such documents, the rule that an entity must be
7739      * declared is a well-formedness constraint only if
7740      * standalone='yes'.
7741      */
7742     if (ent == NULL) {
7743         if ((ctxt->standalone == 1) ||
7744             ((ctxt->hasExternalSubset == 0) &&
7745              (ctxt->hasPErefs == 0))) {
7746             xmlFatalErrMsgStr(ctxt, XML_ERR_UNDECLARED_ENTITY,
7747                      "Entity '%s' not defined\n", name);
7748         } else {
7749             xmlErrMsgStr(ctxt, XML_WAR_UNDECLARED_ENTITY,
7750                      "Entity '%s' not defined\n", name);
7751             if ((ctxt->inSubset == 0) &&
7752                 (ctxt->sax != NULL) &&
7753                 (ctxt->sax->reference != NULL)) {
7754                 ctxt->sax->reference(ctxt->userData, name);
7755             }
7756         }
7757         xmlParserEntityCheck(ctxt, 0, ent, 0);
7758         ctxt->valid = 0;
7759     }
7760
7761     /*
7762      * [ WFC: Parsed Entity ]
7763      * An entity reference must not contain the name of an
7764      * unparsed entity
7765      */
7766     else if (ent->etype == XML_EXTERNAL_GENERAL_UNPARSED_ENTITY) {
7767         xmlFatalErrMsgStr(ctxt, XML_ERR_UNPARSED_ENTITY,
7768                  "Entity reference to unparsed entity %s\n", name);
7769     }
7770
7771     /*
7772      * [ WFC: No External Entity References ]
7773      * Attribute values cannot contain direct or indirect
7774      * entity references to external entities.
7775      */
7776     else if ((ctxt->instate == XML_PARSER_ATTRIBUTE_VALUE) &&
7777              (ent->etype == XML_EXTERNAL_GENERAL_PARSED_ENTITY)) {
7778         xmlFatalErrMsgStr(ctxt, XML_ERR_ENTITY_IS_EXTERNAL,
7779              "Attribute references external entity '%s'\n", name);
7780     }
7781     /*
7782      * [ WFC: No < in Attribute Values ]
7783      * The replacement text of any entity referred to directly or
7784      * indirectly in an attribute value (other than "&lt;") must
7785      * not contain a <.
7786      */
7787     else if ((ctxt->instate == XML_PARSER_ATTRIBUTE_VALUE) &&
7788              (ent != NULL) &&
7789              (ent->etype != XML_INTERNAL_PREDEFINED_ENTITY)) {
7790         if (((ent->checked & 1) || (ent->checked == 0)) &&
7791              (ent->content != NULL) && (xmlStrchr(ent->content, '<'))) {
7792             xmlFatalErrMsgStr(ctxt, XML_ERR_LT_IN_ATTRIBUTE,
7793         "'<' in entity '%s' is not allowed in attributes values\n", name);
7794         }
7795     }
7796
7797     /*
7798      * Internal check, no parameter entities here ...
7799      */
7800     else {
7801         switch (ent->etype) {
7802             case XML_INTERNAL_PARAMETER_ENTITY:
7803             case XML_EXTERNAL_PARAMETER_ENTITY:
7804             xmlFatalErrMsgStr(ctxt, XML_ERR_ENTITY_IS_PARAMETER,
7805              "Attempt to reference the parameter entity '%s'\n",
7806                               name);
7807             break;
7808             default:
7809             break;
7810         }
7811     }
7812
7813     /*
7814      * [ WFC: No Recursion ]
7815      * A parsed entity must not contain a recursive reference
7816      * to itself, either directly or indirectly.
7817      * Done somewhere else
7818      */
7819     return(ent);
7820 }
7821
7822 /**
7823  * xmlParseStringEntityRef:
7824  * @ctxt:  an XML parser context
7825  * @str:  a pointer to an index in the string
7826  *
7827  * parse ENTITY references declarations, but this version parses it from
7828  * a string value.
7829  *
7830  * [68] EntityRef ::= '&' Name ';'
7831  *
7832  * [ WFC: Entity Declared ]
7833  * In a document without any DTD, a document with only an internal DTD
7834  * subset which contains no parameter entity references, or a document
7835  * with "standalone='yes'", the Name given in the entity reference
7836  * must match that in an entity declaration, except that well-formed
7837  * documents need not declare any of the following entities: amp, lt,
7838  * gt, apos, quot.  The declaration of a parameter entity must precede
7839  * any reference to it.  Similarly, the declaration of a general entity
7840  * must precede any reference to it which appears in a default value in an
7841  * attribute-list declaration. Note that if entities are declared in the
7842  * external subset or in external parameter entities, a non-validating
7843  * processor is not obligated to read and process their declarations;
7844  * for such documents, the rule that an entity must be declared is a
7845  * well-formedness constraint only if standalone='yes'.
7846  *
7847  * [ WFC: Parsed Entity ]
7848  * An entity reference must not contain the name of an unparsed entity
7849  *
7850  * Returns the xmlEntityPtr if found, or NULL otherwise. The str pointer
7851  * is updated to the current location in the string.
7852  */
7853 static xmlEntityPtr
7854 xmlParseStringEntityRef(xmlParserCtxtPtr ctxt, const xmlChar ** str) {
7855     xmlChar *name;
7856     const xmlChar *ptr;
7857     xmlChar cur;
7858     xmlEntityPtr ent = NULL;
7859
7860     if ((str == NULL) || (*str == NULL))
7861         return(NULL);
7862     ptr = *str;
7863     cur = *ptr;
7864     if (cur != '&')
7865         return(NULL);
7866
7867     ptr++;
7868     name = xmlParseStringName(ctxt, &ptr);
7869     if (name == NULL) {
7870         xmlFatalErrMsg(ctxt, XML_ERR_NAME_REQUIRED,
7871                        "xmlParseStringEntityRef: no name\n");
7872         *str = ptr;
7873         return(NULL);
7874     }
7875     if (*ptr != ';') {
7876         xmlFatalErr(ctxt, XML_ERR_ENTITYREF_SEMICOL_MISSING, NULL);
7877         xmlFree(name);
7878         *str = ptr;
7879         return(NULL);
7880     }
7881     ptr++;
7882
7883
7884     /*
7885      * Predefined entities override any extra definition
7886      */
7887     if ((ctxt->options & XML_PARSE_OLDSAX) == 0) {
7888         ent = xmlGetPredefinedEntity(name);
7889         if (ent != NULL) {
7890             xmlFree(name);
7891             *str = ptr;
7892             return(ent);
7893         }
7894     }
7895
7896     /*
7897      * Increate the number of entity references parsed
7898      */
7899     ctxt->nbentities++;
7900
7901     /*
7902      * Ask first SAX for entity resolution, otherwise try the
7903      * entities which may have stored in the parser context.
7904      */
7905     if (ctxt->sax != NULL) {
7906         if (ctxt->sax->getEntity != NULL)
7907             ent = ctxt->sax->getEntity(ctxt->userData, name);
7908         if ((ent == NULL) && (ctxt->options & XML_PARSE_OLDSAX))
7909             ent = xmlGetPredefinedEntity(name);
7910         if ((ent == NULL) && (ctxt->userData==ctxt)) {
7911             ent = xmlSAX2GetEntity(ctxt, name);
7912         }
7913     }
7914     if (ctxt->instate == XML_PARSER_EOF) {
7915         xmlFree(name);
7916         return(NULL);
7917     }
7918
7919     /*
7920      * [ WFC: Entity Declared ]
7921      * In a document without any DTD, a document with only an
7922      * internal DTD subset which contains no parameter entity
7923      * references, or a document with "standalone='yes'", the
7924      * Name given in the entity reference must match that in an
7925      * entity declaration, except that well-formed documents
7926      * need not declare any of the following entities: amp, lt,
7927      * gt, apos, quot.
7928      * The declaration of a parameter entity must precede any
7929      * reference to it.
7930      * Similarly, the declaration of a general entity must
7931      * precede any reference to it which appears in a default
7932      * value in an attribute-list declaration. Note that if
7933      * entities are declared in the external subset or in
7934      * external parameter entities, a non-validating processor
7935      * is not obligated to read and process their declarations;
7936      * for such documents, the rule that an entity must be
7937      * declared is a well-formedness constraint only if
7938      * standalone='yes'.
7939      */
7940     if (ent == NULL) {
7941         if ((ctxt->standalone == 1) ||
7942             ((ctxt->hasExternalSubset == 0) &&
7943              (ctxt->hasPErefs == 0))) {
7944             xmlFatalErrMsgStr(ctxt, XML_ERR_UNDECLARED_ENTITY,
7945                      "Entity '%s' not defined\n", name);
7946         } else {
7947             xmlErrMsgStr(ctxt, XML_WAR_UNDECLARED_ENTITY,
7948                           "Entity '%s' not defined\n",
7949                           name);
7950         }
7951         xmlParserEntityCheck(ctxt, 0, ent, 0);
7952         /* TODO ? check regressions ctxt->valid = 0; */
7953     }
7954
7955     /*
7956      * [ WFC: Parsed Entity ]
7957      * An entity reference must not contain the name of an
7958      * unparsed entity
7959      */
7960     else if (ent->etype == XML_EXTERNAL_GENERAL_UNPARSED_ENTITY) {
7961         xmlFatalErrMsgStr(ctxt, XML_ERR_UNPARSED_ENTITY,
7962                  "Entity reference to unparsed entity %s\n", name);
7963     }
7964
7965     /*
7966      * [ WFC: No External Entity References ]
7967      * Attribute values cannot contain direct or indirect
7968      * entity references to external entities.
7969      */
7970     else if ((ctxt->instate == XML_PARSER_ATTRIBUTE_VALUE) &&
7971              (ent->etype == XML_EXTERNAL_GENERAL_PARSED_ENTITY)) {
7972         xmlFatalErrMsgStr(ctxt, XML_ERR_ENTITY_IS_EXTERNAL,
7973          "Attribute references external entity '%s'\n", name);
7974     }
7975     /*
7976      * [ WFC: No < in Attribute Values ]
7977      * The replacement text of any entity referred to directly or
7978      * indirectly in an attribute value (other than "&lt;") must
7979      * not contain a <.
7980      */
7981     else if ((ctxt->instate == XML_PARSER_ATTRIBUTE_VALUE) &&
7982              (ent != NULL) && (ent->content != NULL) &&
7983              (ent->etype != XML_INTERNAL_PREDEFINED_ENTITY) &&
7984              (xmlStrchr(ent->content, '<'))) {
7985         xmlFatalErrMsgStr(ctxt, XML_ERR_LT_IN_ATTRIBUTE,
7986      "'<' in entity '%s' is not allowed in attributes values\n",
7987                           name);
7988     }
7989
7990     /*
7991      * Internal check, no parameter entities here ...
7992      */
7993     else {
7994         switch (ent->etype) {
7995             case XML_INTERNAL_PARAMETER_ENTITY:
7996             case XML_EXTERNAL_PARAMETER_ENTITY:
7997                 xmlFatalErrMsgStr(ctxt, XML_ERR_ENTITY_IS_PARAMETER,
7998              "Attempt to reference the parameter entity '%s'\n",
7999                                   name);
8000             break;
8001             default:
8002             break;
8003         }
8004     }
8005
8006     /*
8007      * [ WFC: No Recursion ]
8008      * A parsed entity must not contain a recursive reference
8009      * to itself, either directly or indirectly.
8010      * Done somewhere else
8011      */
8012
8013     xmlFree(name);
8014     *str = ptr;
8015     return(ent);
8016 }
8017
8018 /**
8019  * xmlParsePEReference:
8020  * @ctxt:  an XML parser context
8021  *
8022  * parse PEReference declarations
8023  * The entity content is handled directly by pushing it's content as
8024  * a new input stream.
8025  *
8026  * [69] PEReference ::= '%' Name ';'
8027  *
8028  * [ WFC: No Recursion ]
8029  * A parsed entity must not contain a recursive
8030  * reference to itself, either directly or indirectly.
8031  *
8032  * [ WFC: Entity Declared ]
8033  * In a document without any DTD, a document with only an internal DTD
8034  * subset which contains no parameter entity references, or a document
8035  * with "standalone='yes'", ...  ... The declaration of a parameter
8036  * entity must precede any reference to it...
8037  *
8038  * [ VC: Entity Declared ]
8039  * In a document with an external subset or external parameter entities
8040  * with "standalone='no'", ...  ... The declaration of a parameter entity
8041  * must precede any reference to it...
8042  *
8043  * [ WFC: In DTD ]
8044  * Parameter-entity references may only appear in the DTD.
8045  * NOTE: misleading but this is handled.
8046  */
8047 void
8048 xmlParsePEReference(xmlParserCtxtPtr ctxt)
8049 {
8050     const xmlChar *name;
8051     xmlEntityPtr entity = NULL;
8052     xmlParserInputPtr input;
8053
8054     if (RAW != '%')
8055         return;
8056     NEXT;
8057     name = xmlParseName(ctxt);
8058     if (name == NULL) {
8059         xmlFatalErrMsg(ctxt, XML_ERR_NAME_REQUIRED,
8060                        "xmlParsePEReference: no name\n");
8061         return;
8062     }
8063     if (RAW != ';') {
8064         xmlFatalErr(ctxt, XML_ERR_ENTITYREF_SEMICOL_MISSING, NULL);
8065         return;
8066     }
8067
8068     NEXT;
8069
8070     /*
8071      * Increate the number of entity references parsed
8072      */
8073     ctxt->nbentities++;
8074
8075     /*
8076      * Request the entity from SAX
8077      */
8078     if ((ctxt->sax != NULL) &&
8079         (ctxt->sax->getParameterEntity != NULL))
8080         entity = ctxt->sax->getParameterEntity(ctxt->userData, name);
8081     if (ctxt->instate == XML_PARSER_EOF)
8082         return;
8083     if (entity == NULL) {
8084         /*
8085          * [ WFC: Entity Declared ]
8086          * In a document without any DTD, a document with only an
8087          * internal DTD subset which contains no parameter entity
8088          * references, or a document with "standalone='yes'", ...
8089          * ... The declaration of a parameter entity must precede
8090          * any reference to it...
8091          */
8092         if ((ctxt->standalone == 1) ||
8093             ((ctxt->hasExternalSubset == 0) &&
8094              (ctxt->hasPErefs == 0))) {
8095             xmlFatalErrMsgStr(ctxt, XML_ERR_UNDECLARED_ENTITY,
8096                               "PEReference: %%%s; not found\n",
8097                               name);
8098         } else {
8099             /*
8100              * [ VC: Entity Declared ]
8101              * In a document with an external subset or external
8102              * parameter entities with "standalone='no'", ...
8103              * ... The declaration of a parameter entity must
8104              * precede any reference to it...
8105              */
8106             xmlWarningMsg(ctxt, XML_WAR_UNDECLARED_ENTITY,
8107                           "PEReference: %%%s; not found\n",
8108                           name, NULL);
8109             ctxt->valid = 0;
8110         }
8111         xmlParserEntityCheck(ctxt, 0, NULL, 0);
8112     } else {
8113         /*
8114          * Internal checking in case the entity quest barfed
8115          */
8116         if ((entity->etype != XML_INTERNAL_PARAMETER_ENTITY) &&
8117             (entity->etype != XML_EXTERNAL_PARAMETER_ENTITY)) {
8118             xmlWarningMsg(ctxt, XML_WAR_UNDECLARED_ENTITY,
8119                   "Internal: %%%s; is not a parameter entity\n",
8120                           name, NULL);
8121         } else if (ctxt->input->free != deallocblankswrapper) {
8122             input = xmlNewBlanksWrapperInputStream(ctxt, entity);
8123             if (xmlPushInput(ctxt, input) < 0)
8124                 return;
8125         } else {
8126             /*
8127              * TODO !!!
8128              * handle the extra spaces added before and after
8129              * c.f. http://www.w3.org/TR/REC-xml#as-PE
8130              */
8131             input = xmlNewEntityInputStream(ctxt, entity);
8132             if (xmlPushInput(ctxt, input) < 0)
8133                 return;
8134             if ((entity->etype == XML_EXTERNAL_PARAMETER_ENTITY) &&
8135                 (CMP5(CUR_PTR, '<', '?', 'x', 'm', 'l')) &&
8136                 (IS_BLANK_CH(NXT(5)))) {
8137                 xmlParseTextDecl(ctxt);
8138                 if (ctxt->errNo ==
8139                     XML_ERR_UNSUPPORTED_ENCODING) {
8140                     /*
8141                      * The XML REC instructs us to stop parsing
8142                      * right here
8143                      */
8144                     xmlHaltParser(ctxt);
8145                     return;
8146                 }
8147             }
8148         }
8149     }
8150     ctxt->hasPErefs = 1;
8151 }
8152
8153 /**
8154  * xmlLoadEntityContent:
8155  * @ctxt:  an XML parser context
8156  * @entity: an unloaded system entity
8157  *
8158  * Load the original content of the given system entity from the
8159  * ExternalID/SystemID given. This is to be used for Included in Literal
8160  * http://www.w3.org/TR/REC-xml/#inliteral processing of entities references
8161  *
8162  * Returns 0 in case of success and -1 in case of failure
8163  */
8164 static int
8165 xmlLoadEntityContent(xmlParserCtxtPtr ctxt, xmlEntityPtr entity) {
8166     xmlParserInputPtr input;
8167     xmlBufferPtr buf;
8168     int l, c;
8169     int count = 0;
8170
8171     if ((ctxt == NULL) || (entity == NULL) ||
8172         ((entity->etype != XML_EXTERNAL_PARAMETER_ENTITY) &&
8173          (entity->etype != XML_EXTERNAL_GENERAL_PARSED_ENTITY)) ||
8174         (entity->content != NULL)) {
8175         xmlFatalErr(ctxt, XML_ERR_INTERNAL_ERROR,
8176                     "xmlLoadEntityContent parameter error");
8177         return(-1);
8178     }
8179
8180     if (xmlParserDebugEntities)
8181         xmlGenericError(xmlGenericErrorContext,
8182                 "Reading %s entity content input\n", entity->name);
8183
8184     buf = xmlBufferCreate();
8185     if (buf == NULL) {
8186         xmlFatalErr(ctxt, XML_ERR_INTERNAL_ERROR,
8187                     "xmlLoadEntityContent parameter error");
8188         return(-1);
8189     }
8190
8191     input = xmlNewEntityInputStream(ctxt, entity);
8192     if (input == NULL) {
8193         xmlFatalErr(ctxt, XML_ERR_INTERNAL_ERROR,
8194                     "xmlLoadEntityContent input error");
8195         xmlBufferFree(buf);
8196         return(-1);
8197     }
8198
8199     /*
8200      * Push the entity as the current input, read char by char
8201      * saving to the buffer until the end of the entity or an error
8202      */
8203     if (xmlPushInput(ctxt, input) < 0) {
8204         xmlBufferFree(buf);
8205         return(-1);
8206     }
8207
8208     GROW;
8209     c = CUR_CHAR(l);
8210     while ((ctxt->input == input) && (ctxt->input->cur < ctxt->input->end) &&
8211            (IS_CHAR(c))) {
8212         xmlBufferAdd(buf, ctxt->input->cur, l);
8213         if (count++ > XML_PARSER_CHUNK_SIZE) {
8214             count = 0;
8215             GROW;
8216             if (ctxt->instate == XML_PARSER_EOF) {
8217                 xmlBufferFree(buf);
8218                 return(-1);
8219             }
8220         }
8221         NEXTL(l);
8222         c = CUR_CHAR(l);
8223         if (c == 0) {
8224             count = 0;
8225             GROW;
8226             if (ctxt->instate == XML_PARSER_EOF) {
8227                 xmlBufferFree(buf);
8228                 return(-1);
8229             }
8230             c = CUR_CHAR(l);
8231         }
8232     }
8233
8234     if ((ctxt->input == input) && (ctxt->input->cur >= ctxt->input->end)) {
8235         xmlPopInput(ctxt);
8236     } else if (!IS_CHAR(c)) {
8237         xmlFatalErrMsgInt(ctxt, XML_ERR_INVALID_CHAR,
8238                           "xmlLoadEntityContent: invalid char value %d\n",
8239                           c);
8240         xmlBufferFree(buf);
8241         return(-1);
8242     }
8243     entity->content = buf->content;
8244     buf->content = NULL;
8245     xmlBufferFree(buf);
8246
8247     return(0);
8248 }
8249
8250 /**
8251  * xmlParseStringPEReference:
8252  * @ctxt:  an XML parser context
8253  * @str:  a pointer to an index in the string
8254  *
8255  * parse PEReference declarations
8256  *
8257  * [69] PEReference ::= '%' Name ';'
8258  *
8259  * [ WFC: No Recursion ]
8260  * A parsed entity must not contain a recursive
8261  * reference to itself, either directly or indirectly.
8262  *
8263  * [ WFC: Entity Declared ]
8264  * In a document without any DTD, a document with only an internal DTD
8265  * subset which contains no parameter entity references, or a document
8266  * with "standalone='yes'", ...  ... The declaration of a parameter
8267  * entity must precede any reference to it...
8268  *
8269  * [ VC: Entity Declared ]
8270  * In a document with an external subset or external parameter entities
8271  * with "standalone='no'", ...  ... The declaration of a parameter entity
8272  * must precede any reference to it...
8273  *
8274  * [ WFC: In DTD ]
8275  * Parameter-entity references may only appear in the DTD.
8276  * NOTE: misleading but this is handled.
8277  *
8278  * Returns the string of the entity content.
8279  *         str is updated to the current value of the index
8280  */
8281 static xmlEntityPtr
8282 xmlParseStringPEReference(xmlParserCtxtPtr ctxt, const xmlChar **str) {
8283     const xmlChar *ptr;
8284     xmlChar cur;
8285     xmlChar *name;
8286     xmlEntityPtr entity = NULL;
8287
8288     if ((str == NULL) || (*str == NULL)) return(NULL);
8289     ptr = *str;
8290     cur = *ptr;
8291     if (cur != '%')
8292         return(NULL);
8293     ptr++;
8294     name = xmlParseStringName(ctxt, &ptr);
8295     if (name == NULL) {
8296         xmlFatalErrMsg(ctxt, XML_ERR_NAME_REQUIRED,
8297                        "xmlParseStringPEReference: no name\n");
8298         *str = ptr;
8299         return(NULL);
8300     }
8301     cur = *ptr;
8302     if (cur != ';') {
8303         xmlFatalErr(ctxt, XML_ERR_ENTITYREF_SEMICOL_MISSING, NULL);
8304         xmlFree(name);
8305         *str = ptr;
8306         return(NULL);
8307     }
8308     ptr++;
8309
8310     /*
8311      * Increate the number of entity references parsed
8312      */
8313     ctxt->nbentities++;
8314
8315     /*
8316      * Request the entity from SAX
8317      */
8318     if ((ctxt->sax != NULL) &&
8319         (ctxt->sax->getParameterEntity != NULL))
8320         entity = ctxt->sax->getParameterEntity(ctxt->userData, name);
8321     if (ctxt->instate == XML_PARSER_EOF) {
8322         xmlFree(name);
8323         return(NULL);
8324     }
8325     if (entity == NULL) {
8326         /*
8327          * [ WFC: Entity Declared ]
8328          * In a document without any DTD, a document with only an
8329          * internal DTD subset which contains no parameter entity
8330          * references, or a document with "standalone='yes'", ...
8331          * ... The declaration of a parameter entity must precede
8332          * any reference to it...
8333          */
8334         if ((ctxt->standalone == 1) ||
8335             ((ctxt->hasExternalSubset == 0) && (ctxt->hasPErefs == 0))) {
8336             xmlFatalErrMsgStr(ctxt, XML_ERR_UNDECLARED_ENTITY,
8337                  "PEReference: %%%s; not found\n", name);
8338         } else {
8339             /*
8340              * [ VC: Entity Declared ]
8341              * In a document with an external subset or external
8342              * parameter entities with "standalone='no'", ...
8343              * ... The declaration of a parameter entity must
8344              * precede any reference to it...
8345              */
8346             xmlWarningMsg(ctxt, XML_WAR_UNDECLARED_ENTITY,
8347                           "PEReference: %%%s; not found\n",
8348                           name, NULL);
8349             ctxt->valid = 0;
8350         }
8351         xmlParserEntityCheck(ctxt, 0, NULL, 0);
8352     } else {
8353         /*
8354          * Internal checking in case the entity quest barfed
8355          */
8356         if ((entity->etype != XML_INTERNAL_PARAMETER_ENTITY) &&
8357             (entity->etype != XML_EXTERNAL_PARAMETER_ENTITY)) {
8358             xmlWarningMsg(ctxt, XML_WAR_UNDECLARED_ENTITY,
8359                           "%%%s; is not a parameter entity\n",
8360                           name, NULL);
8361         }
8362     }
8363     ctxt->hasPErefs = 1;
8364     xmlFree(name);
8365     *str = ptr;
8366     return(entity);
8367 }
8368
8369 /**
8370  * xmlParseDocTypeDecl:
8371  * @ctxt:  an XML parser context
8372  *
8373  * parse a DOCTYPE declaration
8374  *
8375  * [28] doctypedecl ::= '<!DOCTYPE' S Name (S ExternalID)? S?
8376  *                      ('[' (markupdecl | PEReference | S)* ']' S?)? '>'
8377  *
8378  * [ VC: Root Element Type ]
8379  * The Name in the document type declaration must match the element
8380  * type of the root element.
8381  */
8382
8383 void
8384 xmlParseDocTypeDecl(xmlParserCtxtPtr ctxt) {
8385     const xmlChar *name = NULL;
8386     xmlChar *ExternalID = NULL;
8387     xmlChar *URI = NULL;
8388
8389     /*
8390      * We know that '<!DOCTYPE' has been detected.
8391      */
8392     SKIP(9);
8393
8394     SKIP_BLANKS;
8395
8396     /*
8397      * Parse the DOCTYPE name.
8398      */
8399     name = xmlParseName(ctxt);
8400     if (name == NULL) {
8401         xmlFatalErrMsg(ctxt, XML_ERR_NAME_REQUIRED,
8402                        "xmlParseDocTypeDecl : no DOCTYPE name !\n");
8403     }
8404     ctxt->intSubName = name;
8405
8406     SKIP_BLANKS;
8407
8408     /*
8409      * Check for SystemID and ExternalID
8410      */
8411     URI = xmlParseExternalID(ctxt, &ExternalID, 1);
8412
8413     if ((URI != NULL) || (ExternalID != NULL)) {
8414         ctxt->hasExternalSubset = 1;
8415     }
8416     ctxt->extSubURI = URI;
8417     ctxt->extSubSystem = ExternalID;
8418
8419     SKIP_BLANKS;
8420
8421     /*
8422      * Create and update the internal subset.
8423      */
8424     if ((ctxt->sax != NULL) && (ctxt->sax->internalSubset != NULL) &&
8425         (!ctxt->disableSAX))
8426         ctxt->sax->internalSubset(ctxt->userData, name, ExternalID, URI);
8427     if (ctxt->instate == XML_PARSER_EOF)
8428         return;
8429
8430     /*
8431      * Is there any internal subset declarations ?
8432      * they are handled separately in xmlParseInternalSubset()
8433      */
8434     if (RAW == '[')
8435         return;
8436
8437     /*
8438      * We should be at the end of the DOCTYPE declaration.
8439      */
8440     if (RAW != '>') {
8441         xmlFatalErr(ctxt, XML_ERR_DOCTYPE_NOT_FINISHED, NULL);
8442     }
8443     NEXT;
8444 }
8445
8446 /**
8447  * xmlParseInternalSubset:
8448  * @ctxt:  an XML parser context
8449  *
8450  * parse the internal subset declaration
8451  *
8452  * [28 end] ('[' (markupdecl | PEReference | S)* ']' S?)? '>'
8453  */
8454
8455 static void
8456 xmlParseInternalSubset(xmlParserCtxtPtr ctxt) {
8457     /*
8458      * Is there any DTD definition ?
8459      */
8460     if (RAW == '[') {
8461         ctxt->instate = XML_PARSER_DTD;
8462         NEXT;
8463         /*
8464          * Parse the succession of Markup declarations and
8465          * PEReferences.
8466          * Subsequence (markupdecl | PEReference | S)*
8467          */
8468         while ((RAW != ']') && (ctxt->instate != XML_PARSER_EOF)) {
8469             const xmlChar *check = CUR_PTR;
8470             unsigned int cons = ctxt->input->consumed;
8471
8472             SKIP_BLANKS;
8473             xmlParseMarkupDecl(ctxt);
8474             xmlParsePEReference(ctxt);
8475
8476             /*
8477              * Pop-up of finished entities.
8478              */
8479             while ((RAW == 0) && (ctxt->inputNr > 1))
8480                 xmlPopInput(ctxt);
8481
8482             if ((CUR_PTR == check) && (cons == ctxt->input->consumed)) {
8483                 xmlFatalErr(ctxt, XML_ERR_INTERNAL_ERROR,
8484              "xmlParseInternalSubset: error detected in Markup declaration\n");
8485                 break;
8486             }
8487         }
8488         if (RAW == ']') {
8489             NEXT;
8490             SKIP_BLANKS;
8491         }
8492     }
8493
8494     /*
8495      * We should be at the end of the DOCTYPE declaration.
8496      */
8497     if (RAW != '>') {
8498         xmlFatalErr(ctxt, XML_ERR_DOCTYPE_NOT_FINISHED, NULL);
8499         return;
8500     }
8501     NEXT;
8502 }
8503
8504 #ifdef LIBXML_SAX1_ENABLED
8505 /**
8506  * xmlParseAttribute:
8507  * @ctxt:  an XML parser context
8508  * @value:  a xmlChar ** used to store the value of the attribute
8509  *
8510  * parse an attribute
8511  *
8512  * [41] Attribute ::= Name Eq AttValue
8513  *
8514  * [ WFC: No External Entity References ]
8515  * Attribute values cannot contain direct or indirect entity references
8516  * to external entities.
8517  *
8518  * [ WFC: No < in Attribute Values ]
8519  * The replacement text of any entity referred to directly or indirectly in
8520  * an attribute value (other than "&lt;") must not contain a <.
8521  *
8522  * [ VC: Attribute Value Type ]
8523  * The attribute must have been declared; the value must be of the type
8524  * declared for it.
8525  *
8526  * [25] Eq ::= S? '=' S?
8527  *
8528  * With namespace:
8529  *
8530  * [NS 11] Attribute ::= QName Eq AttValue
8531  *
8532  * Also the case QName == xmlns:??? is handled independently as a namespace
8533  * definition.
8534  *
8535  * Returns the attribute name, and the value in *value.
8536  */
8537
8538 const xmlChar *
8539 xmlParseAttribute(xmlParserCtxtPtr ctxt, xmlChar **value) {
8540     const xmlChar *name;
8541     xmlChar *val;
8542
8543     *value = NULL;
8544     GROW;
8545     name = xmlParseName(ctxt);
8546     if (name == NULL) {
8547         xmlFatalErrMsg(ctxt, XML_ERR_NAME_REQUIRED,
8548                        "error parsing attribute name\n");
8549         return(NULL);
8550     }
8551
8552     /*
8553      * read the value
8554      */
8555     SKIP_BLANKS;
8556     if (RAW == '=') {
8557         NEXT;
8558         SKIP_BLANKS;
8559         val = xmlParseAttValue(ctxt);
8560         ctxt->instate = XML_PARSER_CONTENT;
8561     } else {
8562         xmlFatalErrMsgStr(ctxt, XML_ERR_ATTRIBUTE_WITHOUT_VALUE,
8563                "Specification mandate value for attribute %s\n", name);
8564         return(NULL);
8565     }
8566
8567     /*
8568      * Check that xml:lang conforms to the specification
8569      * No more registered as an error, just generate a warning now
8570      * since this was deprecated in XML second edition
8571      */
8572     if ((ctxt->pedantic) && (xmlStrEqual(name, BAD_CAST "xml:lang"))) {
8573         if (!xmlCheckLanguageID(val)) {
8574             xmlWarningMsg(ctxt, XML_WAR_LANG_VALUE,
8575                           "Malformed value for xml:lang : %s\n",
8576                           val, NULL);
8577         }
8578     }
8579
8580     /*
8581      * Check that xml:space conforms to the specification
8582      */
8583     if (xmlStrEqual(name, BAD_CAST "xml:space")) {
8584         if (xmlStrEqual(val, BAD_CAST "default"))
8585             *(ctxt->space) = 0;
8586         else if (xmlStrEqual(val, BAD_CAST "preserve"))
8587             *(ctxt->space) = 1;
8588         else {
8589                 xmlWarningMsg(ctxt, XML_WAR_SPACE_VALUE,
8590 "Invalid value \"%s\" for xml:space : \"default\" or \"preserve\" expected\n",
8591                                  val, NULL);
8592         }
8593     }
8594
8595     *value = val;
8596     return(name);
8597 }
8598
8599 /**
8600  * xmlParseStartTag:
8601  * @ctxt:  an XML parser context
8602  *
8603  * parse a start of tag either for rule element or
8604  * EmptyElement. In both case we don't parse the tag closing chars.
8605  *
8606  * [40] STag ::= '<' Name (S Attribute)* S? '>'
8607  *
8608  * [ WFC: Unique Att Spec ]
8609  * No attribute name may appear more than once in the same start-tag or
8610  * empty-element tag.
8611  *
8612  * [44] EmptyElemTag ::= '<' Name (S Attribute)* S? '/>'
8613  *
8614  * [ WFC: Unique Att Spec ]
8615  * No attribute name may appear more than once in the same start-tag or
8616  * empty-element tag.
8617  *
8618  * With namespace:
8619  *
8620  * [NS 8] STag ::= '<' QName (S Attribute)* S? '>'
8621  *
8622  * [NS 10] EmptyElement ::= '<' QName (S Attribute)* S? '/>'
8623  *
8624  * Returns the element name parsed
8625  */
8626
8627 const xmlChar *
8628 xmlParseStartTag(xmlParserCtxtPtr ctxt) {
8629     const xmlChar *name;
8630     const xmlChar *attname;
8631     xmlChar *attvalue;
8632     const xmlChar **atts = ctxt->atts;
8633     int nbatts = 0;
8634     int maxatts = ctxt->maxatts;
8635     int i;
8636
8637     if (RAW != '<') return(NULL);
8638     NEXT1;
8639
8640     name = xmlParseName(ctxt);
8641     if (name == NULL) {
8642         xmlFatalErrMsg(ctxt, XML_ERR_NAME_REQUIRED,
8643              "xmlParseStartTag: invalid element name\n");
8644         return(NULL);
8645     }
8646
8647     /*
8648      * Now parse the attributes, it ends up with the ending
8649      *
8650      * (S Attribute)* S?
8651      */
8652     SKIP_BLANKS;
8653     GROW;
8654
8655     while (((RAW != '>') &&
8656            ((RAW != '/') || (NXT(1) != '>')) &&
8657            (IS_BYTE_CHAR(RAW))) && (ctxt->instate != XML_PARSER_EOF)) {
8658         const xmlChar *q = CUR_PTR;
8659         unsigned int cons = ctxt->input->consumed;
8660
8661         attname = xmlParseAttribute(ctxt, &attvalue);
8662         if ((attname != NULL) && (attvalue != NULL)) {
8663             /*
8664              * [ WFC: Unique Att Spec ]
8665              * No attribute name may appear more than once in the same
8666              * start-tag or empty-element tag.
8667              */
8668             for (i = 0; i < nbatts;i += 2) {
8669                 if (xmlStrEqual(atts[i], attname)) {
8670                     xmlErrAttributeDup(ctxt, NULL, attname);
8671                     xmlFree(attvalue);
8672                     goto failed;
8673                 }
8674             }
8675             /*
8676              * Add the pair to atts
8677              */
8678             if (atts == NULL) {
8679                 maxatts = 22; /* allow for 10 attrs by default */
8680                 atts = (const xmlChar **)
8681                        xmlMalloc(maxatts * sizeof(xmlChar *));
8682                 if (atts == NULL) {
8683                     xmlErrMemory(ctxt, NULL);
8684                     if (attvalue != NULL)
8685                         xmlFree(attvalue);
8686                     goto failed;
8687                 }
8688                 ctxt->atts = atts;
8689                 ctxt->maxatts = maxatts;
8690             } else if (nbatts + 4 > maxatts) {
8691                 const xmlChar **n;
8692
8693                 maxatts *= 2;
8694                 n = (const xmlChar **) xmlRealloc((void *) atts,
8695                                              maxatts * sizeof(const xmlChar *));
8696                 if (n == NULL) {
8697                     xmlErrMemory(ctxt, NULL);
8698                     if (attvalue != NULL)
8699                         xmlFree(attvalue);
8700                     goto failed;
8701                 }
8702                 atts = n;
8703                 ctxt->atts = atts;
8704                 ctxt->maxatts = maxatts;
8705             }
8706             atts[nbatts++] = attname;
8707             atts[nbatts++] = attvalue;
8708             atts[nbatts] = NULL;
8709             atts[nbatts + 1] = NULL;
8710         } else {
8711             if (attvalue != NULL)
8712                 xmlFree(attvalue);
8713         }
8714
8715 failed:
8716
8717         GROW
8718         if ((RAW == '>') || (((RAW == '/') && (NXT(1) == '>'))))
8719             break;
8720         if (!IS_BLANK_CH(RAW)) {
8721             xmlFatalErrMsg(ctxt, XML_ERR_SPACE_REQUIRED,
8722                            "attributes construct error\n");
8723         }
8724         SKIP_BLANKS;
8725         if ((cons == ctxt->input->consumed) && (q == CUR_PTR) &&
8726             (attname == NULL) && (attvalue == NULL)) {
8727             xmlFatalErrMsg(ctxt, XML_ERR_INTERNAL_ERROR,
8728                            "xmlParseStartTag: problem parsing attributes\n");
8729             break;
8730         }
8731         SHRINK;
8732         GROW;
8733     }
8734
8735     /*
8736      * SAX: Start of Element !
8737      */
8738     if ((ctxt->sax != NULL) && (ctxt->sax->startElement != NULL) &&
8739         (!ctxt->disableSAX)) {
8740         if (nbatts > 0)
8741             ctxt->sax->startElement(ctxt->userData, name, atts);
8742         else
8743             ctxt->sax->startElement(ctxt->userData, name, NULL);
8744     }
8745
8746     if (atts != NULL) {
8747         /* Free only the content strings */
8748         for (i = 1;i < nbatts;i+=2)
8749             if (atts[i] != NULL)
8750                xmlFree((xmlChar *) atts[i]);
8751     }
8752     return(name);
8753 }
8754
8755 /**
8756  * xmlParseEndTag1:
8757  * @ctxt:  an XML parser context
8758  * @line:  line of the start tag
8759  * @nsNr:  number of namespaces on the start tag
8760  *
8761  * parse an end of tag
8762  *
8763  * [42] ETag ::= '</' Name S? '>'
8764  *
8765  * With namespace
8766  *
8767  * [NS 9] ETag ::= '</' QName S? '>'
8768  */
8769
8770 static void
8771 xmlParseEndTag1(xmlParserCtxtPtr ctxt, int line) {
8772     const xmlChar *name;
8773
8774     GROW;
8775     if ((RAW != '<') || (NXT(1) != '/')) {
8776         xmlFatalErrMsg(ctxt, XML_ERR_LTSLASH_REQUIRED,
8777                        "xmlParseEndTag: '</' not found\n");
8778         return;
8779     }
8780     SKIP(2);
8781
8782     name = xmlParseNameAndCompare(ctxt,ctxt->name);
8783
8784     /*
8785      * We should definitely be at the ending "S? '>'" part
8786      */
8787     GROW;
8788     SKIP_BLANKS;
8789     if ((!IS_BYTE_CHAR(RAW)) || (RAW != '>')) {
8790         xmlFatalErr(ctxt, XML_ERR_GT_REQUIRED, NULL);
8791     } else
8792         NEXT1;
8793
8794     /*
8795      * [ WFC: Element Type Match ]
8796      * The Name in an element's end-tag must match the element type in the
8797      * start-tag.
8798      *
8799      */
8800     if (name != (xmlChar*)1) {
8801         if (name == NULL) name = BAD_CAST "unparseable";
8802         xmlFatalErrMsgStrIntStr(ctxt, XML_ERR_TAG_NAME_MISMATCH,
8803                      "Opening and ending tag mismatch: %s line %d and %s\n",
8804                                 ctxt->name, line, name);
8805     }
8806
8807     /*
8808      * SAX: End of Tag
8809      */
8810     if ((ctxt->sax != NULL) && (ctxt->sax->endElement != NULL) &&
8811         (!ctxt->disableSAX))
8812         ctxt->sax->endElement(ctxt->userData, ctxt->name);
8813
8814     namePop(ctxt);
8815     spacePop(ctxt);
8816     return;
8817 }
8818
8819 /**
8820  * xmlParseEndTag:
8821  * @ctxt:  an XML parser context
8822  *
8823  * parse an end of tag
8824  *
8825  * [42] ETag ::= '</' Name S? '>'
8826  *
8827  * With namespace
8828  *
8829  * [NS 9] ETag ::= '</' QName S? '>'
8830  */
8831
8832 void
8833 xmlParseEndTag(xmlParserCtxtPtr ctxt) {
8834     xmlParseEndTag1(ctxt, 0);
8835 }
8836 #endif /* LIBXML_SAX1_ENABLED */
8837
8838 /************************************************************************
8839  *                                                                      *
8840  *                    SAX 2 specific operations                         *
8841  *                                                                      *
8842  ************************************************************************/
8843
8844 /*
8845  * xmlGetNamespace:
8846  * @ctxt:  an XML parser context
8847  * @prefix:  the prefix to lookup
8848  *
8849  * Lookup the namespace name for the @prefix (which ca be NULL)
8850  * The prefix must come from the @ctxt->dict dictionary
8851  *
8852  * Returns the namespace name or NULL if not bound
8853  */
8854 static const xmlChar *
8855 xmlGetNamespace(xmlParserCtxtPtr ctxt, const xmlChar *prefix) {
8856     int i;
8857
8858     if (prefix == ctxt->str_xml) return(ctxt->str_xml_ns);
8859     for (i = ctxt->nsNr - 2;i >= 0;i-=2)
8860         if (ctxt->nsTab[i] == prefix) {
8861             if ((prefix == NULL) && (*ctxt->nsTab[i + 1] == 0))
8862                 return(NULL);
8863             return(ctxt->nsTab[i + 1]);
8864         }
8865     return(NULL);
8866 }
8867
8868 /**
8869  * xmlParseQName:
8870  * @ctxt:  an XML parser context
8871  * @prefix:  pointer to store the prefix part
8872  *
8873  * parse an XML Namespace QName
8874  *
8875  * [6]  QName  ::= (Prefix ':')? LocalPart
8876  * [7]  Prefix  ::= NCName
8877  * [8]  LocalPart  ::= NCName
8878  *
8879  * Returns the Name parsed or NULL
8880  */
8881
8882 static const xmlChar *
8883 xmlParseQName(xmlParserCtxtPtr ctxt, const xmlChar **prefix) {
8884     const xmlChar *l, *p;
8885
8886     GROW;
8887
8888     l = xmlParseNCName(ctxt);
8889     if (l == NULL) {
8890         if (CUR == ':') {
8891             l = xmlParseName(ctxt);
8892             if (l != NULL) {
8893                 xmlNsErr(ctxt, XML_NS_ERR_QNAME,
8894                          "Failed to parse QName '%s'\n", l, NULL, NULL);
8895                 *prefix = NULL;
8896                 return(l);
8897             }
8898         }
8899         return(NULL);
8900     }
8901     if (CUR == ':') {
8902         NEXT;
8903         p = l;
8904         l = xmlParseNCName(ctxt);
8905         if (l == NULL) {
8906             xmlChar *tmp;
8907
8908             xmlNsErr(ctxt, XML_NS_ERR_QNAME,
8909                      "Failed to parse QName '%s:'\n", p, NULL, NULL);
8910             l = xmlParseNmtoken(ctxt);
8911             if (l == NULL)
8912                 tmp = xmlBuildQName(BAD_CAST "", p, NULL, 0);
8913             else {
8914                 tmp = xmlBuildQName(l, p, NULL, 0);
8915                 xmlFree((char *)l);
8916             }
8917             p = xmlDictLookup(ctxt->dict, tmp, -1);
8918             if (tmp != NULL) xmlFree(tmp);
8919             *prefix = NULL;
8920             return(p);
8921         }
8922         if (CUR == ':') {
8923             xmlChar *tmp;
8924
8925             xmlNsErr(ctxt, XML_NS_ERR_QNAME,
8926                      "Failed to parse QName '%s:%s:'\n", p, l, NULL);
8927             NEXT;
8928             tmp = (xmlChar *) xmlParseName(ctxt);
8929             if (tmp != NULL) {
8930                 tmp = xmlBuildQName(tmp, l, NULL, 0);
8931                 l = xmlDictLookup(ctxt->dict, tmp, -1);
8932                 if (tmp != NULL) xmlFree(tmp);
8933                 *prefix = p;
8934                 return(l);
8935             }
8936             tmp = xmlBuildQName(BAD_CAST "", l, NULL, 0);
8937             l = xmlDictLookup(ctxt->dict, tmp, -1);
8938             if (tmp != NULL) xmlFree(tmp);
8939             *prefix = p;
8940             return(l);
8941         }
8942         *prefix = p;
8943     } else
8944         *prefix = NULL;
8945     return(l);
8946 }
8947
8948 /**
8949  * xmlParseQNameAndCompare:
8950  * @ctxt:  an XML parser context
8951  * @name:  the localname
8952  * @prefix:  the prefix, if any.
8953  *
8954  * parse an XML name and compares for match
8955  * (specialized for endtag parsing)
8956  *
8957  * Returns NULL for an illegal name, (xmlChar*) 1 for success
8958  * and the name for mismatch
8959  */
8960
8961 static const xmlChar *
8962 xmlParseQNameAndCompare(xmlParserCtxtPtr ctxt, xmlChar const *name,
8963                         xmlChar const *prefix) {
8964     const xmlChar *cmp;
8965     const xmlChar *in;
8966     const xmlChar *ret;
8967     const xmlChar *prefix2;
8968
8969     if (prefix == NULL) return(xmlParseNameAndCompare(ctxt, name));
8970
8971     GROW;
8972     in = ctxt->input->cur;
8973
8974     cmp = prefix;
8975     while (*in != 0 && *in == *cmp) {
8976         ++in;
8977         ++cmp;
8978     }
8979     if ((*cmp == 0) && (*in == ':')) {
8980         in++;
8981         cmp = name;
8982         while (*in != 0 && *in == *cmp) {
8983             ++in;
8984             ++cmp;
8985         }
8986         if (*cmp == 0 && (*in == '>' || IS_BLANK_CH (*in))) {
8987             /* success */
8988             ctxt->input->cur = in;
8989             return((const xmlChar*) 1);
8990         }
8991     }
8992     /*
8993      * all strings coms from the dictionary, equality can be done directly
8994      */
8995     ret = xmlParseQName (ctxt, &prefix2);
8996     if ((ret == name) && (prefix == prefix2))
8997         return((const xmlChar*) 1);
8998     return ret;
8999 }
9000
9001 /**
9002  * xmlParseAttValueInternal:
9003  * @ctxt:  an XML parser context
9004  * @len:  attribute len result
9005  * @alloc:  whether the attribute was reallocated as a new string
9006  * @normalize:  if 1 then further non-CDATA normalization must be done
9007  *
9008  * parse a value for an attribute.
9009  * NOTE: if no normalization is needed, the routine will return pointers
9010  *       directly from the data buffer.
9011  *
9012  * 3.3.3 Attribute-Value Normalization:
9013  * Before the value of an attribute is passed to the application or
9014  * checked for validity, the XML processor must normalize it as follows:
9015  * - a character reference is processed by appending the referenced
9016  *   character to the attribute value
9017  * - an entity reference is processed by recursively processing the
9018  *   replacement text of the entity
9019  * - a whitespace character (#x20, #xD, #xA, #x9) is processed by
9020  *   appending #x20 to the normalized value, except that only a single
9021  *   #x20 is appended for a "#xD#xA" sequence that is part of an external
9022  *   parsed entity or the literal entity value of an internal parsed entity
9023  * - other characters are processed by appending them to the normalized value
9024  * If the declared value is not CDATA, then the XML processor must further
9025  * process the normalized attribute value by discarding any leading and
9026  * trailing space (#x20) characters, and by replacing sequences of space
9027  * (#x20) characters by a single space (#x20) character.
9028  * All attributes for which no declaration has been read should be treated
9029  * by a non-validating parser as if declared CDATA.
9030  *
9031  * Returns the AttValue parsed or NULL. The value has to be freed by the
9032  *     caller if it was copied, this can be detected by val[*len] == 0.
9033  */
9034
9035 static xmlChar *
9036 xmlParseAttValueInternal(xmlParserCtxtPtr ctxt, int *len, int *alloc,
9037                          int normalize)
9038 {
9039     xmlChar limit = 0;
9040     const xmlChar *in = NULL, *start, *end, *last;
9041     xmlChar *ret = NULL;
9042     int line, col;
9043
9044     GROW;
9045     in = (xmlChar *) CUR_PTR;
9046     line = ctxt->input->line;
9047     col = ctxt->input->col;
9048     if (*in != '"' && *in != '\'') {
9049         xmlFatalErr(ctxt, XML_ERR_ATTRIBUTE_NOT_STARTED, NULL);
9050         return (NULL);
9051     }
9052     ctxt->instate = XML_PARSER_ATTRIBUTE_VALUE;
9053
9054     /*
9055      * try to handle in this routine the most common case where no
9056      * allocation of a new string is required and where content is
9057      * pure ASCII.
9058      */
9059     limit = *in++;
9060     col++;
9061     end = ctxt->input->end;
9062     start = in;
9063     if (in >= end) {
9064         const xmlChar *oldbase = ctxt->input->base;
9065         GROW;
9066         if (oldbase != ctxt->input->base) {
9067             long delta = ctxt->input->base - oldbase;
9068             start = start + delta;
9069             in = in + delta;
9070         }
9071         end = ctxt->input->end;
9072     }
9073     if (normalize) {
9074         /*
9075          * Skip any leading spaces
9076          */
9077         while ((in < end) && (*in != limit) &&
9078                ((*in == 0x20) || (*in == 0x9) ||
9079                 (*in == 0xA) || (*in == 0xD))) {
9080             if (*in == 0xA) {
9081                 line++; col = 1;
9082             } else {
9083                 col++;
9084             }
9085             in++;
9086             start = in;
9087             if (in >= end) {
9088                 const xmlChar *oldbase = ctxt->input->base;
9089                 GROW;
9090                 if (ctxt->instate == XML_PARSER_EOF)
9091                     return(NULL);
9092                 if (oldbase != ctxt->input->base) {
9093                     long delta = ctxt->input->base - oldbase;
9094                     start = start + delta;
9095                     in = in + delta;
9096                 }
9097                 end = ctxt->input->end;
9098                 if (((in - start) > XML_MAX_TEXT_LENGTH) &&
9099                     ((ctxt->options & XML_PARSE_HUGE) == 0)) {
9100                     xmlFatalErrMsg(ctxt, XML_ERR_ATTRIBUTE_NOT_FINISHED,
9101                                    "AttValue length too long\n");
9102                     return(NULL);
9103                 }
9104             }
9105         }
9106         while ((in < end) && (*in != limit) && (*in >= 0x20) &&
9107                (*in <= 0x7f) && (*in != '&') && (*in != '<')) {
9108             col++;
9109             if ((*in++ == 0x20) && (*in == 0x20)) break;
9110             if (in >= end) {
9111                 const xmlChar *oldbase = ctxt->input->base;
9112                 GROW;
9113                 if (ctxt->instate == XML_PARSER_EOF)
9114                     return(NULL);
9115                 if (oldbase != ctxt->input->base) {
9116                     long delta = ctxt->input->base - oldbase;
9117                     start = start + delta;
9118                     in = in + delta;
9119                 }
9120                 end = ctxt->input->end;
9121                 if (((in - start) > XML_MAX_TEXT_LENGTH) &&
9122                     ((ctxt->options & XML_PARSE_HUGE) == 0)) {
9123                     xmlFatalErrMsg(ctxt, XML_ERR_ATTRIBUTE_NOT_FINISHED,
9124                                    "AttValue length too long\n");
9125                     return(NULL);
9126                 }
9127             }
9128         }
9129         last = in;
9130         /*
9131          * skip the trailing blanks
9132          */
9133         while ((last[-1] == 0x20) && (last > start)) last--;
9134         while ((in < end) && (*in != limit) &&
9135                ((*in == 0x20) || (*in == 0x9) ||
9136                 (*in == 0xA) || (*in == 0xD))) {
9137             if (*in == 0xA) {
9138                 line++, col = 1;
9139             } else {
9140                 col++;
9141             }
9142             in++;
9143             if (in >= end) {
9144                 const xmlChar *oldbase = ctxt->input->base;
9145                 GROW;
9146                 if (ctxt->instate == XML_PARSER_EOF)
9147                     return(NULL);
9148                 if (oldbase != ctxt->input->base) {
9149                     long delta = ctxt->input->base - oldbase;
9150                     start = start + delta;
9151                     in = in + delta;
9152                     last = last + delta;
9153                 }
9154                 end = ctxt->input->end;
9155                 if (((in - start) > XML_MAX_TEXT_LENGTH) &&
9156                     ((ctxt->options & XML_PARSE_HUGE) == 0)) {
9157                     xmlFatalErrMsg(ctxt, XML_ERR_ATTRIBUTE_NOT_FINISHED,
9158                                    "AttValue length too long\n");
9159                     return(NULL);
9160                 }
9161             }
9162         }
9163         if (((in - start) > XML_MAX_TEXT_LENGTH) &&
9164             ((ctxt->options & XML_PARSE_HUGE) == 0)) {
9165             xmlFatalErrMsg(ctxt, XML_ERR_ATTRIBUTE_NOT_FINISHED,
9166                            "AttValue length too long\n");
9167             return(NULL);
9168         }
9169         if (*in != limit) goto need_complex;
9170     } else {
9171         while ((in < end) && (*in != limit) && (*in >= 0x20) &&
9172                (*in <= 0x7f) && (*in != '&') && (*in != '<')) {
9173             in++;
9174             col++;
9175             if (in >= end) {
9176                 const xmlChar *oldbase = ctxt->input->base;
9177                 GROW;
9178                 if (ctxt->instate == XML_PARSER_EOF)
9179                     return(NULL);
9180                 if (oldbase != ctxt->input->base) {
9181                     long delta = ctxt->input->base - oldbase;
9182                     start = start + delta;
9183                     in = in + delta;
9184                 }
9185                 end = ctxt->input->end;
9186                 if (((in - start) > XML_MAX_TEXT_LENGTH) &&
9187                     ((ctxt->options & XML_PARSE_HUGE) == 0)) {
9188                     xmlFatalErrMsg(ctxt, XML_ERR_ATTRIBUTE_NOT_FINISHED,
9189                                    "AttValue length too long\n");
9190                     return(NULL);
9191                 }
9192             }
9193         }
9194         last = in;
9195         if (((in - start) > XML_MAX_TEXT_LENGTH) &&
9196             ((ctxt->options & XML_PARSE_HUGE) == 0)) {
9197             xmlFatalErrMsg(ctxt, XML_ERR_ATTRIBUTE_NOT_FINISHED,
9198                            "AttValue length too long\n");
9199             return(NULL);
9200         }
9201         if (*in != limit) goto need_complex;
9202     }
9203     in++;
9204     col++;
9205     if (len != NULL) {
9206         *len = last - start;
9207         ret = (xmlChar *) start;
9208     } else {
9209         if (alloc) *alloc = 1;
9210         ret = xmlStrndup(start, last - start);
9211     }
9212     CUR_PTR = in;
9213     ctxt->input->line = line;
9214     ctxt->input->col = col;
9215     if (alloc) *alloc = 0;
9216     return ret;
9217 need_complex:
9218     if (alloc) *alloc = 1;
9219     return xmlParseAttValueComplex(ctxt, len, normalize);
9220 }
9221
9222 /**
9223  * xmlParseAttribute2:
9224  * @ctxt:  an XML parser context
9225  * @pref:  the element prefix
9226  * @elem:  the element name
9227  * @prefix:  a xmlChar ** used to store the value of the attribute prefix
9228  * @value:  a xmlChar ** used to store the value of the attribute
9229  * @len:  an int * to save the length of the attribute
9230  * @alloc:  an int * to indicate if the attribute was allocated
9231  *
9232  * parse an attribute in the new SAX2 framework.
9233  *
9234  * Returns the attribute name, and the value in *value, .
9235  */
9236
9237 static const xmlChar *
9238 xmlParseAttribute2(xmlParserCtxtPtr ctxt,
9239                    const xmlChar * pref, const xmlChar * elem,
9240                    const xmlChar ** prefix, xmlChar ** value,
9241                    int *len, int *alloc)
9242 {
9243     const xmlChar *name;
9244     xmlChar *val, *internal_val = NULL;
9245     int normalize = 0;
9246
9247     *value = NULL;
9248     GROW;
9249     name = xmlParseQName(ctxt, prefix);
9250     if (name == NULL) {
9251         xmlFatalErrMsg(ctxt, XML_ERR_NAME_REQUIRED,
9252                        "error parsing attribute name\n");
9253         return (NULL);
9254     }
9255
9256     /*
9257      * get the type if needed
9258      */
9259     if (ctxt->attsSpecial != NULL) {
9260         int type;
9261
9262         type = (int) (long) xmlHashQLookup2(ctxt->attsSpecial,
9263                                             pref, elem, *prefix, name);
9264         if (type != 0)
9265             normalize = 1;
9266     }
9267
9268     /*
9269      * read the value
9270      */
9271     SKIP_BLANKS;
9272     if (RAW == '=') {
9273         NEXT;
9274         SKIP_BLANKS;
9275         val = xmlParseAttValueInternal(ctxt, len, alloc, normalize);
9276         if (normalize) {
9277             /*
9278              * Sometimes a second normalisation pass for spaces is needed
9279              * but that only happens if charrefs or entities refernces
9280              * have been used in the attribute value, i.e. the attribute
9281              * value have been extracted in an allocated string already.
9282              */
9283             if (*alloc) {
9284                 const xmlChar *val2;
9285
9286                 val2 = xmlAttrNormalizeSpace2(ctxt, val, len);
9287                 if ((val2 != NULL) && (val2 != val)) {
9288                     xmlFree(val);
9289                     val = (xmlChar *) val2;
9290                 }
9291             }
9292         }
9293         ctxt->instate = XML_PARSER_CONTENT;
9294     } else {
9295         xmlFatalErrMsgStr(ctxt, XML_ERR_ATTRIBUTE_WITHOUT_VALUE,
9296                           "Specification mandate value for attribute %s\n",
9297                           name);
9298         return (NULL);
9299     }
9300
9301     if (*prefix == ctxt->str_xml) {
9302         /*
9303          * Check that xml:lang conforms to the specification
9304          * No more registered as an error, just generate a warning now
9305          * since this was deprecated in XML second edition
9306          */
9307         if ((ctxt->pedantic) && (xmlStrEqual(name, BAD_CAST "lang"))) {
9308             internal_val = xmlStrndup(val, *len);
9309             if (!xmlCheckLanguageID(internal_val)) {
9310                 xmlWarningMsg(ctxt, XML_WAR_LANG_VALUE,
9311                               "Malformed value for xml:lang : %s\n",
9312                               internal_val, NULL);
9313             }
9314         }
9315
9316         /*
9317          * Check that xml:space conforms to the specification
9318          */
9319         if (xmlStrEqual(name, BAD_CAST "space")) {
9320             internal_val = xmlStrndup(val, *len);
9321             if (xmlStrEqual(internal_val, BAD_CAST "default"))
9322                 *(ctxt->space) = 0;
9323             else if (xmlStrEqual(internal_val, BAD_CAST "preserve"))
9324                 *(ctxt->space) = 1;
9325             else {
9326                 xmlWarningMsg(ctxt, XML_WAR_SPACE_VALUE,
9327                               "Invalid value \"%s\" for xml:space : \"default\" or \"preserve\" expected\n",
9328                               internal_val, NULL);
9329             }
9330         }
9331         if (internal_val) {
9332             xmlFree(internal_val);
9333         }
9334     }
9335
9336     *value = val;
9337     return (name);
9338 }
9339 /**
9340  * xmlParseStartTag2:
9341  * @ctxt:  an XML parser context
9342  *
9343  * parse a start of tag either for rule element or
9344  * EmptyElement. In both case we don't parse the tag closing chars.
9345  * This routine is called when running SAX2 parsing
9346  *
9347  * [40] STag ::= '<' Name (S Attribute)* S? '>'
9348  *
9349  * [ WFC: Unique Att Spec ]
9350  * No attribute name may appear more than once in the same start-tag or
9351  * empty-element tag.
9352  *
9353  * [44] EmptyElemTag ::= '<' Name (S Attribute)* S? '/>'
9354  *
9355  * [ WFC: Unique Att Spec ]
9356  * No attribute name may appear more than once in the same start-tag or
9357  * empty-element tag.
9358  *
9359  * With namespace:
9360  *
9361  * [NS 8] STag ::= '<' QName (S Attribute)* S? '>'
9362  *
9363  * [NS 10] EmptyElement ::= '<' QName (S Attribute)* S? '/>'
9364  *
9365  * Returns the element name parsed
9366  */
9367
9368 static const xmlChar *
9369 xmlParseStartTag2(xmlParserCtxtPtr ctxt, const xmlChar **pref,
9370                   const xmlChar **URI, int *tlen) {
9371     const xmlChar *localname;
9372     const xmlChar *prefix;
9373     const xmlChar *attname;
9374     const xmlChar *aprefix;
9375     const xmlChar *nsname;
9376     xmlChar *attvalue;
9377     const xmlChar **atts = ctxt->atts;
9378     int maxatts = ctxt->maxatts;
9379     int nratts, nbatts, nbdef;
9380     int i, j, nbNs, attval, oldline, oldcol, inputNr;
9381     const xmlChar *base;
9382     unsigned long cur;
9383     int nsNr = ctxt->nsNr;
9384
9385     if (RAW != '<') return(NULL);
9386     NEXT1;
9387
9388     /*
9389      * NOTE: it is crucial with the SAX2 API to never call SHRINK beyond that
9390      *       point since the attribute values may be stored as pointers to
9391      *       the buffer and calling SHRINK would destroy them !
9392      *       The Shrinking is only possible once the full set of attribute
9393      *       callbacks have been done.
9394      */
9395 reparse:
9396     SHRINK;
9397     base = ctxt->input->base;
9398     cur = ctxt->input->cur - ctxt->input->base;
9399     inputNr = ctxt->inputNr;
9400     oldline = ctxt->input->line;
9401     oldcol = ctxt->input->col;
9402     nbatts = 0;
9403     nratts = 0;
9404     nbdef = 0;
9405     nbNs = 0;
9406     attval = 0;
9407     /* Forget any namespaces added during an earlier parse of this element. */
9408     ctxt->nsNr = nsNr;
9409
9410     localname = xmlParseQName(ctxt, &prefix);
9411     if (localname == NULL) {
9412         xmlFatalErrMsg(ctxt, XML_ERR_NAME_REQUIRED,
9413                        "StartTag: invalid element name\n");
9414         return(NULL);
9415     }
9416     *tlen = ctxt->input->cur - ctxt->input->base - cur;
9417
9418     /*
9419      * Now parse the attributes, it ends up with the ending
9420      *
9421      * (S Attribute)* S?
9422      */
9423     SKIP_BLANKS;
9424     GROW;
9425     if ((ctxt->input->base != base) || (inputNr != ctxt->inputNr))
9426         goto base_changed;
9427
9428     while (((RAW != '>') &&
9429            ((RAW != '/') || (NXT(1) != '>')) &&
9430            (IS_BYTE_CHAR(RAW))) && (ctxt->instate != XML_PARSER_EOF)) {
9431         const xmlChar *q = CUR_PTR;
9432         unsigned int cons = ctxt->input->consumed;
9433         int len = -1, alloc = 0;
9434
9435         attname = xmlParseAttribute2(ctxt, prefix, localname,
9436                                      &aprefix, &attvalue, &len, &alloc);
9437         if ((ctxt->input->base != base) || (inputNr != ctxt->inputNr)) {
9438             if ((attvalue != NULL) && (alloc != 0))
9439                 xmlFree(attvalue);
9440             attvalue = NULL;
9441             goto base_changed;
9442         }
9443         if ((attname != NULL) && (attvalue != NULL)) {
9444             if (len < 0) len = xmlStrlen(attvalue);
9445             if ((attname == ctxt->str_xmlns) && (aprefix == NULL)) {
9446                 const xmlChar *URL = xmlDictLookup(ctxt->dict, attvalue, len);
9447                 xmlURIPtr uri;
9448
9449                 if (URL == NULL) {
9450                     xmlErrMemory(ctxt, "dictionary allocation failure");
9451                     if ((attvalue != NULL) && (alloc != 0))
9452                         xmlFree(attvalue);
9453                     return(NULL);
9454                 }
9455                 if (*URL != 0) {
9456                     uri = xmlParseURI((const char *) URL);
9457                     if (uri == NULL) {
9458                         xmlNsErr(ctxt, XML_WAR_NS_URI,
9459                                  "xmlns: '%s' is not a valid URI\n",
9460                                            URL, NULL, NULL);
9461                     } else {
9462                         if (uri->scheme == NULL) {
9463                             xmlNsWarn(ctxt, XML_WAR_NS_URI_RELATIVE,
9464                                       "xmlns: URI %s is not absolute\n",
9465                                       URL, NULL, NULL);
9466                         }
9467                         xmlFreeURI(uri);
9468                     }
9469                     if (URL == ctxt->str_xml_ns) {
9470                         if (attname != ctxt->str_xml) {
9471                             xmlNsErr(ctxt, XML_NS_ERR_XML_NAMESPACE,
9472                          "xml namespace URI cannot be the default namespace\n",
9473                                      NULL, NULL, NULL);
9474                         }
9475                         goto skip_default_ns;
9476                     }
9477                     if ((len == 29) &&
9478                         (xmlStrEqual(URL,
9479                                  BAD_CAST "http://www.w3.org/2000/xmlns/"))) {
9480                         xmlNsErr(ctxt, XML_NS_ERR_XML_NAMESPACE,
9481                              "reuse of the xmlns namespace name is forbidden\n",
9482                                  NULL, NULL, NULL);
9483                         goto skip_default_ns;
9484                     }
9485                 }
9486                 /*
9487                  * check that it's not a defined namespace
9488                  */
9489                 for (j = 1;j <= nbNs;j++)
9490                     if (ctxt->nsTab[ctxt->nsNr - 2 * j] == NULL)
9491                         break;
9492                 if (j <= nbNs)
9493                     xmlErrAttributeDup(ctxt, NULL, attname);
9494                 else
9495                     if (nsPush(ctxt, NULL, URL) > 0) nbNs++;
9496 skip_default_ns:
9497                 if ((attvalue != NULL) && (alloc != 0)) {
9498                     xmlFree(attvalue);
9499                     attvalue = NULL;
9500                 }
9501                 if ((RAW == '>') || (((RAW == '/') && (NXT(1) == '>'))))
9502                     break;
9503                 if (!IS_BLANK_CH(RAW)) {
9504                     xmlFatalErrMsg(ctxt, XML_ERR_SPACE_REQUIRED,
9505                                    "attributes construct error\n");
9506                     break;
9507                 }
9508                 SKIP_BLANKS;
9509                 if ((ctxt->input->base != base) || (inputNr != ctxt->inputNr))
9510                     goto base_changed;
9511                 continue;
9512             }
9513             if (aprefix == ctxt->str_xmlns) {
9514                 const xmlChar *URL = xmlDictLookup(ctxt->dict, attvalue, len);
9515                 xmlURIPtr uri;
9516
9517                 if (attname == ctxt->str_xml) {
9518                     if (URL != ctxt->str_xml_ns) {
9519                         xmlNsErr(ctxt, XML_NS_ERR_XML_NAMESPACE,
9520                                  "xml namespace prefix mapped to wrong URI\n",
9521                                  NULL, NULL, NULL);
9522                     }
9523                     /*
9524                      * Do not keep a namespace definition node
9525                      */
9526                     goto skip_ns;
9527                 }
9528                 if (URL == ctxt->str_xml_ns) {
9529                     if (attname != ctxt->str_xml) {
9530                         xmlNsErr(ctxt, XML_NS_ERR_XML_NAMESPACE,
9531                                  "xml namespace URI mapped to wrong prefix\n",
9532                                  NULL, NULL, NULL);
9533                     }
9534                     goto skip_ns;
9535                 }
9536                 if (attname == ctxt->str_xmlns) {
9537                     xmlNsErr(ctxt, XML_NS_ERR_XML_NAMESPACE,
9538                              "redefinition of the xmlns prefix is forbidden\n",
9539                              NULL, NULL, NULL);
9540                     goto skip_ns;
9541                 }
9542                 if ((len == 29) &&
9543                     (xmlStrEqual(URL,
9544                                  BAD_CAST "http://www.w3.org/2000/xmlns/"))) {
9545                     xmlNsErr(ctxt, XML_NS_ERR_XML_NAMESPACE,
9546                              "reuse of the xmlns namespace name is forbidden\n",
9547                              NULL, NULL, NULL);
9548                     goto skip_ns;
9549                 }
9550                 if ((URL == NULL) || (URL[0] == 0)) {
9551                     xmlNsErr(ctxt, XML_NS_ERR_XML_NAMESPACE,
9552                              "xmlns:%s: Empty XML namespace is not allowed\n",
9553                                   attname, NULL, NULL);
9554                     goto skip_ns;
9555                 } else {
9556                     uri = xmlParseURI((const char *) URL);
9557                     if (uri == NULL) {
9558                         xmlNsErr(ctxt, XML_WAR_NS_URI,
9559                              "xmlns:%s: '%s' is not a valid URI\n",
9560                                            attname, URL, NULL);
9561                     } else {
9562                         if ((ctxt->pedantic) && (uri->scheme == NULL)) {
9563                             xmlNsWarn(ctxt, XML_WAR_NS_URI_RELATIVE,
9564                                       "xmlns:%s: URI %s is not absolute\n",
9565                                       attname, URL, NULL);
9566                         }
9567                         xmlFreeURI(uri);
9568                     }
9569                 }
9570
9571                 /*
9572                  * check that it's not a defined namespace
9573                  */
9574                 for (j = 1;j <= nbNs;j++)
9575                     if (ctxt->nsTab[ctxt->nsNr - 2 * j] == attname)
9576                         break;
9577                 if (j <= nbNs)
9578                     xmlErrAttributeDup(ctxt, aprefix, attname);
9579                 else
9580                     if (nsPush(ctxt, attname, URL) > 0) nbNs++;
9581 skip_ns:
9582                 if ((attvalue != NULL) && (alloc != 0)) {
9583                     xmlFree(attvalue);
9584                     attvalue = NULL;
9585                 }
9586                 if ((RAW == '>') || (((RAW == '/') && (NXT(1) == '>'))))
9587                     break;
9588                 if (!IS_BLANK_CH(RAW)) {
9589                     xmlFatalErrMsg(ctxt, XML_ERR_SPACE_REQUIRED,
9590                                    "attributes construct error\n");
9591                     break;
9592                 }
9593                 SKIP_BLANKS;
9594                 if ((ctxt->input->base != base) || (inputNr != ctxt->inputNr))
9595                     goto base_changed;
9596                 continue;
9597             }
9598
9599             /*
9600              * Add the pair to atts
9601              */
9602             if ((atts == NULL) || (nbatts + 5 > maxatts)) {
9603                 if (xmlCtxtGrowAttrs(ctxt, nbatts + 5) < 0) {
9604                     if (attvalue[len] == 0)
9605                         xmlFree(attvalue);
9606                     goto failed;
9607                 }
9608                 maxatts = ctxt->maxatts;
9609                 atts = ctxt->atts;
9610             }
9611             ctxt->attallocs[nratts++] = alloc;
9612             atts[nbatts++] = attname;
9613             atts[nbatts++] = aprefix;
9614             atts[nbatts++] = NULL; /* the URI will be fetched later */
9615             atts[nbatts++] = attvalue;
9616             attvalue += len;
9617             atts[nbatts++] = attvalue;
9618             /*
9619              * tag if some deallocation is needed
9620              */
9621             if (alloc != 0) attval = 1;
9622         } else {
9623             if ((attvalue != NULL) && (attvalue[len] == 0))
9624                 xmlFree(attvalue);
9625         }
9626
9627 failed:
9628
9629         GROW
9630         if (ctxt->instate == XML_PARSER_EOF)
9631             break;
9632         if ((ctxt->input->base != base) || (inputNr != ctxt->inputNr))
9633             goto base_changed;
9634         if ((RAW == '>') || (((RAW == '/') && (NXT(1) == '>'))))
9635             break;
9636         if (!IS_BLANK_CH(RAW)) {
9637             xmlFatalErrMsg(ctxt, XML_ERR_SPACE_REQUIRED,
9638                            "attributes construct error\n");
9639             break;
9640         }
9641         SKIP_BLANKS;
9642         if ((cons == ctxt->input->consumed) && (q == CUR_PTR) &&
9643             (attname == NULL) && (attvalue == NULL)) {
9644             xmlFatalErr(ctxt, XML_ERR_INTERNAL_ERROR,
9645                  "xmlParseStartTag: problem parsing attributes\n");
9646             break;
9647         }
9648         GROW;
9649         if ((ctxt->input->base != base) || (inputNr != ctxt->inputNr))
9650             goto base_changed;
9651     }
9652
9653     /*
9654      * The attributes defaulting
9655      */
9656     if (ctxt->attsDefault != NULL) {
9657         xmlDefAttrsPtr defaults;
9658
9659         defaults = xmlHashLookup2(ctxt->attsDefault, localname, prefix);
9660         if (defaults != NULL) {
9661             for (i = 0;i < defaults->nbAttrs;i++) {
9662                 attname = defaults->values[5 * i];
9663                 aprefix = defaults->values[5 * i + 1];
9664
9665                 /*
9666                  * special work for namespaces defaulted defs
9667                  */
9668                 if ((attname == ctxt->str_xmlns) && (aprefix == NULL)) {
9669                     /*
9670                      * check that it's not a defined namespace
9671                      */
9672                     for (j = 1;j <= nbNs;j++)
9673                         if (ctxt->nsTab[ctxt->nsNr - 2 * j] == NULL)
9674                             break;
9675                     if (j <= nbNs) continue;
9676
9677                     nsname = xmlGetNamespace(ctxt, NULL);
9678                     if (nsname != defaults->values[5 * i + 2]) {
9679                         if (nsPush(ctxt, NULL,
9680                                    defaults->values[5 * i + 2]) > 0)
9681                             nbNs++;
9682                     }
9683                 } else if (aprefix == ctxt->str_xmlns) {
9684                     /*
9685                      * check that it's not a defined namespace
9686                      */
9687                     for (j = 1;j <= nbNs;j++)
9688                         if (ctxt->nsTab[ctxt->nsNr - 2 * j] == attname)
9689                             break;
9690                     if (j <= nbNs) continue;
9691
9692                     nsname = xmlGetNamespace(ctxt, attname);
9693                     if (nsname != defaults->values[2]) {
9694                         if (nsPush(ctxt, attname,
9695                                    defaults->values[5 * i + 2]) > 0)
9696                             nbNs++;
9697                     }
9698                 } else {
9699                     /*
9700                      * check that it's not a defined attribute
9701                      */
9702                     for (j = 0;j < nbatts;j+=5) {
9703                         if ((attname == atts[j]) && (aprefix == atts[j+1]))
9704                             break;
9705                     }
9706                     if (j < nbatts) continue;
9707
9708                     if ((atts == NULL) || (nbatts + 5 > maxatts)) {
9709                         if (xmlCtxtGrowAttrs(ctxt, nbatts + 5) < 0) {
9710                             return(NULL);
9711                         }
9712                         maxatts = ctxt->maxatts;
9713                         atts = ctxt->atts;
9714                     }
9715                     atts[nbatts++] = attname;
9716                     atts[nbatts++] = aprefix;
9717                     if (aprefix == NULL)
9718                         atts[nbatts++] = NULL;
9719                     else
9720                         atts[nbatts++] = xmlGetNamespace(ctxt, aprefix);
9721                     atts[nbatts++] = defaults->values[5 * i + 2];
9722                     atts[nbatts++] = defaults->values[5 * i + 3];
9723                     if ((ctxt->standalone == 1) &&
9724                         (defaults->values[5 * i + 4] != NULL)) {
9725                         xmlValidityError(ctxt, XML_DTD_STANDALONE_DEFAULTED,
9726           "standalone: attribute %s on %s defaulted from external subset\n",
9727                                          attname, localname);
9728                     }
9729                     nbdef++;
9730                 }
9731             }
9732         }
9733     }
9734
9735     /*
9736      * The attributes checkings
9737      */
9738     for (i = 0; i < nbatts;i += 5) {
9739         /*
9740         * The default namespace does not apply to attribute names.
9741         */
9742         if (atts[i + 1] != NULL) {
9743             nsname = xmlGetNamespace(ctxt, atts[i + 1]);
9744             if (nsname == NULL) {
9745                 xmlNsErr(ctxt, XML_NS_ERR_UNDEFINED_NAMESPACE,
9746                     "Namespace prefix %s for %s on %s is not defined\n",
9747                     atts[i + 1], atts[i], localname);
9748             }
9749             atts[i + 2] = nsname;
9750         } else
9751             nsname = NULL;
9752         /*
9753          * [ WFC: Unique Att Spec ]
9754          * No attribute name may appear more than once in the same
9755          * start-tag or empty-element tag.
9756          * As extended by the Namespace in XML REC.
9757          */
9758         for (j = 0; j < i;j += 5) {
9759             if (atts[i] == atts[j]) {
9760                 if (atts[i+1] == atts[j+1]) {
9761                     xmlErrAttributeDup(ctxt, atts[i+1], atts[i]);
9762                     break;
9763                 }
9764                 if ((nsname != NULL) && (atts[j + 2] == nsname)) {
9765                     xmlNsErr(ctxt, XML_NS_ERR_ATTRIBUTE_REDEFINED,
9766                              "Namespaced Attribute %s in '%s' redefined\n",
9767                              atts[i], nsname, NULL);
9768                     break;
9769                 }
9770             }
9771         }
9772     }
9773
9774     nsname = xmlGetNamespace(ctxt, prefix);
9775     if ((prefix != NULL) && (nsname == NULL)) {
9776         xmlNsErr(ctxt, XML_NS_ERR_UNDEFINED_NAMESPACE,
9777                  "Namespace prefix %s on %s is not defined\n",
9778                  prefix, localname, NULL);
9779     }
9780     *pref = prefix;
9781     *URI = nsname;
9782
9783     /*
9784      * SAX: Start of Element !
9785      */
9786     if ((ctxt->sax != NULL) && (ctxt->sax->startElementNs != NULL) &&
9787         (!ctxt->disableSAX)) {
9788         if (nbNs > 0)
9789             ctxt->sax->startElementNs(ctxt->userData, localname, prefix,
9790                           nsname, nbNs, &ctxt->nsTab[ctxt->nsNr - 2 * nbNs],
9791                           nbatts / 5, nbdef, atts);
9792         else
9793             ctxt->sax->startElementNs(ctxt->userData, localname, prefix,
9794                           nsname, 0, NULL, nbatts / 5, nbdef, atts);
9795     }
9796
9797     /*
9798      * Free up attribute allocated strings if needed
9799      */
9800     if (attval != 0) {
9801         for (i = 3,j = 0; j < nratts;i += 5,j++)
9802             if ((ctxt->attallocs[j] != 0) && (atts[i] != NULL))
9803                 xmlFree((xmlChar *) atts[i]);
9804     }
9805
9806     return(localname);
9807
9808 base_changed:
9809     /*
9810      * the attribute strings are valid iif the base didn't changed
9811      */
9812     if (attval != 0) {
9813         for (i = 3,j = 0; j < nratts;i += 5,j++)
9814             if ((ctxt->attallocs[j] != 0) && (atts[i] != NULL))
9815                 xmlFree((xmlChar *) atts[i]);
9816     }
9817
9818     /*
9819      * We can't switch from one entity to another in the middle
9820      * of a start tag
9821      */
9822     if (inputNr != ctxt->inputNr) {
9823         xmlFatalErrMsg(ctxt, XML_ERR_ENTITY_BOUNDARY,
9824                     "Start tag doesn't start and stop in the same entity\n");
9825         return(NULL);
9826     }
9827
9828     ctxt->input->cur = ctxt->input->base + cur;
9829     ctxt->input->line = oldline;
9830     ctxt->input->col = oldcol;
9831     if (ctxt->wellFormed == 1) {
9832         goto reparse;
9833     }
9834     return(NULL);
9835 }
9836
9837 /**
9838  * xmlParseEndTag2:
9839  * @ctxt:  an XML parser context
9840  * @line:  line of the start tag
9841  * @nsNr:  number of namespaces on the start tag
9842  *
9843  * parse an end of tag
9844  *
9845  * [42] ETag ::= '</' Name S? '>'
9846  *
9847  * With namespace
9848  *
9849  * [NS 9] ETag ::= '</' QName S? '>'
9850  */
9851
9852 static void
9853 xmlParseEndTag2(xmlParserCtxtPtr ctxt, const xmlChar *prefix,
9854                 const xmlChar *URI, int line, int nsNr, int tlen) {
9855     const xmlChar *name;
9856     size_t curLength;
9857
9858     GROW;
9859     if ((RAW != '<') || (NXT(1) != '/')) {
9860         xmlFatalErr(ctxt, XML_ERR_LTSLASH_REQUIRED, NULL);
9861         return;
9862     }
9863     SKIP(2);
9864
9865     curLength = ctxt->input->end - ctxt->input->cur;
9866     if ((tlen > 0) && (curLength >= (size_t)tlen) &&
9867         (xmlStrncmp(ctxt->input->cur, ctxt->name, tlen) == 0)) {
9868         if ((curLength >= (size_t)(tlen + 1)) &&
9869             (ctxt->input->cur[tlen] == '>')) {
9870             ctxt->input->cur += tlen + 1;
9871             ctxt->input->col += tlen + 1;
9872             goto done;
9873         }
9874         ctxt->input->cur += tlen;
9875         ctxt->input->col += tlen;
9876         name = (xmlChar*)1;
9877     } else {
9878         if (prefix == NULL)
9879             name = xmlParseNameAndCompare(ctxt, ctxt->name);
9880         else
9881             name = xmlParseQNameAndCompare(ctxt, ctxt->name, prefix);
9882     }
9883
9884     /*
9885      * We should definitely be at the ending "S? '>'" part
9886      */
9887     GROW;
9888     if (ctxt->instate == XML_PARSER_EOF)
9889         return;
9890     SKIP_BLANKS;
9891     if ((!IS_BYTE_CHAR(RAW)) || (RAW != '>')) {
9892         xmlFatalErr(ctxt, XML_ERR_GT_REQUIRED, NULL);
9893     } else
9894         NEXT1;
9895
9896     /*
9897      * [ WFC: Element Type Match ]
9898      * The Name in an element's end-tag must match the element type in the
9899      * start-tag.
9900      *
9901      */
9902     if (name != (xmlChar*)1) {
9903         if (name == NULL) name = BAD_CAST "unparseable";
9904         if ((line == 0) && (ctxt->node != NULL))
9905             line = ctxt->node->line;
9906         xmlFatalErrMsgStrIntStr(ctxt, XML_ERR_TAG_NAME_MISMATCH,
9907                      "Opening and ending tag mismatch: %s line %d and %s\n",
9908                                 ctxt->name, line, name);
9909     }
9910
9911     /*
9912      * SAX: End of Tag
9913      */
9914 done:
9915     if ((ctxt->sax != NULL) && (ctxt->sax->endElementNs != NULL) &&
9916         (!ctxt->disableSAX))
9917         ctxt->sax->endElementNs(ctxt->userData, ctxt->name, prefix, URI);
9918
9919     spacePop(ctxt);
9920     if (nsNr != 0)
9921         nsPop(ctxt, nsNr);
9922     return;
9923 }
9924
9925 /**
9926  * xmlParseCDSect:
9927  * @ctxt:  an XML parser context
9928  *
9929  * Parse escaped pure raw content.
9930  *
9931  * [18] CDSect ::= CDStart CData CDEnd
9932  *
9933  * [19] CDStart ::= '<![CDATA['
9934  *
9935  * [20] Data ::= (Char* - (Char* ']]>' Char*))
9936  *
9937  * [21] CDEnd ::= ']]>'
9938  */
9939 void
9940 xmlParseCDSect(xmlParserCtxtPtr ctxt) {
9941     xmlChar *buf = NULL;
9942     int len = 0;
9943     int size = XML_PARSER_BUFFER_SIZE;
9944     int r, rl;
9945     int s, sl;
9946     int cur, l;
9947     int count = 0;
9948
9949     /* Check 2.6.0 was NXT(0) not RAW */
9950     if (CMP9(CUR_PTR, '<', '!', '[', 'C', 'D', 'A', 'T', 'A', '[')) {
9951         SKIP(9);
9952     } else
9953         return;
9954
9955     ctxt->instate = XML_PARSER_CDATA_SECTION;
9956     r = CUR_CHAR(rl);
9957     if (!IS_CHAR(r)) {
9958         xmlFatalErr(ctxt, XML_ERR_CDATA_NOT_FINISHED, NULL);
9959         ctxt->instate = XML_PARSER_CONTENT;
9960         return;
9961     }
9962     NEXTL(rl);
9963     s = CUR_CHAR(sl);
9964     if (!IS_CHAR(s)) {
9965         xmlFatalErr(ctxt, XML_ERR_CDATA_NOT_FINISHED, NULL);
9966         ctxt->instate = XML_PARSER_CONTENT;
9967         return;
9968     }
9969     NEXTL(sl);
9970     cur = CUR_CHAR(l);
9971     buf = (xmlChar *) xmlMallocAtomic(size * sizeof(xmlChar));
9972     if (buf == NULL) {
9973         xmlErrMemory(ctxt, NULL);
9974         return;
9975     }
9976     while (IS_CHAR(cur) &&
9977            ((r != ']') || (s != ']') || (cur != '>'))) {
9978         if (len + 5 >= size) {
9979             xmlChar *tmp;
9980
9981             if ((size > XML_MAX_TEXT_LENGTH) &&
9982                 ((ctxt->options & XML_PARSE_HUGE) == 0)) {
9983                 xmlFatalErrMsgStr(ctxt, XML_ERR_CDATA_NOT_FINISHED,
9984                              "CData section too big found", NULL);
9985                 xmlFree (buf);
9986                 return;
9987             }
9988             tmp = (xmlChar *) xmlRealloc(buf, size * 2 * sizeof(xmlChar));
9989             if (tmp == NULL) {
9990                 xmlFree(buf);
9991                 xmlErrMemory(ctxt, NULL);
9992                 return;
9993             }
9994             buf = tmp;
9995             size *= 2;
9996         }
9997         COPY_BUF(rl,buf,len,r);
9998         r = s;
9999         rl = sl;
10000         s = cur;
10001         sl = l;
10002         count++;
10003         if (count > 50) {
10004             GROW;
10005             if (ctxt->instate == XML_PARSER_EOF) {
10006                 xmlFree(buf);
10007                 return;
10008             }
10009             count = 0;
10010         }
10011         NEXTL(l);
10012         cur = CUR_CHAR(l);
10013     }
10014     buf[len] = 0;
10015     ctxt->instate = XML_PARSER_CONTENT;
10016     if (cur != '>') {
10017         xmlFatalErrMsgStr(ctxt, XML_ERR_CDATA_NOT_FINISHED,
10018                              "CData section not finished\n%.50s\n", buf);
10019         xmlFree(buf);
10020         return;
10021     }
10022     NEXTL(l);
10023
10024     /*
10025      * OK the buffer is to be consumed as cdata.
10026      */
10027     if ((ctxt->sax != NULL) && (!ctxt->disableSAX)) {
10028         if (ctxt->sax->cdataBlock != NULL)
10029             ctxt->sax->cdataBlock(ctxt->userData, buf, len);
10030         else if (ctxt->sax->characters != NULL)
10031             ctxt->sax->characters(ctxt->userData, buf, len);
10032     }
10033     xmlFree(buf);
10034 }
10035
10036 /**
10037  * xmlParseContent:
10038  * @ctxt:  an XML parser context
10039  *
10040  * Parse a content:
10041  *
10042  * [43] content ::= (element | CharData | Reference | CDSect | PI | Comment)*
10043  */
10044
10045 void
10046 xmlParseContent(xmlParserCtxtPtr ctxt) {
10047     GROW;
10048     while ((RAW != 0) &&
10049            ((RAW != '<') || (NXT(1) != '/')) &&
10050            (ctxt->instate != XML_PARSER_EOF)) {
10051         const xmlChar *test = CUR_PTR;
10052         unsigned int cons = ctxt->input->consumed;
10053         const xmlChar *cur = ctxt->input->cur;
10054
10055         /*
10056          * First case : a Processing Instruction.
10057          */
10058         if ((*cur == '<') && (cur[1] == '?')) {
10059             xmlParsePI(ctxt);
10060         }
10061
10062         /*
10063          * Second case : a CDSection
10064          */
10065         /* 2.6.0 test was *cur not RAW */
10066         else if (CMP9(CUR_PTR, '<', '!', '[', 'C', 'D', 'A', 'T', 'A', '[')) {
10067             xmlParseCDSect(ctxt);
10068         }
10069
10070         /*
10071          * Third case :  a comment
10072          */
10073         else if ((*cur == '<') && (NXT(1) == '!') &&
10074                  (NXT(2) == '-') && (NXT(3) == '-')) {
10075             xmlParseComment(ctxt);
10076             ctxt->instate = XML_PARSER_CONTENT;
10077         }
10078
10079         /*
10080          * Fourth case :  a sub-element.
10081          */
10082         else if (*cur == '<') {
10083             xmlParseElement(ctxt);
10084         }
10085
10086         /*
10087          * Fifth case : a reference. If if has not been resolved,
10088          *    parsing returns it's Name, create the node
10089          */
10090
10091         else if (*cur == '&') {
10092             xmlParseReference(ctxt);
10093         }
10094
10095         /*
10096          * Last case, text. Note that References are handled directly.
10097          */
10098         else {
10099             xmlParseCharData(ctxt, 0);
10100         }
10101
10102         GROW;
10103         /*
10104          * Pop-up of finished entities.
10105          */
10106         while ((RAW == 0) && (ctxt->inputNr > 1))
10107             xmlPopInput(ctxt);
10108         SHRINK;
10109
10110         if ((cons == ctxt->input->consumed) && (test == CUR_PTR)) {
10111             xmlFatalErr(ctxt, XML_ERR_INTERNAL_ERROR,
10112                         "detected an error in element content\n");
10113             xmlHaltParser(ctxt);
10114             break;
10115         }
10116     }
10117 }
10118
10119 /**
10120  * xmlParseElement:
10121  * @ctxt:  an XML parser context
10122  *
10123  * parse an XML element, this is highly recursive
10124  *
10125  * [39] element ::= EmptyElemTag | STag content ETag
10126  *
10127  * [ WFC: Element Type Match ]
10128  * The Name in an element's end-tag must match the element type in the
10129  * start-tag.
10130  *
10131  */
10132
10133 void
10134 xmlParseElement(xmlParserCtxtPtr ctxt) {
10135     const xmlChar *name;
10136     const xmlChar *prefix = NULL;
10137     const xmlChar *URI = NULL;
10138     xmlParserNodeInfo node_info;
10139     int line, tlen = 0;
10140     xmlNodePtr ret;
10141     int nsNr = ctxt->nsNr;
10142
10143     if (((unsigned int) ctxt->nameNr > xmlParserMaxDepth) &&
10144         ((ctxt->options & XML_PARSE_HUGE) == 0)) {
10145         xmlFatalErrMsgInt(ctxt, XML_ERR_INTERNAL_ERROR,
10146                  "Excessive depth in document: %d use XML_PARSE_HUGE option\n",
10147                           xmlParserMaxDepth);
10148         xmlHaltParser(ctxt);
10149         return;
10150     }
10151
10152     /* Capture start position */
10153     if (ctxt->record_info) {
10154         node_info.begin_pos = ctxt->input->consumed +
10155                           (CUR_PTR - ctxt->input->base);
10156         node_info.begin_line = ctxt->input->line;
10157     }
10158
10159     if (ctxt->spaceNr == 0)
10160         spacePush(ctxt, -1);
10161     else if (*ctxt->space == -2)
10162         spacePush(ctxt, -1);
10163     else
10164         spacePush(ctxt, *ctxt->space);
10165
10166     line = ctxt->input->line;
10167 #ifdef LIBXML_SAX1_ENABLED
10168     if (ctxt->sax2)
10169 #endif /* LIBXML_SAX1_ENABLED */
10170         name = xmlParseStartTag2(ctxt, &prefix, &URI, &tlen);
10171 #ifdef LIBXML_SAX1_ENABLED
10172     else
10173         name = xmlParseStartTag(ctxt);
10174 #endif /* LIBXML_SAX1_ENABLED */
10175     if (ctxt->instate == XML_PARSER_EOF)
10176         return;
10177     if (name == NULL) {
10178         spacePop(ctxt);
10179         return;
10180     }
10181     namePush(ctxt, name);
10182     ret = ctxt->node;
10183
10184 #ifdef LIBXML_VALID_ENABLED
10185     /*
10186      * [ VC: Root Element Type ]
10187      * The Name in the document type declaration must match the element
10188      * type of the root element.
10189      */
10190     if (ctxt->validate && ctxt->wellFormed && ctxt->myDoc &&
10191         ctxt->node && (ctxt->node == ctxt->myDoc->children))
10192         ctxt->valid &= xmlValidateRoot(&ctxt->vctxt, ctxt->myDoc);
10193 #endif /* LIBXML_VALID_ENABLED */
10194
10195     /*
10196      * Check for an Empty Element.
10197      */
10198     if ((RAW == '/') && (NXT(1) == '>')) {
10199         SKIP(2);
10200         if (ctxt->sax2) {
10201             if ((ctxt->sax != NULL) && (ctxt->sax->endElementNs != NULL) &&
10202                 (!ctxt->disableSAX))
10203                 ctxt->sax->endElementNs(ctxt->userData, name, prefix, URI);
10204 #ifdef LIBXML_SAX1_ENABLED
10205         } else {
10206             if ((ctxt->sax != NULL) && (ctxt->sax->endElement != NULL) &&
10207                 (!ctxt->disableSAX))
10208                 ctxt->sax->endElement(ctxt->userData, name);
10209 #endif /* LIBXML_SAX1_ENABLED */
10210         }
10211         namePop(ctxt);
10212         spacePop(ctxt);
10213         if (nsNr != ctxt->nsNr)
10214             nsPop(ctxt, ctxt->nsNr - nsNr);
10215         if ( ret != NULL && ctxt->record_info ) {
10216            node_info.end_pos = ctxt->input->consumed +
10217                               (CUR_PTR - ctxt->input->base);
10218            node_info.end_line = ctxt->input->line;
10219            node_info.node = ret;
10220            xmlParserAddNodeInfo(ctxt, &node_info);
10221         }
10222         return;
10223     }
10224     if (RAW == '>') {
10225         NEXT1;
10226     } else {
10227         xmlFatalErrMsgStrIntStr(ctxt, XML_ERR_GT_REQUIRED,
10228                      "Couldn't find end of Start Tag %s line %d\n",
10229                                 name, line, NULL);
10230
10231         /*
10232          * end of parsing of this node.
10233          */
10234         nodePop(ctxt);
10235         namePop(ctxt);
10236         spacePop(ctxt);
10237         if (nsNr != ctxt->nsNr)
10238             nsPop(ctxt, ctxt->nsNr - nsNr);
10239
10240         /*
10241          * Capture end position and add node
10242          */
10243         if ( ret != NULL && ctxt->record_info ) {
10244            node_info.end_pos = ctxt->input->consumed +
10245                               (CUR_PTR - ctxt->input->base);
10246            node_info.end_line = ctxt->input->line;
10247            node_info.node = ret;
10248            xmlParserAddNodeInfo(ctxt, &node_info);
10249         }
10250         return;
10251     }
10252
10253     /*
10254      * Parse the content of the element:
10255      */
10256     xmlParseContent(ctxt);
10257     if (ctxt->instate == XML_PARSER_EOF)
10258         return;
10259     if (!IS_BYTE_CHAR(RAW)) {
10260         xmlFatalErrMsgStrIntStr(ctxt, XML_ERR_TAG_NOT_FINISHED,
10261          "Premature end of data in tag %s line %d\n",
10262                                 name, line, NULL);
10263
10264         /*
10265          * end of parsing of this node.
10266          */
10267         nodePop(ctxt);
10268         namePop(ctxt);
10269         spacePop(ctxt);
10270         if (nsNr != ctxt->nsNr)
10271             nsPop(ctxt, ctxt->nsNr - nsNr);
10272         return;
10273     }
10274
10275     /*
10276      * parse the end of tag: '</' should be here.
10277      */
10278     if (ctxt->sax2) {
10279         xmlParseEndTag2(ctxt, prefix, URI, line, ctxt->nsNr - nsNr, tlen);
10280         namePop(ctxt);
10281     }
10282 #ifdef LIBXML_SAX1_ENABLED
10283       else
10284         xmlParseEndTag1(ctxt, line);
10285 #endif /* LIBXML_SAX1_ENABLED */
10286
10287     /*
10288      * Capture end position and add node
10289      */
10290     if ( ret != NULL && ctxt->record_info ) {
10291        node_info.end_pos = ctxt->input->consumed +
10292                           (CUR_PTR - ctxt->input->base);
10293        node_info.end_line = ctxt->input->line;
10294        node_info.node = ret;
10295        xmlParserAddNodeInfo(ctxt, &node_info);
10296     }
10297 }
10298
10299 /**
10300  * xmlParseVersionNum:
10301  * @ctxt:  an XML parser context
10302  *
10303  * parse the XML version value.
10304  *
10305  * [26] VersionNum ::= '1.' [0-9]+
10306  *
10307  * In practice allow [0-9].[0-9]+ at that level
10308  *
10309  * Returns the string giving the XML version number, or NULL
10310  */
10311 xmlChar *
10312 xmlParseVersionNum(xmlParserCtxtPtr ctxt) {
10313     xmlChar *buf = NULL;
10314     int len = 0;
10315     int size = 10;
10316     xmlChar cur;
10317
10318     buf = (xmlChar *) xmlMallocAtomic(size * sizeof(xmlChar));
10319     if (buf == NULL) {
10320         xmlErrMemory(ctxt, NULL);
10321         return(NULL);
10322     }
10323     cur = CUR;
10324     if (!((cur >= '0') && (cur <= '9'))) {
10325         xmlFree(buf);
10326         return(NULL);
10327     }
10328     buf[len++] = cur;
10329     NEXT;
10330     cur=CUR;
10331     if (cur != '.') {
10332         xmlFree(buf);
10333         return(NULL);
10334     }
10335     buf[len++] = cur;
10336     NEXT;
10337     cur=CUR;
10338     while ((cur >= '0') && (cur <= '9')) {
10339         if (len + 1 >= size) {
10340             xmlChar *tmp;
10341
10342             size *= 2;
10343             tmp = (xmlChar *) xmlRealloc(buf, size * sizeof(xmlChar));
10344             if (tmp == NULL) {
10345                 xmlFree(buf);
10346                 xmlErrMemory(ctxt, NULL);
10347                 return(NULL);
10348             }
10349             buf = tmp;
10350         }
10351         buf[len++] = cur;
10352         NEXT;
10353         cur=CUR;
10354     }
10355     buf[len] = 0;
10356     return(buf);
10357 }
10358
10359 /**
10360  * xmlParseVersionInfo:
10361  * @ctxt:  an XML parser context
10362  *
10363  * parse the XML version.
10364  *
10365  * [24] VersionInfo ::= S 'version' Eq (' VersionNum ' | " VersionNum ")
10366  *
10367  * [25] Eq ::= S? '=' S?
10368  *
10369  * Returns the version string, e.g. "1.0"
10370  */
10371
10372 xmlChar *
10373 xmlParseVersionInfo(xmlParserCtxtPtr ctxt) {
10374     xmlChar *version = NULL;
10375
10376     if (CMP7(CUR_PTR, 'v', 'e', 'r', 's', 'i', 'o', 'n')) {
10377         SKIP(7);
10378         SKIP_BLANKS;
10379         if (RAW != '=') {
10380             xmlFatalErr(ctxt, XML_ERR_EQUAL_REQUIRED, NULL);
10381             return(NULL);
10382         }
10383         NEXT;
10384         SKIP_BLANKS;
10385         if (RAW == '"') {
10386             NEXT;
10387             version = xmlParseVersionNum(ctxt);
10388             if (RAW != '"') {
10389                 xmlFatalErr(ctxt, XML_ERR_STRING_NOT_CLOSED, NULL);
10390             } else
10391                 NEXT;
10392         } else if (RAW == '\''){
10393             NEXT;
10394             version = xmlParseVersionNum(ctxt);
10395             if (RAW != '\'') {
10396                 xmlFatalErr(ctxt, XML_ERR_STRING_NOT_CLOSED, NULL);
10397             } else
10398                 NEXT;
10399         } else {
10400             xmlFatalErr(ctxt, XML_ERR_STRING_NOT_STARTED, NULL);
10401         }
10402     }
10403     return(version);
10404 }
10405
10406 /**
10407  * xmlParseEncName:
10408  * @ctxt:  an XML parser context
10409  *
10410  * parse the XML encoding name
10411  *
10412  * [81] EncName ::= [A-Za-z] ([A-Za-z0-9._] | '-')*
10413  *
10414  * Returns the encoding name value or NULL
10415  */
10416 xmlChar *
10417 xmlParseEncName(xmlParserCtxtPtr ctxt) {
10418     xmlChar *buf = NULL;
10419     int len = 0;
10420     int size = 10;
10421     xmlChar cur;
10422
10423     cur = CUR;
10424     if (((cur >= 'a') && (cur <= 'z')) ||
10425         ((cur >= 'A') && (cur <= 'Z'))) {
10426         buf = (xmlChar *) xmlMallocAtomic(size * sizeof(xmlChar));
10427         if (buf == NULL) {
10428             xmlErrMemory(ctxt, NULL);
10429             return(NULL);
10430         }
10431
10432         buf[len++] = cur;
10433         NEXT;
10434         cur = CUR;
10435         while (((cur >= 'a') && (cur <= 'z')) ||
10436                ((cur >= 'A') && (cur <= 'Z')) ||
10437                ((cur >= '0') && (cur <= '9')) ||
10438                (cur == '.') || (cur == '_') ||
10439                (cur == '-')) {
10440             if (len + 1 >= size) {
10441                 xmlChar *tmp;
10442
10443                 size *= 2;
10444                 tmp = (xmlChar *) xmlRealloc(buf, size * sizeof(xmlChar));
10445                 if (tmp == NULL) {
10446                     xmlErrMemory(ctxt, NULL);
10447                     xmlFree(buf);
10448                     return(NULL);
10449                 }
10450                 buf = tmp;
10451             }
10452             buf[len++] = cur;
10453             NEXT;
10454             cur = CUR;
10455             if (cur == 0) {
10456                 SHRINK;
10457                 GROW;
10458                 cur = CUR;
10459             }
10460         }
10461         buf[len] = 0;
10462     } else {
10463         xmlFatalErr(ctxt, XML_ERR_ENCODING_NAME, NULL);
10464     }
10465     return(buf);
10466 }
10467
10468 /**
10469  * xmlParseEncodingDecl:
10470  * @ctxt:  an XML parser context
10471  *
10472  * parse the XML encoding declaration
10473  *
10474  * [80] EncodingDecl ::= S 'encoding' Eq ('"' EncName '"' |  "'" EncName "'")
10475  *
10476  * this setups the conversion filters.
10477  *
10478  * Returns the encoding value or NULL
10479  */
10480
10481 const xmlChar *
10482 xmlParseEncodingDecl(xmlParserCtxtPtr ctxt) {
10483     xmlChar *encoding = NULL;
10484
10485     SKIP_BLANKS;
10486     if (CMP8(CUR_PTR, 'e', 'n', 'c', 'o', 'd', 'i', 'n', 'g')) {
10487         SKIP(8);
10488         SKIP_BLANKS;
10489         if (RAW != '=') {
10490             xmlFatalErr(ctxt, XML_ERR_EQUAL_REQUIRED, NULL);
10491             return(NULL);
10492         }
10493         NEXT;
10494         SKIP_BLANKS;
10495         if (RAW == '"') {
10496             NEXT;
10497             encoding = xmlParseEncName(ctxt);
10498             if (RAW != '"') {
10499                 xmlFatalErr(ctxt, XML_ERR_STRING_NOT_CLOSED, NULL);
10500                 xmlFree((xmlChar *) encoding);
10501                 return(NULL);
10502             } else
10503                 NEXT;
10504         } else if (RAW == '\''){
10505             NEXT;
10506             encoding = xmlParseEncName(ctxt);
10507             if (RAW != '\'') {
10508                 xmlFatalErr(ctxt, XML_ERR_STRING_NOT_CLOSED, NULL);
10509                 xmlFree((xmlChar *) encoding);
10510                 return(NULL);
10511             } else
10512                 NEXT;
10513         } else {
10514             xmlFatalErr(ctxt, XML_ERR_STRING_NOT_STARTED, NULL);
10515         }
10516
10517         /*
10518          * Non standard parsing, allowing the user to ignore encoding
10519          */
10520         if (ctxt->options & XML_PARSE_IGNORE_ENC) {
10521             xmlFree((xmlChar *) encoding);
10522             return(NULL);
10523         }
10524
10525         /*
10526          * UTF-16 encoding stwich has already taken place at this stage,
10527          * more over the little-endian/big-endian selection is already done
10528          */
10529         if ((encoding != NULL) &&
10530             ((!xmlStrcasecmp(encoding, BAD_CAST "UTF-16")) ||
10531              (!xmlStrcasecmp(encoding, BAD_CAST "UTF16")))) {
10532             /*
10533              * If no encoding was passed to the parser, that we are
10534              * using UTF-16 and no decoder is present i.e. the
10535              * document is apparently UTF-8 compatible, then raise an
10536              * encoding mismatch fatal error
10537              */
10538             if ((ctxt->encoding == NULL) &&
10539                 (ctxt->input->buf != NULL) &&
10540                 (ctxt->input->buf->encoder == NULL)) {
10541                 xmlFatalErrMsg(ctxt, XML_ERR_INVALID_ENCODING,
10542                   "Document labelled UTF-16 but has UTF-8 content\n");
10543             }
10544             if (ctxt->encoding != NULL)
10545                 xmlFree((xmlChar *) ctxt->encoding);
10546             ctxt->encoding = encoding;
10547         }
10548         /*
10549          * UTF-8 encoding is handled natively
10550          */
10551         else if ((encoding != NULL) &&
10552             ((!xmlStrcasecmp(encoding, BAD_CAST "UTF-8")) ||
10553              (!xmlStrcasecmp(encoding, BAD_CAST "UTF8")))) {
10554             if (ctxt->encoding != NULL)
10555                 xmlFree((xmlChar *) ctxt->encoding);
10556             ctxt->encoding = encoding;
10557         }
10558         else if (encoding != NULL) {
10559             xmlCharEncodingHandlerPtr handler;
10560
10561             if (ctxt->input->encoding != NULL)
10562                 xmlFree((xmlChar *) ctxt->input->encoding);
10563             ctxt->input->encoding = encoding;
10564
10565             handler = xmlFindCharEncodingHandler((const char *) encoding);
10566             if (handler != NULL) {
10567                 if (xmlSwitchToEncoding(ctxt, handler) < 0) {
10568                     /* failed to convert */
10569                     ctxt->errNo = XML_ERR_UNSUPPORTED_ENCODING;
10570                     return(NULL);
10571                 }
10572             } else {
10573                 xmlFatalErrMsgStr(ctxt, XML_ERR_UNSUPPORTED_ENCODING,
10574                         "Unsupported encoding %s\n", encoding);
10575                 return(NULL);
10576             }
10577         }
10578     }
10579     return(encoding);
10580 }
10581
10582 /**
10583  * xmlParseSDDecl:
10584  * @ctxt:  an XML parser context
10585  *
10586  * parse the XML standalone declaration
10587  *
10588  * [32] SDDecl ::= S 'standalone' Eq
10589  *                 (("'" ('yes' | 'no') "'") | ('"' ('yes' | 'no')'"'))
10590  *
10591  * [ VC: Standalone Document Declaration ]
10592  * TODO The standalone document declaration must have the value "no"
10593  * if any external markup declarations contain declarations of:
10594  *  - attributes with default values, if elements to which these
10595  *    attributes apply appear in the document without specifications
10596  *    of values for these attributes, or
10597  *  - entities (other than amp, lt, gt, apos, quot), if references
10598  *    to those entities appear in the document, or
10599  *  - attributes with values subject to normalization, where the
10600  *    attribute appears in the document with a value which will change
10601  *    as a result of normalization, or
10602  *  - element types with element content, if white space occurs directly
10603  *    within any instance of those types.
10604  *
10605  * Returns:
10606  *   1 if standalone="yes"
10607  *   0 if standalone="no"
10608  *  -2 if standalone attribute is missing or invalid
10609  *        (A standalone value of -2 means that the XML declaration was found,
10610  *         but no value was specified for the standalone attribute).
10611  */
10612
10613 int
10614 xmlParseSDDecl(xmlParserCtxtPtr ctxt) {
10615     int standalone = -2;
10616
10617     SKIP_BLANKS;
10618     if (CMP10(CUR_PTR, 's', 't', 'a', 'n', 'd', 'a', 'l', 'o', 'n', 'e')) {
10619         SKIP(10);
10620         SKIP_BLANKS;
10621         if (RAW != '=') {
10622             xmlFatalErr(ctxt, XML_ERR_EQUAL_REQUIRED, NULL);
10623             return(standalone);
10624         }
10625         NEXT;
10626         SKIP_BLANKS;
10627         if (RAW == '\''){
10628             NEXT;
10629             if ((RAW == 'n') && (NXT(1) == 'o')) {
10630                 standalone = 0;
10631                 SKIP(2);
10632             } else if ((RAW == 'y') && (NXT(1) == 'e') &&
10633                        (NXT(2) == 's')) {
10634                 standalone = 1;
10635                 SKIP(3);
10636             } else {
10637                 xmlFatalErr(ctxt, XML_ERR_STANDALONE_VALUE, NULL);
10638             }
10639             if (RAW != '\'') {
10640                 xmlFatalErr(ctxt, XML_ERR_STRING_NOT_CLOSED, NULL);
10641             } else
10642                 NEXT;
10643         } else if (RAW == '"'){
10644             NEXT;
10645             if ((RAW == 'n') && (NXT(1) == 'o')) {
10646                 standalone = 0;
10647                 SKIP(2);
10648             } else if ((RAW == 'y') && (NXT(1) == 'e') &&
10649                        (NXT(2) == 's')) {
10650                 standalone = 1;
10651                 SKIP(3);
10652             } else {
10653                 xmlFatalErr(ctxt, XML_ERR_STANDALONE_VALUE, NULL);
10654             }
10655             if (RAW != '"') {
10656                 xmlFatalErr(ctxt, XML_ERR_STRING_NOT_CLOSED, NULL);
10657             } else
10658                 NEXT;
10659         } else {
10660             xmlFatalErr(ctxt, XML_ERR_STRING_NOT_STARTED, NULL);
10661         }
10662     }
10663     return(standalone);
10664 }
10665
10666 /**
10667  * xmlParseXMLDecl:
10668  * @ctxt:  an XML parser context
10669  *
10670  * parse an XML declaration header
10671  *
10672  * [23] XMLDecl ::= '<?xml' VersionInfo EncodingDecl? SDDecl? S? '?>'
10673  */
10674
10675 void
10676 xmlParseXMLDecl(xmlParserCtxtPtr ctxt) {
10677     xmlChar *version;
10678
10679     /*
10680      * This value for standalone indicates that the document has an
10681      * XML declaration but it does not have a standalone attribute.
10682      * It will be overwritten later if a standalone attribute is found.
10683      */
10684     ctxt->input->standalone = -2;
10685
10686     /*
10687      * We know that '<?xml' is here.
10688      */
10689     SKIP(5);
10690
10691     if (!IS_BLANK_CH(RAW)) {
10692         xmlFatalErrMsg(ctxt, XML_ERR_SPACE_REQUIRED,
10693                        "Blank needed after '<?xml'\n");
10694     }
10695     SKIP_BLANKS;
10696
10697     /*
10698      * We must have the VersionInfo here.
10699      */
10700     version = xmlParseVersionInfo(ctxt);
10701     if (version == NULL) {
10702         xmlFatalErr(ctxt, XML_ERR_VERSION_MISSING, NULL);
10703     } else {
10704         if (!xmlStrEqual(version, (const xmlChar *) XML_DEFAULT_VERSION)) {
10705             /*
10706              * Changed here for XML-1.0 5th edition
10707              */
10708             if (ctxt->options & XML_PARSE_OLD10) {
10709                 xmlFatalErrMsgStr(ctxt, XML_ERR_UNKNOWN_VERSION,
10710                                   "Unsupported version '%s'\n",
10711                                   version);
10712             } else {
10713                 if ((version[0] == '1') && ((version[1] == '.'))) {
10714                     xmlWarningMsg(ctxt, XML_WAR_UNKNOWN_VERSION,
10715                                   "Unsupported version '%s'\n",
10716                                   version, NULL);
10717                 } else {
10718                     xmlFatalErrMsgStr(ctxt, XML_ERR_UNKNOWN_VERSION,
10719                                       "Unsupported version '%s'\n",
10720                                       version);
10721                 }
10722             }
10723         }
10724         if (ctxt->version != NULL)
10725             xmlFree((void *) ctxt->version);
10726         ctxt->version = version;
10727     }
10728
10729     /*
10730      * We may have the encoding declaration
10731      */
10732     if (!IS_BLANK_CH(RAW)) {
10733         if ((RAW == '?') && (NXT(1) == '>')) {
10734             SKIP(2);
10735             return;
10736         }
10737         xmlFatalErrMsg(ctxt, XML_ERR_SPACE_REQUIRED, "Blank needed here\n");
10738     }
10739     xmlParseEncodingDecl(ctxt);
10740     if ((ctxt->errNo == XML_ERR_UNSUPPORTED_ENCODING) ||
10741          (ctxt->instate == XML_PARSER_EOF)) {
10742         /*
10743          * The XML REC instructs us to stop parsing right here
10744          */
10745         return;
10746     }
10747
10748     /*
10749      * We may have the standalone status.
10750      */
10751     if ((ctxt->input->encoding != NULL) && (!IS_BLANK_CH(RAW))) {
10752         if ((RAW == '?') && (NXT(1) == '>')) {
10753             SKIP(2);
10754             return;
10755         }
10756         xmlFatalErrMsg(ctxt, XML_ERR_SPACE_REQUIRED, "Blank needed here\n");
10757     }
10758
10759     /*
10760      * We can grow the input buffer freely at that point
10761      */
10762     GROW;
10763
10764     SKIP_BLANKS;
10765     ctxt->input->standalone = xmlParseSDDecl(ctxt);
10766
10767     SKIP_BLANKS;
10768     if ((RAW == '?') && (NXT(1) == '>')) {
10769         SKIP(2);
10770     } else if (RAW == '>') {
10771         /* Deprecated old WD ... */
10772         xmlFatalErr(ctxt, XML_ERR_XMLDECL_NOT_FINISHED, NULL);
10773         NEXT;
10774     } else {
10775         xmlFatalErr(ctxt, XML_ERR_XMLDECL_NOT_FINISHED, NULL);
10776         MOVETO_ENDTAG(CUR_PTR);
10777         NEXT;
10778     }
10779 }
10780
10781 /**
10782  * xmlParseMisc:
10783  * @ctxt:  an XML parser context
10784  *
10785  * parse an XML Misc* optional field.
10786  *
10787  * [27] Misc ::= Comment | PI |  S
10788  */
10789
10790 void
10791 xmlParseMisc(xmlParserCtxtPtr ctxt) {
10792     while ((ctxt->instate != XML_PARSER_EOF) &&
10793            (((RAW == '<') && (NXT(1) == '?')) ||
10794             (CMP4(CUR_PTR, '<', '!', '-', '-')) ||
10795             IS_BLANK_CH(CUR))) {
10796         if ((RAW == '<') && (NXT(1) == '?')) {
10797             xmlParsePI(ctxt);
10798         } else if (IS_BLANK_CH(CUR)) {
10799             NEXT;
10800         } else
10801             xmlParseComment(ctxt);
10802     }
10803 }
10804
10805 /**
10806  * xmlParseDocument:
10807  * @ctxt:  an XML parser context
10808  *
10809  * parse an XML document (and build a tree if using the standard SAX
10810  * interface).
10811  *
10812  * [1] document ::= prolog element Misc*
10813  *
10814  * [22] prolog ::= XMLDecl? Misc* (doctypedecl Misc*)?
10815  *
10816  * Returns 0, -1 in case of error. the parser context is augmented
10817  *                as a result of the parsing.
10818  */
10819
10820 int
10821 xmlParseDocument(xmlParserCtxtPtr ctxt) {
10822     xmlChar start[4];
10823     xmlCharEncoding enc;
10824
10825     xmlInitParser();
10826
10827     if ((ctxt == NULL) || (ctxt->input == NULL))
10828         return(-1);
10829
10830     GROW;
10831
10832     /*
10833      * SAX: detecting the level.
10834      */
10835     xmlDetectSAX2(ctxt);
10836
10837     /*
10838      * SAX: beginning of the document processing.
10839      */
10840     if ((ctxt->sax) && (ctxt->sax->setDocumentLocator))
10841         ctxt->sax->setDocumentLocator(ctxt->userData, &xmlDefaultSAXLocator);
10842     if (ctxt->instate == XML_PARSER_EOF)
10843         return(-1);
10844
10845     if ((ctxt->encoding == NULL) &&
10846         ((ctxt->input->end - ctxt->input->cur) >= 4)) {
10847         /*
10848          * Get the 4 first bytes and decode the charset
10849          * if enc != XML_CHAR_ENCODING_NONE
10850          * plug some encoding conversion routines.
10851          */
10852         start[0] = RAW;
10853         start[1] = NXT(1);
10854         start[2] = NXT(2);
10855         start[3] = NXT(3);
10856         enc = xmlDetectCharEncoding(&start[0], 4);
10857         if (enc != XML_CHAR_ENCODING_NONE) {
10858             xmlSwitchEncoding(ctxt, enc);
10859         }
10860     }
10861
10862
10863     if (CUR == 0) {
10864         xmlFatalErr(ctxt, XML_ERR_DOCUMENT_EMPTY, NULL);
10865         return(-1);
10866     }
10867
10868     /*
10869      * Check for the XMLDecl in the Prolog.
10870      * do not GROW here to avoid the detected encoder to decode more
10871      * than just the first line, unless the amount of data is really
10872      * too small to hold "<?xml version="1.0" encoding="foo"
10873      */
10874     if ((ctxt->input->end - ctxt->input->cur) < 35) {
10875        GROW;
10876     }
10877     if ((CMP5(CUR_PTR, '<', '?', 'x', 'm', 'l')) && (IS_BLANK_CH(NXT(5)))) {
10878
10879         /*
10880          * Note that we will switch encoding on the fly.
10881          */
10882         xmlParseXMLDecl(ctxt);
10883         if ((ctxt->errNo == XML_ERR_UNSUPPORTED_ENCODING) ||
10884             (ctxt->instate == XML_PARSER_EOF)) {
10885             /*
10886              * The XML REC instructs us to stop parsing right here
10887              */
10888             return(-1);
10889         }
10890         ctxt->standalone = ctxt->input->standalone;
10891         SKIP_BLANKS;
10892     } else {
10893         ctxt->version = xmlCharStrdup(XML_DEFAULT_VERSION);
10894     }
10895     if ((ctxt->sax) && (ctxt->sax->startDocument) && (!ctxt->disableSAX))
10896         ctxt->sax->startDocument(ctxt->userData);
10897     if (ctxt->instate == XML_PARSER_EOF)
10898         return(-1);
10899     if ((ctxt->myDoc != NULL) && (ctxt->input != NULL) &&
10900         (ctxt->input->buf != NULL) && (ctxt->input->buf->compressed >= 0)) {
10901         ctxt->myDoc->compression = ctxt->input->buf->compressed;
10902     }
10903
10904     /*
10905      * The Misc part of the Prolog
10906      */
10907     GROW;
10908     xmlParseMisc(ctxt);
10909
10910     /*
10911      * Then possibly doc type declaration(s) and more Misc
10912      * (doctypedecl Misc*)?
10913      */
10914     GROW;
10915     if (CMP9(CUR_PTR, '<', '!', 'D', 'O', 'C', 'T', 'Y', 'P', 'E')) {
10916
10917         ctxt->inSubset = 1;
10918         xmlParseDocTypeDecl(ctxt);
10919         if (RAW == '[') {
10920             ctxt->instate = XML_PARSER_DTD;
10921             xmlParseInternalSubset(ctxt);
10922             if (ctxt->instate == XML_PARSER_EOF)
10923                 return(-1);
10924         }
10925
10926         /*
10927          * Create and update the external subset.
10928          */
10929         ctxt->inSubset = 2;
10930         if ((ctxt->sax != NULL) && (ctxt->sax->externalSubset != NULL) &&
10931             (!ctxt->disableSAX))
10932             ctxt->sax->externalSubset(ctxt->userData, ctxt->intSubName,
10933                                       ctxt->extSubSystem, ctxt->extSubURI);
10934         if (ctxt->instate == XML_PARSER_EOF)
10935             return(-1);
10936         ctxt->inSubset = 0;
10937
10938         xmlCleanSpecialAttr(ctxt);
10939
10940         ctxt->instate = XML_PARSER_PROLOG;
10941         xmlParseMisc(ctxt);
10942     }
10943
10944     /*
10945      * Time to start parsing the tree itself
10946      */
10947     GROW;
10948     if (RAW != '<') {
10949         xmlFatalErrMsg(ctxt, XML_ERR_DOCUMENT_EMPTY,
10950                        "Start tag expected, '<' not found\n");
10951     } else {
10952         ctxt->instate = XML_PARSER_CONTENT;
10953         xmlParseElement(ctxt);
10954         ctxt->instate = XML_PARSER_EPILOG;
10955
10956
10957         /*
10958          * The Misc part at the end
10959          */
10960         xmlParseMisc(ctxt);
10961
10962         if (RAW != 0) {
10963             xmlFatalErr(ctxt, XML_ERR_DOCUMENT_END, NULL);
10964         }
10965         ctxt->instate = XML_PARSER_EOF;
10966     }
10967
10968     /*
10969      * SAX: end of the document processing.
10970      */
10971     if ((ctxt->sax) && (ctxt->sax->endDocument != NULL))
10972         ctxt->sax->endDocument(ctxt->userData);
10973
10974     /*
10975      * Remove locally kept entity definitions if the tree was not built
10976      */
10977     if ((ctxt->myDoc != NULL) &&
10978         (xmlStrEqual(ctxt->myDoc->version, SAX_COMPAT_MODE))) {
10979         xmlFreeDoc(ctxt->myDoc);
10980         ctxt->myDoc = NULL;
10981     }
10982
10983     if ((ctxt->wellFormed) && (ctxt->myDoc != NULL)) {
10984         ctxt->myDoc->properties |= XML_DOC_WELLFORMED;
10985         if (ctxt->valid)
10986             ctxt->myDoc->properties |= XML_DOC_DTDVALID;
10987         if (ctxt->nsWellFormed)
10988             ctxt->myDoc->properties |= XML_DOC_NSVALID;
10989         if (ctxt->options & XML_PARSE_OLD10)
10990             ctxt->myDoc->properties |= XML_DOC_OLD10;
10991     }
10992     if (! ctxt->wellFormed) {
10993         ctxt->valid = 0;
10994         return(-1);
10995     }
10996     return(0);
10997 }
10998
10999 /**
11000  * xmlParseExtParsedEnt:
11001  * @ctxt:  an XML parser context
11002  *
11003  * parse a general parsed entity
11004  * An external general parsed entity is well-formed if it matches the
11005  * production labeled extParsedEnt.
11006  *
11007  * [78] extParsedEnt ::= TextDecl? content
11008  *
11009  * Returns 0, -1 in case of error. the parser context is augmented
11010  *                as a result of the parsing.
11011  */
11012
11013 int
11014 xmlParseExtParsedEnt(xmlParserCtxtPtr ctxt) {
11015     xmlChar start[4];
11016     xmlCharEncoding enc;
11017
11018     if ((ctxt == NULL) || (ctxt->input == NULL))
11019         return(-1);
11020
11021     xmlDefaultSAXHandlerInit();
11022
11023     xmlDetectSAX2(ctxt);
11024
11025     GROW;
11026
11027     /*
11028      * SAX: beginning of the document processing.
11029      */
11030     if ((ctxt->sax) && (ctxt->sax->setDocumentLocator))
11031         ctxt->sax->setDocumentLocator(ctxt->userData, &xmlDefaultSAXLocator);
11032
11033     /*
11034      * Get the 4 first bytes and decode the charset
11035      * if enc != XML_CHAR_ENCODING_NONE
11036      * plug some encoding conversion routines.
11037      */
11038     if ((ctxt->input->end - ctxt->input->cur) >= 4) {
11039         start[0] = RAW;
11040         start[1] = NXT(1);
11041         start[2] = NXT(2);
11042         start[3] = NXT(3);
11043         enc = xmlDetectCharEncoding(start, 4);
11044         if (enc != XML_CHAR_ENCODING_NONE) {
11045             xmlSwitchEncoding(ctxt, enc);
11046         }
11047     }
11048
11049
11050     if (CUR == 0) {
11051         xmlFatalErr(ctxt, XML_ERR_DOCUMENT_EMPTY, NULL);
11052     }
11053
11054     /*
11055      * Check for the XMLDecl in the Prolog.
11056      */
11057     GROW;
11058     if ((CMP5(CUR_PTR, '<', '?', 'x', 'm', 'l')) && (IS_BLANK_CH(NXT(5)))) {
11059
11060         /*
11061          * Note that we will switch encoding on the fly.
11062          */
11063         xmlParseXMLDecl(ctxt);
11064         if (ctxt->errNo == XML_ERR_UNSUPPORTED_ENCODING) {
11065             /*
11066              * The XML REC instructs us to stop parsing right here
11067              */
11068             return(-1);
11069         }
11070         SKIP_BLANKS;
11071     } else {
11072         ctxt->version = xmlCharStrdup(XML_DEFAULT_VERSION);
11073     }
11074     if ((ctxt->sax) && (ctxt->sax->startDocument) && (!ctxt->disableSAX))
11075         ctxt->sax->startDocument(ctxt->userData);
11076     if (ctxt->instate == XML_PARSER_EOF)
11077         return(-1);
11078
11079     /*
11080      * Doing validity checking on chunk doesn't make sense
11081      */
11082     ctxt->instate = XML_PARSER_CONTENT;
11083     ctxt->validate = 0;
11084     ctxt->loadsubset = 0;
11085     ctxt->depth = 0;
11086
11087     xmlParseContent(ctxt);
11088     if (ctxt->instate == XML_PARSER_EOF)
11089         return(-1);
11090
11091     if ((RAW == '<') && (NXT(1) == '/')) {
11092         xmlFatalErr(ctxt, XML_ERR_NOT_WELL_BALANCED, NULL);
11093     } else if (RAW != 0) {
11094         xmlFatalErr(ctxt, XML_ERR_EXTRA_CONTENT, NULL);
11095     }
11096
11097     /*
11098      * SAX: end of the document processing.
11099      */
11100     if ((ctxt->sax) && (ctxt->sax->endDocument != NULL))
11101         ctxt->sax->endDocument(ctxt->userData);
11102
11103     if (! ctxt->wellFormed) return(-1);
11104     return(0);
11105 }
11106
11107 #ifdef LIBXML_PUSH_ENABLED
11108 /************************************************************************
11109  *                                                                      *
11110  *              Progressive parsing interfaces                          *
11111  *                                                                      *
11112  ************************************************************************/
11113
11114 /**
11115  * xmlParseLookupSequence:
11116  * @ctxt:  an XML parser context
11117  * @first:  the first char to lookup
11118  * @next:  the next char to lookup or zero
11119  * @third:  the next char to lookup or zero
11120  *
11121  * Try to find if a sequence (first, next, third) or  just (first next) or
11122  * (first) is available in the input stream.
11123  * This function has a side effect of (possibly) incrementing ctxt->checkIndex
11124  * to avoid rescanning sequences of bytes, it DOES change the state of the
11125  * parser, do not use liberally.
11126  *
11127  * Returns the index to the current parsing point if the full sequence
11128  *      is available, -1 otherwise.
11129  */
11130 static int
11131 xmlParseLookupSequence(xmlParserCtxtPtr ctxt, xmlChar first,
11132                        xmlChar next, xmlChar third) {
11133     int base, len;
11134     xmlParserInputPtr in;
11135     const xmlChar *buf;
11136
11137     in = ctxt->input;
11138     if (in == NULL) return(-1);
11139     base = in->cur - in->base;
11140     if (base < 0) return(-1);
11141     if (ctxt->checkIndex > base)
11142         base = ctxt->checkIndex;
11143     if (in->buf == NULL) {
11144         buf = in->base;
11145         len = in->length;
11146     } else {
11147         buf = xmlBufContent(in->buf->buffer);
11148         len = xmlBufUse(in->buf->buffer);
11149     }
11150     /* take into account the sequence length */
11151     if (third) len -= 2;
11152     else if (next) len --;
11153     for (;base < len;base++) {
11154         if (buf[base] == first) {
11155             if (third != 0) {
11156                 if ((buf[base + 1] != next) ||
11157                     (buf[base + 2] != third)) continue;
11158             } else if (next != 0) {
11159                 if (buf[base + 1] != next) continue;
11160             }
11161             ctxt->checkIndex = 0;
11162 #ifdef DEBUG_PUSH
11163             if (next == 0)
11164                 xmlGenericError(xmlGenericErrorContext,
11165                         "PP: lookup '%c' found at %d\n",
11166                         first, base);
11167             else if (third == 0)
11168                 xmlGenericError(xmlGenericErrorContext,
11169                         "PP: lookup '%c%c' found at %d\n",
11170                         first, next, base);
11171             else
11172                 xmlGenericError(xmlGenericErrorContext,
11173                         "PP: lookup '%c%c%c' found at %d\n",
11174                         first, next, third, base);
11175 #endif
11176             return(base - (in->cur - in->base));
11177         }
11178     }
11179     ctxt->checkIndex = base;
11180 #ifdef DEBUG_PUSH
11181     if (next == 0)
11182         xmlGenericError(xmlGenericErrorContext,
11183                 "PP: lookup '%c' failed\n", first);
11184     else if (third == 0)
11185         xmlGenericError(xmlGenericErrorContext,
11186                 "PP: lookup '%c%c' failed\n", first, next);
11187     else
11188         xmlGenericError(xmlGenericErrorContext,
11189                 "PP: lookup '%c%c%c' failed\n", first, next, third);
11190 #endif
11191     return(-1);
11192 }
11193
11194 /**
11195  * xmlParseGetLasts:
11196  * @ctxt:  an XML parser context
11197  * @lastlt:  pointer to store the last '<' from the input
11198  * @lastgt:  pointer to store the last '>' from the input
11199  *
11200  * Lookup the last < and > in the current chunk
11201  */
11202 static void
11203 xmlParseGetLasts(xmlParserCtxtPtr ctxt, const xmlChar **lastlt,
11204                  const xmlChar **lastgt) {
11205     const xmlChar *tmp;
11206
11207     if ((ctxt == NULL) || (lastlt == NULL) || (lastgt == NULL)) {
11208         xmlGenericError(xmlGenericErrorContext,
11209                     "Internal error: xmlParseGetLasts\n");
11210         return;
11211     }
11212     if ((ctxt->progressive != 0) && (ctxt->inputNr == 1)) {
11213         tmp = ctxt->input->end;
11214         tmp--;
11215         while ((tmp >= ctxt->input->base) && (*tmp != '<')) tmp--;
11216         if (tmp < ctxt->input->base) {
11217             *lastlt = NULL;
11218             *lastgt = NULL;
11219         } else {
11220             *lastlt = tmp;
11221             tmp++;
11222             while ((tmp < ctxt->input->end) && (*tmp != '>')) {
11223                 if (*tmp == '\'') {
11224                     tmp++;
11225                     while ((tmp < ctxt->input->end) && (*tmp != '\'')) tmp++;
11226                     if (tmp < ctxt->input->end) tmp++;
11227                 } else if (*tmp == '"') {
11228                     tmp++;
11229                     while ((tmp < ctxt->input->end) && (*tmp != '"')) tmp++;
11230                     if (tmp < ctxt->input->end) tmp++;
11231                 } else
11232                     tmp++;
11233             }
11234             if (tmp < ctxt->input->end)
11235                 *lastgt = tmp;
11236             else {
11237                 tmp = *lastlt;
11238                 tmp--;
11239                 while ((tmp >= ctxt->input->base) && (*tmp != '>')) tmp--;
11240                 if (tmp >= ctxt->input->base)
11241                     *lastgt = tmp;
11242                 else
11243                     *lastgt = NULL;
11244             }
11245         }
11246     } else {
11247         *lastlt = NULL;
11248         *lastgt = NULL;
11249     }
11250 }
11251 /**
11252  * xmlCheckCdataPush:
11253  * @cur: pointer to the block of characters
11254  * @len: length of the block in bytes
11255  * @complete: 1 if complete CDATA block is passed in, 0 if partial block
11256  *
11257  * Check that the block of characters is okay as SCdata content [20]
11258  *
11259  * Returns the number of bytes to pass if okay, a negative index where an
11260  *         UTF-8 error occured otherwise
11261  */
11262 static int
11263 xmlCheckCdataPush(const xmlChar *utf, int len, int complete) {
11264     int ix;
11265     unsigned char c;
11266     int codepoint;
11267
11268     if ((utf == NULL) || (len <= 0))
11269         return(0);
11270
11271     for (ix = 0; ix < len;) {      /* string is 0-terminated */
11272         c = utf[ix];
11273         if ((c & 0x80) == 0x00) {       /* 1-byte code, starts with 10 */
11274             if (c >= 0x20)
11275                 ix++;
11276             else if ((c == 0xA) || (c == 0xD) || (c == 0x9))
11277                 ix++;
11278             else
11279                 return(-ix);
11280         } else if ((c & 0xe0) == 0xc0) {/* 2-byte code, starts with 110 */
11281             if (ix + 2 > len) return(complete ? -ix : ix);
11282             if ((utf[ix+1] & 0xc0 ) != 0x80)
11283                 return(-ix);
11284             codepoint = (utf[ix] & 0x1f) << 6;
11285             codepoint |= utf[ix+1] & 0x3f;
11286             if (!xmlIsCharQ(codepoint))
11287                 return(-ix);
11288             ix += 2;
11289         } else if ((c & 0xf0) == 0xe0) {/* 3-byte code, starts with 1110 */
11290             if (ix + 3 > len) return(complete ? -ix : ix);
11291             if (((utf[ix+1] & 0xc0) != 0x80) ||
11292                 ((utf[ix+2] & 0xc0) != 0x80))
11293                     return(-ix);
11294             codepoint = (utf[ix] & 0xf) << 12;
11295             codepoint |= (utf[ix+1] & 0x3f) << 6;
11296             codepoint |= utf[ix+2] & 0x3f;
11297             if (!xmlIsCharQ(codepoint))
11298                 return(-ix);
11299             ix += 3;
11300         } else if ((c & 0xf8) == 0xf0) {/* 4-byte code, starts with 11110 */
11301             if (ix + 4 > len) return(complete ? -ix : ix);
11302             if (((utf[ix+1] & 0xc0) != 0x80) ||
11303                 ((utf[ix+2] & 0xc0) != 0x80) ||
11304                 ((utf[ix+3] & 0xc0) != 0x80))
11305                     return(-ix);
11306             codepoint = (utf[ix] & 0x7) << 18;
11307             codepoint |= (utf[ix+1] & 0x3f) << 12;
11308             codepoint |= (utf[ix+2] & 0x3f) << 6;
11309             codepoint |= utf[ix+3] & 0x3f;
11310             if (!xmlIsCharQ(codepoint))
11311                 return(-ix);
11312             ix += 4;
11313         } else                          /* unknown encoding */
11314             return(-ix);
11315       }
11316       return(ix);
11317 }
11318
11319 /**
11320  * xmlParseTryOrFinish:
11321  * @ctxt:  an XML parser context
11322  * @terminate:  last chunk indicator
11323  *
11324  * Try to progress on parsing
11325  *
11326  * Returns zero if no parsing was possible
11327  */
11328 static int
11329 xmlParseTryOrFinish(xmlParserCtxtPtr ctxt, int terminate) {
11330     int ret = 0;
11331     int avail, tlen;
11332     xmlChar cur, next;
11333     const xmlChar *lastlt, *lastgt;
11334
11335     if (ctxt->input == NULL)
11336         return(0);
11337
11338 #ifdef DEBUG_PUSH
11339     switch (ctxt->instate) {
11340         case XML_PARSER_EOF:
11341             xmlGenericError(xmlGenericErrorContext,
11342                     "PP: try EOF\n"); break;
11343         case XML_PARSER_START:
11344             xmlGenericError(xmlGenericErrorContext,
11345                     "PP: try START\n"); break;
11346         case XML_PARSER_MISC:
11347             xmlGenericError(xmlGenericErrorContext,
11348                     "PP: try MISC\n");break;
11349         case XML_PARSER_COMMENT:
11350             xmlGenericError(xmlGenericErrorContext,
11351                     "PP: try COMMENT\n");break;
11352         case XML_PARSER_PROLOG:
11353             xmlGenericError(xmlGenericErrorContext,
11354                     "PP: try PROLOG\n");break;
11355         case XML_PARSER_START_TAG:
11356             xmlGenericError(xmlGenericErrorContext,
11357                     "PP: try START_TAG\n");break;
11358         case XML_PARSER_CONTENT:
11359             xmlGenericError(xmlGenericErrorContext,
11360                     "PP: try CONTENT\n");break;
11361         case XML_PARSER_CDATA_SECTION:
11362             xmlGenericError(xmlGenericErrorContext,
11363                     "PP: try CDATA_SECTION\n");break;
11364         case XML_PARSER_END_TAG:
11365             xmlGenericError(xmlGenericErrorContext,
11366                     "PP: try END_TAG\n");break;
11367         case XML_PARSER_ENTITY_DECL:
11368             xmlGenericError(xmlGenericErrorContext,
11369                     "PP: try ENTITY_DECL\n");break;
11370         case XML_PARSER_ENTITY_VALUE:
11371             xmlGenericError(xmlGenericErrorContext,
11372                     "PP: try ENTITY_VALUE\n");break;
11373         case XML_PARSER_ATTRIBUTE_VALUE:
11374             xmlGenericError(xmlGenericErrorContext,
11375                     "PP: try ATTRIBUTE_VALUE\n");break;
11376         case XML_PARSER_DTD:
11377             xmlGenericError(xmlGenericErrorContext,
11378                     "PP: try DTD\n");break;
11379         case XML_PARSER_EPILOG:
11380             xmlGenericError(xmlGenericErrorContext,
11381                     "PP: try EPILOG\n");break;
11382         case XML_PARSER_PI:
11383             xmlGenericError(xmlGenericErrorContext,
11384                     "PP: try PI\n");break;
11385         case XML_PARSER_IGNORE:
11386             xmlGenericError(xmlGenericErrorContext,
11387                     "PP: try IGNORE\n");break;
11388     }
11389 #endif
11390
11391     if ((ctxt->input != NULL) &&
11392         (ctxt->input->cur - ctxt->input->base > 4096)) {
11393         xmlSHRINK(ctxt);
11394         ctxt->checkIndex = 0;
11395     }
11396     xmlParseGetLasts(ctxt, &lastlt, &lastgt);
11397
11398     while (ctxt->instate != XML_PARSER_EOF) {
11399         if ((ctxt->errNo != XML_ERR_OK) && (ctxt->disableSAX == 1))
11400             return(0);
11401
11402
11403         /*
11404          * Pop-up of finished entities.
11405          */
11406         while ((RAW == 0) && (ctxt->inputNr > 1))
11407             xmlPopInput(ctxt);
11408
11409         if (ctxt->input == NULL) break;
11410         if (ctxt->input->buf == NULL)
11411             avail = ctxt->input->length -
11412                     (ctxt->input->cur - ctxt->input->base);
11413         else {
11414             /*
11415              * If we are operating on converted input, try to flush
11416              * remainng chars to avoid them stalling in the non-converted
11417              * buffer. But do not do this in document start where
11418              * encoding="..." may not have been read and we work on a
11419              * guessed encoding.
11420              */
11421             if ((ctxt->instate != XML_PARSER_START) &&
11422                 (ctxt->input->buf->raw != NULL) &&
11423                 (xmlBufIsEmpty(ctxt->input->buf->raw) == 0)) {
11424                 size_t base = xmlBufGetInputBase(ctxt->input->buf->buffer,
11425                                                  ctxt->input);
11426                 size_t current = ctxt->input->cur - ctxt->input->base;
11427
11428                 xmlParserInputBufferPush(ctxt->input->buf, 0, "");
11429                 xmlBufSetInputBaseCur(ctxt->input->buf->buffer, ctxt->input,
11430                                       base, current);
11431             }
11432             avail = xmlBufUse(ctxt->input->buf->buffer) -
11433                     (ctxt->input->cur - ctxt->input->base);
11434         }
11435         if (avail < 1)
11436             goto done;
11437         switch (ctxt->instate) {
11438             case XML_PARSER_EOF:
11439                 /*
11440                  * Document parsing is done !
11441                  */
11442                 goto done;
11443             case XML_PARSER_START:
11444                 if (ctxt->charset == XML_CHAR_ENCODING_NONE) {
11445                     xmlChar start[4];
11446                     xmlCharEncoding enc;
11447
11448                     /*
11449                      * Very first chars read from the document flow.
11450                      */
11451                     if (avail < 4)
11452                         goto done;
11453
11454                     /*
11455                      * Get the 4 first bytes and decode the charset
11456                      * if enc != XML_CHAR_ENCODING_NONE
11457                      * plug some encoding conversion routines,
11458                      * else xmlSwitchEncoding will set to (default)
11459                      * UTF8.
11460                      */
11461                     start[0] = RAW;
11462                     start[1] = NXT(1);
11463                     start[2] = NXT(2);
11464                     start[3] = NXT(3);
11465                     enc = xmlDetectCharEncoding(start, 4);
11466                     xmlSwitchEncoding(ctxt, enc);
11467                     break;
11468                 }
11469
11470                 if (avail < 2)
11471                     goto done;
11472                 cur = ctxt->input->cur[0];
11473                 next = ctxt->input->cur[1];
11474                 if (cur == 0) {
11475                     if ((ctxt->sax) && (ctxt->sax->setDocumentLocator))
11476                         ctxt->sax->setDocumentLocator(ctxt->userData,
11477                                                       &xmlDefaultSAXLocator);
11478                     xmlFatalErr(ctxt, XML_ERR_DOCUMENT_EMPTY, NULL);
11479                     xmlHaltParser(ctxt);
11480 #ifdef DEBUG_PUSH
11481                     xmlGenericError(xmlGenericErrorContext,
11482                             "PP: entering EOF\n");
11483 #endif
11484                     if ((ctxt->sax) && (ctxt->sax->endDocument != NULL))
11485                         ctxt->sax->endDocument(ctxt->userData);
11486                     goto done;
11487                 }
11488                 if ((cur == '<') && (next == '?')) {
11489                     /* PI or XML decl */
11490                     if (avail < 5) return(ret);
11491                     if ((!terminate) &&
11492                         (xmlParseLookupSequence(ctxt, '?', '>', 0) < 0))
11493                         return(ret);
11494                     if ((ctxt->sax) && (ctxt->sax->setDocumentLocator))
11495                         ctxt->sax->setDocumentLocator(ctxt->userData,
11496                                                       &xmlDefaultSAXLocator);
11497                     if ((ctxt->input->cur[2] == 'x') &&
11498                         (ctxt->input->cur[3] == 'm') &&
11499                         (ctxt->input->cur[4] == 'l') &&
11500                         (IS_BLANK_CH(ctxt->input->cur[5]))) {
11501                         ret += 5;
11502 #ifdef DEBUG_PUSH
11503                         xmlGenericError(xmlGenericErrorContext,
11504                                 "PP: Parsing XML Decl\n");
11505 #endif
11506                         xmlParseXMLDecl(ctxt);
11507                         if (ctxt->errNo == XML_ERR_UNSUPPORTED_ENCODING) {
11508                             /*
11509                              * The XML REC instructs us to stop parsing right
11510                              * here
11511                              */
11512                             xmlHaltParser(ctxt);
11513                             return(0);
11514                         }
11515                         ctxt->standalone = ctxt->input->standalone;
11516                         if ((ctxt->encoding == NULL) &&
11517                             (ctxt->input->encoding != NULL))
11518                             ctxt->encoding = xmlStrdup(ctxt->input->encoding);
11519                         if ((ctxt->sax) && (ctxt->sax->startDocument) &&
11520                             (!ctxt->disableSAX))
11521                             ctxt->sax->startDocument(ctxt->userData);
11522                         ctxt->instate = XML_PARSER_MISC;
11523 #ifdef DEBUG_PUSH
11524                         xmlGenericError(xmlGenericErrorContext,
11525                                 "PP: entering MISC\n");
11526 #endif
11527                     } else {
11528                         ctxt->version = xmlCharStrdup(XML_DEFAULT_VERSION);
11529                         if ((ctxt->sax) && (ctxt->sax->startDocument) &&
11530                             (!ctxt->disableSAX))
11531                             ctxt->sax->startDocument(ctxt->userData);
11532                         ctxt->instate = XML_PARSER_MISC;
11533 #ifdef DEBUG_PUSH
11534                         xmlGenericError(xmlGenericErrorContext,
11535                                 "PP: entering MISC\n");
11536 #endif
11537                     }
11538                 } else {
11539                     if ((ctxt->sax) && (ctxt->sax->setDocumentLocator))
11540                         ctxt->sax->setDocumentLocator(ctxt->userData,
11541                                                       &xmlDefaultSAXLocator);
11542                     ctxt->version = xmlCharStrdup(XML_DEFAULT_VERSION);
11543                     if (ctxt->version == NULL) {
11544                         xmlErrMemory(ctxt, NULL);
11545                         break;
11546                     }
11547                     if ((ctxt->sax) && (ctxt->sax->startDocument) &&
11548                         (!ctxt->disableSAX))
11549                         ctxt->sax->startDocument(ctxt->userData);
11550                     ctxt->instate = XML_PARSER_MISC;
11551 #ifdef DEBUG_PUSH
11552                     xmlGenericError(xmlGenericErrorContext,
11553                             "PP: entering MISC\n");
11554 #endif
11555                 }
11556                 break;
11557             case XML_PARSER_START_TAG: {
11558                 const xmlChar *name;
11559                 const xmlChar *prefix = NULL;
11560                 const xmlChar *URI = NULL;
11561                 int nsNr = ctxt->nsNr;
11562
11563                 if ((avail < 2) && (ctxt->inputNr == 1))
11564                     goto done;
11565                 cur = ctxt->input->cur[0];
11566                 if (cur != '<') {
11567                     xmlFatalErr(ctxt, XML_ERR_DOCUMENT_EMPTY, NULL);
11568                     xmlHaltParser(ctxt);
11569                     if ((ctxt->sax) && (ctxt->sax->endDocument != NULL))
11570                         ctxt->sax->endDocument(ctxt->userData);
11571                     goto done;
11572                 }
11573                 if (!terminate) {
11574                     if (ctxt->progressive) {
11575                         /* > can be found unescaped in attribute values */
11576                         if ((lastgt == NULL) || (ctxt->input->cur >= lastgt))
11577                             goto done;
11578                     } else if (xmlParseLookupSequence(ctxt, '>', 0, 0) < 0) {
11579                         goto done;
11580                     }
11581                 }
11582                 if (ctxt->spaceNr == 0)
11583                     spacePush(ctxt, -1);
11584                 else if (*ctxt->space == -2)
11585                     spacePush(ctxt, -1);
11586                 else
11587                     spacePush(ctxt, *ctxt->space);
11588 #ifdef LIBXML_SAX1_ENABLED
11589                 if (ctxt->sax2)
11590 #endif /* LIBXML_SAX1_ENABLED */
11591                     name = xmlParseStartTag2(ctxt, &prefix, &URI, &tlen);
11592 #ifdef LIBXML_SAX1_ENABLED
11593                 else
11594                     name = xmlParseStartTag(ctxt);
11595 #endif /* LIBXML_SAX1_ENABLED */
11596                 if (ctxt->instate == XML_PARSER_EOF)
11597                     goto done;
11598                 if (name == NULL) {
11599                     spacePop(ctxt);
11600                     xmlHaltParser(ctxt);
11601                     if ((ctxt->sax) && (ctxt->sax->endDocument != NULL))
11602                         ctxt->sax->endDocument(ctxt->userData);
11603                     goto done;
11604                 }
11605 #ifdef LIBXML_VALID_ENABLED
11606                 /*
11607                  * [ VC: Root Element Type ]
11608                  * The Name in the document type declaration must match
11609                  * the element type of the root element.
11610                  */
11611                 if (ctxt->validate && ctxt->wellFormed && ctxt->myDoc &&
11612                     ctxt->node && (ctxt->node == ctxt->myDoc->children))
11613                     ctxt->valid &= xmlValidateRoot(&ctxt->vctxt, ctxt->myDoc);
11614 #endif /* LIBXML_VALID_ENABLED */
11615
11616                 /*
11617                  * Check for an Empty Element.
11618                  */
11619                 if ((RAW == '/') && (NXT(1) == '>')) {
11620                     SKIP(2);
11621
11622                     if (ctxt->sax2) {
11623                         if ((ctxt->sax != NULL) &&
11624                             (ctxt->sax->endElementNs != NULL) &&
11625                             (!ctxt->disableSAX))
11626                             ctxt->sax->endElementNs(ctxt->userData, name,
11627                                                     prefix, URI);
11628                         if (ctxt->nsNr - nsNr > 0)
11629                             nsPop(ctxt, ctxt->nsNr - nsNr);
11630 #ifdef LIBXML_SAX1_ENABLED
11631                     } else {
11632                         if ((ctxt->sax != NULL) &&
11633                             (ctxt->sax->endElement != NULL) &&
11634                             (!ctxt->disableSAX))
11635                             ctxt->sax->endElement(ctxt->userData, name);
11636 #endif /* LIBXML_SAX1_ENABLED */
11637                     }
11638                     if (ctxt->instate == XML_PARSER_EOF)
11639                         goto done;
11640                     spacePop(ctxt);
11641                     if (ctxt->nameNr == 0) {
11642                         ctxt->instate = XML_PARSER_EPILOG;
11643                     } else {
11644                         ctxt->instate = XML_PARSER_CONTENT;
11645                     }
11646                     ctxt->progressive = 1;
11647                     break;
11648                 }
11649                 if (RAW == '>') {
11650                     NEXT;
11651                 } else {
11652                     xmlFatalErrMsgStr(ctxt, XML_ERR_GT_REQUIRED,
11653                                          "Couldn't find end of Start Tag %s\n",
11654                                          name);
11655                     nodePop(ctxt);
11656                     spacePop(ctxt);
11657                 }
11658                 if (ctxt->sax2)
11659                     nameNsPush(ctxt, name, prefix, URI, ctxt->nsNr - nsNr);
11660 #ifdef LIBXML_SAX1_ENABLED
11661                 else
11662                     namePush(ctxt, name);
11663 #endif /* LIBXML_SAX1_ENABLED */
11664
11665                 ctxt->instate = XML_PARSER_CONTENT;
11666                 ctxt->progressive = 1;
11667                 break;
11668             }
11669             case XML_PARSER_CONTENT: {
11670                 const xmlChar *test;
11671                 unsigned int cons;
11672                 if ((avail < 2) && (ctxt->inputNr == 1))
11673                     goto done;
11674                 cur = ctxt->input->cur[0];
11675                 next = ctxt->input->cur[1];
11676
11677                 test = CUR_PTR;
11678                 cons = ctxt->input->consumed;
11679                 if ((cur == '<') && (next == '/')) {
11680                     ctxt->instate = XML_PARSER_END_TAG;
11681                     break;
11682                 } else if ((cur == '<') && (next == '?')) {
11683                     if ((!terminate) &&
11684                         (xmlParseLookupSequence(ctxt, '?', '>', 0) < 0)) {
11685                         ctxt->progressive = XML_PARSER_PI;
11686                         goto done;
11687                     }
11688                     xmlParsePI(ctxt);
11689                     ctxt->instate = XML_PARSER_CONTENT;
11690                     ctxt->progressive = 1;
11691                 } else if ((cur == '<') && (next != '!')) {
11692                     ctxt->instate = XML_PARSER_START_TAG;
11693                     break;
11694                 } else if ((cur == '<') && (next == '!') &&
11695                            (ctxt->input->cur[2] == '-') &&
11696                            (ctxt->input->cur[3] == '-')) {
11697                     int term;
11698
11699                     if (avail < 4)
11700                         goto done;
11701                     ctxt->input->cur += 4;
11702                     term = xmlParseLookupSequence(ctxt, '-', '-', '>');
11703                     ctxt->input->cur -= 4;
11704                     if ((!terminate) && (term < 0)) {
11705                         ctxt->progressive = XML_PARSER_COMMENT;
11706                         goto done;
11707                     }
11708                     xmlParseComment(ctxt);
11709                     ctxt->instate = XML_PARSER_CONTENT;
11710                     ctxt->progressive = 1;
11711                 } else if ((cur == '<') && (ctxt->input->cur[1] == '!') &&
11712                     (ctxt->input->cur[2] == '[') &&
11713                     (ctxt->input->cur[3] == 'C') &&
11714                     (ctxt->input->cur[4] == 'D') &&
11715                     (ctxt->input->cur[5] == 'A') &&
11716                     (ctxt->input->cur[6] == 'T') &&
11717                     (ctxt->input->cur[7] == 'A') &&
11718                     (ctxt->input->cur[8] == '[')) {
11719                     SKIP(9);
11720                     ctxt->instate = XML_PARSER_CDATA_SECTION;
11721                     break;
11722                 } else if ((cur == '<') && (next == '!') &&
11723                            (avail < 9)) {
11724                     goto done;
11725                 } else if (cur == '&') {
11726                     if ((!terminate) &&
11727                         (xmlParseLookupSequence(ctxt, ';', 0, 0) < 0))
11728                         goto done;
11729                     xmlParseReference(ctxt);
11730                 } else {
11731                     /* TODO Avoid the extra copy, handle directly !!! */
11732                     /*
11733                      * Goal of the following test is:
11734                      *  - minimize calls to the SAX 'character' callback
11735                      *    when they are mergeable
11736                      *  - handle an problem for isBlank when we only parse
11737                      *    a sequence of blank chars and the next one is
11738                      *    not available to check against '<' presence.
11739                      *  - tries to homogenize the differences in SAX
11740                      *    callbacks between the push and pull versions
11741                      *    of the parser.
11742                      */
11743                     if ((ctxt->inputNr == 1) &&
11744                         (avail < XML_PARSER_BIG_BUFFER_SIZE)) {
11745                         if (!terminate) {
11746                             if (ctxt->progressive) {
11747                                 if ((lastlt == NULL) ||
11748                                     (ctxt->input->cur > lastlt))
11749                                     goto done;
11750                             } else if (xmlParseLookupSequence(ctxt,
11751                                                               '<', 0, 0) < 0) {
11752                                 goto done;
11753                             }
11754                         }
11755                     }
11756                     ctxt->checkIndex = 0;
11757                     xmlParseCharData(ctxt, 0);
11758                 }
11759                 /*
11760                  * Pop-up of finished entities.
11761                  */
11762                 while ((RAW == 0) && (ctxt->inputNr > 1))
11763                     xmlPopInput(ctxt);
11764                 if ((cons == ctxt->input->consumed) && (test == CUR_PTR)) {
11765                     xmlFatalErr(ctxt, XML_ERR_INTERNAL_ERROR,
11766                                 "detected an error in element content\n");
11767                     xmlHaltParser(ctxt);
11768                     break;
11769                 }
11770                 break;
11771             }
11772             case XML_PARSER_END_TAG:
11773                 if (avail < 2)
11774                     goto done;
11775                 if (!terminate) {
11776                     if (ctxt->progressive) {
11777                         /* > can be found unescaped in attribute values */
11778                         if ((lastgt == NULL) || (ctxt->input->cur >= lastgt))
11779                             goto done;
11780                     } else if (xmlParseLookupSequence(ctxt, '>', 0, 0) < 0) {
11781                         goto done;
11782                     }
11783                 }
11784                 if (ctxt->sax2) {
11785                     xmlParseEndTag2(ctxt,
11786                            (void *) ctxt->pushTab[ctxt->nameNr * 3 - 3],
11787                            (void *) ctxt->pushTab[ctxt->nameNr * 3 - 2], 0,
11788                        (int) (long) ctxt->pushTab[ctxt->nameNr * 3 - 1], 0);
11789                     nameNsPop(ctxt);
11790                 }
11791 #ifdef LIBXML_SAX1_ENABLED
11792                   else
11793                     xmlParseEndTag1(ctxt, 0);
11794 #endif /* LIBXML_SAX1_ENABLED */
11795                 if (ctxt->instate == XML_PARSER_EOF) {
11796                     /* Nothing */
11797                 } else if (ctxt->nameNr == 0) {
11798                     ctxt->instate = XML_PARSER_EPILOG;
11799                 } else {
11800                     ctxt->instate = XML_PARSER_CONTENT;
11801                 }
11802                 break;
11803             case XML_PARSER_CDATA_SECTION: {
11804                 /*
11805                  * The Push mode need to have the SAX callback for
11806                  * cdataBlock merge back contiguous callbacks.
11807                  */
11808                 int base;
11809
11810                 base = xmlParseLookupSequence(ctxt, ']', ']', '>');
11811                 if (base < 0) {
11812                     if (avail >= XML_PARSER_BIG_BUFFER_SIZE + 2) {
11813                         int tmp;
11814
11815                         tmp = xmlCheckCdataPush(ctxt->input->cur,
11816                                                 XML_PARSER_BIG_BUFFER_SIZE, 0);
11817                         if (tmp < 0) {
11818                             tmp = -tmp;
11819                             ctxt->input->cur += tmp;
11820                             goto encoding_error;
11821                         }
11822                         if ((ctxt->sax != NULL) && (!ctxt->disableSAX)) {
11823                             if (ctxt->sax->cdataBlock != NULL)
11824                                 ctxt->sax->cdataBlock(ctxt->userData,
11825                                                       ctxt->input->cur, tmp);
11826                             else if (ctxt->sax->characters != NULL)
11827                                 ctxt->sax->characters(ctxt->userData,
11828                                                       ctxt->input->cur, tmp);
11829                         }
11830                         if (ctxt->instate == XML_PARSER_EOF)
11831                             goto done;
11832                         SKIPL(tmp);
11833                         ctxt->checkIndex = 0;
11834                     }
11835                     goto done;
11836                 } else {
11837                     int tmp;
11838
11839                     tmp = xmlCheckCdataPush(ctxt->input->cur, base, 1);
11840                     if ((tmp < 0) || (tmp != base)) {
11841                         tmp = -tmp;
11842                         ctxt->input->cur += tmp;
11843                         goto encoding_error;
11844                     }
11845                     if ((ctxt->sax != NULL) && (base == 0) &&
11846                         (ctxt->sax->cdataBlock != NULL) &&
11847                         (!ctxt->disableSAX)) {
11848                         /*
11849                          * Special case to provide identical behaviour
11850                          * between pull and push parsers on enpty CDATA
11851                          * sections
11852                          */
11853                          if ((ctxt->input->cur - ctxt->input->base >= 9) &&
11854                              (!strncmp((const char *)&ctxt->input->cur[-9],
11855                                        "<![CDATA[", 9)))
11856                              ctxt->sax->cdataBlock(ctxt->userData,
11857                                                    BAD_CAST "", 0);
11858                     } else if ((ctxt->sax != NULL) && (base > 0) &&
11859                         (!ctxt->disableSAX)) {
11860                         if (ctxt->sax->cdataBlock != NULL)
11861                             ctxt->sax->cdataBlock(ctxt->userData,
11862                                                   ctxt->input->cur, base);
11863                         else if (ctxt->sax->characters != NULL)
11864                             ctxt->sax->characters(ctxt->userData,
11865                                                   ctxt->input->cur, base);
11866                     }
11867                     if (ctxt->instate == XML_PARSER_EOF)
11868                         goto done;
11869                     SKIPL(base + 3);
11870                     ctxt->checkIndex = 0;
11871                     ctxt->instate = XML_PARSER_CONTENT;
11872 #ifdef DEBUG_PUSH
11873                     xmlGenericError(xmlGenericErrorContext,
11874                             "PP: entering CONTENT\n");
11875 #endif
11876                 }
11877                 break;
11878             }
11879             case XML_PARSER_MISC:
11880                 SKIP_BLANKS;
11881                 if (ctxt->input->buf == NULL)
11882                     avail = ctxt->input->length -
11883                             (ctxt->input->cur - ctxt->input->base);
11884                 else
11885                     avail = xmlBufUse(ctxt->input->buf->buffer) -
11886                             (ctxt->input->cur - ctxt->input->base);
11887                 if (avail < 2)
11888                     goto done;
11889                 cur = ctxt->input->cur[0];
11890                 next = ctxt->input->cur[1];
11891                 if ((cur == '<') && (next == '?')) {
11892                     if ((!terminate) &&
11893                         (xmlParseLookupSequence(ctxt, '?', '>', 0) < 0)) {
11894                         ctxt->progressive = XML_PARSER_PI;
11895                         goto done;
11896                     }
11897 #ifdef DEBUG_PUSH
11898                     xmlGenericError(xmlGenericErrorContext,
11899                             "PP: Parsing PI\n");
11900 #endif
11901                     xmlParsePI(ctxt);
11902                     if (ctxt->instate == XML_PARSER_EOF)
11903                         goto done;
11904                     ctxt->instate = XML_PARSER_MISC;
11905                     ctxt->progressive = 1;
11906                     ctxt->checkIndex = 0;
11907                 } else if ((cur == '<') && (next == '!') &&
11908                     (ctxt->input->cur[2] == '-') &&
11909                     (ctxt->input->cur[3] == '-')) {
11910                     if ((!terminate) &&
11911                         (xmlParseLookupSequence(ctxt, '-', '-', '>') < 0)) {
11912                         ctxt->progressive = XML_PARSER_COMMENT;
11913                         goto done;
11914                     }
11915 #ifdef DEBUG_PUSH
11916                     xmlGenericError(xmlGenericErrorContext,
11917                             "PP: Parsing Comment\n");
11918 #endif
11919                     xmlParseComment(ctxt);
11920                     if (ctxt->instate == XML_PARSER_EOF)
11921                         goto done;
11922                     ctxt->instate = XML_PARSER_MISC;
11923                     ctxt->progressive = 1;
11924                     ctxt->checkIndex = 0;
11925                 } else if ((cur == '<') && (next == '!') &&
11926                     (ctxt->input->cur[2] == 'D') &&
11927                     (ctxt->input->cur[3] == 'O') &&
11928                     (ctxt->input->cur[4] == 'C') &&
11929                     (ctxt->input->cur[5] == 'T') &&
11930                     (ctxt->input->cur[6] == 'Y') &&
11931                     (ctxt->input->cur[7] == 'P') &&
11932                     (ctxt->input->cur[8] == 'E')) {
11933                     if ((!terminate) &&
11934                         (xmlParseLookupSequence(ctxt, '>', 0, 0) < 0)) {
11935                         ctxt->progressive = XML_PARSER_DTD;
11936                         goto done;
11937                     }
11938 #ifdef DEBUG_PUSH
11939                     xmlGenericError(xmlGenericErrorContext,
11940                             "PP: Parsing internal subset\n");
11941 #endif
11942                     ctxt->inSubset = 1;
11943                     ctxt->progressive = 0;
11944                     ctxt->checkIndex = 0;
11945                     xmlParseDocTypeDecl(ctxt);
11946                     if (ctxt->instate == XML_PARSER_EOF)
11947                         goto done;
11948                     if (RAW == '[') {
11949                         ctxt->instate = XML_PARSER_DTD;
11950 #ifdef DEBUG_PUSH
11951                         xmlGenericError(xmlGenericErrorContext,
11952                                 "PP: entering DTD\n");
11953 #endif
11954                     } else {
11955                         /*
11956                          * Create and update the external subset.
11957                          */
11958                         ctxt->inSubset = 2;
11959                         if ((ctxt->sax != NULL) && (!ctxt->disableSAX) &&
11960                             (ctxt->sax->externalSubset != NULL))
11961                             ctxt->sax->externalSubset(ctxt->userData,
11962                                     ctxt->intSubName, ctxt->extSubSystem,
11963                                     ctxt->extSubURI);
11964                         ctxt->inSubset = 0;
11965                         xmlCleanSpecialAttr(ctxt);
11966                         ctxt->instate = XML_PARSER_PROLOG;
11967 #ifdef DEBUG_PUSH
11968                         xmlGenericError(xmlGenericErrorContext,
11969                                 "PP: entering PROLOG\n");
11970 #endif
11971                     }
11972                 } else if ((cur == '<') && (next == '!') &&
11973                            (avail < 9)) {
11974                     goto done;
11975                 } else {
11976                     ctxt->instate = XML_PARSER_START_TAG;
11977                     ctxt->progressive = XML_PARSER_START_TAG;
11978                     xmlParseGetLasts(ctxt, &lastlt, &lastgt);
11979 #ifdef DEBUG_PUSH
11980                     xmlGenericError(xmlGenericErrorContext,
11981                             "PP: entering START_TAG\n");
11982 #endif
11983                 }
11984                 break;
11985             case XML_PARSER_PROLOG:
11986                 SKIP_BLANKS;
11987                 if (ctxt->input->buf == NULL)
11988                     avail = ctxt->input->length - (ctxt->input->cur - ctxt->input->base);
11989                 else
11990                     avail = xmlBufUse(ctxt->input->buf->buffer) -
11991                             (ctxt->input->cur - ctxt->input->base);
11992                 if (avail < 2)
11993                     goto done;
11994                 cur = ctxt->input->cur[0];
11995                 next = ctxt->input->cur[1];
11996                 if ((cur == '<') && (next == '?')) {
11997                     if ((!terminate) &&
11998                         (xmlParseLookupSequence(ctxt, '?', '>', 0) < 0)) {
11999                         ctxt->progressive = XML_PARSER_PI;
12000                         goto done;
12001                     }
12002 #ifdef DEBUG_PUSH
12003                     xmlGenericError(xmlGenericErrorContext,
12004                             "PP: Parsing PI\n");
12005 #endif
12006                     xmlParsePI(ctxt);
12007                     if (ctxt->instate == XML_PARSER_EOF)
12008                         goto done;
12009                     ctxt->instate = XML_PARSER_PROLOG;
12010                     ctxt->progressive = 1;
12011                 } else if ((cur == '<') && (next == '!') &&
12012                     (ctxt->input->cur[2] == '-') && (ctxt->input->cur[3] == '-')) {
12013                     if ((!terminate) &&
12014                         (xmlParseLookupSequence(ctxt, '-', '-', '>') < 0)) {
12015                         ctxt->progressive = XML_PARSER_COMMENT;
12016                         goto done;
12017                     }
12018 #ifdef DEBUG_PUSH
12019                     xmlGenericError(xmlGenericErrorContext,
12020                             "PP: Parsing Comment\n");
12021 #endif
12022                     xmlParseComment(ctxt);
12023                     if (ctxt->instate == XML_PARSER_EOF)
12024                         goto done;
12025                     ctxt->instate = XML_PARSER_PROLOG;
12026                     ctxt->progressive = 1;
12027                 } else if ((cur == '<') && (next == '!') &&
12028                            (avail < 4)) {
12029                     goto done;
12030                 } else {
12031                     ctxt->instate = XML_PARSER_START_TAG;
12032                     if (ctxt->progressive == 0)
12033                         ctxt->progressive = XML_PARSER_START_TAG;
12034                     xmlParseGetLasts(ctxt, &lastlt, &lastgt);
12035 #ifdef DEBUG_PUSH
12036                     xmlGenericError(xmlGenericErrorContext,
12037                             "PP: entering START_TAG\n");
12038 #endif
12039                 }
12040                 break;
12041             case XML_PARSER_EPILOG:
12042                 SKIP_BLANKS;
12043                 if (ctxt->input->buf == NULL)
12044                     avail = ctxt->input->length - (ctxt->input->cur - ctxt->input->base);
12045                 else
12046                     avail = xmlBufUse(ctxt->input->buf->buffer) -
12047                             (ctxt->input->cur - ctxt->input->base);
12048                 if (avail < 2)
12049                     goto done;
12050                 cur = ctxt->input->cur[0];
12051                 next = ctxt->input->cur[1];
12052                 if ((cur == '<') && (next == '?')) {
12053                     if ((!terminate) &&
12054                         (xmlParseLookupSequence(ctxt, '?', '>', 0) < 0)) {
12055                         ctxt->progressive = XML_PARSER_PI;
12056                         goto done;
12057                     }
12058 #ifdef DEBUG_PUSH
12059                     xmlGenericError(xmlGenericErrorContext,
12060                             "PP: Parsing PI\n");
12061 #endif
12062                     xmlParsePI(ctxt);
12063                     if (ctxt->instate == XML_PARSER_EOF)
12064                         goto done;
12065                     ctxt->instate = XML_PARSER_EPILOG;
12066                     ctxt->progressive = 1;
12067                 } else if ((cur == '<') && (next == '!') &&
12068                     (ctxt->input->cur[2] == '-') && (ctxt->input->cur[3] == '-')) {
12069                     if ((!terminate) &&
12070                         (xmlParseLookupSequence(ctxt, '-', '-', '>') < 0)) {
12071                         ctxt->progressive = XML_PARSER_COMMENT;
12072                         goto done;
12073                     }
12074 #ifdef DEBUG_PUSH
12075                     xmlGenericError(xmlGenericErrorContext,
12076                             "PP: Parsing Comment\n");
12077 #endif
12078                     xmlParseComment(ctxt);
12079                     if (ctxt->instate == XML_PARSER_EOF)
12080                         goto done;
12081                     ctxt->instate = XML_PARSER_EPILOG;
12082                     ctxt->progressive = 1;
12083                 } else if ((cur == '<') && (next == '!') &&
12084                            (avail < 4)) {
12085                     goto done;
12086                 } else {
12087                     xmlFatalErr(ctxt, XML_ERR_DOCUMENT_END, NULL);
12088                     xmlHaltParser(ctxt);
12089 #ifdef DEBUG_PUSH
12090                     xmlGenericError(xmlGenericErrorContext,
12091                             "PP: entering EOF\n");
12092 #endif
12093                     if ((ctxt->sax) && (ctxt->sax->endDocument != NULL))
12094                         ctxt->sax->endDocument(ctxt->userData);
12095                     goto done;
12096                 }
12097                 break;
12098             case XML_PARSER_DTD: {
12099                 /*
12100                  * Sorry but progressive parsing of the internal subset
12101                  * is not expected to be supported. We first check that
12102                  * the full content of the internal subset is available and
12103                  * the parsing is launched only at that point.
12104                  * Internal subset ends up with "']' S? '>'" in an unescaped
12105                  * section and not in a ']]>' sequence which are conditional
12106                  * sections (whoever argued to keep that crap in XML deserve
12107                  * a place in hell !).
12108                  */
12109                 int base, i;
12110                 xmlChar *buf;
12111                 xmlChar quote = 0;
12112                 size_t use;
12113
12114                 base = ctxt->input->cur - ctxt->input->base;
12115                 if (base < 0) return(0);
12116                 if (ctxt->checkIndex > base)
12117                     base = ctxt->checkIndex;
12118                 buf = xmlBufContent(ctxt->input->buf->buffer);
12119                 use = xmlBufUse(ctxt->input->buf->buffer);
12120                 for (;(unsigned int) base < use; base++) {
12121                     if (quote != 0) {
12122                         if (buf[base] == quote)
12123                             quote = 0;
12124                         continue;
12125                     }
12126                     if ((quote == 0) && (buf[base] == '<')) {
12127                         int found  = 0;
12128                         /* special handling of comments */
12129                         if (((unsigned int) base + 4 < use) &&
12130                             (buf[base + 1] == '!') &&
12131                             (buf[base + 2] == '-') &&
12132                             (buf[base + 3] == '-')) {
12133                             for (;(unsigned int) base + 3 < use; base++) {
12134                                 if ((buf[base] == '-') &&
12135                                     (buf[base + 1] == '-') &&
12136                                     (buf[base + 2] == '>')) {
12137                                     found = 1;
12138                                     base += 2;
12139                                     break;
12140                                 }
12141                             }
12142                             if (!found) {
12143 #if 0
12144                                 fprintf(stderr, "unfinished comment\n");
12145 #endif
12146                                 break; /* for */
12147                             }
12148                             continue;
12149                         }
12150                     }
12151                     if (buf[base] == '"') {
12152                         quote = '"';
12153                         continue;
12154                     }
12155                     if (buf[base] == '\'') {
12156                         quote = '\'';
12157                         continue;
12158                     }
12159                     if (buf[base] == ']') {
12160 #if 0
12161                         fprintf(stderr, "%c%c%c%c: ", buf[base],
12162                                 buf[base + 1], buf[base + 2], buf[base + 3]);
12163 #endif
12164                         if ((unsigned int) base +1 >= use)
12165                             break;
12166                         if (buf[base + 1] == ']') {
12167                             /* conditional crap, skip both ']' ! */
12168                             base++;
12169                             continue;
12170                         }
12171                         for (i = 1; (unsigned int) base + i < use; i++) {
12172                             if (buf[base + i] == '>') {
12173 #if 0
12174                                 fprintf(stderr, "found\n");
12175 #endif
12176                                 goto found_end_int_subset;
12177                             }
12178                             if (!IS_BLANK_CH(buf[base + i])) {
12179 #if 0
12180                                 fprintf(stderr, "not found\n");
12181 #endif
12182                                 goto not_end_of_int_subset;
12183                             }
12184                         }
12185 #if 0
12186                         fprintf(stderr, "end of stream\n");
12187 #endif
12188                         break;
12189
12190                     }
12191 not_end_of_int_subset:
12192                     continue; /* for */
12193                 }
12194                 /*
12195                  * We didn't found the end of the Internal subset
12196                  */
12197                 if (quote == 0)
12198                     ctxt->checkIndex = base;
12199                 else
12200                     ctxt->checkIndex = 0;
12201 #ifdef DEBUG_PUSH
12202                 if (next == 0)
12203                     xmlGenericError(xmlGenericErrorContext,
12204                             "PP: lookup of int subset end filed\n");
12205 #endif
12206                 goto done;
12207
12208 found_end_int_subset:
12209                 ctxt->checkIndex = 0;
12210                 xmlParseInternalSubset(ctxt);
12211                 if (ctxt->instate == XML_PARSER_EOF)
12212                     goto done;
12213                 ctxt->inSubset = 2;
12214                 if ((ctxt->sax != NULL) && (!ctxt->disableSAX) &&
12215                     (ctxt->sax->externalSubset != NULL))
12216                     ctxt->sax->externalSubset(ctxt->userData, ctxt->intSubName,
12217                             ctxt->extSubSystem, ctxt->extSubURI);
12218                 ctxt->inSubset = 0;
12219                 xmlCleanSpecialAttr(ctxt);
12220                 if (ctxt->instate == XML_PARSER_EOF)
12221                     goto done;
12222                 ctxt->instate = XML_PARSER_PROLOG;
12223                 ctxt->checkIndex = 0;
12224 #ifdef DEBUG_PUSH
12225                 xmlGenericError(xmlGenericErrorContext,
12226                         "PP: entering PROLOG\n");
12227 #endif
12228                 break;
12229             }
12230             case XML_PARSER_COMMENT:
12231                 xmlGenericError(xmlGenericErrorContext,
12232                         "PP: internal error, state == COMMENT\n");
12233                 ctxt->instate = XML_PARSER_CONTENT;
12234 #ifdef DEBUG_PUSH
12235                 xmlGenericError(xmlGenericErrorContext,
12236                         "PP: entering CONTENT\n");
12237 #endif
12238                 break;
12239             case XML_PARSER_IGNORE:
12240                 xmlGenericError(xmlGenericErrorContext,
12241                         "PP: internal error, state == IGNORE");
12242                 ctxt->instate = XML_PARSER_DTD;
12243 #ifdef DEBUG_PUSH
12244                 xmlGenericError(xmlGenericErrorContext,
12245                         "PP: entering DTD\n");
12246 #endif
12247                 break;
12248             case XML_PARSER_PI:
12249                 xmlGenericError(xmlGenericErrorContext,
12250                         "PP: internal error, state == PI\n");
12251                 ctxt->instate = XML_PARSER_CONTENT;
12252 #ifdef DEBUG_PUSH
12253                 xmlGenericError(xmlGenericErrorContext,
12254                         "PP: entering CONTENT\n");
12255 #endif
12256                 break;
12257             case XML_PARSER_ENTITY_DECL:
12258                 xmlGenericError(xmlGenericErrorContext,
12259                         "PP: internal error, state == ENTITY_DECL\n");
12260                 ctxt->instate = XML_PARSER_DTD;
12261 #ifdef DEBUG_PUSH
12262                 xmlGenericError(xmlGenericErrorContext,
12263                         "PP: entering DTD\n");
12264 #endif
12265                 break;
12266             case XML_PARSER_ENTITY_VALUE:
12267                 xmlGenericError(xmlGenericErrorContext,
12268                         "PP: internal error, state == ENTITY_VALUE\n");
12269                 ctxt->instate = XML_PARSER_CONTENT;
12270 #ifdef DEBUG_PUSH
12271                 xmlGenericError(xmlGenericErrorContext,
12272                         "PP: entering DTD\n");
12273 #endif
12274                 break;
12275             case XML_PARSER_ATTRIBUTE_VALUE:
12276                 xmlGenericError(xmlGenericErrorContext,
12277                         "PP: internal error, state == ATTRIBUTE_VALUE\n");
12278                 ctxt->instate = XML_PARSER_START_TAG;
12279 #ifdef DEBUG_PUSH
12280                 xmlGenericError(xmlGenericErrorContext,
12281                         "PP: entering START_TAG\n");
12282 #endif
12283                 break;
12284             case XML_PARSER_SYSTEM_LITERAL:
12285                 xmlGenericError(xmlGenericErrorContext,
12286                         "PP: internal error, state == SYSTEM_LITERAL\n");
12287                 ctxt->instate = XML_PARSER_START_TAG;
12288 #ifdef DEBUG_PUSH
12289                 xmlGenericError(xmlGenericErrorContext,
12290                         "PP: entering START_TAG\n");
12291 #endif
12292                 break;
12293             case XML_PARSER_PUBLIC_LITERAL:
12294                 xmlGenericError(xmlGenericErrorContext,
12295                         "PP: internal error, state == PUBLIC_LITERAL\n");
12296                 ctxt->instate = XML_PARSER_START_TAG;
12297 #ifdef DEBUG_PUSH
12298                 xmlGenericError(xmlGenericErrorContext,
12299                         "PP: entering START_TAG\n");
12300 #endif
12301                 break;
12302         }
12303     }
12304 done:
12305 #ifdef DEBUG_PUSH
12306     xmlGenericError(xmlGenericErrorContext, "PP: done %d\n", ret);
12307 #endif
12308     return(ret);
12309 encoding_error:
12310     {
12311         char buffer[150];
12312
12313         snprintf(buffer, 149, "Bytes: 0x%02X 0x%02X 0x%02X 0x%02X\n",
12314                         ctxt->input->cur[0], ctxt->input->cur[1],
12315                         ctxt->input->cur[2], ctxt->input->cur[3]);
12316         __xmlErrEncoding(ctxt, XML_ERR_INVALID_CHAR,
12317                      "Input is not proper UTF-8, indicate encoding !\n%s",
12318                      BAD_CAST buffer, NULL);
12319     }
12320     return(0);
12321 }
12322
12323 /**
12324  * xmlParseCheckTransition:
12325  * @ctxt:  an XML parser context
12326  * @chunk:  a char array
12327  * @size:  the size in byte of the chunk
12328  *
12329  * Check depending on the current parser state if the chunk given must be
12330  * processed immediately or one need more data to advance on parsing.
12331  *
12332  * Returns -1 in case of error, 0 if the push is not needed and 1 if needed
12333  */
12334 static int
12335 xmlParseCheckTransition(xmlParserCtxtPtr ctxt, const char *chunk, int size) {
12336     if ((ctxt == NULL) || (chunk == NULL) || (size < 0))
12337         return(-1);
12338     if (ctxt->instate == XML_PARSER_START_TAG) {
12339         if (memchr(chunk, '>', size) != NULL)
12340             return(1);
12341         return(0);
12342     }
12343     if (ctxt->progressive == XML_PARSER_COMMENT) {
12344         if (memchr(chunk, '>', size) != NULL)
12345             return(1);
12346         return(0);
12347     }
12348     if (ctxt->instate == XML_PARSER_CDATA_SECTION) {
12349         if (memchr(chunk, '>', size) != NULL)
12350             return(1);
12351         return(0);
12352     }
12353     if (ctxt->progressive == XML_PARSER_PI) {
12354         if (memchr(chunk, '>', size) != NULL)
12355             return(1);
12356         return(0);
12357     }
12358     if (ctxt->instate == XML_PARSER_END_TAG) {
12359         if (memchr(chunk, '>', size) != NULL)
12360             return(1);
12361         return(0);
12362     }
12363     if ((ctxt->progressive == XML_PARSER_DTD) ||
12364         (ctxt->instate == XML_PARSER_DTD)) {
12365         if (memchr(chunk, '>', size) != NULL)
12366             return(1);
12367         return(0);
12368     }
12369     return(1);
12370 }
12371
12372 /**
12373  * xmlParseChunk:
12374  * @ctxt:  an XML parser context
12375  * @chunk:  an char array
12376  * @size:  the size in byte of the chunk
12377  * @terminate:  last chunk indicator
12378  *
12379  * Parse a Chunk of memory
12380  *
12381  * Returns zero if no error, the xmlParserErrors otherwise.
12382  */
12383 int
12384 xmlParseChunk(xmlParserCtxtPtr ctxt, const char *chunk, int size,
12385               int terminate) {
12386     int end_in_lf = 0;
12387     int remain = 0;
12388     size_t old_avail = 0;
12389     size_t avail = 0;
12390
12391     if (ctxt == NULL)
12392         return(XML_ERR_INTERNAL_ERROR);
12393     if ((ctxt->errNo != XML_ERR_OK) && (ctxt->disableSAX == 1))
12394         return(ctxt->errNo);
12395     if (ctxt->instate == XML_PARSER_EOF)
12396         return(-1);
12397     if (ctxt->instate == XML_PARSER_START)
12398         xmlDetectSAX2(ctxt);
12399     if ((size > 0) && (chunk != NULL) && (!terminate) &&
12400         (chunk[size - 1] == '\r')) {
12401         end_in_lf = 1;
12402         size--;
12403     }
12404
12405 xmldecl_done:
12406
12407     if ((size > 0) && (chunk != NULL) && (ctxt->input != NULL) &&
12408         (ctxt->input->buf != NULL) && (ctxt->instate != XML_PARSER_EOF))  {
12409         size_t base = xmlBufGetInputBase(ctxt->input->buf->buffer, ctxt->input);
12410         size_t cur = ctxt->input->cur - ctxt->input->base;
12411         int res;
12412
12413         old_avail = xmlBufUse(ctxt->input->buf->buffer);
12414         /*
12415          * Specific handling if we autodetected an encoding, we should not
12416          * push more than the first line ... which depend on the encoding
12417          * And only push the rest once the final encoding was detected
12418          */
12419         if ((ctxt->instate == XML_PARSER_START) && (ctxt->input != NULL) &&
12420             (ctxt->input->buf != NULL) && (ctxt->input->buf->encoder != NULL)) {
12421             unsigned int len = 45;
12422
12423             if ((xmlStrcasestr(BAD_CAST ctxt->input->buf->encoder->name,
12424                                BAD_CAST "UTF-16")) ||
12425                 (xmlStrcasestr(BAD_CAST ctxt->input->buf->encoder->name,
12426                                BAD_CAST "UTF16")))
12427                 len = 90;
12428             else if ((xmlStrcasestr(BAD_CAST ctxt->input->buf->encoder->name,
12429                                     BAD_CAST "UCS-4")) ||
12430                      (xmlStrcasestr(BAD_CAST ctxt->input->buf->encoder->name,
12431                                     BAD_CAST "UCS4")))
12432                 len = 180;
12433
12434             if (ctxt->input->buf->rawconsumed < len)
12435                 len -= ctxt->input->buf->rawconsumed;
12436
12437             /*
12438              * Change size for reading the initial declaration only
12439              * if size is greater than len. Otherwise, memmove in xmlBufferAdd
12440              * will blindly copy extra bytes from memory.
12441              */
12442             if ((unsigned int) size > len) {
12443                 remain = size - len;
12444                 size = len;
12445             } else {
12446                 remain = 0;
12447             }
12448         }
12449         res = xmlParserInputBufferPush(ctxt->input->buf, size, chunk);
12450         if (res < 0) {
12451             ctxt->errNo = XML_PARSER_EOF;
12452             xmlHaltParser(ctxt);
12453             return (XML_PARSER_EOF);
12454         }
12455         xmlBufSetInputBaseCur(ctxt->input->buf->buffer, ctxt->input, base, cur);
12456 #ifdef DEBUG_PUSH
12457         xmlGenericError(xmlGenericErrorContext, "PP: pushed %d\n", size);
12458 #endif
12459
12460     } else if (ctxt->instate != XML_PARSER_EOF) {
12461         if ((ctxt->input != NULL) && ctxt->input->buf != NULL) {
12462             xmlParserInputBufferPtr in = ctxt->input->buf;
12463             if ((in->encoder != NULL) && (in->buffer != NULL) &&
12464                     (in->raw != NULL)) {
12465                 int nbchars;
12466                 size_t base = xmlBufGetInputBase(in->buffer, ctxt->input);
12467                 size_t current = ctxt->input->cur - ctxt->input->base;
12468
12469                 nbchars = xmlCharEncInput(in, terminate);
12470                 if (nbchars < 0) {
12471                     /* TODO 2.6.0 */
12472                     xmlGenericError(xmlGenericErrorContext,
12473                                     "xmlParseChunk: encoder error\n");
12474                     return(XML_ERR_INVALID_ENCODING);
12475                 }
12476                 xmlBufSetInputBaseCur(in->buffer, ctxt->input, base, current);
12477             }
12478         }
12479     }
12480     if (remain != 0) {
12481         xmlParseTryOrFinish(ctxt, 0);
12482     } else {
12483         if ((ctxt->input != NULL) && (ctxt->input->buf != NULL))
12484             avail = xmlBufUse(ctxt->input->buf->buffer);
12485         /*
12486          * Depending on the current state it may not be such
12487          * a good idea to try parsing if there is nothing in the chunk
12488          * which would be worth doing a parser state transition and we
12489          * need to wait for more data
12490          */
12491         if ((terminate) || (avail > XML_MAX_TEXT_LENGTH) ||
12492             (old_avail == 0) || (avail == 0) ||
12493             (xmlParseCheckTransition(ctxt,
12494                        (const char *)&ctxt->input->base[old_avail],
12495                                      avail - old_avail)))
12496             xmlParseTryOrFinish(ctxt, terminate);
12497     }
12498     if (ctxt->instate == XML_PARSER_EOF)
12499         return(ctxt->errNo);
12500
12501     if ((ctxt->input != NULL) &&
12502          (((ctxt->input->end - ctxt->input->cur) > XML_MAX_LOOKUP_LIMIT) ||
12503          ((ctxt->input->cur - ctxt->input->base) > XML_MAX_LOOKUP_LIMIT)) &&
12504         ((ctxt->options & XML_PARSE_HUGE) == 0)) {
12505         xmlFatalErr(ctxt, XML_ERR_INTERNAL_ERROR, "Huge input lookup");
12506         xmlHaltParser(ctxt);
12507     }
12508     if ((ctxt->errNo != XML_ERR_OK) && (ctxt->disableSAX == 1))
12509         return(ctxt->errNo);
12510
12511     if (remain != 0) {
12512         chunk += size;
12513         size = remain;
12514         remain = 0;
12515         goto xmldecl_done;
12516     }
12517     if ((end_in_lf == 1) && (ctxt->input != NULL) &&
12518         (ctxt->input->buf != NULL)) {
12519         size_t base = xmlBufGetInputBase(ctxt->input->buf->buffer,
12520                                          ctxt->input);
12521         size_t current = ctxt->input->cur - ctxt->input->base;
12522
12523         xmlParserInputBufferPush(ctxt->input->buf, 1, "\r");
12524
12525         xmlBufSetInputBaseCur(ctxt->input->buf->buffer, ctxt->input,
12526                               base, current);
12527     }
12528     if (terminate) {
12529         /*
12530          * Check for termination
12531          */
12532         int cur_avail = 0;
12533
12534         if (ctxt->input != NULL) {
12535             if (ctxt->input->buf == NULL)
12536                 cur_avail = ctxt->input->length -
12537                             (ctxt->input->cur - ctxt->input->base);
12538             else
12539                 cur_avail = xmlBufUse(ctxt->input->buf->buffer) -
12540                                       (ctxt->input->cur - ctxt->input->base);
12541         }
12542
12543         if ((ctxt->instate != XML_PARSER_EOF) &&
12544             (ctxt->instate != XML_PARSER_EPILOG)) {
12545             xmlFatalErr(ctxt, XML_ERR_DOCUMENT_END, NULL);
12546         }
12547         if ((ctxt->instate == XML_PARSER_EPILOG) && (cur_avail > 0)) {
12548             xmlFatalErr(ctxt, XML_ERR_DOCUMENT_END, NULL);
12549         }
12550         if (ctxt->instate != XML_PARSER_EOF) {
12551             if ((ctxt->sax) && (ctxt->sax->endDocument != NULL))
12552                 ctxt->sax->endDocument(ctxt->userData);
12553         }
12554         ctxt->instate = XML_PARSER_EOF;
12555     }
12556     if (ctxt->wellFormed == 0)
12557         return((xmlParserErrors) ctxt->errNo);
12558     else
12559         return(0);
12560 }
12561
12562 /************************************************************************
12563  *                                                                      *
12564  *              I/O front end functions to the parser                   *
12565  *                                                                      *
12566  ************************************************************************/
12567
12568 /**
12569  * xmlCreatePushParserCtxt:
12570  * @sax:  a SAX handler
12571  * @user_data:  The user data returned on SAX callbacks
12572  * @chunk:  a pointer to an array of chars
12573  * @size:  number of chars in the array
12574  * @filename:  an optional file name or URI
12575  *
12576  * Create a parser context for using the XML parser in push mode.
12577  * If @buffer and @size are non-NULL, the data is used to detect
12578  * the encoding.  The remaining characters will be parsed so they
12579  * don't need to be fed in again through xmlParseChunk.
12580  * To allow content encoding detection, @size should be >= 4
12581  * The value of @filename is used for fetching external entities
12582  * and error/warning reports.
12583  *
12584  * Returns the new parser context or NULL
12585  */
12586
12587 xmlParserCtxtPtr
12588 xmlCreatePushParserCtxt(xmlSAXHandlerPtr sax, void *user_data,
12589                         const char *chunk, int size, const char *filename) {
12590     xmlParserCtxtPtr ctxt;
12591     xmlParserInputPtr inputStream;
12592     xmlParserInputBufferPtr buf;
12593     xmlCharEncoding enc = XML_CHAR_ENCODING_NONE;
12594
12595     /*
12596      * plug some encoding conversion routines
12597      */
12598     if ((chunk != NULL) && (size >= 4))
12599         enc = xmlDetectCharEncoding((const xmlChar *) chunk, size);
12600
12601     buf = xmlAllocParserInputBuffer(enc);
12602     if (buf == NULL) return(NULL);
12603
12604     ctxt = xmlNewParserCtxt();
12605     if (ctxt == NULL) {
12606         xmlErrMemory(NULL, "creating parser: out of memory\n");
12607         xmlFreeParserInputBuffer(buf);
12608         return(NULL);
12609     }
12610     ctxt->dictNames = 1;
12611     ctxt->pushTab = (void **) xmlMalloc(ctxt->nameMax * 3 * sizeof(xmlChar *));
12612     if (ctxt->pushTab == NULL) {
12613         xmlErrMemory(ctxt, NULL);
12614         xmlFreeParserInputBuffer(buf);
12615         xmlFreeParserCtxt(ctxt);
12616         return(NULL);
12617     }
12618     if (sax != NULL) {
12619 #ifdef LIBXML_SAX1_ENABLED
12620         if (ctxt->sax != (xmlSAXHandlerPtr) &xmlDefaultSAXHandler)
12621 #endif /* LIBXML_SAX1_ENABLED */
12622             xmlFree(ctxt->sax);
12623         ctxt->sax = (xmlSAXHandlerPtr) xmlMalloc(sizeof(xmlSAXHandler));
12624         if (ctxt->sax == NULL) {
12625             xmlErrMemory(ctxt, NULL);
12626             xmlFreeParserInputBuffer(buf);
12627             xmlFreeParserCtxt(ctxt);
12628             return(NULL);
12629         }
12630         memset(ctxt->sax, 0, sizeof(xmlSAXHandler));
12631         if (sax->initialized == XML_SAX2_MAGIC)
12632             memcpy(ctxt->sax, sax, sizeof(xmlSAXHandler));
12633         else
12634             memcpy(ctxt->sax, sax, sizeof(xmlSAXHandlerV1));
12635         if (user_data != NULL)
12636             ctxt->userData = user_data;
12637     }
12638     if (filename == NULL) {
12639         ctxt->directory = NULL;
12640     } else {
12641         ctxt->directory = xmlParserGetDirectory(filename);
12642     }
12643
12644     inputStream = xmlNewInputStream(ctxt);
12645     if (inputStream == NULL) {
12646         xmlFreeParserCtxt(ctxt);
12647         xmlFreeParserInputBuffer(buf);
12648         return(NULL);
12649     }
12650
12651     if (filename == NULL)
12652         inputStream->filename = NULL;
12653     else {
12654         inputStream->filename = (char *)
12655             xmlCanonicPath((const xmlChar *) filename);
12656         if (inputStream->filename == NULL) {
12657             xmlFreeParserCtxt(ctxt);
12658             xmlFreeParserInputBuffer(buf);
12659             return(NULL);
12660         }
12661     }
12662     inputStream->buf = buf;
12663     xmlBufResetInput(inputStream->buf->buffer, inputStream);
12664     inputPush(ctxt, inputStream);
12665
12666     /*
12667      * If the caller didn't provide an initial 'chunk' for determining
12668      * the encoding, we set the context to XML_CHAR_ENCODING_NONE so
12669      * that it can be automatically determined later
12670      */
12671     if ((size == 0) || (chunk == NULL)) {
12672         ctxt->charset = XML_CHAR_ENCODING_NONE;
12673     } else if ((ctxt->input != NULL) && (ctxt->input->buf != NULL)) {
12674         size_t base = xmlBufGetInputBase(ctxt->input->buf->buffer, ctxt->input);
12675         size_t cur = ctxt->input->cur - ctxt->input->base;
12676
12677         xmlParserInputBufferPush(ctxt->input->buf, size, chunk);
12678
12679         xmlBufSetInputBaseCur(ctxt->input->buf->buffer, ctxt->input, base, cur);
12680 #ifdef DEBUG_PUSH
12681         xmlGenericError(xmlGenericErrorContext, "PP: pushed %d\n", size);
12682 #endif
12683     }
12684
12685     if (enc != XML_CHAR_ENCODING_NONE) {
12686         xmlSwitchEncoding(ctxt, enc);
12687     }
12688
12689     return(ctxt);
12690 }
12691 #endif /* LIBXML_PUSH_ENABLED */
12692
12693 /**
12694  * xmlHaltParser:
12695  * @ctxt:  an XML parser context
12696  *
12697  * Blocks further parser processing don't override error
12698  * for internal use
12699  */
12700 static void
12701 xmlHaltParser(xmlParserCtxtPtr ctxt) {
12702     if (ctxt == NULL)
12703         return;
12704     ctxt->instate = XML_PARSER_EOF;
12705     ctxt->disableSAX = 1;
12706     if (ctxt->input != NULL) {
12707         /*
12708          * in case there was a specific allocation deallocate before
12709          * overriding base
12710          */
12711         if (ctxt->input->free != NULL) {
12712             ctxt->input->free((xmlChar *) ctxt->input->base);
12713             ctxt->input->free = NULL;
12714         }
12715         ctxt->input->cur = BAD_CAST"";
12716         ctxt->input->base = ctxt->input->cur;
12717     }
12718 }
12719
12720 /**
12721  * xmlStopParser:
12722  * @ctxt:  an XML parser context
12723  *
12724  * Blocks further parser processing
12725  */
12726 void
12727 xmlStopParser(xmlParserCtxtPtr ctxt) {
12728     if (ctxt == NULL)
12729         return;
12730     xmlHaltParser(ctxt);
12731     ctxt->errNo = XML_ERR_USER_STOP;
12732 }
12733
12734 /**
12735  * xmlCreateIOParserCtxt:
12736  * @sax:  a SAX handler
12737  * @user_data:  The user data returned on SAX callbacks
12738  * @ioread:  an I/O read function
12739  * @ioclose:  an I/O close function
12740  * @ioctx:  an I/O handler
12741  * @enc:  the charset encoding if known
12742  *
12743  * Create a parser context for using the XML parser with an existing
12744  * I/O stream
12745  *
12746  * Returns the new parser context or NULL
12747  */
12748 xmlParserCtxtPtr
12749 xmlCreateIOParserCtxt(xmlSAXHandlerPtr sax, void *user_data,
12750         xmlInputReadCallback   ioread, xmlInputCloseCallback  ioclose,
12751         void *ioctx, xmlCharEncoding enc) {
12752     xmlParserCtxtPtr ctxt;
12753     xmlParserInputPtr inputStream;
12754     xmlParserInputBufferPtr buf;
12755
12756     if (ioread == NULL) return(NULL);
12757
12758     buf = xmlParserInputBufferCreateIO(ioread, ioclose, ioctx, enc);
12759     if (buf == NULL) {
12760         if (ioclose != NULL)
12761             ioclose(ioctx);
12762         return (NULL);
12763     }
12764
12765     ctxt = xmlNewParserCtxt();
12766     if (ctxt == NULL) {
12767         xmlFreeParserInputBuffer(buf);
12768         return(NULL);
12769     }
12770     if (sax != NULL) {
12771 #ifdef LIBXML_SAX1_ENABLED
12772         if (ctxt->sax != (xmlSAXHandlerPtr) &xmlDefaultSAXHandler)
12773 #endif /* LIBXML_SAX1_ENABLED */
12774             xmlFree(ctxt->sax);
12775         ctxt->sax = (xmlSAXHandlerPtr) xmlMalloc(sizeof(xmlSAXHandler));
12776         if (ctxt->sax == NULL) {
12777             xmlErrMemory(ctxt, NULL);
12778             xmlFreeParserCtxt(ctxt);
12779             return(NULL);
12780         }
12781         memset(ctxt->sax, 0, sizeof(xmlSAXHandler));
12782         if (sax->initialized == XML_SAX2_MAGIC)
12783             memcpy(ctxt->sax, sax, sizeof(xmlSAXHandler));
12784         else
12785             memcpy(ctxt->sax, sax, sizeof(xmlSAXHandlerV1));
12786         if (user_data != NULL)
12787             ctxt->userData = user_data;
12788     }
12789
12790     inputStream = xmlNewIOInputStream(ctxt, buf, enc);
12791     if (inputStream == NULL) {
12792         xmlFreeParserCtxt(ctxt);
12793         return(NULL);
12794     }
12795     inputPush(ctxt, inputStream);
12796
12797     return(ctxt);
12798 }
12799
12800 #ifdef LIBXML_VALID_ENABLED
12801 /************************************************************************
12802  *                                                                      *
12803  *              Front ends when parsing a DTD                           *
12804  *                                                                      *
12805  ************************************************************************/
12806
12807 /**
12808  * xmlIOParseDTD:
12809  * @sax:  the SAX handler block or NULL
12810  * @input:  an Input Buffer
12811  * @enc:  the charset encoding if known
12812  *
12813  * Load and parse a DTD
12814  *
12815  * Returns the resulting xmlDtdPtr or NULL in case of error.
12816  * @input will be freed by the function in any case.
12817  */
12818
12819 xmlDtdPtr
12820 xmlIOParseDTD(xmlSAXHandlerPtr sax, xmlParserInputBufferPtr input,
12821               xmlCharEncoding enc) {
12822     xmlDtdPtr ret = NULL;
12823     xmlParserCtxtPtr ctxt;
12824     xmlParserInputPtr pinput = NULL;
12825     xmlChar start[4];
12826
12827     if (input == NULL)
12828         return(NULL);
12829
12830     ctxt = xmlNewParserCtxt();
12831     if (ctxt == NULL) {
12832         xmlFreeParserInputBuffer(input);
12833         return(NULL);
12834     }
12835
12836     /* We are loading a DTD */
12837     ctxt->options |= XML_PARSE_DTDLOAD;
12838
12839     /*
12840      * Set-up the SAX context
12841      */
12842     if (sax != NULL) {
12843         if (ctxt->sax != NULL)
12844             xmlFree(ctxt->sax);
12845         ctxt->sax = sax;
12846         ctxt->userData = ctxt;
12847     }
12848     xmlDetectSAX2(ctxt);
12849
12850     /*
12851      * generate a parser input from the I/O handler
12852      */
12853
12854     pinput = xmlNewIOInputStream(ctxt, input, XML_CHAR_ENCODING_NONE);
12855     if (pinput == NULL) {
12856         if (sax != NULL) ctxt->sax = NULL;
12857         xmlFreeParserInputBuffer(input);
12858         xmlFreeParserCtxt(ctxt);
12859         return(NULL);
12860     }
12861
12862     /*
12863      * plug some encoding conversion routines here.
12864      */
12865     if (xmlPushInput(ctxt, pinput) < 0) {
12866         if (sax != NULL) ctxt->sax = NULL;
12867         xmlFreeParserCtxt(ctxt);
12868         return(NULL);
12869     }
12870     if (enc != XML_CHAR_ENCODING_NONE) {
12871         xmlSwitchEncoding(ctxt, enc);
12872     }
12873
12874     pinput->filename = NULL;
12875     pinput->line = 1;
12876     pinput->col = 1;
12877     pinput->base = ctxt->input->cur;
12878     pinput->cur = ctxt->input->cur;
12879     pinput->free = NULL;
12880
12881     /*
12882      * let's parse that entity knowing it's an external subset.
12883      */
12884     ctxt->inSubset = 2;
12885     ctxt->myDoc = xmlNewDoc(BAD_CAST "1.0");
12886     if (ctxt->myDoc == NULL) {
12887         xmlErrMemory(ctxt, "New Doc failed");
12888         return(NULL);
12889     }
12890     ctxt->myDoc->properties = XML_DOC_INTERNAL;
12891     ctxt->myDoc->extSubset = xmlNewDtd(ctxt->myDoc, BAD_CAST "none",
12892                                        BAD_CAST "none", BAD_CAST "none");
12893
12894     if ((enc == XML_CHAR_ENCODING_NONE) &&
12895         ((ctxt->input->end - ctxt->input->cur) >= 4)) {
12896         /*
12897          * Get the 4 first bytes and decode the charset
12898          * if enc != XML_CHAR_ENCODING_NONE
12899          * plug some encoding conversion routines.
12900          */
12901         start[0] = RAW;
12902         start[1] = NXT(1);
12903         start[2] = NXT(2);
12904         start[3] = NXT(3);
12905         enc = xmlDetectCharEncoding(start, 4);
12906         if (enc != XML_CHAR_ENCODING_NONE) {
12907             xmlSwitchEncoding(ctxt, enc);
12908         }
12909     }
12910
12911     xmlParseExternalSubset(ctxt, BAD_CAST "none", BAD_CAST "none");
12912
12913     if (ctxt->myDoc != NULL) {
12914         if (ctxt->wellFormed) {
12915             ret = ctxt->myDoc->extSubset;
12916             ctxt->myDoc->extSubset = NULL;
12917             if (ret != NULL) {
12918                 xmlNodePtr tmp;
12919
12920                 ret->doc = NULL;
12921                 tmp = ret->children;
12922                 while (tmp != NULL) {
12923                     tmp->doc = NULL;
12924                     tmp = tmp->next;
12925                 }
12926             }
12927         } else {
12928             ret = NULL;
12929         }
12930         xmlFreeDoc(ctxt->myDoc);
12931         ctxt->myDoc = NULL;
12932     }
12933     if (sax != NULL) ctxt->sax = NULL;
12934     xmlFreeParserCtxt(ctxt);
12935
12936     return(ret);
12937 }
12938
12939 /**
12940  * xmlSAXParseDTD:
12941  * @sax:  the SAX handler block
12942  * @ExternalID:  a NAME* containing the External ID of the DTD
12943  * @SystemID:  a NAME* containing the URL to the DTD
12944  *
12945  * Load and parse an external subset.
12946  *
12947  * Returns the resulting xmlDtdPtr or NULL in case of error.
12948  */
12949
12950 xmlDtdPtr
12951 xmlSAXParseDTD(xmlSAXHandlerPtr sax, const xmlChar *ExternalID,
12952                           const xmlChar *SystemID) {
12953     xmlDtdPtr ret = NULL;
12954     xmlParserCtxtPtr ctxt;
12955     xmlParserInputPtr input = NULL;
12956     xmlCharEncoding enc;
12957     xmlChar* systemIdCanonic;
12958
12959     if ((ExternalID == NULL) && (SystemID == NULL)) return(NULL);
12960
12961     ctxt = xmlNewParserCtxt();
12962     if (ctxt == NULL) {
12963         return(NULL);
12964     }
12965
12966     /* We are loading a DTD */
12967     ctxt->options |= XML_PARSE_DTDLOAD;
12968
12969     /*
12970      * Set-up the SAX context
12971      */
12972     if (sax != NULL) {
12973         if (ctxt->sax != NULL)
12974             xmlFree(ctxt->sax);
12975         ctxt->sax = sax;
12976         ctxt->userData = ctxt;
12977     }
12978
12979     /*
12980      * Canonicalise the system ID
12981      */
12982     systemIdCanonic = xmlCanonicPath(SystemID);
12983     if ((SystemID != NULL) && (systemIdCanonic == NULL)) {
12984         xmlFreeParserCtxt(ctxt);
12985         return(NULL);
12986     }
12987
12988     /*
12989      * Ask the Entity resolver to load the damn thing
12990      */
12991
12992     if ((ctxt->sax != NULL) && (ctxt->sax->resolveEntity != NULL))
12993         input = ctxt->sax->resolveEntity(ctxt->userData, ExternalID,
12994                                          systemIdCanonic);
12995     if (input == NULL) {
12996         if (sax != NULL) ctxt->sax = NULL;
12997         xmlFreeParserCtxt(ctxt);
12998         if (systemIdCanonic != NULL)
12999             xmlFree(systemIdCanonic);
13000         return(NULL);
13001     }
13002
13003     /*
13004      * plug some encoding conversion routines here.
13005      */
13006     if (xmlPushInput(ctxt, input) < 0) {
13007         if (sax != NULL) ctxt->sax = NULL;
13008         xmlFreeParserCtxt(ctxt);
13009         if (systemIdCanonic != NULL)
13010             xmlFree(systemIdCanonic);
13011         return(NULL);
13012     }
13013     if ((ctxt->input->end - ctxt->input->cur) >= 4) {
13014         enc = xmlDetectCharEncoding(ctxt->input->cur, 4);
13015         xmlSwitchEncoding(ctxt, enc);
13016     }
13017
13018     if (input->filename == NULL)
13019         input->filename = (char *) systemIdCanonic;
13020     else
13021         xmlFree(systemIdCanonic);
13022     input->line = 1;
13023     input->col = 1;
13024     input->base = ctxt->input->cur;
13025     input->cur = ctxt->input->cur;
13026     input->free = NULL;
13027
13028     /*
13029      * let's parse that entity knowing it's an external subset.
13030      */
13031     ctxt->inSubset = 2;
13032     ctxt->myDoc = xmlNewDoc(BAD_CAST "1.0");
13033     if (ctxt->myDoc == NULL) {
13034         xmlErrMemory(ctxt, "New Doc failed");
13035         if (sax != NULL) ctxt->sax = NULL;
13036         xmlFreeParserCtxt(ctxt);
13037         return(NULL);
13038     }
13039     ctxt->myDoc->properties = XML_DOC_INTERNAL;
13040     ctxt->myDoc->extSubset = xmlNewDtd(ctxt->myDoc, BAD_CAST "none",
13041                                        ExternalID, SystemID);
13042     xmlParseExternalSubset(ctxt, ExternalID, SystemID);
13043
13044     if (ctxt->myDoc != NULL) {
13045         if (ctxt->wellFormed) {
13046             ret = ctxt->myDoc->extSubset;
13047             ctxt->myDoc->extSubset = NULL;
13048             if (ret != NULL) {
13049                 xmlNodePtr tmp;
13050
13051                 ret->doc = NULL;
13052                 tmp = ret->children;
13053                 while (tmp != NULL) {
13054                     tmp->doc = NULL;
13055                     tmp = tmp->next;
13056                 }
13057             }
13058         } else {
13059             ret = NULL;
13060         }
13061         xmlFreeDoc(ctxt->myDoc);
13062         ctxt->myDoc = NULL;
13063     }
13064     if (sax != NULL) ctxt->sax = NULL;
13065     xmlFreeParserCtxt(ctxt);
13066
13067     return(ret);
13068 }
13069
13070
13071 /**
13072  * xmlParseDTD:
13073  * @ExternalID:  a NAME* containing the External ID of the DTD
13074  * @SystemID:  a NAME* containing the URL to the DTD
13075  *
13076  * Load and parse an external subset.
13077  *
13078  * Returns the resulting xmlDtdPtr or NULL in case of error.
13079  */
13080
13081 xmlDtdPtr
13082 xmlParseDTD(const xmlChar *ExternalID, const xmlChar *SystemID) {
13083     return(xmlSAXParseDTD(NULL, ExternalID, SystemID));
13084 }
13085 #endif /* LIBXML_VALID_ENABLED */
13086
13087 /************************************************************************
13088  *                                                                      *
13089  *              Front ends when parsing an Entity                       *
13090  *                                                                      *
13091  ************************************************************************/
13092
13093 /**
13094  * xmlParseCtxtExternalEntity:
13095  * @ctx:  the existing parsing context
13096  * @URL:  the URL for the entity to load
13097  * @ID:  the System ID for the entity to load
13098  * @lst:  the return value for the set of parsed nodes
13099  *
13100  * Parse an external general entity within an existing parsing context
13101  * An external general parsed entity is well-formed if it matches the
13102  * production labeled extParsedEnt.
13103  *
13104  * [78] extParsedEnt ::= TextDecl? content
13105  *
13106  * Returns 0 if the entity is well formed, -1 in case of args problem and
13107  *    the parser error code otherwise
13108  */
13109
13110 int
13111 xmlParseCtxtExternalEntity(xmlParserCtxtPtr ctx, const xmlChar *URL,
13112                        const xmlChar *ID, xmlNodePtr *lst) {
13113     xmlParserCtxtPtr ctxt;
13114     xmlDocPtr newDoc;
13115     xmlNodePtr newRoot;
13116     xmlSAXHandlerPtr oldsax = NULL;
13117     int ret = 0;
13118     xmlChar start[4];
13119     xmlCharEncoding enc;
13120
13121     if (ctx == NULL) return(-1);
13122
13123     if (((ctx->depth > 40) && ((ctx->options & XML_PARSE_HUGE) == 0)) ||
13124         (ctx->depth > 1024)) {
13125         return(XML_ERR_ENTITY_LOOP);
13126     }
13127
13128     if (lst != NULL)
13129         *lst = NULL;
13130     if ((URL == NULL) && (ID == NULL))
13131         return(-1);
13132     if (ctx->myDoc == NULL) /* @@ relax but check for dereferences */
13133         return(-1);
13134
13135     ctxt = xmlCreateEntityParserCtxtInternal(URL, ID, NULL, ctx);
13136     if (ctxt == NULL) {
13137         return(-1);
13138     }
13139
13140     oldsax = ctxt->sax;
13141     ctxt->sax = ctx->sax;
13142     xmlDetectSAX2(ctxt);
13143     newDoc = xmlNewDoc(BAD_CAST "1.0");
13144     if (newDoc == NULL) {
13145         xmlFreeParserCtxt(ctxt);
13146         return(-1);
13147     }
13148     newDoc->properties = XML_DOC_INTERNAL;
13149     if (ctx->myDoc->dict) {
13150         newDoc->dict = ctx->myDoc->dict;
13151         xmlDictReference(newDoc->dict);
13152     }
13153     if (ctx->myDoc != NULL) {
13154         newDoc->intSubset = ctx->myDoc->intSubset;
13155         newDoc->extSubset = ctx->myDoc->extSubset;
13156     }
13157     if (ctx->myDoc->URL != NULL) {
13158         newDoc->URL = xmlStrdup(ctx->myDoc->URL);
13159     }
13160     newRoot = xmlNewDocNode(newDoc, NULL, BAD_CAST "pseudoroot", NULL);
13161     if (newRoot == NULL) {
13162         ctxt->sax = oldsax;
13163         xmlFreeParserCtxt(ctxt);
13164         newDoc->intSubset = NULL;
13165         newDoc->extSubset = NULL;
13166         xmlFreeDoc(newDoc);
13167         return(-1);
13168     }
13169     xmlAddChild((xmlNodePtr) newDoc, newRoot);
13170     nodePush(ctxt, newDoc->children);
13171     if (ctx->myDoc == NULL) {
13172         ctxt->myDoc = newDoc;
13173     } else {
13174         ctxt->myDoc = ctx->myDoc;
13175         newDoc->children->doc = ctx->myDoc;
13176     }
13177
13178     /*
13179      * Get the 4 first bytes and decode the charset
13180      * if enc != XML_CHAR_ENCODING_NONE
13181      * plug some encoding conversion routines.
13182      */
13183     GROW
13184     if ((ctxt->input->end - ctxt->input->cur) >= 4) {
13185         start[0] = RAW;
13186         start[1] = NXT(1);
13187         start[2] = NXT(2);
13188         start[3] = NXT(3);
13189         enc = xmlDetectCharEncoding(start, 4);
13190         if (enc != XML_CHAR_ENCODING_NONE) {
13191             xmlSwitchEncoding(ctxt, enc);
13192         }
13193     }
13194
13195     /*
13196      * Parse a possible text declaration first
13197      */
13198     if ((CMP5(CUR_PTR, '<', '?', 'x', 'm', 'l')) && (IS_BLANK_CH(NXT(5)))) {
13199         xmlParseTextDecl(ctxt);
13200         /*
13201          * An XML-1.0 document can't reference an entity not XML-1.0
13202          */
13203         if ((xmlStrEqual(ctx->version, BAD_CAST "1.0")) &&
13204             (!xmlStrEqual(ctxt->input->version, BAD_CAST "1.0"))) {
13205             xmlFatalErrMsg(ctxt, XML_ERR_VERSION_MISMATCH,
13206                            "Version mismatch between document and entity\n");
13207         }
13208     }
13209
13210     /*
13211      * If the user provided its own SAX callbacks then reuse the
13212      * useData callback field, otherwise the expected setup in a
13213      * DOM builder is to have userData == ctxt
13214      */
13215     if (ctx->userData == ctx)
13216         ctxt->userData = ctxt;
13217     else
13218         ctxt->userData = ctx->userData;
13219
13220     /*
13221      * Doing validity checking on chunk doesn't make sense
13222      */
13223     ctxt->instate = XML_PARSER_CONTENT;
13224     ctxt->validate = ctx->validate;
13225     ctxt->valid = ctx->valid;
13226     ctxt->loadsubset = ctx->loadsubset;
13227     ctxt->depth = ctx->depth + 1;
13228     ctxt->replaceEntities = ctx->replaceEntities;
13229     if (ctxt->validate) {
13230         ctxt->vctxt.error = ctx->vctxt.error;
13231         ctxt->vctxt.warning = ctx->vctxt.warning;
13232     } else {
13233         ctxt->vctxt.error = NULL;
13234         ctxt->vctxt.warning = NULL;
13235     }
13236     ctxt->vctxt.nodeTab = NULL;
13237     ctxt->vctxt.nodeNr = 0;
13238     ctxt->vctxt.nodeMax = 0;
13239     ctxt->vctxt.node = NULL;
13240     if (ctxt->dict != NULL) xmlDictFree(ctxt->dict);
13241     ctxt->dict = ctx->dict;
13242     ctxt->str_xml = xmlDictLookup(ctxt->dict, BAD_CAST "xml", 3);
13243     ctxt->str_xmlns = xmlDictLookup(ctxt->dict, BAD_CAST "xmlns", 5);
13244     ctxt->str_xml_ns = xmlDictLookup(ctxt->dict, XML_XML_NAMESPACE, 36);
13245     ctxt->dictNames = ctx->dictNames;
13246     ctxt->attsDefault = ctx->attsDefault;
13247     ctxt->attsSpecial = ctx->attsSpecial;
13248     ctxt->linenumbers = ctx->linenumbers;
13249
13250     xmlParseContent(ctxt);
13251
13252     ctx->validate = ctxt->validate;
13253     ctx->valid = ctxt->valid;
13254     if ((RAW == '<') && (NXT(1) == '/')) {
13255         xmlFatalErr(ctxt, XML_ERR_NOT_WELL_BALANCED, NULL);
13256     } else if (RAW != 0) {
13257         xmlFatalErr(ctxt, XML_ERR_EXTRA_CONTENT, NULL);
13258     }
13259     if (ctxt->node != newDoc->children) {
13260         xmlFatalErr(ctxt, XML_ERR_NOT_WELL_BALANCED, NULL);
13261     }
13262
13263     if (!ctxt->wellFormed) {
13264         if (ctxt->errNo == 0)
13265             ret = 1;
13266         else
13267             ret = ctxt->errNo;
13268     } else {
13269         if (lst != NULL) {
13270             xmlNodePtr cur;
13271
13272             /*
13273              * Return the newly created nodeset after unlinking it from
13274              * they pseudo parent.
13275              */
13276             cur = newDoc->children->children;
13277             *lst = cur;
13278             while (cur != NULL) {
13279                 cur->parent = NULL;
13280                 cur = cur->next;
13281             }
13282             newDoc->children->children = NULL;
13283         }
13284         ret = 0;
13285     }
13286     ctxt->sax = oldsax;
13287     ctxt->dict = NULL;
13288     ctxt->attsDefault = NULL;
13289     ctxt->attsSpecial = NULL;
13290     xmlFreeParserCtxt(ctxt);
13291     newDoc->intSubset = NULL;
13292     newDoc->extSubset = NULL;
13293     xmlFreeDoc(newDoc);
13294
13295     return(ret);
13296 }
13297
13298 /**
13299  * xmlParseExternalEntityPrivate:
13300  * @doc:  the document the chunk pertains to
13301  * @oldctxt:  the previous parser context if available
13302  * @sax:  the SAX handler bloc (possibly NULL)
13303  * @user_data:  The user data returned on SAX callbacks (possibly NULL)
13304  * @depth:  Used for loop detection, use 0
13305  * @URL:  the URL for the entity to load
13306  * @ID:  the System ID for the entity to load
13307  * @list:  the return value for the set of parsed nodes
13308  *
13309  * Private version of xmlParseExternalEntity()
13310  *
13311  * Returns 0 if the entity is well formed, -1 in case of args problem and
13312  *    the parser error code otherwise
13313  */
13314
13315 static xmlParserErrors
13316 xmlParseExternalEntityPrivate(xmlDocPtr doc, xmlParserCtxtPtr oldctxt,
13317                       xmlSAXHandlerPtr sax,
13318                       void *user_data, int depth, const xmlChar *URL,
13319                       const xmlChar *ID, xmlNodePtr *list) {
13320     xmlParserCtxtPtr ctxt;
13321     xmlDocPtr newDoc;
13322     xmlNodePtr newRoot;
13323     xmlSAXHandlerPtr oldsax = NULL;
13324     xmlParserErrors ret = XML_ERR_OK;
13325     xmlChar start[4];
13326     xmlCharEncoding enc;
13327
13328     if (((depth > 40) &&
13329         ((oldctxt == NULL) || (oldctxt->options & XML_PARSE_HUGE) == 0)) ||
13330         (depth > 1024)) {
13331         return(XML_ERR_ENTITY_LOOP);
13332     }
13333
13334     if (list != NULL)
13335         *list = NULL;
13336     if ((URL == NULL) && (ID == NULL))
13337         return(XML_ERR_INTERNAL_ERROR);
13338     if (doc == NULL)
13339         return(XML_ERR_INTERNAL_ERROR);
13340
13341
13342     ctxt = xmlCreateEntityParserCtxtInternal(URL, ID, NULL, oldctxt);
13343     if (ctxt == NULL) return(XML_WAR_UNDECLARED_ENTITY);
13344     ctxt->userData = ctxt;
13345     if (oldctxt != NULL) {
13346         ctxt->_private = oldctxt->_private;
13347         ctxt->loadsubset = oldctxt->loadsubset;
13348         ctxt->validate = oldctxt->validate;
13349         ctxt->external = oldctxt->external;
13350         ctxt->record_info = oldctxt->record_info;
13351         ctxt->node_seq.maximum = oldctxt->node_seq.maximum;
13352         ctxt->node_seq.length = oldctxt->node_seq.length;
13353         ctxt->node_seq.buffer = oldctxt->node_seq.buffer;
13354     } else {
13355         /*
13356          * Doing validity checking on chunk without context
13357          * doesn't make sense
13358          */
13359         ctxt->_private = NULL;
13360         ctxt->validate = 0;
13361         ctxt->external = 2;
13362         ctxt->loadsubset = 0;
13363     }
13364     if (sax != NULL) {
13365         oldsax = ctxt->sax;
13366         ctxt->sax = sax;
13367         if (user_data != NULL)
13368             ctxt->userData = user_data;
13369     }
13370     xmlDetectSAX2(ctxt);
13371     newDoc = xmlNewDoc(BAD_CAST "1.0");
13372     if (newDoc == NULL) {
13373         ctxt->node_seq.maximum = 0;
13374         ctxt->node_seq.length = 0;
13375         ctxt->node_seq.buffer = NULL;
13376         xmlFreeParserCtxt(ctxt);
13377         return(XML_ERR_INTERNAL_ERROR);
13378     }
13379     newDoc->properties = XML_DOC_INTERNAL;
13380     newDoc->intSubset = doc->intSubset;
13381     newDoc->extSubset = doc->extSubset;
13382     newDoc->dict = doc->dict;
13383     xmlDictReference(newDoc->dict);
13384
13385     if (doc->URL != NULL) {
13386         newDoc->URL = xmlStrdup(doc->URL);
13387     }
13388     newRoot = xmlNewDocNode(newDoc, NULL, BAD_CAST "pseudoroot", NULL);
13389     if (newRoot == NULL) {
13390         if (sax != NULL)
13391             ctxt->sax = oldsax;
13392         ctxt->node_seq.maximum = 0;
13393         ctxt->node_seq.length = 0;
13394         ctxt->node_seq.buffer = NULL;
13395         xmlFreeParserCtxt(ctxt);
13396         newDoc->intSubset = NULL;
13397         newDoc->extSubset = NULL;
13398         xmlFreeDoc(newDoc);
13399         return(XML_ERR_INTERNAL_ERROR);
13400     }
13401     xmlAddChild((xmlNodePtr) newDoc, newRoot);
13402     nodePush(ctxt, newDoc->children);
13403     ctxt->myDoc = doc;
13404     newRoot->doc = doc;
13405
13406     /*
13407      * Get the 4 first bytes and decode the charset
13408      * if enc != XML_CHAR_ENCODING_NONE
13409      * plug some encoding conversion routines.
13410      */
13411     GROW;
13412     if ((ctxt->input->end - ctxt->input->cur) >= 4) {
13413         start[0] = RAW;
13414         start[1] = NXT(1);
13415         start[2] = NXT(2);
13416         start[3] = NXT(3);
13417         enc = xmlDetectCharEncoding(start, 4);
13418         if (enc != XML_CHAR_ENCODING_NONE) {
13419             xmlSwitchEncoding(ctxt, enc);
13420         }
13421     }
13422
13423     /*
13424      * Parse a possible text declaration first
13425      */
13426     if ((CMP5(CUR_PTR, '<', '?', 'x', 'm', 'l')) && (IS_BLANK_CH(NXT(5)))) {
13427         xmlParseTextDecl(ctxt);
13428     }
13429
13430     ctxt->instate = XML_PARSER_CONTENT;
13431     ctxt->depth = depth;
13432
13433     xmlParseContent(ctxt);
13434
13435     if ((RAW == '<') && (NXT(1) == '/')) {
13436         xmlFatalErr(ctxt, XML_ERR_NOT_WELL_BALANCED, NULL);
13437     } else if (RAW != 0) {
13438         xmlFatalErr(ctxt, XML_ERR_EXTRA_CONTENT, NULL);
13439     }
13440     if (ctxt->node != newDoc->children) {
13441         xmlFatalErr(ctxt, XML_ERR_NOT_WELL_BALANCED, NULL);
13442     }
13443
13444     if (!ctxt->wellFormed) {
13445         if (ctxt->errNo == 0)
13446             ret = XML_ERR_INTERNAL_ERROR;
13447         else
13448             ret = (xmlParserErrors)ctxt->errNo;
13449     } else {
13450         if (list != NULL) {
13451             xmlNodePtr cur;
13452
13453             /*
13454              * Return the newly created nodeset after unlinking it from
13455              * they pseudo parent.
13456              */
13457             cur = newDoc->children->children;
13458             *list = cur;
13459             while (cur != NULL) {
13460                 cur->parent = NULL;
13461                 cur = cur->next;
13462             }
13463             newDoc->children->children = NULL;
13464         }
13465         ret = XML_ERR_OK;
13466     }
13467
13468     /*
13469      * Record in the parent context the number of entities replacement
13470      * done when parsing that reference.
13471      */
13472     if (oldctxt != NULL)
13473         oldctxt->nbentities += ctxt->nbentities;
13474
13475     /*
13476      * Also record the size of the entity parsed
13477      */
13478     if (ctxt->input != NULL && oldctxt != NULL) {
13479         oldctxt->sizeentities += ctxt->input->consumed;
13480         oldctxt->sizeentities += (ctxt->input->cur - ctxt->input->base);
13481     }
13482     /*
13483      * And record the last error if any
13484      */
13485     if (ctxt->lastError.code != XML_ERR_OK)
13486         xmlCopyError(&ctxt->lastError, &oldctxt->lastError);
13487
13488     if (sax != NULL)
13489         ctxt->sax = oldsax;
13490     if (oldctxt != NULL) {
13491         oldctxt->node_seq.maximum = ctxt->node_seq.maximum;
13492         oldctxt->node_seq.length = ctxt->node_seq.length;
13493         oldctxt->node_seq.buffer = ctxt->node_seq.buffer;
13494     }
13495     ctxt->node_seq.maximum = 0;
13496     ctxt->node_seq.length = 0;
13497     ctxt->node_seq.buffer = NULL;
13498     xmlFreeParserCtxt(ctxt);
13499     newDoc->intSubset = NULL;
13500     newDoc->extSubset = NULL;
13501     xmlFreeDoc(newDoc);
13502
13503     return(ret);
13504 }
13505
13506 #ifdef LIBXML_SAX1_ENABLED
13507 /**
13508  * xmlParseExternalEntity:
13509  * @doc:  the document the chunk pertains to
13510  * @sax:  the SAX handler bloc (possibly NULL)
13511  * @user_data:  The user data returned on SAX callbacks (possibly NULL)
13512  * @depth:  Used for loop detection, use 0
13513  * @URL:  the URL for the entity to load
13514  * @ID:  the System ID for the entity to load
13515  * @lst:  the return value for the set of parsed nodes
13516  *
13517  * Parse an external general entity
13518  * An external general parsed entity is well-formed if it matches the
13519  * production labeled extParsedEnt.
13520  *
13521  * [78] extParsedEnt ::= TextDecl? content
13522  *
13523  * Returns 0 if the entity is well formed, -1 in case of args problem and
13524  *    the parser error code otherwise
13525  */
13526
13527 int
13528 xmlParseExternalEntity(xmlDocPtr doc, xmlSAXHandlerPtr sax, void *user_data,
13529           int depth, const xmlChar *URL, const xmlChar *ID, xmlNodePtr *lst) {
13530     return(xmlParseExternalEntityPrivate(doc, NULL, sax, user_data, depth, URL,
13531                                        ID, lst));
13532 }
13533
13534 /**
13535  * xmlParseBalancedChunkMemory:
13536  * @doc:  the document the chunk pertains to
13537  * @sax:  the SAX handler bloc (possibly NULL)
13538  * @user_data:  The user data returned on SAX callbacks (possibly NULL)
13539  * @depth:  Used for loop detection, use 0
13540  * @string:  the input string in UTF8 or ISO-Latin (zero terminated)
13541  * @lst:  the return value for the set of parsed nodes
13542  *
13543  * Parse a well-balanced chunk of an XML document
13544  * called by the parser
13545  * The allowed sequence for the Well Balanced Chunk is the one defined by
13546  * the content production in the XML grammar:
13547  *
13548  * [43] content ::= (element | CharData | Reference | CDSect | PI | Comment)*
13549  *
13550  * Returns 0 if the chunk is well balanced, -1 in case of args problem and
13551  *    the parser error code otherwise
13552  */
13553
13554 int
13555 xmlParseBalancedChunkMemory(xmlDocPtr doc, xmlSAXHandlerPtr sax,
13556      void *user_data, int depth, const xmlChar *string, xmlNodePtr *lst) {
13557     return xmlParseBalancedChunkMemoryRecover( doc, sax, user_data,
13558                                                 depth, string, lst, 0 );
13559 }
13560 #endif /* LIBXML_SAX1_ENABLED */
13561
13562 /**
13563  * xmlParseBalancedChunkMemoryInternal:
13564  * @oldctxt:  the existing parsing context
13565  * @string:  the input string in UTF8 or ISO-Latin (zero terminated)
13566  * @user_data:  the user data field for the parser context
13567  * @lst:  the return value for the set of parsed nodes
13568  *
13569  *
13570  * Parse a well-balanced chunk of an XML document
13571  * called by the parser
13572  * The allowed sequence for the Well Balanced Chunk is the one defined by
13573  * the content production in the XML grammar:
13574  *
13575  * [43] content ::= (element | CharData | Reference | CDSect | PI | Comment)*
13576  *
13577  * Returns XML_ERR_OK if the chunk is well balanced, and the parser
13578  * error code otherwise
13579  *
13580  * In case recover is set to 1, the nodelist will not be empty even if
13581  * the parsed chunk is not well balanced.
13582  */
13583 static xmlParserErrors
13584 xmlParseBalancedChunkMemoryInternal(xmlParserCtxtPtr oldctxt,
13585         const xmlChar *string, void *user_data, xmlNodePtr *lst) {
13586     xmlParserCtxtPtr ctxt;
13587     xmlDocPtr newDoc = NULL;
13588     xmlNodePtr newRoot;
13589     xmlSAXHandlerPtr oldsax = NULL;
13590     xmlNodePtr content = NULL;
13591     xmlNodePtr last = NULL;
13592     int size;
13593     xmlParserErrors ret = XML_ERR_OK;
13594 #ifdef SAX2
13595     int i;
13596 #endif
13597
13598     if (((oldctxt->depth > 40) && ((oldctxt->options & XML_PARSE_HUGE) == 0)) ||
13599         (oldctxt->depth >  1024)) {
13600         return(XML_ERR_ENTITY_LOOP);
13601     }
13602
13603
13604     if (lst != NULL)
13605         *lst = NULL;
13606     if (string == NULL)
13607         return(XML_ERR_INTERNAL_ERROR);
13608
13609     size = xmlStrlen(string);
13610
13611     ctxt = xmlCreateMemoryParserCtxt((char *) string, size);
13612     if (ctxt == NULL) return(XML_WAR_UNDECLARED_ENTITY);
13613     if (user_data != NULL)
13614         ctxt->userData = user_data;
13615     else
13616         ctxt->userData = ctxt;
13617     if (ctxt->dict != NULL) xmlDictFree(ctxt->dict);
13618     ctxt->dict = oldctxt->dict;
13619     ctxt->str_xml = xmlDictLookup(ctxt->dict, BAD_CAST "xml", 3);
13620     ctxt->str_xmlns = xmlDictLookup(ctxt->dict, BAD_CAST "xmlns", 5);
13621     ctxt->str_xml_ns = xmlDictLookup(ctxt->dict, XML_XML_NAMESPACE, 36);
13622
13623 #ifdef SAX2
13624     /* propagate namespaces down the entity */
13625     for (i = 0;i < oldctxt->nsNr;i += 2) {
13626         nsPush(ctxt, oldctxt->nsTab[i], oldctxt->nsTab[i+1]);
13627     }
13628 #endif
13629
13630     oldsax = ctxt->sax;
13631     ctxt->sax = oldctxt->sax;
13632     xmlDetectSAX2(ctxt);
13633     ctxt->replaceEntities = oldctxt->replaceEntities;
13634     ctxt->options = oldctxt->options;
13635
13636     ctxt->_private = oldctxt->_private;
13637     if (oldctxt->myDoc == NULL) {
13638         newDoc = xmlNewDoc(BAD_CAST "1.0");
13639         if (newDoc == NULL) {
13640             ctxt->sax = oldsax;
13641             ctxt->dict = NULL;
13642             xmlFreeParserCtxt(ctxt);
13643             return(XML_ERR_INTERNAL_ERROR);
13644         }
13645         newDoc->properties = XML_DOC_INTERNAL;
13646         newDoc->dict = ctxt->dict;
13647         xmlDictReference(newDoc->dict);
13648         ctxt->myDoc = newDoc;
13649     } else {
13650         ctxt->myDoc = oldctxt->myDoc;
13651         content = ctxt->myDoc->children;
13652         last = ctxt->myDoc->last;
13653     }
13654     newRoot = xmlNewDocNode(ctxt->myDoc, NULL, BAD_CAST "pseudoroot", NULL);
13655     if (newRoot == NULL) {
13656         ctxt->sax = oldsax;
13657         ctxt->dict = NULL;
13658         xmlFreeParserCtxt(ctxt);
13659         if (newDoc != NULL) {
13660             xmlFreeDoc(newDoc);
13661         }
13662         return(XML_ERR_INTERNAL_ERROR);
13663     }
13664     ctxt->myDoc->children = NULL;
13665     ctxt->myDoc->last = NULL;
13666     xmlAddChild((xmlNodePtr) ctxt->myDoc, newRoot);
13667     nodePush(ctxt, ctxt->myDoc->children);
13668     ctxt->instate = XML_PARSER_CONTENT;
13669     ctxt->depth = oldctxt->depth + 1;
13670
13671     ctxt->validate = 0;
13672     ctxt->loadsubset = oldctxt->loadsubset;
13673     if ((oldctxt->validate) || (oldctxt->replaceEntities != 0)) {
13674         /*
13675          * ID/IDREF registration will be done in xmlValidateElement below
13676          */
13677         ctxt->loadsubset |= XML_SKIP_IDS;
13678     }
13679     ctxt->dictNames = oldctxt->dictNames;
13680     ctxt->attsDefault = oldctxt->attsDefault;
13681     ctxt->attsSpecial = oldctxt->attsSpecial;
13682
13683     xmlParseContent(ctxt);
13684     if ((RAW == '<') && (NXT(1) == '/')) {
13685         xmlFatalErr(ctxt, XML_ERR_NOT_WELL_BALANCED, NULL);
13686     } else if (RAW != 0) {
13687         xmlFatalErr(ctxt, XML_ERR_EXTRA_CONTENT, NULL);
13688     }
13689     if (ctxt->node != ctxt->myDoc->children) {
13690         xmlFatalErr(ctxt, XML_ERR_NOT_WELL_BALANCED, NULL);
13691     }
13692
13693     if (!ctxt->wellFormed) {
13694         if (ctxt->errNo == 0)
13695             ret = XML_ERR_INTERNAL_ERROR;
13696         else
13697             ret = (xmlParserErrors)ctxt->errNo;
13698     } else {
13699       ret = XML_ERR_OK;
13700     }
13701
13702     if ((lst != NULL) && (ret == XML_ERR_OK)) {
13703         xmlNodePtr cur;
13704
13705         /*
13706          * Return the newly created nodeset after unlinking it from
13707          * they pseudo parent.
13708          */
13709         cur = ctxt->myDoc->children->children;
13710         *lst = cur;
13711         while (cur != NULL) {
13712 #ifdef LIBXML_VALID_ENABLED
13713             if ((oldctxt->validate) && (oldctxt->wellFormed) &&
13714                 (oldctxt->myDoc) && (oldctxt->myDoc->intSubset) &&
13715                 (cur->type == XML_ELEMENT_NODE)) {
13716                 oldctxt->valid &= xmlValidateElement(&oldctxt->vctxt,
13717                         oldctxt->myDoc, cur);
13718             }
13719 #endif /* LIBXML_VALID_ENABLED */
13720             cur->parent = NULL;
13721             cur = cur->next;
13722         }
13723         ctxt->myDoc->children->children = NULL;
13724     }
13725     if (ctxt->myDoc != NULL) {
13726         xmlFreeNode(ctxt->myDoc->children);
13727         ctxt->myDoc->children = content;
13728         ctxt->myDoc->last = last;
13729     }
13730
13731     /*
13732      * Record in the parent context the number of entities replacement
13733      * done when parsing that reference.
13734      */
13735     if (oldctxt != NULL)
13736         oldctxt->nbentities += ctxt->nbentities;
13737
13738     /*
13739      * Also record the last error if any
13740      */
13741     if (ctxt->lastError.code != XML_ERR_OK)
13742         xmlCopyError(&ctxt->lastError, &oldctxt->lastError);
13743
13744     ctxt->sax = oldsax;
13745     ctxt->dict = NULL;
13746     ctxt->attsDefault = NULL;
13747     ctxt->attsSpecial = NULL;
13748     xmlFreeParserCtxt(ctxt);
13749     if (newDoc != NULL) {
13750         xmlFreeDoc(newDoc);
13751     }
13752
13753     return(ret);
13754 }
13755
13756 /**
13757  * xmlParseInNodeContext:
13758  * @node:  the context node
13759  * @data:  the input string
13760  * @datalen:  the input string length in bytes
13761  * @options:  a combination of xmlParserOption
13762  * @lst:  the return value for the set of parsed nodes
13763  *
13764  * Parse a well-balanced chunk of an XML document
13765  * within the context (DTD, namespaces, etc ...) of the given node.
13766  *
13767  * The allowed sequence for the data is a Well Balanced Chunk defined by
13768  * the content production in the XML grammar:
13769  *
13770  * [43] content ::= (element | CharData | Reference | CDSect | PI | Comment)*
13771  *
13772  * Returns XML_ERR_OK if the chunk is well balanced, and the parser
13773  * error code otherwise
13774  */
13775 xmlParserErrors
13776 xmlParseInNodeContext(xmlNodePtr node, const char *data, int datalen,
13777                       int options, xmlNodePtr *lst) {
13778 #ifdef SAX2
13779     xmlParserCtxtPtr ctxt;
13780     xmlDocPtr doc = NULL;
13781     xmlNodePtr fake, cur;
13782     int nsnr = 0;
13783
13784     xmlParserErrors ret = XML_ERR_OK;
13785
13786     /*
13787      * check all input parameters, grab the document
13788      */
13789     if ((lst == NULL) || (node == NULL) || (data == NULL) || (datalen < 0))
13790         return(XML_ERR_INTERNAL_ERROR);
13791     switch (node->type) {
13792         case XML_ELEMENT_NODE:
13793         case XML_ATTRIBUTE_NODE:
13794         case XML_TEXT_NODE:
13795         case XML_CDATA_SECTION_NODE:
13796         case XML_ENTITY_REF_NODE:
13797         case XML_PI_NODE:
13798         case XML_COMMENT_NODE:
13799         case XML_DOCUMENT_NODE:
13800         case XML_HTML_DOCUMENT_NODE:
13801             break;
13802         default:
13803             return(XML_ERR_INTERNAL_ERROR);
13804
13805     }
13806     while ((node != NULL) && (node->type != XML_ELEMENT_NODE) &&
13807            (node->type != XML_DOCUMENT_NODE) &&
13808            (node->type != XML_HTML_DOCUMENT_NODE))
13809         node = node->parent;
13810     if (node == NULL)
13811         return(XML_ERR_INTERNAL_ERROR);
13812     if (node->type == XML_ELEMENT_NODE)
13813         doc = node->doc;
13814     else
13815         doc = (xmlDocPtr) node;
13816     if (doc == NULL)
13817         return(XML_ERR_INTERNAL_ERROR);
13818
13819     /*
13820      * allocate a context and set-up everything not related to the
13821      * node position in the tree
13822      */
13823     if (doc->type == XML_DOCUMENT_NODE)
13824         ctxt = xmlCreateMemoryParserCtxt((char *) data, datalen);
13825 #ifdef LIBXML_HTML_ENABLED
13826     else if (doc->type == XML_HTML_DOCUMENT_NODE) {
13827         ctxt = htmlCreateMemoryParserCtxt((char *) data, datalen);
13828         /*
13829          * When parsing in context, it makes no sense to add implied
13830          * elements like html/body/etc...
13831          */
13832         options |= HTML_PARSE_NOIMPLIED;
13833     }
13834 #endif
13835     else
13836         return(XML_ERR_INTERNAL_ERROR);
13837
13838     if (ctxt == NULL)
13839         return(XML_ERR_NO_MEMORY);
13840
13841     /*
13842      * Use input doc's dict if present, else assure XML_PARSE_NODICT is set.
13843      * We need a dictionary for xmlDetectSAX2, so if there's no doc dict
13844      * we must wait until the last moment to free the original one.
13845      */
13846     if (doc->dict != NULL) {
13847         if (ctxt->dict != NULL)
13848             xmlDictFree(ctxt->dict);
13849         ctxt->dict = doc->dict;
13850     } else
13851         options |= XML_PARSE_NODICT;
13852
13853     if (doc->encoding != NULL) {
13854         xmlCharEncodingHandlerPtr hdlr;
13855
13856         if (ctxt->encoding != NULL)
13857             xmlFree((xmlChar *) ctxt->encoding);
13858         ctxt->encoding = xmlStrdup((const xmlChar *) doc->encoding);
13859
13860         hdlr = xmlFindCharEncodingHandler((const char *) doc->encoding);
13861         if (hdlr != NULL) {
13862             xmlSwitchToEncoding(ctxt, hdlr);
13863         } else {
13864             return(XML_ERR_UNSUPPORTED_ENCODING);
13865         }
13866     }
13867
13868     xmlCtxtUseOptionsInternal(ctxt, options, NULL);
13869     xmlDetectSAX2(ctxt);
13870     ctxt->myDoc = doc;
13871     /* parsing in context, i.e. as within existing content */
13872     ctxt->instate = XML_PARSER_CONTENT;
13873
13874     fake = xmlNewComment(NULL);
13875     if (fake == NULL) {
13876         xmlFreeParserCtxt(ctxt);
13877         return(XML_ERR_NO_MEMORY);
13878     }
13879     xmlAddChild(node, fake);
13880
13881     if (node->type == XML_ELEMENT_NODE) {
13882         nodePush(ctxt, node);
13883         /*
13884          * initialize the SAX2 namespaces stack
13885          */
13886         cur = node;
13887         while ((cur != NULL) && (cur->type == XML_ELEMENT_NODE)) {
13888             xmlNsPtr ns = cur->nsDef;
13889             const xmlChar *iprefix, *ihref;
13890
13891             while (ns != NULL) {
13892                 if (ctxt->dict) {
13893                     iprefix = xmlDictLookup(ctxt->dict, ns->prefix, -1);
13894                     ihref = xmlDictLookup(ctxt->dict, ns->href, -1);
13895                 } else {
13896                     iprefix = ns->prefix;
13897                     ihref = ns->href;
13898                 }
13899
13900                 if (xmlGetNamespace(ctxt, iprefix) == NULL) {
13901                     nsPush(ctxt, iprefix, ihref);
13902                     nsnr++;
13903                 }
13904                 ns = ns->next;
13905             }
13906             cur = cur->parent;
13907         }
13908     }
13909
13910     if ((ctxt->validate) || (ctxt->replaceEntities != 0)) {
13911         /*
13912          * ID/IDREF registration will be done in xmlValidateElement below
13913          */
13914         ctxt->loadsubset |= XML_SKIP_IDS;
13915     }
13916
13917 #ifdef LIBXML_HTML_ENABLED
13918     if (doc->type == XML_HTML_DOCUMENT_NODE)
13919         __htmlParseContent(ctxt);
13920     else
13921 #endif
13922         xmlParseContent(ctxt);
13923
13924     nsPop(ctxt, nsnr);
13925     if ((RAW == '<') && (NXT(1) == '/')) {
13926         xmlFatalErr(ctxt, XML_ERR_NOT_WELL_BALANCED, NULL);
13927     } else if (RAW != 0) {
13928         xmlFatalErr(ctxt, XML_ERR_EXTRA_CONTENT, NULL);
13929     }
13930     if ((ctxt->node != NULL) && (ctxt->node != node)) {
13931         xmlFatalErr(ctxt, XML_ERR_NOT_WELL_BALANCED, NULL);
13932         ctxt->wellFormed = 0;
13933     }
13934
13935     if (!ctxt->wellFormed) {
13936         if (ctxt->errNo == 0)
13937             ret = XML_ERR_INTERNAL_ERROR;
13938         else
13939             ret = (xmlParserErrors)ctxt->errNo;
13940     } else {
13941         ret = XML_ERR_OK;
13942     }
13943
13944     /*
13945      * Return the newly created nodeset after unlinking it from
13946      * the pseudo sibling.
13947      */
13948
13949     cur = fake->next;
13950     fake->next = NULL;
13951     node->last = fake;
13952
13953     if (cur != NULL) {
13954         cur->prev = NULL;
13955     }
13956
13957     *lst = cur;
13958
13959     while (cur != NULL) {
13960         cur->parent = NULL;
13961         cur = cur->next;
13962     }
13963
13964     xmlUnlinkNode(fake);
13965     xmlFreeNode(fake);
13966
13967
13968     if (ret != XML_ERR_OK) {
13969         xmlFreeNodeList(*lst);
13970         *lst = NULL;
13971     }
13972
13973     if (doc->dict != NULL)
13974         ctxt->dict = NULL;
13975     xmlFreeParserCtxt(ctxt);
13976
13977     return(ret);
13978 #else /* !SAX2 */
13979     return(XML_ERR_INTERNAL_ERROR);
13980 #endif
13981 }
13982
13983 #ifdef LIBXML_SAX1_ENABLED
13984 /**
13985  * xmlParseBalancedChunkMemoryRecover:
13986  * @doc:  the document the chunk pertains to
13987  * @sax:  the SAX handler bloc (possibly NULL)
13988  * @user_data:  The user data returned on SAX callbacks (possibly NULL)
13989  * @depth:  Used for loop detection, use 0
13990  * @string:  the input string in UTF8 or ISO-Latin (zero terminated)
13991  * @lst:  the return value for the set of parsed nodes
13992  * @recover: return nodes even if the data is broken (use 0)
13993  *
13994  *
13995  * Parse a well-balanced chunk of an XML document
13996  * called by the parser
13997  * The allowed sequence for the Well Balanced Chunk is the one defined by
13998  * the content production in the XML grammar:
13999  *
14000  * [43] content ::= (element | CharData | Reference | CDSect | PI | Comment)*
14001  *
14002  * Returns 0 if the chunk is well balanced, -1 in case of args problem and
14003  *    the parser error code otherwise
14004  *
14005  * In case recover is set to 1, the nodelist will not be empty even if
14006  * the parsed chunk is not well balanced, assuming the parsing succeeded to
14007  * some extent.
14008  */
14009 int
14010 xmlParseBalancedChunkMemoryRecover(xmlDocPtr doc, xmlSAXHandlerPtr sax,
14011      void *user_data, int depth, const xmlChar *string, xmlNodePtr *lst,
14012      int recover) {
14013     xmlParserCtxtPtr ctxt;
14014     xmlDocPtr newDoc;
14015     xmlSAXHandlerPtr oldsax = NULL;
14016     xmlNodePtr content, newRoot;
14017     int size;
14018     int ret = 0;
14019
14020     if (depth > 40) {
14021         return(XML_ERR_ENTITY_LOOP);
14022     }
14023
14024
14025     if (lst != NULL)
14026         *lst = NULL;
14027     if (string == NULL)
14028         return(-1);
14029
14030     size = xmlStrlen(string);
14031
14032     ctxt = xmlCreateMemoryParserCtxt((char *) string, size);
14033     if (ctxt == NULL) return(-1);
14034     ctxt->userData = ctxt;
14035     if (sax != NULL) {
14036         oldsax = ctxt->sax;
14037         ctxt->sax = sax;
14038         if (user_data != NULL)
14039             ctxt->userData = user_data;
14040     }
14041     newDoc = xmlNewDoc(BAD_CAST "1.0");
14042     if (newDoc == NULL) {
14043         xmlFreeParserCtxt(ctxt);
14044         return(-1);
14045     }
14046     newDoc->properties = XML_DOC_INTERNAL;
14047     if ((doc != NULL) && (doc->dict != NULL)) {
14048         xmlDictFree(ctxt->dict);
14049         ctxt->dict = doc->dict;
14050         xmlDictReference(ctxt->dict);
14051         ctxt->str_xml = xmlDictLookup(ctxt->dict, BAD_CAST "xml", 3);
14052         ctxt->str_xmlns = xmlDictLookup(ctxt->dict, BAD_CAST "xmlns", 5);
14053         ctxt->str_xml_ns = xmlDictLookup(ctxt->dict, XML_XML_NAMESPACE, 36);
14054         ctxt->dictNames = 1;
14055     } else {
14056         xmlCtxtUseOptionsInternal(ctxt, XML_PARSE_NODICT, NULL);
14057     }
14058     if (doc != NULL) {
14059         newDoc->intSubset = doc->intSubset;
14060         newDoc->extSubset = doc->extSubset;
14061     }
14062     newRoot = xmlNewDocNode(newDoc, NULL, BAD_CAST "pseudoroot", NULL);
14063     if (newRoot == NULL) {
14064         if (sax != NULL)
14065             ctxt->sax = oldsax;
14066         xmlFreeParserCtxt(ctxt);
14067         newDoc->intSubset = NULL;
14068         newDoc->extSubset = NULL;
14069         xmlFreeDoc(newDoc);
14070         return(-1);
14071     }
14072     xmlAddChild((xmlNodePtr) newDoc, newRoot);
14073     nodePush(ctxt, newRoot);
14074     if (doc == NULL) {
14075         ctxt->myDoc = newDoc;
14076     } else {
14077         ctxt->myDoc = newDoc;
14078         newDoc->children->doc = doc;
14079         /* Ensure that doc has XML spec namespace */
14080         xmlSearchNsByHref(doc, (xmlNodePtr)doc, XML_XML_NAMESPACE);
14081         newDoc->oldNs = doc->oldNs;
14082     }
14083     ctxt->instate = XML_PARSER_CONTENT;
14084     ctxt->depth = depth;
14085
14086     /*
14087      * Doing validity checking on chunk doesn't make sense
14088      */
14089     ctxt->validate = 0;
14090     ctxt->loadsubset = 0;
14091     xmlDetectSAX2(ctxt);
14092
14093     if ( doc != NULL ){
14094         content = doc->children;
14095         doc->children = NULL;
14096         xmlParseContent(ctxt);
14097         doc->children = content;
14098     }
14099     else {
14100         xmlParseContent(ctxt);
14101     }
14102     if ((RAW == '<') && (NXT(1) == '/')) {
14103         xmlFatalErr(ctxt, XML_ERR_NOT_WELL_BALANCED, NULL);
14104     } else if (RAW != 0) {
14105         xmlFatalErr(ctxt, XML_ERR_EXTRA_CONTENT, NULL);
14106     }
14107     if (ctxt->node != newDoc->children) {
14108         xmlFatalErr(ctxt, XML_ERR_NOT_WELL_BALANCED, NULL);
14109     }
14110
14111     if (!ctxt->wellFormed) {
14112         if (ctxt->errNo == 0)
14113             ret = 1;
14114         else
14115             ret = ctxt->errNo;
14116     } else {
14117       ret = 0;
14118     }
14119
14120     if ((lst != NULL) && ((ret == 0) || (recover == 1))) {
14121         xmlNodePtr cur;
14122
14123         /*
14124          * Return the newly created nodeset after unlinking it from
14125          * they pseudo parent.
14126          */
14127         cur = newDoc->children->children;
14128         *lst = cur;
14129         while (cur != NULL) {
14130             xmlSetTreeDoc(cur, doc);
14131             cur->parent = NULL;
14132             cur = cur->next;
14133         }
14134         newDoc->children->children = NULL;
14135     }
14136
14137     if (sax != NULL)
14138         ctxt->sax = oldsax;
14139     xmlFreeParserCtxt(ctxt);
14140     newDoc->intSubset = NULL;
14141     newDoc->extSubset = NULL;
14142     newDoc->oldNs = NULL;
14143     xmlFreeDoc(newDoc);
14144
14145     return(ret);
14146 }
14147
14148 /**
14149  * xmlSAXParseEntity:
14150  * @sax:  the SAX handler block
14151  * @filename:  the filename
14152  *
14153  * parse an XML external entity out of context and build a tree.
14154  * It use the given SAX function block to handle the parsing callback.
14155  * If sax is NULL, fallback to the default DOM tree building routines.
14156  *
14157  * [78] extParsedEnt ::= TextDecl? content
14158  *
14159  * This correspond to a "Well Balanced" chunk
14160  *
14161  * Returns the resulting document tree
14162  */
14163
14164 xmlDocPtr
14165 xmlSAXParseEntity(xmlSAXHandlerPtr sax, const char *filename) {
14166     xmlDocPtr ret;
14167     xmlParserCtxtPtr ctxt;
14168
14169     ctxt = xmlCreateFileParserCtxt(filename);
14170     if (ctxt == NULL) {
14171         return(NULL);
14172     }
14173     if (sax != NULL) {
14174         if (ctxt->sax != NULL)
14175             xmlFree(ctxt->sax);
14176         ctxt->sax = sax;
14177         ctxt->userData = NULL;
14178     }
14179
14180     xmlParseExtParsedEnt(ctxt);
14181
14182     if (ctxt->wellFormed)
14183         ret = ctxt->myDoc;
14184     else {
14185         ret = NULL;
14186         xmlFreeDoc(ctxt->myDoc);
14187         ctxt->myDoc = NULL;
14188     }
14189     if (sax != NULL)
14190         ctxt->sax = NULL;
14191     xmlFreeParserCtxt(ctxt);
14192
14193     return(ret);
14194 }
14195
14196 /**
14197  * xmlParseEntity:
14198  * @filename:  the filename
14199  *
14200  * parse an XML external entity out of context and build a tree.
14201  *
14202  * [78] extParsedEnt ::= TextDecl? content
14203  *
14204  * This correspond to a "Well Balanced" chunk
14205  *
14206  * Returns the resulting document tree
14207  */
14208
14209 xmlDocPtr
14210 xmlParseEntity(const char *filename) {
14211     return(xmlSAXParseEntity(NULL, filename));
14212 }
14213 #endif /* LIBXML_SAX1_ENABLED */
14214
14215 /**
14216  * xmlCreateEntityParserCtxtInternal:
14217  * @URL:  the entity URL
14218  * @ID:  the entity PUBLIC ID
14219  * @base:  a possible base for the target URI
14220  * @pctx:  parser context used to set options on new context
14221  *
14222  * Create a parser context for an external entity
14223  * Automatic support for ZLIB/Compress compressed document is provided
14224  * by default if found at compile-time.
14225  *
14226  * Returns the new parser context or NULL
14227  */
14228 static xmlParserCtxtPtr
14229 xmlCreateEntityParserCtxtInternal(const xmlChar *URL, const xmlChar *ID,
14230                           const xmlChar *base, xmlParserCtxtPtr pctx) {
14231     xmlParserCtxtPtr ctxt;
14232     xmlParserInputPtr inputStream;
14233     char *directory = NULL;
14234     xmlChar *uri;
14235
14236     ctxt = xmlNewParserCtxt();
14237     if (ctxt == NULL) {
14238         return(NULL);
14239     }
14240
14241     if (pctx != NULL) {
14242         ctxt->options = pctx->options;
14243         ctxt->_private = pctx->_private;
14244     }
14245
14246     uri = xmlBuildURI(URL, base);
14247
14248     if (uri == NULL) {
14249         inputStream = xmlLoadExternalEntity((char *)URL, (char *)ID, ctxt);
14250         if (inputStream == NULL) {
14251             xmlFreeParserCtxt(ctxt);
14252             return(NULL);
14253         }
14254
14255         inputPush(ctxt, inputStream);
14256
14257         if ((ctxt->directory == NULL) && (directory == NULL))
14258             directory = xmlParserGetDirectory((char *)URL);
14259         if ((ctxt->directory == NULL) && (directory != NULL))
14260             ctxt->directory = directory;
14261     } else {
14262         inputStream = xmlLoadExternalEntity((char *)uri, (char *)ID, ctxt);
14263         if (inputStream == NULL) {
14264             xmlFree(uri);
14265             xmlFreeParserCtxt(ctxt);
14266             return(NULL);
14267         }
14268
14269         inputPush(ctxt, inputStream);
14270
14271         if ((ctxt->directory == NULL) && (directory == NULL))
14272             directory = xmlParserGetDirectory((char *)uri);
14273         if ((ctxt->directory == NULL) && (directory != NULL))
14274             ctxt->directory = directory;
14275         xmlFree(uri);
14276     }
14277     return(ctxt);
14278 }
14279
14280 /**
14281  * xmlCreateEntityParserCtxt:
14282  * @URL:  the entity URL
14283  * @ID:  the entity PUBLIC ID
14284  * @base:  a possible base for the target URI
14285  *
14286  * Create a parser context for an external entity
14287  * Automatic support for ZLIB/Compress compressed document is provided
14288  * by default if found at compile-time.
14289  *
14290  * Returns the new parser context or NULL
14291  */
14292 xmlParserCtxtPtr
14293 xmlCreateEntityParserCtxt(const xmlChar *URL, const xmlChar *ID,
14294                           const xmlChar *base) {
14295     return xmlCreateEntityParserCtxtInternal(URL, ID, base, NULL);
14296
14297 }
14298
14299 /************************************************************************
14300  *                                                                      *
14301  *              Front ends when parsing from a file                     *
14302  *                                                                      *
14303  ************************************************************************/
14304
14305 /**
14306  * xmlCreateURLParserCtxt:
14307  * @filename:  the filename or URL
14308  * @options:  a combination of xmlParserOption
14309  *
14310  * Create a parser context for a file or URL content.
14311  * Automatic support for ZLIB/Compress compressed document is provided
14312  * by default if found at compile-time and for file accesses
14313  *
14314  * Returns the new parser context or NULL
14315  */
14316 xmlParserCtxtPtr
14317 xmlCreateURLParserCtxt(const char *filename, int options)
14318 {
14319     xmlParserCtxtPtr ctxt;
14320     xmlParserInputPtr inputStream;
14321     char *directory = NULL;
14322
14323     ctxt = xmlNewParserCtxt();
14324     if (ctxt == NULL) {
14325         xmlErrMemory(NULL, "cannot allocate parser context");
14326         return(NULL);
14327     }
14328
14329     if (options)
14330         xmlCtxtUseOptionsInternal(ctxt, options, NULL);
14331     ctxt->linenumbers = 1;
14332
14333     inputStream = xmlLoadExternalEntity(filename, NULL, ctxt);
14334     if (inputStream == NULL) {
14335         xmlFreeParserCtxt(ctxt);
14336         return(NULL);
14337     }
14338
14339     inputPush(ctxt, inputStream);
14340     if ((ctxt->directory == NULL) && (directory == NULL))
14341         directory = xmlParserGetDirectory(filename);
14342     if ((ctxt->directory == NULL) && (directory != NULL))
14343         ctxt->directory = directory;
14344
14345     return(ctxt);
14346 }
14347
14348 /**
14349  * xmlCreateFileParserCtxt:
14350  * @filename:  the filename
14351  *
14352  * Create a parser context for a file content.
14353  * Automatic support for ZLIB/Compress compressed document is provided
14354  * by default if found at compile-time.
14355  *
14356  * Returns the new parser context or NULL
14357  */
14358 xmlParserCtxtPtr
14359 xmlCreateFileParserCtxt(const char *filename)
14360 {
14361     return(xmlCreateURLParserCtxt(filename, 0));
14362 }
14363
14364 #ifdef LIBXML_SAX1_ENABLED
14365 /**
14366  * xmlSAXParseFileWithData:
14367  * @sax:  the SAX handler block
14368  * @filename:  the filename
14369  * @recovery:  work in recovery mode, i.e. tries to read no Well Formed
14370  *             documents
14371  * @data:  the userdata
14372  *
14373  * parse an XML file and build a tree. Automatic support for ZLIB/Compress
14374  * compressed document is provided by default if found at compile-time.
14375  * It use the given SAX function block to handle the parsing callback.
14376  * If sax is NULL, fallback to the default DOM tree building routines.
14377  *
14378  * User data (void *) is stored within the parser context in the
14379  * context's _private member, so it is available nearly everywhere in libxml
14380  *
14381  * Returns the resulting document tree
14382  */
14383
14384 xmlDocPtr
14385 xmlSAXParseFileWithData(xmlSAXHandlerPtr sax, const char *filename,
14386                         int recovery, void *data) {
14387     xmlDocPtr ret;
14388     xmlParserCtxtPtr ctxt;
14389
14390     xmlInitParser();
14391
14392     ctxt = xmlCreateFileParserCtxt(filename);
14393     if (ctxt == NULL) {
14394         return(NULL);
14395     }
14396     if (sax != NULL) {
14397         if (ctxt->sax != NULL)
14398             xmlFree(ctxt->sax);
14399         ctxt->sax = sax;
14400     }
14401     xmlDetectSAX2(ctxt);
14402     if (data!=NULL) {
14403         ctxt->_private = data;
14404     }
14405
14406     if (ctxt->directory == NULL)
14407         ctxt->directory = xmlParserGetDirectory(filename);
14408
14409     ctxt->recovery = recovery;
14410
14411     xmlParseDocument(ctxt);
14412
14413     if ((ctxt->wellFormed) || recovery) {
14414         ret = ctxt->myDoc;
14415         if (ret != NULL) {
14416             if (ctxt->input->buf->compressed > 0)
14417                 ret->compression = 9;
14418             else
14419                 ret->compression = ctxt->input->buf->compressed;
14420         }
14421     }
14422     else {
14423        ret = NULL;
14424        xmlFreeDoc(ctxt->myDoc);
14425        ctxt->myDoc = NULL;
14426     }
14427     if (sax != NULL)
14428         ctxt->sax = NULL;
14429     xmlFreeParserCtxt(ctxt);
14430
14431     return(ret);
14432 }
14433
14434 /**
14435  * xmlSAXParseFile:
14436  * @sax:  the SAX handler block
14437  * @filename:  the filename
14438  * @recovery:  work in recovery mode, i.e. tries to read no Well Formed
14439  *             documents
14440  *
14441  * parse an XML file and build a tree. Automatic support for ZLIB/Compress
14442  * compressed document is provided by default if found at compile-time.
14443  * It use the given SAX function block to handle the parsing callback.
14444  * If sax is NULL, fallback to the default DOM tree building routines.
14445  *
14446  * Returns the resulting document tree
14447  */
14448
14449 xmlDocPtr
14450 xmlSAXParseFile(xmlSAXHandlerPtr sax, const char *filename,
14451                           int recovery) {
14452     return(xmlSAXParseFileWithData(sax,filename,recovery,NULL));
14453 }
14454
14455 /**
14456  * xmlRecoverDoc:
14457  * @cur:  a pointer to an array of xmlChar
14458  *
14459  * parse an XML in-memory document and build a tree.
14460  * In the case the document is not Well Formed, a attempt to build a
14461  * tree is tried anyway
14462  *
14463  * Returns the resulting document tree or NULL in case of failure
14464  */
14465
14466 xmlDocPtr
14467 xmlRecoverDoc(const xmlChar *cur) {
14468     return(xmlSAXParseDoc(NULL, cur, 1));
14469 }
14470
14471 /**
14472  * xmlParseFile:
14473  * @filename:  the filename
14474  *
14475  * parse an XML file and build a tree. Automatic support for ZLIB/Compress
14476  * compressed document is provided by default if found at compile-time.
14477  *
14478  * Returns the resulting document tree if the file was wellformed,
14479  * NULL otherwise.
14480  */
14481
14482 xmlDocPtr
14483 xmlParseFile(const char *filename) {
14484     return(xmlSAXParseFile(NULL, filename, 0));
14485 }
14486
14487 /**
14488  * xmlRecoverFile:
14489  * @filename:  the filename
14490  *
14491  * parse an XML file and build a tree. Automatic support for ZLIB/Compress
14492  * compressed document is provided by default if found at compile-time.
14493  * In the case the document is not Well Formed, it attempts to build
14494  * a tree anyway
14495  *
14496  * Returns the resulting document tree or NULL in case of failure
14497  */
14498
14499 xmlDocPtr
14500 xmlRecoverFile(const char *filename) {
14501     return(xmlSAXParseFile(NULL, filename, 1));
14502 }
14503
14504
14505 /**
14506  * xmlSetupParserForBuffer:
14507  * @ctxt:  an XML parser context
14508  * @buffer:  a xmlChar * buffer
14509  * @filename:  a file name
14510  *
14511  * Setup the parser context to parse a new buffer; Clears any prior
14512  * contents from the parser context. The buffer parameter must not be
14513  * NULL, but the filename parameter can be
14514  */
14515 void
14516 xmlSetupParserForBuffer(xmlParserCtxtPtr ctxt, const xmlChar* buffer,
14517                              const char* filename)
14518 {
14519     xmlParserInputPtr input;
14520
14521     if ((ctxt == NULL) || (buffer == NULL))
14522         return;
14523
14524     input = xmlNewInputStream(ctxt);
14525     if (input == NULL) {
14526         xmlErrMemory(NULL, "parsing new buffer: out of memory\n");
14527         xmlClearParserCtxt(ctxt);
14528         return;
14529     }
14530
14531     xmlClearParserCtxt(ctxt);
14532     if (filename != NULL)
14533         input->filename = (char *) xmlCanonicPath((const xmlChar *)filename);
14534     input->base = buffer;
14535     input->cur = buffer;
14536     input->end = &buffer[xmlStrlen(buffer)];
14537     inputPush(ctxt, input);
14538 }
14539
14540 /**
14541  * xmlSAXUserParseFile:
14542  * @sax:  a SAX handler
14543  * @user_data:  The user data returned on SAX callbacks
14544  * @filename:  a file name
14545  *
14546  * parse an XML file and call the given SAX handler routines.
14547  * Automatic support for ZLIB/Compress compressed document is provided
14548  *
14549  * Returns 0 in case of success or a error number otherwise
14550  */
14551 int
14552 xmlSAXUserParseFile(xmlSAXHandlerPtr sax, void *user_data,
14553                     const char *filename) {
14554     int ret = 0;
14555     xmlParserCtxtPtr ctxt;
14556
14557     ctxt = xmlCreateFileParserCtxt(filename);
14558     if (ctxt == NULL) return -1;
14559     if (ctxt->sax != (xmlSAXHandlerPtr) &xmlDefaultSAXHandler)
14560         xmlFree(ctxt->sax);
14561     ctxt->sax = sax;
14562     xmlDetectSAX2(ctxt);
14563
14564     if (user_data != NULL)
14565         ctxt->userData = user_data;
14566
14567     xmlParseDocument(ctxt);
14568
14569     if (ctxt->wellFormed)
14570         ret = 0;
14571     else {
14572         if (ctxt->errNo != 0)
14573             ret = ctxt->errNo;
14574         else
14575             ret = -1;
14576     }
14577     if (sax != NULL)
14578         ctxt->sax = NULL;
14579     if (ctxt->myDoc != NULL) {
14580         xmlFreeDoc(ctxt->myDoc);
14581         ctxt->myDoc = NULL;
14582     }
14583     xmlFreeParserCtxt(ctxt);
14584
14585     return ret;
14586 }
14587 #endif /* LIBXML_SAX1_ENABLED */
14588
14589 /************************************************************************
14590  *                                                                      *
14591  *              Front ends when parsing from memory                     *
14592  *                                                                      *
14593  ************************************************************************/
14594
14595 /**
14596  * xmlCreateMemoryParserCtxt:
14597  * @buffer:  a pointer to a char array
14598  * @size:  the size of the array
14599  *
14600  * Create a parser context for an XML in-memory document.
14601  *
14602  * Returns the new parser context or NULL
14603  */
14604 xmlParserCtxtPtr
14605 xmlCreateMemoryParserCtxt(const char *buffer, int size) {
14606     xmlParserCtxtPtr ctxt;
14607     xmlParserInputPtr input;
14608     xmlParserInputBufferPtr buf;
14609
14610     if (buffer == NULL)
14611         return(NULL);
14612     if (size <= 0)
14613         return(NULL);
14614
14615     ctxt = xmlNewParserCtxt();
14616     if (ctxt == NULL)
14617         return(NULL);
14618
14619     /* TODO: xmlParserInputBufferCreateStatic, requires some serious changes */
14620     buf = xmlParserInputBufferCreateMem(buffer, size, XML_CHAR_ENCODING_NONE);
14621     if (buf == NULL) {
14622         xmlFreeParserCtxt(ctxt);
14623         return(NULL);
14624     }
14625
14626     input = xmlNewInputStream(ctxt);
14627     if (input == NULL) {
14628         xmlFreeParserInputBuffer(buf);
14629         xmlFreeParserCtxt(ctxt);
14630         return(NULL);
14631     }
14632
14633     input->filename = NULL;
14634     input->buf = buf;
14635     xmlBufResetInput(input->buf->buffer, input);
14636
14637     inputPush(ctxt, input);
14638     return(ctxt);
14639 }
14640
14641 #ifdef LIBXML_SAX1_ENABLED
14642 /**
14643  * xmlSAXParseMemoryWithData:
14644  * @sax:  the SAX handler block
14645  * @buffer:  an pointer to a char array
14646  * @size:  the size of the array
14647  * @recovery:  work in recovery mode, i.e. tries to read no Well Formed
14648  *             documents
14649  * @data:  the userdata
14650  *
14651  * parse an XML in-memory block and use the given SAX function block
14652  * to handle the parsing callback. If sax is NULL, fallback to the default
14653  * DOM tree building routines.
14654  *
14655  * User data (void *) is stored within the parser context in the
14656  * context's _private member, so it is available nearly everywhere in libxml
14657  *
14658  * Returns the resulting document tree
14659  */
14660
14661 xmlDocPtr
14662 xmlSAXParseMemoryWithData(xmlSAXHandlerPtr sax, const char *buffer,
14663                   int size, int recovery, void *data) {
14664     xmlDocPtr ret;
14665     xmlParserCtxtPtr ctxt;
14666
14667     xmlInitParser();
14668
14669     ctxt = xmlCreateMemoryParserCtxt(buffer, size);
14670     if (ctxt == NULL) return(NULL);
14671     if (sax != NULL) {
14672         if (ctxt->sax != NULL)
14673             xmlFree(ctxt->sax);
14674         ctxt->sax = sax;
14675     }
14676     xmlDetectSAX2(ctxt);
14677     if (data!=NULL) {
14678         ctxt->_private=data;
14679     }
14680
14681     ctxt->recovery = recovery;
14682
14683     xmlParseDocument(ctxt);
14684
14685     if ((ctxt->wellFormed) || recovery) ret = ctxt->myDoc;
14686     else {
14687        ret = NULL;
14688        xmlFreeDoc(ctxt->myDoc);
14689        ctxt->myDoc = NULL;
14690     }
14691     if (sax != NULL)
14692         ctxt->sax = NULL;
14693     xmlFreeParserCtxt(ctxt);
14694
14695     return(ret);
14696 }
14697
14698 /**
14699  * xmlSAXParseMemory:
14700  * @sax:  the SAX handler block
14701  * @buffer:  an pointer to a char array
14702  * @size:  the size of the array
14703  * @recovery:  work in recovery mode, i.e. tries to read not Well Formed
14704  *             documents
14705  *
14706  * parse an XML in-memory block and use the given SAX function block
14707  * to handle the parsing callback. If sax is NULL, fallback to the default
14708  * DOM tree building routines.
14709  *
14710  * Returns the resulting document tree
14711  */
14712 xmlDocPtr
14713 xmlSAXParseMemory(xmlSAXHandlerPtr sax, const char *buffer,
14714                   int size, int recovery) {
14715     return xmlSAXParseMemoryWithData(sax, buffer, size, recovery, NULL);
14716 }
14717
14718 /**
14719  * xmlParseMemory:
14720  * @buffer:  an pointer to a char array
14721  * @size:  the size of the array
14722  *
14723  * parse an XML in-memory block and build a tree.
14724  *
14725  * Returns the resulting document tree
14726  */
14727
14728 xmlDocPtr xmlParseMemory(const char *buffer, int size) {
14729    return(xmlSAXParseMemory(NULL, buffer, size, 0));
14730 }
14731
14732 /**
14733  * xmlRecoverMemory:
14734  * @buffer:  an pointer to a char array
14735  * @size:  the size of the array
14736  *
14737  * parse an XML in-memory block and build a tree.
14738  * In the case the document is not Well Formed, an attempt to
14739  * build a tree is tried anyway
14740  *
14741  * Returns the resulting document tree or NULL in case of error
14742  */
14743
14744 xmlDocPtr xmlRecoverMemory(const char *buffer, int size) {
14745    return(xmlSAXParseMemory(NULL, buffer, size, 1));
14746 }
14747
14748 /**
14749  * xmlSAXUserParseMemory:
14750  * @sax:  a SAX handler
14751  * @user_data:  The user data returned on SAX callbacks
14752  * @buffer:  an in-memory XML document input
14753  * @size:  the length of the XML document in bytes
14754  *
14755  * A better SAX parsing routine.
14756  * parse an XML in-memory buffer and call the given SAX handler routines.
14757  *
14758  * Returns 0 in case of success or a error number otherwise
14759  */
14760 int xmlSAXUserParseMemory(xmlSAXHandlerPtr sax, void *user_data,
14761                           const char *buffer, int size) {
14762     int ret = 0;
14763     xmlParserCtxtPtr ctxt;
14764
14765     xmlInitParser();
14766
14767     ctxt = xmlCreateMemoryParserCtxt(buffer, size);
14768     if (ctxt == NULL) return -1;
14769     if (ctxt->sax != (xmlSAXHandlerPtr) &xmlDefaultSAXHandler)
14770         xmlFree(ctxt->sax);
14771     ctxt->sax = sax;
14772     xmlDetectSAX2(ctxt);
14773
14774     if (user_data != NULL)
14775         ctxt->userData = user_data;
14776
14777     xmlParseDocument(ctxt);
14778
14779     if (ctxt->wellFormed)
14780         ret = 0;
14781     else {
14782         if (ctxt->errNo != 0)
14783             ret = ctxt->errNo;
14784         else
14785             ret = -1;
14786     }
14787     if (sax != NULL)
14788         ctxt->sax = NULL;
14789     if (ctxt->myDoc != NULL) {
14790         xmlFreeDoc(ctxt->myDoc);
14791         ctxt->myDoc = NULL;
14792     }
14793     xmlFreeParserCtxt(ctxt);
14794
14795     return ret;
14796 }
14797 #endif /* LIBXML_SAX1_ENABLED */
14798
14799 /**
14800  * xmlCreateDocParserCtxt:
14801  * @cur:  a pointer to an array of xmlChar
14802  *
14803  * Creates a parser context for an XML in-memory document.
14804  *
14805  * Returns the new parser context or NULL
14806  */
14807 xmlParserCtxtPtr
14808 xmlCreateDocParserCtxt(const xmlChar *cur) {
14809     int len;
14810
14811     if (cur == NULL)
14812         return(NULL);
14813     len = xmlStrlen(cur);
14814     return(xmlCreateMemoryParserCtxt((const char *)cur, len));
14815 }
14816
14817 #ifdef LIBXML_SAX1_ENABLED
14818 /**
14819  * xmlSAXParseDoc:
14820  * @sax:  the SAX handler block
14821  * @cur:  a pointer to an array of xmlChar
14822  * @recovery:  work in recovery mode, i.e. tries to read no Well Formed
14823  *             documents
14824  *
14825  * parse an XML in-memory document and build a tree.
14826  * It use the given SAX function block to handle the parsing callback.
14827  * If sax is NULL, fallback to the default DOM tree building routines.
14828  *
14829  * Returns the resulting document tree
14830  */
14831
14832 xmlDocPtr
14833 xmlSAXParseDoc(xmlSAXHandlerPtr sax, const xmlChar *cur, int recovery) {
14834     xmlDocPtr ret;
14835     xmlParserCtxtPtr ctxt;
14836     xmlSAXHandlerPtr oldsax = NULL;
14837
14838     if (cur == NULL) return(NULL);
14839
14840
14841     ctxt = xmlCreateDocParserCtxt(cur);
14842     if (ctxt == NULL) return(NULL);
14843     if (sax != NULL) {
14844         oldsax = ctxt->sax;
14845         ctxt->sax = sax;
14846         ctxt->userData = NULL;
14847     }
14848     xmlDetectSAX2(ctxt);
14849
14850     xmlParseDocument(ctxt);
14851     if ((ctxt->wellFormed) || recovery) ret = ctxt->myDoc;
14852     else {
14853        ret = NULL;
14854        xmlFreeDoc(ctxt->myDoc);
14855        ctxt->myDoc = NULL;
14856     }
14857     if (sax != NULL)
14858         ctxt->sax = oldsax;
14859     xmlFreeParserCtxt(ctxt);
14860
14861     return(ret);
14862 }
14863
14864 /**
14865  * xmlParseDoc:
14866  * @cur:  a pointer to an array of xmlChar
14867  *
14868  * parse an XML in-memory document and build a tree.
14869  *
14870  * Returns the resulting document tree
14871  */
14872
14873 xmlDocPtr
14874 xmlParseDoc(const xmlChar *cur) {
14875     return(xmlSAXParseDoc(NULL, cur, 0));
14876 }
14877 #endif /* LIBXML_SAX1_ENABLED */
14878
14879 #ifdef LIBXML_LEGACY_ENABLED
14880 /************************************************************************
14881  *                                                                      *
14882  *      Specific function to keep track of entities references          *
14883  *      and used by the XSLT debugger                                   *
14884  *                                                                      *
14885  ************************************************************************/
14886
14887 static xmlEntityReferenceFunc xmlEntityRefFunc = NULL;
14888
14889 /**
14890  * xmlAddEntityReference:
14891  * @ent : A valid entity
14892  * @firstNode : A valid first node for children of entity
14893  * @lastNode : A valid last node of children entity
14894  *
14895  * Notify of a reference to an entity of type XML_EXTERNAL_GENERAL_PARSED_ENTITY
14896  */
14897 static void
14898 xmlAddEntityReference(xmlEntityPtr ent, xmlNodePtr firstNode,
14899                       xmlNodePtr lastNode)
14900 {
14901     if (xmlEntityRefFunc != NULL) {
14902         (*xmlEntityRefFunc) (ent, firstNode, lastNode);
14903     }
14904 }
14905
14906
14907 /**
14908  * xmlSetEntityReferenceFunc:
14909  * @func: A valid function
14910  *
14911  * Set the function to call call back when a xml reference has been made
14912  */
14913 void
14914 xmlSetEntityReferenceFunc(xmlEntityReferenceFunc func)
14915 {
14916     xmlEntityRefFunc = func;
14917 }
14918 #endif /* LIBXML_LEGACY_ENABLED */
14919
14920 /************************************************************************
14921  *                                                                      *
14922  *                              Miscellaneous                           *
14923  *                                                                      *
14924  ************************************************************************/
14925
14926 #ifdef LIBXML_XPATH_ENABLED
14927 #include <libxml/xpath.h>
14928 #endif
14929
14930 extern void XMLCDECL xmlGenericErrorDefaultFunc(void *ctx, const char *msg, ...);
14931 static int xmlParserInitialized = 0;
14932
14933 /**
14934  * xmlInitParser:
14935  *
14936  * Initialization function for the XML parser.
14937  * This is not reentrant. Call once before processing in case of
14938  * use in multithreaded programs.
14939  */
14940
14941 void
14942 xmlInitParser(void) {
14943     if (xmlParserInitialized != 0)
14944         return;
14945
14946 #ifdef LIBXML_THREAD_ENABLED
14947     __xmlGlobalInitMutexLock();
14948     if (xmlParserInitialized == 0) {
14949 #endif
14950         xmlInitThreads();
14951         xmlInitGlobals();
14952         if ((xmlGenericError == xmlGenericErrorDefaultFunc) ||
14953             (xmlGenericError == NULL))
14954             initGenericErrorDefaultFunc(NULL);
14955         xmlInitMemory();
14956         xmlInitializeDict();
14957         xmlInitCharEncodingHandlers();
14958         xmlDefaultSAXHandlerInit();
14959         xmlRegisterDefaultInputCallbacks();
14960 #ifdef LIBXML_OUTPUT_ENABLED
14961         xmlRegisterDefaultOutputCallbacks();
14962 #endif /* LIBXML_OUTPUT_ENABLED */
14963 #ifdef LIBXML_HTML_ENABLED
14964         htmlInitAutoClose();
14965         htmlDefaultSAXHandlerInit();
14966 #endif
14967 #ifdef LIBXML_XPATH_ENABLED
14968         xmlXPathInit();
14969 #endif
14970         xmlParserInitialized = 1;
14971 #ifdef LIBXML_THREAD_ENABLED
14972     }
14973     __xmlGlobalInitMutexUnlock();
14974 #endif
14975 }
14976
14977 /**
14978  * xmlCleanupParser:
14979  *
14980  * This function name is somewhat misleading. It does not clean up
14981  * parser state, it cleans up memory allocated by the library itself.
14982  * It is a cleanup function for the XML library. It tries to reclaim all
14983  * related global memory allocated for the library processing.
14984  * It doesn't deallocate any document related memory. One should
14985  * call xmlCleanupParser() only when the process has finished using
14986  * the library and all XML/HTML documents built with it.
14987  * See also xmlInitParser() which has the opposite function of preparing
14988  * the library for operations.
14989  *
14990  * WARNING: if your application is multithreaded or has plugin support
14991  *          calling this may crash the application if another thread or
14992  *          a plugin is still using libxml2. It's sometimes very hard to
14993  *          guess if libxml2 is in use in the application, some libraries
14994  *          or plugins may use it without notice. In case of doubt abstain
14995  *          from calling this function or do it just before calling exit()
14996  *          to avoid leak reports from valgrind !
14997  */
14998
14999 void
15000 xmlCleanupParser(void) {
15001     if (!xmlParserInitialized)
15002         return;
15003
15004     xmlCleanupCharEncodingHandlers();
15005 #ifdef LIBXML_CATALOG_ENABLED
15006     xmlCatalogCleanup();
15007 #endif
15008     xmlDictCleanup();
15009     xmlCleanupInputCallbacks();
15010 #ifdef LIBXML_OUTPUT_ENABLED
15011     xmlCleanupOutputCallbacks();
15012 #endif
15013 #ifdef LIBXML_SCHEMAS_ENABLED
15014     xmlSchemaCleanupTypes();
15015     xmlRelaxNGCleanupTypes();
15016 #endif
15017     xmlResetLastError();
15018     xmlCleanupGlobals();
15019     xmlCleanupThreads(); /* must be last if called not from the main thread */
15020     xmlCleanupMemory();
15021     xmlParserInitialized = 0;
15022 }
15023
15024 /************************************************************************
15025  *                                                                      *
15026  *      New set (2.6.0) of simpler and more flexible APIs               *
15027  *                                                                      *
15028  ************************************************************************/
15029
15030 /**
15031  * DICT_FREE:
15032  * @str:  a string
15033  *
15034  * Free a string if it is not owned by the "dict" dictionary in the
15035  * current scope
15036  */
15037 #define DICT_FREE(str)                                          \
15038         if ((str) && ((!dict) ||                                \
15039             (xmlDictOwns(dict, (const xmlChar *)(str)) == 0)))  \
15040             xmlFree((char *)(str));
15041
15042 /**
15043  * xmlCtxtReset:
15044  * @ctxt: an XML parser context
15045  *
15046  * Reset a parser context
15047  */
15048 void
15049 xmlCtxtReset(xmlParserCtxtPtr ctxt)
15050 {
15051     xmlParserInputPtr input;
15052     xmlDictPtr dict;
15053
15054     if (ctxt == NULL)
15055         return;
15056
15057     dict = ctxt->dict;
15058
15059     while ((input = inputPop(ctxt)) != NULL) { /* Non consuming */
15060         xmlFreeInputStream(input);
15061     }
15062     ctxt->inputNr = 0;
15063     ctxt->input = NULL;
15064
15065     ctxt->spaceNr = 0;
15066     if (ctxt->spaceTab != NULL) {
15067         ctxt->spaceTab[0] = -1;
15068         ctxt->space = &ctxt->spaceTab[0];
15069     } else {
15070         ctxt->space = NULL;
15071     }
15072
15073
15074     ctxt->nodeNr = 0;
15075     ctxt->node = NULL;
15076
15077     ctxt->nameNr = 0;
15078     ctxt->name = NULL;
15079
15080     DICT_FREE(ctxt->version);
15081     ctxt->version = NULL;
15082     DICT_FREE(ctxt->encoding);
15083     ctxt->encoding = NULL;
15084     DICT_FREE(ctxt->directory);
15085     ctxt->directory = NULL;
15086     DICT_FREE(ctxt->extSubURI);
15087     ctxt->extSubURI = NULL;
15088     DICT_FREE(ctxt->extSubSystem);
15089     ctxt->extSubSystem = NULL;
15090     if (ctxt->myDoc != NULL)
15091         xmlFreeDoc(ctxt->myDoc);
15092     ctxt->myDoc = NULL;
15093
15094     ctxt->standalone = -1;
15095     ctxt->hasExternalSubset = 0;
15096     ctxt->hasPErefs = 0;
15097     ctxt->html = 0;
15098     ctxt->external = 0;
15099     ctxt->instate = XML_PARSER_START;
15100     ctxt->token = 0;
15101
15102     ctxt->wellFormed = 1;
15103     ctxt->nsWellFormed = 1;
15104     ctxt->disableSAX = 0;
15105     ctxt->valid = 1;
15106 #if 0
15107     ctxt->vctxt.userData = ctxt;
15108     ctxt->vctxt.error = xmlParserValidityError;
15109     ctxt->vctxt.warning = xmlParserValidityWarning;
15110 #endif
15111     ctxt->record_info = 0;
15112     ctxt->nbChars = 0;
15113     ctxt->checkIndex = 0;
15114     ctxt->inSubset = 0;
15115     ctxt->errNo = XML_ERR_OK;
15116     ctxt->depth = 0;
15117     ctxt->charset = XML_CHAR_ENCODING_UTF8;
15118     ctxt->catalogs = NULL;
15119     ctxt->nbentities = 0;
15120     ctxt->sizeentities = 0;
15121     ctxt->sizeentcopy = 0;
15122     xmlInitNodeInfoSeq(&ctxt->node_seq);
15123
15124     if (ctxt->attsDefault != NULL) {
15125         xmlHashFree(ctxt->attsDefault, (xmlHashDeallocator) xmlFree);
15126         ctxt->attsDefault = NULL;
15127     }
15128     if (ctxt->attsSpecial != NULL) {
15129         xmlHashFree(ctxt->attsSpecial, NULL);
15130         ctxt->attsSpecial = NULL;
15131     }
15132
15133 #ifdef LIBXML_CATALOG_ENABLED
15134     if (ctxt->catalogs != NULL)
15135         xmlCatalogFreeLocal(ctxt->catalogs);
15136 #endif
15137     if (ctxt->lastError.code != XML_ERR_OK)
15138         xmlResetError(&ctxt->lastError);
15139 }
15140
15141 /**
15142  * xmlCtxtResetPush:
15143  * @ctxt: an XML parser context
15144  * @chunk:  a pointer to an array of chars
15145  * @size:  number of chars in the array
15146  * @filename:  an optional file name or URI
15147  * @encoding:  the document encoding, or NULL
15148  *
15149  * Reset a push parser context
15150  *
15151  * Returns 0 in case of success and 1 in case of error
15152  */
15153 int
15154 xmlCtxtResetPush(xmlParserCtxtPtr ctxt, const char *chunk,
15155                  int size, const char *filename, const char *encoding)
15156 {
15157     xmlParserInputPtr inputStream;
15158     xmlParserInputBufferPtr buf;
15159     xmlCharEncoding enc = XML_CHAR_ENCODING_NONE;
15160
15161     if (ctxt == NULL)
15162         return(1);
15163
15164     if ((encoding == NULL) && (chunk != NULL) && (size >= 4))
15165         enc = xmlDetectCharEncoding((const xmlChar *) chunk, size);
15166
15167     buf = xmlAllocParserInputBuffer(enc);
15168     if (buf == NULL)
15169         return(1);
15170
15171     if (ctxt == NULL) {
15172         xmlFreeParserInputBuffer(buf);
15173         return(1);
15174     }
15175
15176     xmlCtxtReset(ctxt);
15177
15178     if (ctxt->pushTab == NULL) {
15179         ctxt->pushTab = (void **) xmlMalloc(ctxt->nameMax * 3 *
15180                                             sizeof(xmlChar *));
15181         if (ctxt->pushTab == NULL) {
15182             xmlErrMemory(ctxt, NULL);
15183             xmlFreeParserInputBuffer(buf);
15184             return(1);
15185         }
15186     }
15187
15188     if (filename == NULL) {
15189         ctxt->directory = NULL;
15190     } else {
15191         ctxt->directory = xmlParserGetDirectory(filename);
15192     }
15193
15194     inputStream = xmlNewInputStream(ctxt);
15195     if (inputStream == NULL) {
15196         xmlFreeParserInputBuffer(buf);
15197         return(1);
15198     }
15199
15200     if (filename == NULL)
15201         inputStream->filename = NULL;
15202     else
15203         inputStream->filename = (char *)
15204             xmlCanonicPath((const xmlChar *) filename);
15205     inputStream->buf = buf;
15206     xmlBufResetInput(buf->buffer, inputStream);
15207
15208     inputPush(ctxt, inputStream);
15209
15210     if ((size > 0) && (chunk != NULL) && (ctxt->input != NULL) &&
15211         (ctxt->input->buf != NULL)) {
15212         size_t base = xmlBufGetInputBase(ctxt->input->buf->buffer, ctxt->input);
15213         size_t cur = ctxt->input->cur - ctxt->input->base;
15214
15215         xmlParserInputBufferPush(ctxt->input->buf, size, chunk);
15216
15217         xmlBufSetInputBaseCur(ctxt->input->buf->buffer, ctxt->input, base, cur);
15218 #ifdef DEBUG_PUSH
15219         xmlGenericError(xmlGenericErrorContext, "PP: pushed %d\n", size);
15220 #endif
15221     }
15222
15223     if (encoding != NULL) {
15224         xmlCharEncodingHandlerPtr hdlr;
15225
15226         if (ctxt->encoding != NULL)
15227             xmlFree((xmlChar *) ctxt->encoding);
15228         ctxt->encoding = xmlStrdup((const xmlChar *) encoding);
15229
15230         hdlr = xmlFindCharEncodingHandler(encoding);
15231         if (hdlr != NULL) {
15232             xmlSwitchToEncoding(ctxt, hdlr);
15233         } else {
15234             xmlFatalErrMsgStr(ctxt, XML_ERR_UNSUPPORTED_ENCODING,
15235                               "Unsupported encoding %s\n", BAD_CAST encoding);
15236         }
15237     } else if (enc != XML_CHAR_ENCODING_NONE) {
15238         xmlSwitchEncoding(ctxt, enc);
15239     }
15240
15241     return(0);
15242 }
15243
15244
15245 /**
15246  * xmlCtxtUseOptionsInternal:
15247  * @ctxt: an XML parser context
15248  * @options:  a combination of xmlParserOption
15249  * @encoding:  the user provided encoding to use
15250  *
15251  * Applies the options to the parser context
15252  *
15253  * Returns 0 in case of success, the set of unknown or unimplemented options
15254  *         in case of error.
15255  */
15256 static int
15257 xmlCtxtUseOptionsInternal(xmlParserCtxtPtr ctxt, int options, const char *encoding)
15258 {
15259     if (ctxt == NULL)
15260         return(-1);
15261     if (encoding != NULL) {
15262         if (ctxt->encoding != NULL)
15263             xmlFree((xmlChar *) ctxt->encoding);
15264         ctxt->encoding = xmlStrdup((const xmlChar *) encoding);
15265     }
15266     if (options & XML_PARSE_RECOVER) {
15267         ctxt->recovery = 1;
15268         options -= XML_PARSE_RECOVER;
15269         ctxt->options |= XML_PARSE_RECOVER;
15270     } else
15271         ctxt->recovery = 0;
15272     if (options & XML_PARSE_DTDLOAD) {
15273         ctxt->loadsubset = XML_DETECT_IDS;
15274         options -= XML_PARSE_DTDLOAD;
15275         ctxt->options |= XML_PARSE_DTDLOAD;
15276     } else
15277         ctxt->loadsubset = 0;
15278     if (options & XML_PARSE_DTDATTR) {
15279         ctxt->loadsubset |= XML_COMPLETE_ATTRS;
15280         options -= XML_PARSE_DTDATTR;
15281         ctxt->options |= XML_PARSE_DTDATTR;
15282     }
15283     if (options & XML_PARSE_NOENT) {
15284         ctxt->replaceEntities = 1;
15285         /* ctxt->loadsubset |= XML_DETECT_IDS; */
15286         options -= XML_PARSE_NOENT;
15287         ctxt->options |= XML_PARSE_NOENT;
15288     } else
15289         ctxt->replaceEntities = 0;
15290     if (options & XML_PARSE_PEDANTIC) {
15291         ctxt->pedantic = 1;
15292         options -= XML_PARSE_PEDANTIC;
15293         ctxt->options |= XML_PARSE_PEDANTIC;
15294     } else
15295         ctxt->pedantic = 0;
15296     if (options & XML_PARSE_NOBLANKS) {
15297         ctxt->keepBlanks = 0;
15298         ctxt->sax->ignorableWhitespace = xmlSAX2IgnorableWhitespace;
15299         options -= XML_PARSE_NOBLANKS;
15300         ctxt->options |= XML_PARSE_NOBLANKS;
15301     } else
15302         ctxt->keepBlanks = 1;
15303     if (options & XML_PARSE_DTDVALID) {
15304         ctxt->validate = 1;
15305         if (options & XML_PARSE_NOWARNING)
15306             ctxt->vctxt.warning = NULL;
15307         if (options & XML_PARSE_NOERROR)
15308             ctxt->vctxt.error = NULL;
15309         options -= XML_PARSE_DTDVALID;
15310         ctxt->options |= XML_PARSE_DTDVALID;
15311     } else
15312         ctxt->validate = 0;
15313     if (options & XML_PARSE_NOWARNING) {
15314         ctxt->sax->warning = NULL;
15315         options -= XML_PARSE_NOWARNING;
15316     }
15317     if (options & XML_PARSE_NOERROR) {
15318         ctxt->sax->error = NULL;
15319         ctxt->sax->fatalError = NULL;
15320         options -= XML_PARSE_NOERROR;
15321     }
15322 #ifdef LIBXML_SAX1_ENABLED
15323     if (options & XML_PARSE_SAX1) {
15324         ctxt->sax->startElement = xmlSAX2StartElement;
15325         ctxt->sax->endElement = xmlSAX2EndElement;
15326         ctxt->sax->startElementNs = NULL;
15327         ctxt->sax->endElementNs = NULL;
15328         ctxt->sax->initialized = 1;
15329         options -= XML_PARSE_SAX1;
15330         ctxt->options |= XML_PARSE_SAX1;
15331     }
15332 #endif /* LIBXML_SAX1_ENABLED */
15333     if (options & XML_PARSE_NODICT) {
15334         ctxt->dictNames = 0;
15335         options -= XML_PARSE_NODICT;
15336         ctxt->options |= XML_PARSE_NODICT;
15337     } else {
15338         ctxt->dictNames = 1;
15339     }
15340     if (options & XML_PARSE_NOCDATA) {
15341         ctxt->sax->cdataBlock = NULL;
15342         options -= XML_PARSE_NOCDATA;
15343         ctxt->options |= XML_PARSE_NOCDATA;
15344     }
15345     if (options & XML_PARSE_NSCLEAN) {
15346         ctxt->options |= XML_PARSE_NSCLEAN;
15347         options -= XML_PARSE_NSCLEAN;
15348     }
15349     if (options & XML_PARSE_NONET) {
15350         ctxt->options |= XML_PARSE_NONET;
15351         options -= XML_PARSE_NONET;
15352     }
15353     if (options & XML_PARSE_COMPACT) {
15354         ctxt->options |= XML_PARSE_COMPACT;
15355         options -= XML_PARSE_COMPACT;
15356     }
15357     if (options & XML_PARSE_OLD10) {
15358         ctxt->options |= XML_PARSE_OLD10;
15359         options -= XML_PARSE_OLD10;
15360     }
15361     if (options & XML_PARSE_NOBASEFIX) {
15362         ctxt->options |= XML_PARSE_NOBASEFIX;
15363         options -= XML_PARSE_NOBASEFIX;
15364     }
15365     if (options & XML_PARSE_HUGE) {
15366         ctxt->options |= XML_PARSE_HUGE;
15367         options -= XML_PARSE_HUGE;
15368         if (ctxt->dict != NULL)
15369             xmlDictSetLimit(ctxt->dict, 0);
15370     }
15371     if (options & XML_PARSE_OLDSAX) {
15372         ctxt->options |= XML_PARSE_OLDSAX;
15373         options -= XML_PARSE_OLDSAX;
15374     }
15375     if (options & XML_PARSE_IGNORE_ENC) {
15376         ctxt->options |= XML_PARSE_IGNORE_ENC;
15377         options -= XML_PARSE_IGNORE_ENC;
15378     }
15379     if (options & XML_PARSE_BIG_LINES) {
15380         ctxt->options |= XML_PARSE_BIG_LINES;
15381         options -= XML_PARSE_BIG_LINES;
15382     }
15383     ctxt->linenumbers = 1;
15384     return (options);
15385 }
15386
15387 /**
15388  * xmlCtxtUseOptions:
15389  * @ctxt: an XML parser context
15390  * @options:  a combination of xmlParserOption
15391  *
15392  * Applies the options to the parser context
15393  *
15394  * Returns 0 in case of success, the set of unknown or unimplemented options
15395  *         in case of error.
15396  */
15397 int
15398 xmlCtxtUseOptions(xmlParserCtxtPtr ctxt, int options)
15399 {
15400    return(xmlCtxtUseOptionsInternal(ctxt, options, NULL));
15401 }
15402
15403 /**
15404  * xmlDoRead:
15405  * @ctxt:  an XML parser context
15406  * @URL:  the base URL to use for the document
15407  * @encoding:  the document encoding, or NULL
15408  * @options:  a combination of xmlParserOption
15409  * @reuse:  keep the context for reuse
15410  *
15411  * Common front-end for the xmlRead functions
15412  *
15413  * Returns the resulting document tree or NULL
15414  */
15415 static xmlDocPtr
15416 xmlDoRead(xmlParserCtxtPtr ctxt, const char *URL, const char *encoding,
15417           int options, int reuse)
15418 {
15419     xmlDocPtr ret;
15420
15421     xmlCtxtUseOptionsInternal(ctxt, options, encoding);
15422     if (encoding != NULL) {
15423         xmlCharEncodingHandlerPtr hdlr;
15424
15425         hdlr = xmlFindCharEncodingHandler(encoding);
15426         if (hdlr != NULL)
15427             xmlSwitchToEncoding(ctxt, hdlr);
15428     }
15429     if ((URL != NULL) && (ctxt->input != NULL) &&
15430         (ctxt->input->filename == NULL))
15431         ctxt->input->filename = (char *) xmlStrdup((const xmlChar *) URL);
15432     xmlParseDocument(ctxt);
15433     if ((ctxt->wellFormed) || ctxt->recovery)
15434         ret = ctxt->myDoc;
15435     else {
15436         ret = NULL;
15437         if (ctxt->myDoc != NULL) {
15438             xmlFreeDoc(ctxt->myDoc);
15439         }
15440     }
15441     ctxt->myDoc = NULL;
15442     if (!reuse) {
15443         xmlFreeParserCtxt(ctxt);
15444     }
15445
15446     return (ret);
15447 }
15448
15449 /**
15450  * xmlReadDoc:
15451  * @cur:  a pointer to a zero terminated string
15452  * @URL:  the base URL to use for the document
15453  * @encoding:  the document encoding, or NULL
15454  * @options:  a combination of xmlParserOption
15455  *
15456  * parse an XML in-memory document and build a tree.
15457  *
15458  * Returns the resulting document tree
15459  */
15460 xmlDocPtr
15461 xmlReadDoc(const xmlChar * cur, const char *URL, const char *encoding, int options)
15462 {
15463     xmlParserCtxtPtr ctxt;
15464
15465     if (cur == NULL)
15466         return (NULL);
15467     xmlInitParser();
15468
15469     ctxt = xmlCreateDocParserCtxt(cur);
15470     if (ctxt == NULL)
15471         return (NULL);
15472     return (xmlDoRead(ctxt, URL, encoding, options, 0));
15473 }
15474
15475 /**
15476  * xmlReadFile:
15477  * @filename:  a file or URL
15478  * @encoding:  the document encoding, or NULL
15479  * @options:  a combination of xmlParserOption
15480  *
15481  * parse an XML file from the filesystem or the network.
15482  *
15483  * Returns the resulting document tree
15484  */
15485 xmlDocPtr
15486 xmlReadFile(const char *filename, const char *encoding, int options)
15487 {
15488     xmlParserCtxtPtr ctxt;
15489
15490     xmlInitParser();
15491     ctxt = xmlCreateURLParserCtxt(filename, options);
15492     if (ctxt == NULL)
15493         return (NULL);
15494     return (xmlDoRead(ctxt, NULL, encoding, options, 0));
15495 }
15496
15497 /**
15498  * xmlReadMemory:
15499  * @buffer:  a pointer to a char array
15500  * @size:  the size of the array
15501  * @URL:  the base URL to use for the document
15502  * @encoding:  the document encoding, or NULL
15503  * @options:  a combination of xmlParserOption
15504  *
15505  * parse an XML in-memory document and build a tree.
15506  *
15507  * Returns the resulting document tree
15508  */
15509 xmlDocPtr
15510 xmlReadMemory(const char *buffer, int size, const char *URL, const char *encoding, int options)
15511 {
15512     xmlParserCtxtPtr ctxt;
15513
15514     xmlInitParser();
15515     ctxt = xmlCreateMemoryParserCtxt(buffer, size);
15516     if (ctxt == NULL)
15517         return (NULL);
15518     return (xmlDoRead(ctxt, URL, encoding, options, 0));
15519 }
15520
15521 /**
15522  * xmlReadFd:
15523  * @fd:  an open file descriptor
15524  * @URL:  the base URL to use for the document
15525  * @encoding:  the document encoding, or NULL
15526  * @options:  a combination of xmlParserOption
15527  *
15528  * parse an XML from a file descriptor and build a tree.
15529  * NOTE that the file descriptor will not be closed when the
15530  *      reader is closed or reset.
15531  *
15532  * Returns the resulting document tree
15533  */
15534 xmlDocPtr
15535 xmlReadFd(int fd, const char *URL, const char *encoding, int options)
15536 {
15537     xmlParserCtxtPtr ctxt;
15538     xmlParserInputBufferPtr input;
15539     xmlParserInputPtr stream;
15540
15541     if (fd < 0)
15542         return (NULL);
15543     xmlInitParser();
15544
15545     input = xmlParserInputBufferCreateFd(fd, XML_CHAR_ENCODING_NONE);
15546     if (input == NULL)
15547         return (NULL);
15548     input->closecallback = NULL;
15549     ctxt = xmlNewParserCtxt();
15550     if (ctxt == NULL) {
15551         xmlFreeParserInputBuffer(input);
15552         return (NULL);
15553     }
15554     stream = xmlNewIOInputStream(ctxt, input, XML_CHAR_ENCODING_NONE);
15555     if (stream == NULL) {
15556         xmlFreeParserInputBuffer(input);
15557         xmlFreeParserCtxt(ctxt);
15558         return (NULL);
15559     }
15560     inputPush(ctxt, stream);
15561     return (xmlDoRead(ctxt, URL, encoding, options, 0));
15562 }
15563
15564 /**
15565  * xmlReadIO:
15566  * @ioread:  an I/O read function
15567  * @ioclose:  an I/O close function
15568  * @ioctx:  an I/O handler
15569  * @URL:  the base URL to use for the document
15570  * @encoding:  the document encoding, or NULL
15571  * @options:  a combination of xmlParserOption
15572  *
15573  * parse an XML document from I/O functions and source and build a tree.
15574  *
15575  * Returns the resulting document tree
15576  */
15577 xmlDocPtr
15578 xmlReadIO(xmlInputReadCallback ioread, xmlInputCloseCallback ioclose,
15579           void *ioctx, const char *URL, const char *encoding, int options)
15580 {
15581     xmlParserCtxtPtr ctxt;
15582     xmlParserInputBufferPtr input;
15583     xmlParserInputPtr stream;
15584
15585     if (ioread == NULL)
15586         return (NULL);
15587     xmlInitParser();
15588
15589     input = xmlParserInputBufferCreateIO(ioread, ioclose, ioctx,
15590                                          XML_CHAR_ENCODING_NONE);
15591     if (input == NULL) {
15592         if (ioclose != NULL)
15593             ioclose(ioctx);
15594         return (NULL);
15595     }
15596     ctxt = xmlNewParserCtxt();
15597     if (ctxt == NULL) {
15598         xmlFreeParserInputBuffer(input);
15599         return (NULL);
15600     }
15601     stream = xmlNewIOInputStream(ctxt, input, XML_CHAR_ENCODING_NONE);
15602     if (stream == NULL) {
15603         xmlFreeParserInputBuffer(input);
15604         xmlFreeParserCtxt(ctxt);
15605         return (NULL);
15606     }
15607     inputPush(ctxt, stream);
15608     return (xmlDoRead(ctxt, URL, encoding, options, 0));
15609 }
15610
15611 /**
15612  * xmlCtxtReadDoc:
15613  * @ctxt:  an XML parser context
15614  * @cur:  a pointer to a zero terminated string
15615  * @URL:  the base URL to use for the document
15616  * @encoding:  the document encoding, or NULL
15617  * @options:  a combination of xmlParserOption
15618  *
15619  * parse an XML in-memory document and build a tree.
15620  * This reuses the existing @ctxt parser context
15621  *
15622  * Returns the resulting document tree
15623  */
15624 xmlDocPtr
15625 xmlCtxtReadDoc(xmlParserCtxtPtr ctxt, const xmlChar * cur,
15626                const char *URL, const char *encoding, int options)
15627 {
15628     xmlParserInputPtr stream;
15629
15630     if (cur == NULL)
15631         return (NULL);
15632     if (ctxt == NULL)
15633         return (NULL);
15634     xmlInitParser();
15635
15636     xmlCtxtReset(ctxt);
15637
15638     stream = xmlNewStringInputStream(ctxt, cur);
15639     if (stream == NULL) {
15640         return (NULL);
15641     }
15642     inputPush(ctxt, stream);
15643     return (xmlDoRead(ctxt, URL, encoding, options, 1));
15644 }
15645
15646 /**
15647  * xmlCtxtReadFile:
15648  * @ctxt:  an XML parser context
15649  * @filename:  a file or URL
15650  * @encoding:  the document encoding, or NULL
15651  * @options:  a combination of xmlParserOption
15652  *
15653  * parse an XML file from the filesystem or the network.
15654  * This reuses the existing @ctxt parser context
15655  *
15656  * Returns the resulting document tree
15657  */
15658 xmlDocPtr
15659 xmlCtxtReadFile(xmlParserCtxtPtr ctxt, const char *filename,
15660                 const char *encoding, int options)
15661 {
15662     xmlParserInputPtr stream;
15663
15664     if (filename == NULL)
15665         return (NULL);
15666     if (ctxt == NULL)
15667         return (NULL);
15668     xmlInitParser();
15669
15670     xmlCtxtReset(ctxt);
15671
15672     stream = xmlLoadExternalEntity(filename, NULL, ctxt);
15673     if (stream == NULL) {
15674         return (NULL);
15675     }
15676     inputPush(ctxt, stream);
15677     return (xmlDoRead(ctxt, NULL, encoding, options, 1));
15678 }
15679
15680 /**
15681  * xmlCtxtReadMemory:
15682  * @ctxt:  an XML parser context
15683  * @buffer:  a pointer to a char array
15684  * @size:  the size of the array
15685  * @URL:  the base URL to use for the document
15686  * @encoding:  the document encoding, or NULL
15687  * @options:  a combination of xmlParserOption
15688  *
15689  * parse an XML in-memory document and build a tree.
15690  * This reuses the existing @ctxt parser context
15691  *
15692  * Returns the resulting document tree
15693  */
15694 xmlDocPtr
15695 xmlCtxtReadMemory(xmlParserCtxtPtr ctxt, const char *buffer, int size,
15696                   const char *URL, const char *encoding, int options)
15697 {
15698     xmlParserInputBufferPtr input;
15699     xmlParserInputPtr stream;
15700
15701     if (ctxt == NULL)
15702         return (NULL);
15703     if (buffer == NULL)
15704         return (NULL);
15705     xmlInitParser();
15706
15707     xmlCtxtReset(ctxt);
15708
15709     input = xmlParserInputBufferCreateMem(buffer, size, XML_CHAR_ENCODING_NONE);
15710     if (input == NULL) {
15711         return(NULL);
15712     }
15713
15714     stream = xmlNewIOInputStream(ctxt, input, XML_CHAR_ENCODING_NONE);
15715     if (stream == NULL) {
15716         xmlFreeParserInputBuffer(input);
15717         return(NULL);
15718     }
15719
15720     inputPush(ctxt, stream);
15721     return (xmlDoRead(ctxt, URL, encoding, options, 1));
15722 }
15723
15724 /**
15725  * xmlCtxtReadFd:
15726  * @ctxt:  an XML parser context
15727  * @fd:  an open file descriptor
15728  * @URL:  the base URL to use for the document
15729  * @encoding:  the document encoding, or NULL
15730  * @options:  a combination of xmlParserOption
15731  *
15732  * parse an XML from a file descriptor and build a tree.
15733  * This reuses the existing @ctxt parser context
15734  * NOTE that the file descriptor will not be closed when the
15735  *      reader is closed or reset.
15736  *
15737  * Returns the resulting document tree
15738  */
15739 xmlDocPtr
15740 xmlCtxtReadFd(xmlParserCtxtPtr ctxt, int fd,
15741               const char *URL, const char *encoding, int options)
15742 {
15743     xmlParserInputBufferPtr input;
15744     xmlParserInputPtr stream;
15745
15746     if (fd < 0)
15747         return (NULL);
15748     if (ctxt == NULL)
15749         return (NULL);
15750     xmlInitParser();
15751
15752     xmlCtxtReset(ctxt);
15753
15754
15755     input = xmlParserInputBufferCreateFd(fd, XML_CHAR_ENCODING_NONE);
15756     if (input == NULL)
15757         return (NULL);
15758     input->closecallback = NULL;
15759     stream = xmlNewIOInputStream(ctxt, input, XML_CHAR_ENCODING_NONE);
15760     if (stream == NULL) {
15761         xmlFreeParserInputBuffer(input);
15762         return (NULL);
15763     }
15764     inputPush(ctxt, stream);
15765     return (xmlDoRead(ctxt, URL, encoding, options, 1));
15766 }
15767
15768 /**
15769  * xmlCtxtReadIO:
15770  * @ctxt:  an XML parser context
15771  * @ioread:  an I/O read function
15772  * @ioclose:  an I/O close function
15773  * @ioctx:  an I/O handler
15774  * @URL:  the base URL to use for the document
15775  * @encoding:  the document encoding, or NULL
15776  * @options:  a combination of xmlParserOption
15777  *
15778  * parse an XML document from I/O functions and source and build a tree.
15779  * This reuses the existing @ctxt parser context
15780  *
15781  * Returns the resulting document tree
15782  */
15783 xmlDocPtr
15784 xmlCtxtReadIO(xmlParserCtxtPtr ctxt, xmlInputReadCallback ioread,
15785               xmlInputCloseCallback ioclose, void *ioctx,
15786               const char *URL,
15787               const char *encoding, int options)
15788 {
15789     xmlParserInputBufferPtr input;
15790     xmlParserInputPtr stream;
15791
15792     if (ioread == NULL)
15793         return (NULL);
15794     if (ctxt == NULL)
15795         return (NULL);
15796     xmlInitParser();
15797
15798     xmlCtxtReset(ctxt);
15799
15800     input = xmlParserInputBufferCreateIO(ioread, ioclose, ioctx,
15801                                          XML_CHAR_ENCODING_NONE);
15802     if (input == NULL) {
15803         if (ioclose != NULL)
15804             ioclose(ioctx);
15805         return (NULL);
15806     }
15807     stream = xmlNewIOInputStream(ctxt, input, XML_CHAR_ENCODING_NONE);
15808     if (stream == NULL) {
15809         xmlFreeParserInputBuffer(input);
15810         return (NULL);
15811     }
15812     inputPush(ctxt, stream);
15813     return (xmlDoRead(ctxt, URL, encoding, options, 1));
15814 }
15815
15816 #define bottom_parser
15817 #include "elfgcchack.h"