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 <string.h>
  44 #include <stdarg.h>
  45 #include <libxml/xmlmemory.h>
  46 #include <libxml/threads.h>
  47 #include <libxml/globals.h>
  48 #include <libxml/tree.h>
  49 #include <libxml/parser.h>
  50 #include <libxml/parserInternals.h>
  51 #include <libxml/valid.h>
  52 #include <libxml/entities.h>
  53 #include <libxml/xmlerror.h>
  54 #include <libxml/encoding.h>
  55 #include <libxml/xmlIO.h>
  56 #include <libxml/uri.h>
  57 #ifdef LIBXML_CATALOG_ENABLED
  58 #include <libxml/catalog.h>
  59 #endif
  60 #ifdef LIBXML_SCHEMAS_ENABLED
  61 #include <libxml/xmlschemastypes.h>
  62 #include <libxml/relaxng.h>
  63 #endif
  64 #ifdef HAVE_CTYPE_H
  65 #include <ctype.h>
  66 #endif
  67 #ifdef HAVE_STDLIB_H
  68 #include <stdlib.h>
  69 #endif
  70 #ifdef HAVE_SYS_STAT_H
  71 #include <sys/stat.h>
  72 #endif
  73 #ifdef HAVE_FCNTL_H
  74 #include <fcntl.h>
  75 #endif
  76 #ifdef HAVE_UNISTD_H
  77 #include <unistd.h>
  78 #endif
  79 #ifdef HAVE_ZLIB_H
  80 #include <zlib.h>
  81 #endif
  82 #ifdef HAVE_LZMA_H
  83 #include <lzma.h>
  84 #endif
  85
  86 static void
  87 xmlFatalErr(xmlParserCtxtPtr ctxt, xmlParserErrors error, const char *info);
  88
  89 static xmlParserCtxtPtr
  90 xmlCreateEntityParserCtxtInternal(const xmlChar *URL, const xmlChar *ID,
  91                           const xmlChar *base, xmlParserCtxtPtr pctx);
  92
  93 /************************************************************************
  94  *                                                                      *
  95  *      Arbitrary limits set in the parser. See XML_PARSE_HUGE          *
  96  *                                                                      *
  97  ************************************************************************/
  98
  99 #define XML_PARSER_BIG_ENTITY 1000
 100 #define XML_PARSER_LOT_ENTITY 5000
 101
 102 /*
 103  * XML_PARSER_NON_LINEAR is the threshold where the ratio of parsed entity
 104  *    replacement over the size in byte of the input indicates that you have
 105  *    and eponential behaviour. A value of 10 correspond to at least 3 entity
 106  *    replacement per byte of input.
 107  */
 108 #define XML_PARSER_NON_LINEAR 10
 109
 110 /*
 111  * xmlParserEntityCheck
 112  *
 113  * Function to check non-linear entity expansion behaviour
 114  * This is here to detect and stop exponential linear entity expansion
 115  * This is not a limitation of the parser but a safety
 116  * boundary feature. It can be disabled with the XML_PARSE_HUGE
 117  * parser option.
 118  */
 119 static int
 120 xmlParserEntityCheck(xmlParserCtxtPtr ctxt, unsigned long size,
 121                      xmlEntityPtr ent)
 122 {
 123     unsigned long consumed = 0;
 124
 125     if ((ctxt == NULL) || (ctxt->options & XML_PARSE_HUGE))
 126         return (0);
 127     if (ctxt->lastError.code == XML_ERR_ENTITY_LOOP)
 128         return (1);
 129     if (size != 0) {
 130         /*
 131          * Do the check based on the replacement size of the entity
 132          */
 133         if (size < XML_PARSER_BIG_ENTITY)
 134             return(0);
 135
 136         /*
 137          * A limit on the amount of text data reasonably used
 138          */
 139         if (ctxt->input != NULL) {
 140             consumed = ctxt->input->consumed +
 141                 (ctxt->input->cur - ctxt->input->base);
 142         }
 143         consumed += ctxt->sizeentities;
 144
 145         if ((size < XML_PARSER_NON_LINEAR * consumed) &&
 146             (ctxt->nbentities * 3 < XML_PARSER_NON_LINEAR * consumed))
 147             return (0);
 148     } else if (ent != NULL) {
 149         /*
 150          * use the number of parsed entities in the replacement
 151          */
 152         size = ent->checked;
 153
 154         /*
 155          * The amount of data parsed counting entities size only once
 156          */
 157         if (ctxt->input != NULL) {
 158             consumed = ctxt->input->consumed +
 159                 (ctxt->input->cur - ctxt->input->base);
 160         }
 161         consumed += ctxt->sizeentities;
 162
 163         /*
 164          * Check the density of entities for the amount of data
 165          * knowing an entity reference will take at least 3 bytes
 166          */
 167         if (size * 3 < consumed * XML_PARSER_NON_LINEAR)
 168             return (0);
 169     } else {
 170         /*
 171          * strange we got no data for checking just return
 172          */
 173         return (0);
 174     }
 175
 176     xmlFatalErr(ctxt, XML_ERR_ENTITY_LOOP, NULL);
 177     return (1);
 178 }
 179
 180 /**
 181  * xmlParserMaxDepth:
 182  *
 183  * arbitrary depth limit for the XML documents that we allow to
 184  * process. This is not a limitation of the parser but a safety
 185  * boundary feature. It can be disabled with the XML_PARSE_HUGE
 186  * parser option.
 187  */
 188 unsigned int xmlParserMaxDepth = 256;
 189
 190
 191
 192 #define SAX2 1
 193 #define XML_PARSER_BIG_BUFFER_SIZE 300
 194 #define XML_PARSER_BUFFER_SIZE 100
 195 #define SAX_COMPAT_MODE BAD_CAST "SAX compatibility mode document"
 196
 197 /*
 198  * List of XML prefixed PI allowed by W3C specs
 199  */
 200
 201 static const char *xmlW3CPIs[] = {
 202     "xml-stylesheet",
 203     "xml-model",
 204     NULL
 205 };
 206
 207
 208 /* DEPR void xmlParserHandleReference(xmlParserCtxtPtr ctxt); */
 209 static xmlEntityPtr xmlParseStringPEReference(xmlParserCtxtPtr ctxt,
 210                                               const xmlChar **str);
 211
 212 static xmlParserErrors
 213 xmlParseExternalEntityPrivate(xmlDocPtr doc, xmlParserCtxtPtr oldctxt,
 214                       xmlSAXHandlerPtr sax,
 215                       void *user_data, int depth, const xmlChar *URL,
 216                       const xmlChar *ID, xmlNodePtr *list);
 217
 218 static int
 219 xmlCtxtUseOptionsInternal(xmlParserCtxtPtr ctxt, int options,
 220                           const char *encoding);
 221 #ifdef LIBXML_LEGACY_ENABLED
 222 static void
 223 xmlAddEntityReference(xmlEntityPtr ent, xmlNodePtr firstNode,
 224                       xmlNodePtr lastNode);
 225 #endif /* LIBXML_LEGACY_ENABLED */
 226
 227 static xmlParserErrors
 228 xmlParseBalancedChunkMemoryInternal(xmlParserCtxtPtr oldctxt,
 229                       const xmlChar *string, void *user_data, xmlNodePtr *lst);
 230
 231 static int
 232 xmlLoadEntityContent(xmlParserCtxtPtr ctxt, xmlEntityPtr entity);
 233
 234 /************************************************************************
 235  *                                                                      *
 236  *              Some factorized error routines                          *
 237  *                                                                      *
 238  ************************************************************************/
 239
 240 /**
 241  * xmlErrAttributeDup:
 242  * @ctxt:  an XML parser context
 243  * @prefix:  the attribute prefix
 244  * @localname:  the attribute localname
 245  *
 246  * Handle a redefinition of attribute error
 247  */
 248 static void
 249 xmlErrAttributeDup(xmlParserCtxtPtr ctxt, const xmlChar * prefix,
 250                    const xmlChar * localname)
 251 {
 252     if ((ctxt != NULL) && (ctxt->disableSAX != 0) &&
 253         (ctxt->instate == XML_PARSER_EOF))
 254         return;
 255     if (ctxt != NULL)
 256         ctxt->errNo = XML_ERR_ATTRIBUTE_REDEFINED;
 257
 258     if (prefix == NULL)
 259         __xmlRaiseError(NULL, NULL, NULL, ctxt, NULL, XML_FROM_PARSER,
 260                         XML_ERR_ATTRIBUTE_REDEFINED, XML_ERR_FATAL, NULL, 0,
 261                         (const char *) localname, NULL, NULL, 0, 0,
 262                         "Attribute %s redefined\n", localname);
 263     else
 264         __xmlRaiseError(NULL, NULL, NULL, ctxt, NULL, XML_FROM_PARSER,
 265                         XML_ERR_ATTRIBUTE_REDEFINED, XML_ERR_FATAL, NULL, 0,
 266                         (const char *) prefix, (const char *) localname,
 267                         NULL, 0, 0, "Attribute %s:%s redefined\n", prefix,
 268                         localname);
 269     if (ctxt != NULL) {
 270         ctxt->wellFormed = 0;
 271         if (ctxt->recovery == 0)
 272             ctxt->disableSAX = 1;
 273     }
 274 }
 275
 276 /**
 277  * xmlFatalErr:
 278  * @ctxt:  an XML parser context
 279  * @error:  the error number
 280  * @extra:  extra information string
 281  *
 282  * Handle a fatal parser error, i.e. violating Well-Formedness constraints
 283  */
 284 static void
 285 xmlFatalErr(xmlParserCtxtPtr ctxt, xmlParserErrors error, const char *info)
 286 {
 287     const char *errmsg;
 288
 289     if ((ctxt != NULL) && (ctxt->disableSAX != 0) &&
 290         (ctxt->instate == XML_PARSER_EOF))
 291         return;
 292     switch (error) {
 293         case XML_ERR_INVALID_HEX_CHARREF:
 294             errmsg = "CharRef: invalid hexadecimal value\n";
 295             break;
 296         case XML_ERR_INVALID_DEC_CHARREF:
 297             errmsg = "CharRef: invalid decimal value\n";
 298             break;
 299         case XML_ERR_INVALID_CHARREF:
 300             errmsg = "CharRef: invalid value\n";
 301             break;
 302         case XML_ERR_INTERNAL_ERROR:
 303             errmsg = "internal error";
 304             break;
 305         case XML_ERR_PEREF_AT_EOF:
 306             errmsg = "PEReference at end of document\n";
 307             break;
 308         case XML_ERR_PEREF_IN_PROLOG:
 309             errmsg = "PEReference in prolog\n";
 310             break;
 311         case XML_ERR_PEREF_IN_EPILOG:
 312             errmsg = "PEReference in epilog\n";
 313             break;
 314         case XML_ERR_PEREF_NO_NAME:
 315             errmsg = "PEReference: no name\n";
 316             break;
 317         case XML_ERR_PEREF_SEMICOL_MISSING:
 318             errmsg = "PEReference: expecting ';'\n";
 319             break;
 320         case XML_ERR_ENTITY_LOOP:
 321             errmsg = "Detected an entity reference loop\n";
 322             break;
 323         case XML_ERR_ENTITY_NOT_STARTED:
 324             errmsg = "EntityValue: \" or ' expected\n";
 325             break;
 326         case XML_ERR_ENTITY_PE_INTERNAL:
 327             errmsg = "PEReferences forbidden in internal subset\n";
 328             break;
 329         case XML_ERR_ENTITY_NOT_FINISHED:
 330             errmsg = "EntityValue: \" or ' expected\n";
 331             break;
 332         case XML_ERR_ATTRIBUTE_NOT_STARTED:
 333             errmsg = "AttValue: \" or ' expected\n";
 334             break;
 335         case XML_ERR_LT_IN_ATTRIBUTE:
 336             errmsg = "Unescaped '<' not allowed in attributes values\n";
 337             break;
 338         case XML_ERR_LITERAL_NOT_STARTED:
 339             errmsg = "SystemLiteral \" or ' expected\n";
 340             break;
 341         case XML_ERR_LITERAL_NOT_FINISHED:
 342             errmsg = "Unfinished System or Public ID \" or ' expected\n";
 343             break;
 344         case XML_ERR_MISPLACED_CDATA_END:
 345             errmsg = "Sequence ']]>' not allowed in content\n";
 346             break;
 347         case XML_ERR_URI_REQUIRED:
 348             errmsg = "SYSTEM or PUBLIC, the URI is missing\n";
 349             break;
 350         case XML_ERR_PUBID_REQUIRED:
 351             errmsg = "PUBLIC, the Public Identifier is missing\n";
 352             break;
 353         case XML_ERR_HYPHEN_IN_COMMENT:
 354             errmsg = "Comment must not contain '--' (double-hyphen)\n";
 355             break;
 356         case XML_ERR_PI_NOT_STARTED:
 357             errmsg = "xmlParsePI : no target name\n";
 358             break;
 359         case XML_ERR_RESERVED_XML_NAME:
 360             errmsg = "Invalid PI name\n";
 361             break;
 362         case XML_ERR_NOTATION_NOT_STARTED:
 363             errmsg = "NOTATION: Name expected here\n";
 364             break;
 365         case XML_ERR_NOTATION_NOT_FINISHED:
 366             errmsg = "'>' required to close NOTATION declaration\n";
 367             break;
 368         case XML_ERR_VALUE_REQUIRED:
 369             errmsg = "Entity value required\n";
 370             break;
 371         case XML_ERR_URI_FRAGMENT:
 372             errmsg = "Fragment not allowed";
 373             break;
 374         case XML_ERR_ATTLIST_NOT_STARTED:
 375             errmsg = "'(' required to start ATTLIST enumeration\n";
 376             break;
 377         case XML_ERR_NMTOKEN_REQUIRED:
 378             errmsg = "NmToken expected in ATTLIST enumeration\n";
 379             break;
 380         case XML_ERR_ATTLIST_NOT_FINISHED:
 381             errmsg = "')' required to finish ATTLIST enumeration\n";
 382             break;
 383         case XML_ERR_MIXED_NOT_STARTED:
 384             errmsg = "MixedContentDecl : '|' or ')*' expected\n";
 385             break;
 386         case XML_ERR_PCDATA_REQUIRED:
 387             errmsg = "MixedContentDecl : '#PCDATA' expected\n";
 388             break;
 389         case XML_ERR_ELEMCONTENT_NOT_STARTED:
 390             errmsg = "ContentDecl : Name or '(' expected\n";
 391             break;
 392         case XML_ERR_ELEMCONTENT_NOT_FINISHED:
 393             errmsg = "ContentDecl : ',' '|' or ')' expected\n";
 394             break;
 395         case XML_ERR_PEREF_IN_INT_SUBSET:
 396             errmsg =
 397                 "PEReference: forbidden within markup decl in internal subset\n";
 398             break;
 399         case XML_ERR_GT_REQUIRED:
 400             errmsg = "expected '>'\n";
 401             break;
 402         case XML_ERR_CONDSEC_INVALID:
 403             errmsg = "XML conditional section '[' expected\n";
 404             break;
 405         case XML_ERR_EXT_SUBSET_NOT_FINISHED:
 406             errmsg = "Content error in the external subset\n";
 407             break;
 408         case XML_ERR_CONDSEC_INVALID_KEYWORD:
 409             errmsg =
 410                 "conditional section INCLUDE or IGNORE keyword expected\n";
 411             break;
 412         case XML_ERR_CONDSEC_NOT_FINISHED:
 413             errmsg = "XML conditional section not closed\n";
 414             break;
 415         case XML_ERR_XMLDECL_NOT_STARTED:
 416             errmsg = "Text declaration '<?xml' required\n";
 417             break;
 418         case XML_ERR_XMLDECL_NOT_FINISHED:
 419             errmsg = "parsing XML declaration: '?>' expected\n";
 420             break;
 421         case XML_ERR_EXT_ENTITY_STANDALONE:
 422             errmsg = "external parsed entities cannot be standalone\n";
 423             break;
 424         case XML_ERR_ENTITYREF_SEMICOL_MISSING:
 425             errmsg = "EntityRef: expecting ';'\n";
 426             break;
 427         case XML_ERR_DOCTYPE_NOT_FINISHED:
 428             errmsg = "DOCTYPE improperly terminated\n";
 429             break;
 430         case XML_ERR_LTSLASH_REQUIRED:
 431             errmsg = "EndTag: '</' not found\n";
 432             break;
 433         case XML_ERR_EQUAL_REQUIRED:
 434             errmsg = "expected '='\n";
 435             break;
 436         case XML_ERR_STRING_NOT_CLOSED:
 437             errmsg = "String not closed expecting \" or '\n";
 438             break;
 439         case XML_ERR_STRING_NOT_STARTED:
 440             errmsg = "String not started expecting ' or \"\n";
 441             break;
 442         case XML_ERR_ENCODING_NAME:
 443             errmsg = "Invalid XML encoding name\n";
 444             break;
 445         case XML_ERR_STANDALONE_VALUE:
 446             errmsg = "standalone accepts only 'yes' or 'no'\n";
 447             break;
 448         case XML_ERR_DOCUMENT_EMPTY:
 449             errmsg = "Document is empty\n";
 450             break;
 451         case XML_ERR_DOCUMENT_END:
 452             errmsg = "Extra content at the end of the document\n";
 453             break;
 454         case XML_ERR_NOT_WELL_BALANCED:
 455             errmsg = "chunk is not well balanced\n";
 456             break;
 457         case XML_ERR_EXTRA_CONTENT:
 458             errmsg = "extra content at the end of well balanced chunk\n";
 459             break;
 460         case XML_ERR_VERSION_MISSING:
 461             errmsg = "Malformed declaration expecting version\n";
 462             break;
 463 #if 0
 464         case:
 465             errmsg = "\n";
 466             break;
 467 #endif
 468         default:
 469             errmsg = "Unregistered error message\n";
 470     }
 471     if (ctxt != NULL)
 472         ctxt->errNo = error;
 473     __xmlRaiseError(NULL, NULL, NULL, ctxt, NULL, XML_FROM_PARSER, error,
 474                     XML_ERR_FATAL, NULL, 0, info, NULL, NULL, 0, 0, errmsg,
 475                     info);
 476     if (ctxt != NULL) {
 477         ctxt->wellFormed = 0;
 478         if (ctxt->recovery == 0)
 479             ctxt->disableSAX = 1;
 480     }
 481 }
 482
 483 /**
 484  * xmlFatalErrMsg:
 485  * @ctxt:  an XML parser context
 486  * @error:  the error number
 487  * @msg:  the error message
 488  *
 489  * Handle a fatal parser error, i.e. violating Well-Formedness constraints
 490  */
 491 static void
 492 xmlFatalErrMsg(xmlParserCtxtPtr ctxt, xmlParserErrors error,
 493                const char *msg)
 494 {
 495     if ((ctxt != NULL) && (ctxt->disableSAX != 0) &&
 496         (ctxt->instate == XML_PARSER_EOF))
 497         return;
 498     if (ctxt != NULL)
 499         ctxt->errNo = error;
 500     __xmlRaiseError(NULL, NULL, NULL, ctxt, NULL, XML_FROM_PARSER, error,
 501                     XML_ERR_FATAL, NULL, 0, NULL, NULL, NULL, 0, 0, "%s", msg);
 502     if (ctxt != NULL) {
 503         ctxt->wellFormed = 0;
 504         if (ctxt->recovery == 0)
 505             ctxt->disableSAX = 1;
 506     }
 507 }
 508
 509 /**
 510  * xmlWarningMsg:
 511  * @ctxt:  an XML parser context
 512  * @error:  the error number
 513  * @msg:  the error message
 514  * @str1:  extra data
 515  * @str2:  extra data
 516  *
 517  * Handle a warning.
 518  */
 519 static void
 520 xmlWarningMsg(xmlParserCtxtPtr ctxt, xmlParserErrors error,
 521               const char *msg, const xmlChar *str1, const xmlChar *str2)
 522 {
 523     xmlStructuredErrorFunc schannel = NULL;
 524
 525     if ((ctxt != NULL) && (ctxt->disableSAX != 0) &&
 526         (ctxt->instate == XML_PARSER_EOF))
 527         return;
 528     if ((ctxt != NULL) && (ctxt->sax != NULL) &&
 529         (ctxt->sax->initialized == XML_SAX2_MAGIC))
 530         schannel = ctxt->sax->serror;
 531     if (ctxt != NULL) {
 532         __xmlRaiseError(schannel,
 533                     (ctxt->sax) ? ctxt->sax->warning : NULL,
 534                     ctxt->userData,
 535                     ctxt, NULL, XML_FROM_PARSER, error,
 536                     XML_ERR_WARNING, NULL, 0,
 537                     (const char *) str1, (const char *) str2, NULL, 0, 0,
 538                     msg, (const char *) str1, (const char *) str2);
 539     } else {
 540         __xmlRaiseError(schannel, NULL, NULL,
 541                     ctxt, NULL, XML_FROM_PARSER, error,
 542                     XML_ERR_WARNING, NULL, 0,
 543                     (const char *) str1, (const char *) str2, NULL, 0, 0,
 544                     msg, (const char *) str1, (const char *) str2);
 545     }
 546 }
 547
 548 /**
 549  * xmlValidityError:
 550  * @ctxt:  an XML parser context
 551  * @error:  the error number
 552  * @msg:  the error message
 553  * @str1:  extra data
 554  *
 555  * Handle a validity error.
 556  */
 557 static void
 558 xmlValidityError(xmlParserCtxtPtr ctxt, xmlParserErrors error,
 559               const char *msg, const xmlChar *str1, const xmlChar *str2)
 560 {
 561     xmlStructuredErrorFunc schannel = NULL;
 562
 563     if ((ctxt != NULL) && (ctxt->disableSAX != 0) &&
 564         (ctxt->instate == XML_PARSER_EOF))
 565         return;
 566     if (ctxt != NULL) {
 567         ctxt->errNo = error;
 568         if ((ctxt->sax != NULL) && (ctxt->sax->initialized == XML_SAX2_MAGIC))
 569             schannel = ctxt->sax->serror;
 570     }
 571     if (ctxt != NULL) {
 572         __xmlRaiseError(schannel,
 573                     ctxt->vctxt.error, ctxt->vctxt.userData,
 574                     ctxt, NULL, XML_FROM_DTD, error,
 575                     XML_ERR_ERROR, NULL, 0, (const char *) str1,
 576                     (const char *) str2, NULL, 0, 0,
 577                     msg, (const char *) str1, (const char *) str2);
 578         ctxt->valid = 0;
 579     } else {
 580         __xmlRaiseError(schannel, NULL, NULL,
 581                     ctxt, NULL, XML_FROM_DTD, error,
 582                     XML_ERR_ERROR, NULL, 0, (const char *) str1,
 583                     (const char *) str2, NULL, 0, 0,
 584                     msg, (const char *) str1, (const char *) str2);
 585     }
 586 }
 587
 588 /**
 589  * xmlFatalErrMsgInt:
 590  * @ctxt:  an XML parser context
 591  * @error:  the error number
 592  * @msg:  the error message
 593  * @val:  an integer value
 594  *
 595  * Handle a fatal parser error, i.e. violating Well-Formedness constraints
 596  */
 597 static void
 598 xmlFatalErrMsgInt(xmlParserCtxtPtr ctxt, xmlParserErrors error,
 599                   const char *msg, int val)
 600 {
 601     if ((ctxt != NULL) && (ctxt->disableSAX != 0) &&
 602         (ctxt->instate == XML_PARSER_EOF))
 603         return;
 604     if (ctxt != NULL)
 605         ctxt->errNo = error;
 606     __xmlRaiseError(NULL, NULL, NULL,
 607                     ctxt, NULL, XML_FROM_PARSER, error, XML_ERR_FATAL,
 608                     NULL, 0, NULL, NULL, NULL, val, 0, msg, val);
 609     if (ctxt != NULL) {
 610         ctxt->wellFormed = 0;
 611         if (ctxt->recovery == 0)
 612             ctxt->disableSAX = 1;
 613     }
 614 }
 615
 616 /**
 617  * xmlFatalErrMsgStrIntStr:
 618  * @ctxt:  an XML parser context
 619  * @error:  the error number
 620  * @msg:  the error message
 621  * @str1:  an string info
 622  * @val:  an integer value
 623  * @str2:  an string info
 624  *
 625  * Handle a fatal parser error, i.e. violating Well-Formedness constraints
 626  */
 627 static void
 628 xmlFatalErrMsgStrIntStr(xmlParserCtxtPtr ctxt, xmlParserErrors error,
 629                   const char *msg, const xmlChar *str1, int val,
 630                   const xmlChar *str2)
 631 {
 632     if ((ctxt != NULL) && (ctxt->disableSAX != 0) &&
 633         (ctxt->instate == XML_PARSER_EOF))
 634         return;
 635     if (ctxt != NULL)
 636         ctxt->errNo = error;
 637     __xmlRaiseError(NULL, NULL, NULL,
 638                     ctxt, NULL, XML_FROM_PARSER, error, XML_ERR_FATAL,
 639                     NULL, 0, (const char *) str1, (const char *) str2,
 640                     NULL, val, 0, msg, str1, val, str2);
 641     if (ctxt != NULL) {
 642         ctxt->wellFormed = 0;
 643         if (ctxt->recovery == 0)
 644             ctxt->disableSAX = 1;
 645     }
 646 }
 647
 648 /**
 649  * xmlFatalErrMsgStr:
 650  * @ctxt:  an XML parser context
 651  * @error:  the error number
 652  * @msg:  the error message
 653  * @val:  a string value
 654  *
 655  * Handle a fatal parser error, i.e. violating Well-Formedness constraints
 656  */
 657 static void
 658 xmlFatalErrMsgStr(xmlParserCtxtPtr ctxt, xmlParserErrors error,
 659                   const char *msg, const xmlChar * val)
 660 {
 661     if ((ctxt != NULL) && (ctxt->disableSAX != 0) &&
 662         (ctxt->instate == XML_PARSER_EOF))
 663         return;
 664     if (ctxt != NULL)
 665         ctxt->errNo = error;
 666     __xmlRaiseError(NULL, NULL, NULL, ctxt, NULL,
 667                     XML_FROM_PARSER, error, XML_ERR_FATAL,
 668                     NULL, 0, (const char *) val, NULL, NULL, 0, 0, msg,
 669                     val);
 670     if (ctxt != NULL) {
 671         ctxt->wellFormed = 0;
 672         if (ctxt->recovery == 0)
 673             ctxt->disableSAX = 1;
 674     }
 675 }
 676
 677 /**
 678  * xmlErrMsgStr:
 679  * @ctxt:  an XML parser context
 680  * @error:  the error number
 681  * @msg:  the error message
 682  * @val:  a string value
 683  *
 684  * Handle a non fatal parser error
 685  */
 686 static void
 687 xmlErrMsgStr(xmlParserCtxtPtr ctxt, xmlParserErrors error,
 688                   const char *msg, const xmlChar * val)
 689 {
 690     if ((ctxt != NULL) && (ctxt->disableSAX != 0) &&
 691         (ctxt->instate == XML_PARSER_EOF))
 692         return;
 693     if (ctxt != NULL)
 694         ctxt->errNo = error;
 695     __xmlRaiseError(NULL, NULL, NULL, ctxt, NULL,
 696                     XML_FROM_PARSER, error, XML_ERR_ERROR,
 697                     NULL, 0, (const char *) val, NULL, NULL, 0, 0, msg,
 698                     val);
 699 }
 700
 701 /**
 702  * xmlNsErr:
 703  * @ctxt:  an XML parser context
 704  * @error:  the error number
 705  * @msg:  the message
 706  * @info1:  extra information string
 707  * @info2:  extra information string
 708  *
 709  * Handle a fatal parser error, i.e. violating Well-Formedness constraints
 710  */
 711 static void
 712 xmlNsErr(xmlParserCtxtPtr ctxt, xmlParserErrors error,
 713          const char *msg,
 714          const xmlChar * info1, const xmlChar * info2,
 715          const xmlChar * info3)
 716 {
 717     if ((ctxt != NULL) && (ctxt->disableSAX != 0) &&
 718         (ctxt->instate == XML_PARSER_EOF))
 719         return;
 720     if (ctxt != NULL)
 721         ctxt->errNo = error;
 722     __xmlRaiseError(NULL, NULL, NULL, ctxt, NULL, XML_FROM_NAMESPACE, error,
 723                     XML_ERR_ERROR, NULL, 0, (const char *) info1,
 724                     (const char *) info2, (const char *) info3, 0, 0, msg,
 725                     info1, info2, info3);
 726     if (ctxt != NULL)
 727         ctxt->nsWellFormed = 0;
 728 }
 729
 730 /**
 731  * xmlNsWarn
 732  * @ctxt:  an XML parser context
 733  * @error:  the error number
 734  * @msg:  the message
 735  * @info1:  extra information string
 736  * @info2:  extra information string
 737  *
 738  * Handle a namespace warning error
 739  */
 740 static void
 741 xmlNsWarn(xmlParserCtxtPtr ctxt, xmlParserErrors error,
 742          const char *msg,
 743          const xmlChar * info1, const xmlChar * info2,
 744          const xmlChar * info3)
 745 {
 746     if ((ctxt != NULL) && (ctxt->disableSAX != 0) &&
 747         (ctxt->instate == XML_PARSER_EOF))
 748         return;
 749     __xmlRaiseError(NULL, NULL, NULL, ctxt, NULL, XML_FROM_NAMESPACE, error,
 750                     XML_ERR_WARNING, NULL, 0, (const char *) info1,
 751                     (const char *) info2, (const char *) info3, 0, 0, msg,
 752                     info1, info2, info3);
 753 }
 754
 755 /************************************************************************
 756  *                                                                      *
 757  *              Library wide options                                    *
 758  *                                                                      *
 759  ************************************************************************/
 760
 761 /**
 762   * xmlHasFeature:
 763   * @feature: the feature to be examined
 764   *
 765   * Examines if the library has been compiled with a given feature.
 766   *
 767   * Returns a non-zero value if the feature exist, otherwise zero.
 768   * Returns zero (0) if the feature does not exist or an unknown
 769   * unknown feature is requested, non-zero otherwise.
 770   */
 771 int
 772 xmlHasFeature(xmlFeature feature)
 773 {
 774     switch (feature) {
 775         case XML_WITH_THREAD:
 776 #ifdef LIBXML_THREAD_ENABLED
 777             return(1);
 778 #else
 779             return(0);
 780 #endif
 781         case XML_WITH_TREE:
 782 #ifdef LIBXML_TREE_ENABLED
 783             return(1);
 784 #else
 785             return(0);
 786 #endif
 787         case XML_WITH_OUTPUT:
 788 #ifdef LIBXML_OUTPUT_ENABLED
 789             return(1);
 790 #else
 791             return(0);
 792 #endif
 793         case XML_WITH_PUSH:
 794 #ifdef LIBXML_PUSH_ENABLED
 795             return(1);
 796 #else
 797             return(0);
 798 #endif
 799         case XML_WITH_READER:
 800 #ifdef LIBXML_READER_ENABLED
 801             return(1);
 802 #else
 803             return(0);
 804 #endif
 805         case XML_WITH_PATTERN:
 806 #ifdef LIBXML_PATTERN_ENABLED
 807             return(1);
 808 #else
 809             return(0);
 810 #endif
 811         case XML_WITH_WRITER:
 812 #ifdef LIBXML_WRITER_ENABLED
 813             return(1);
 814 #else
 815             return(0);
 816 #endif
 817         case XML_WITH_SAX1:
 818 #ifdef LIBXML_SAX1_ENABLED
 819             return(1);
 820 #else
 821             return(0);
 822 #endif
 823         case XML_WITH_FTP:
 824 #ifdef LIBXML_FTP_ENABLED
 825             return(1);
 826 #else
 827             return(0);
 828 #endif
 829         case XML_WITH_HTTP:
 830 #ifdef LIBXML_HTTP_ENABLED
 831             return(1);
 832 #else
 833             return(0);
 834 #endif
 835         case XML_WITH_VALID:
 836 #ifdef LIBXML_VALID_ENABLED
 837             return(1);
 838 #else
 839             return(0);
 840 #endif
 841         case XML_WITH_HTML:
 842 #ifdef LIBXML_HTML_ENABLED
 843             return(1);
 844 #else
 845             return(0);
 846 #endif
 847         case XML_WITH_LEGACY:
 848 #ifdef LIBXML_LEGACY_ENABLED
 849             return(1);
 850 #else
 851             return(0);
 852 #endif
 853         case XML_WITH_C14N:
 854 #ifdef LIBXML_C14N_ENABLED
 855             return(1);
 856 #else
 857             return(0);
 858 #endif
 859         case XML_WITH_CATALOG:
 860 #ifdef LIBXML_CATALOG_ENABLED
 861             return(1);
 862 #else
 863             return(0);
 864 #endif
 865         case XML_WITH_XPATH:
 866 #ifdef LIBXML_XPATH_ENABLED
 867             return(1);
 868 #else
 869             return(0);
 870 #endif
 871         case XML_WITH_XPTR:
 872 #ifdef LIBXML_XPTR_ENABLED
 873             return(1);
 874 #else
 875             return(0);
 876 #endif
 877         case XML_WITH_XINCLUDE:
 878 #ifdef LIBXML_XINCLUDE_ENABLED
 879             return(1);
 880 #else
 881             return(0);
 882 #endif
 883         case XML_WITH_ICONV:
 884 #ifdef LIBXML_ICONV_ENABLED
 885             return(1);
 886 #else
 887             return(0);
 888 #endif
 889         case XML_WITH_ISO8859X:
 890 #ifdef LIBXML_ISO8859X_ENABLED
 891             return(1);
 892 #else
 893             return(0);
 894 #endif
 895         case XML_WITH_UNICODE:
 896 #ifdef LIBXML_UNICODE_ENABLED
 897             return(1);
 898 #else
 899             return(0);
 900 #endif
 901         case XML_WITH_REGEXP:
 902 #ifdef LIBXML_REGEXP_ENABLED
 903             return(1);
 904 #else
 905             return(0);
 906 #endif
 907         case XML_WITH_AUTOMATA:
 908 #ifdef LIBXML_AUTOMATA_ENABLED
 909             return(1);
 910 #else
 911             return(0);
 912 #endif
 913         case XML_WITH_EXPR:
 914 #ifdef LIBXML_EXPR_ENABLED
 915             return(1);
 916 #else
 917             return(0);
 918 #endif
 919         case XML_WITH_SCHEMAS:
 920 #ifdef LIBXML_SCHEMAS_ENABLED
 921             return(1);
 922 #else
 923             return(0);
 924 #endif
 925         case XML_WITH_SCHEMATRON:
 926 #ifdef LIBXML_SCHEMATRON_ENABLED
 927             return(1);
 928 #else
 929             return(0);
 930 #endif
 931         case XML_WITH_MODULES:
 932 #ifdef LIBXML_MODULES_ENABLED
 933             return(1);
 934 #else
 935             return(0);
 936 #endif
 937         case XML_WITH_DEBUG:
 938 #ifdef LIBXML_DEBUG_ENABLED
 939             return(1);
 940 #else
 941             return(0);
 942 #endif
 943         case XML_WITH_DEBUG_MEM:
 944 #ifdef DEBUG_MEMORY_LOCATION
 945             return(1);
 946 #else
 947             return(0);
 948 #endif
 949         case XML_WITH_DEBUG_RUN:
 950 #ifdef LIBXML_DEBUG_RUNTIME
 951             return(1);
 952 #else
 953             return(0);
 954 #endif
 955         case XML_WITH_ZLIB:
 956 #ifdef LIBXML_ZLIB_ENABLED
 957             return(1);
 958 #else
 959             return(0);
 960 #endif
 961         case XML_WITH_LZMA:
 962 #ifdef LIBXML_LZMA_ENABLED
 963             return(1);
 964 #else
 965             return(0);
 966 #endif
 967         case XML_WITH_ICU:
 968 #ifdef LIBXML_ICU_ENABLED
 969             return(1);
 970 #else
 971             return(0);
 972 #endif
 973         default:
 974             break;
 975      }
 976      return(0);
 977 }
 978
 979 /************************************************************************
 980  *                                                                      *
 981  *              SAX2 defaulted attributes handling                      *
 982  *                                                                      *
 983  ************************************************************************/
 984
 985 /**
 986  * xmlDetectSAX2:
 987  * @ctxt:  an XML parser context
 988  *
 989  * Do the SAX2 detection and specific intialization
 990  */
 991 static void
 992 xmlDetectSAX2(xmlParserCtxtPtr ctxt) {
 993     if (ctxt == NULL) return;
 994 #ifdef LIBXML_SAX1_ENABLED
 995     if ((ctxt->sax) &&  (ctxt->sax->initialized == XML_SAX2_MAGIC) &&
 996         ((ctxt->sax->startElementNs != NULL) ||
 997          (ctxt->sax->endElementNs != NULL))) ctxt->sax2 = 1;
 998 #else
 999     ctxt->sax2 = 1;
1000 #endif /* LIBXML_SAX1_ENABLED */
1001
1002     ctxt->str_xml = xmlDictLookup(ctxt->dict, BAD_CAST "xml", 3);
1003     ctxt->str_xmlns = xmlDictLookup(ctxt->dict, BAD_CAST "xmlns", 5);
1004     ctxt->str_xml_ns = xmlDictLookup(ctxt->dict, XML_XML_NAMESPACE, 36);
1005     if ((ctxt->str_xml==NULL) || (ctxt->str_xmlns==NULL) ||
1006                 (ctxt->str_xml_ns == NULL)) {
1007         xmlErrMemory(ctxt, NULL);
1008     }
1009 }
1010
1011 typedef struct _xmlDefAttrs xmlDefAttrs;
1012 typedef xmlDefAttrs *xmlDefAttrsPtr;
1013 struct _xmlDefAttrs {
1014     int nbAttrs;        /* number of defaulted attributes on that element */
1015     int maxAttrs;       /* the size of the array */
1016     const xmlChar *values[5]; /* array of localname/prefix/values/external */
1017 };
1018
1019 /**
1020  * xmlAttrNormalizeSpace:
1021  * @src: the source string
1022  * @dst: the target string
1023  *
1024  * Normalize the space in non CDATA attribute values:
1025  * If the attribute type is not CDATA, then the XML processor MUST further
1026  * process the normalized attribute value by discarding any leading and
1027  * trailing space (#x20) characters, and by replacing sequences of space
1028  * (#x20) characters by a single space (#x20) character.
1029  * Note that the size of dst need to be at least src, and if one doesn't need
1030  * to preserve dst (and it doesn't come from a dictionary or read-only) then
1031  * passing src as dst is just fine.
1032  *
1033  * Returns a pointer to the normalized value (dst) or NULL if no conversion
1034  *         is needed.
1035  */
1036 static xmlChar *
1037 xmlAttrNormalizeSpace(const xmlChar *src, xmlChar *dst)
1038 {
1039     if ((src == NULL) || (dst == NULL))
1040         return(NULL);
1041
1042     while (*src == 0x20) src++;
1043     while (*src != 0) {
1044         if (*src == 0x20) {
1045             while (*src == 0x20) src++;
1046             if (*src != 0)
1047                 *dst++ = 0x20;
1048         } else {
1049             *dst++ = *src++;
1050         }
1051     }
1052     *dst = 0;
1053     if (dst == src)
1054        return(NULL);
1055     return(dst);
1056 }
1057
1058 /**
1059  * xmlAttrNormalizeSpace2:
1060  * @src: the source string
1061  *
1062  * Normalize the space in non CDATA attribute values, a slightly more complex
1063  * front end to avoid allocation problems when running on attribute values
1064  * coming from the input.
1065  *
1066  * Returns a pointer to the normalized value (dst) or NULL if no conversion
1067  *         is needed.
1068  */
1069 static const xmlChar *
1070 xmlAttrNormalizeSpace2(xmlParserCtxtPtr ctxt, xmlChar *src, int *len)
1071 {
1072     int i;
1073     int remove_head = 0;
1074     int need_realloc = 0;
1075     const xmlChar *cur;
1076
1077     if ((ctxt == NULL) || (src == NULL) || (len == NULL))
1078         return(NULL);
1079     i = *len;
1080     if (i <= 0)
1081         return(NULL);
1082
1083     cur = src;
1084     while (*cur == 0x20) {
1085         cur++;
1086         remove_head++;
1087     }
1088     while (*cur != 0) {
1089         if (*cur == 0x20) {
1090             cur++;
1091             if ((*cur == 0x20) || (*cur == 0)) {
1092                 need_realloc = 1;
1093                 break;
1094             }
1095         } else
1096             cur++;
1097     }
1098     if (need_realloc) {
1099         xmlChar *ret;
1100
1101         ret = xmlStrndup(src + remove_head, i - remove_head + 1);
1102         if (ret == NULL) {
1103             xmlErrMemory(ctxt, NULL);
1104             return(NULL);
1105         }
1106         xmlAttrNormalizeSpace(ret, ret);
1107         *len = (int) strlen((const char *)ret);
1108         return(ret);
1109     } else if (remove_head) {
1110         *len -= remove_head;
1111         memmove(src, src + remove_head, 1 + *len);
1112         return(src);
1113     }
1114     return(NULL);
1115 }
1116
1117 /**
1118  * xmlAddDefAttrs:
1119  * @ctxt:  an XML parser context
1120  * @fullname:  the element fullname
1121  * @fullattr:  the attribute fullname
1122  * @value:  the attribute value
1123  *
1124  * Add a defaulted attribute for an element
1125  */
1126 static void
1127 xmlAddDefAttrs(xmlParserCtxtPtr ctxt,
1128                const xmlChar *fullname,
1129                const xmlChar *fullattr,
1130                const xmlChar *value) {
1131     xmlDefAttrsPtr defaults;
1132     int len;
1133     const xmlChar *name;
1134     const xmlChar *prefix;
1135
1136     /*
1137      * Allows to detect attribute redefinitions
1138      */
1139     if (ctxt->attsSpecial != NULL) {
1140         if (xmlHashLookup2(ctxt->attsSpecial, fullname, fullattr) != NULL)
1141             return;
1142     }
1143
1144     if (ctxt->attsDefault == NULL) {
1145         ctxt->attsDefault = xmlHashCreateDict(10, ctxt->dict);
1146         if (ctxt->attsDefault == NULL)
1147             goto mem_error;
1148     }
1149
1150     /*
1151      * split the element name into prefix:localname , the string found
1152      * are within the DTD and then not associated to namespace names.
1153      */
1154     name = xmlSplitQName3(fullname, &len);
1155     if (name == NULL) {
1156         name = xmlDictLookup(ctxt->dict, fullname, -1);
1157         prefix = NULL;
1158     } else {
1159         name = xmlDictLookup(ctxt->dict, name, -1);
1160         prefix = xmlDictLookup(ctxt->dict, fullname, len);
1161     }
1162
1163     /*
1164      * make sure there is some storage
1165      */
1166     defaults = xmlHashLookup2(ctxt->attsDefault, name, prefix);
1167     if (defaults == NULL) {
1168         defaults = (xmlDefAttrsPtr) xmlMalloc(sizeof(xmlDefAttrs) +
1169                            (4 * 5) * sizeof(const xmlChar *));
1170         if (defaults == NULL)
1171             goto mem_error;
1172         defaults->nbAttrs = 0;
1173         defaults->maxAttrs = 4;
1174         if (xmlHashUpdateEntry2(ctxt->attsDefault, name, prefix,
1175                                 defaults, NULL) < 0) {
1176             xmlFree(defaults);
1177             goto mem_error;
1178         }
1179     } else if (defaults->nbAttrs >= defaults->maxAttrs) {
1180         xmlDefAttrsPtr temp;
1181
1182         temp = (xmlDefAttrsPtr) xmlRealloc(defaults, sizeof(xmlDefAttrs) +
1183                        (2 * defaults->maxAttrs * 5) * sizeof(const xmlChar *));
1184         if (temp == NULL)
1185             goto mem_error;
1186         defaults = temp;
1187         defaults->maxAttrs *= 2;
1188         if (xmlHashUpdateEntry2(ctxt->attsDefault, name, prefix,
1189                                 defaults, NULL) < 0) {
1190             xmlFree(defaults);
1191             goto mem_error;
1192         }
1193     }
1194
1195     /*
1196      * Split the element name into prefix:localname , the string found
1197      * are within the DTD and hen not associated to namespace names.
1198      */
1199     name = xmlSplitQName3(fullattr, &len);
1200     if (name == NULL) {
1201         name = xmlDictLookup(ctxt->dict, fullattr, -1);
1202         prefix = NULL;
1203     } else {
1204         name = xmlDictLookup(ctxt->dict, name, -1);
1205         prefix = xmlDictLookup(ctxt->dict, fullattr, len);
1206     }
1207
1208     defaults->values[5 * defaults->nbAttrs] = name;
1209     defaults->values[5 * defaults->nbAttrs + 1] = prefix;
1210     /* intern the string and precompute the end */
1211     len = xmlStrlen(value);
1212     value = xmlDictLookup(ctxt->dict, value, len);
1213     defaults->values[5 * defaults->nbAttrs + 2] = value;
1214     defaults->values[5 * defaults->nbAttrs + 3] = value + len;
1215     if (ctxt->external)
1216         defaults->values[5 * defaults->nbAttrs + 4] = BAD_CAST "external";
1217     else
1218         defaults->values[5 * defaults->nbAttrs + 4] = NULL;
1219     defaults->nbAttrs++;
1220
1221     return;
1222
1223 mem_error:
1224     xmlErrMemory(ctxt, NULL);
1225     return;
1226 }
1227
1228 /**
1229  * xmlAddSpecialAttr:
1230  * @ctxt:  an XML parser context
1231  * @fullname:  the element fullname
1232  * @fullattr:  the attribute fullname
1233  * @type:  the attribute type
1234  *
1235  * Register this attribute type
1236  */
1237 static void
1238 xmlAddSpecialAttr(xmlParserCtxtPtr ctxt,
1239                   const xmlChar *fullname,
1240                   const xmlChar *fullattr,
1241                   int type)
1242 {
1243     if (ctxt->attsSpecial == NULL) {
1244         ctxt->attsSpecial = xmlHashCreateDict(10, ctxt->dict);
1245         if (ctxt->attsSpecial == NULL)
1246             goto mem_error;
1247     }
1248
1249     if (xmlHashLookup2(ctxt->attsSpecial, fullname, fullattr) != NULL)
1250         return;
1251
1252     xmlHashAddEntry2(ctxt->attsSpecial, fullname, fullattr,
1253                      (void *) (long) type);
1254     return;
1255
1256 mem_error:
1257     xmlErrMemory(ctxt, NULL);
1258     return;
1259 }
1260
1261 /**
1262  * xmlCleanSpecialAttrCallback:
1263  *
1264  * Removes CDATA attributes from the special attribute table
1265  */
1266 static void
1267 xmlCleanSpecialAttrCallback(void *payload, void *data,
1268                             const xmlChar *fullname, const xmlChar *fullattr,
1269                             const xmlChar *unused ATTRIBUTE_UNUSED) {
1270     xmlParserCtxtPtr ctxt = (xmlParserCtxtPtr) data;
1271
1272     if (((long) payload) == XML_ATTRIBUTE_CDATA) {
1273         xmlHashRemoveEntry2(ctxt->attsSpecial, fullname, fullattr, NULL);
1274     }
1275 }
1276
1277 /**
1278  * xmlCleanSpecialAttr:
1279  * @ctxt:  an XML parser context
1280  *
1281  * Trim the list of attributes defined to remove all those of type
1282  * CDATA as they are not special. This call should be done when finishing
1283  * to parse the DTD and before starting to parse the document root.
1284  */
1285 static void
1286 xmlCleanSpecialAttr(xmlParserCtxtPtr ctxt)
1287 {
1288     if (ctxt->attsSpecial == NULL)
1289         return;
1290
1291     xmlHashScanFull(ctxt->attsSpecial, xmlCleanSpecialAttrCallback, ctxt);
1292
1293     if (xmlHashSize(ctxt->attsSpecial) == 0) {
1294         xmlHashFree(ctxt->attsSpecial, NULL);
1295         ctxt->attsSpecial = NULL;
1296     }
1297     return;
1298 }
1299
1300 /**
1301  * xmlCheckLanguageID:
1302  * @lang:  pointer to the string value
1303  *
1304  * Checks that the value conforms to the LanguageID production:
1305  *
1306  * NOTE: this is somewhat deprecated, those productions were removed from
1307  *       the XML Second edition.
1308  *
1309  * [33] LanguageID ::= Langcode ('-' Subcode)*
1310  * [34] Langcode ::= ISO639Code |  IanaCode |  UserCode
1311  * [35] ISO639Code ::= ([a-z] | [A-Z]) ([a-z] | [A-Z])
1312  * [36] IanaCode ::= ('i' | 'I') '-' ([a-z] | [A-Z])+
1313  * [37] UserCode ::= ('x' | 'X') '-' ([a-z] | [A-Z])+
1314  * [38] Subcode ::= ([a-z] | [A-Z])+
1315  *
1316  * The current REC reference the sucessors of RFC 1766, currently 5646
1317  *
1318  * http://www.rfc-editor.org/rfc/rfc5646.txt
1319  * langtag       = language
1320  *                 ["-" script]
1321  *                 ["-" region]
1322  *                 *("-" variant)
1323  *                 *("-" extension)
1324  *                 ["-" privateuse]
1325  * language      = 2*3ALPHA            ; shortest ISO 639 code
1326  *                 ["-" extlang]       ; sometimes followed by
1327  *                                     ; extended language subtags
1328  *               / 4ALPHA              ; or reserved for future use
1329  *               / 5*8ALPHA            ; or registered language subtag
1330  *
1331  * extlang       = 3ALPHA              ; selected ISO 639 codes
1332  *                 *2("-" 3ALPHA)      ; permanently reserved
1333  *
1334  * script        = 4ALPHA              ; ISO 15924 code
1335  *
1336  * region        = 2ALPHA              ; ISO 3166-1 code
1337  *               / 3DIGIT              ; UN M.49 code
1338  *
1339  * variant       = 5*8alphanum         ; registered variants
1340  *               / (DIGIT 3alphanum)
1341  *
1342  * extension     = singleton 1*("-" (2*8alphanum))
1343  *
1344  *                                     ; Single alphanumerics
1345  *                                     ; "x" reserved for private use
1346  * singleton     = DIGIT               ; 0 - 9
1347  *               / %x41-57             ; A - W
1348  *               / %x59-5A             ; Y - Z
1349  *               / %x61-77             ; a - w
1350  *               / %x79-7A             ; y - z
1351  *
1352  * it sounds right to still allow Irregular i-xxx IANA and user codes too
1353  * The parser below doesn't try to cope with extension or privateuse
1354  * that could be added but that's not interoperable anyway
1355  *
1356  * Returns 1 if correct 0 otherwise
1357  **/
1358 int
1359 xmlCheckLanguageID(const xmlChar * lang)
1360 {
1361     const xmlChar *cur = lang, *nxt;
1362
1363     if (cur == NULL)
1364         return (0);
1365     if (((cur[0] == 'i') && (cur[1] == '-')) ||
1366         ((cur[0] == 'I') && (cur[1] == '-')) ||
1367         ((cur[0] == 'x') && (cur[1] == '-')) ||
1368         ((cur[0] == 'X') && (cur[1] == '-'))) {
1369         /*
1370          * Still allow IANA code and user code which were coming
1371          * from the previous version of the XML-1.0 specification
1372          * it's deprecated but we should not fail
1373          */
1374         cur += 2;
1375         while (((cur[0] >= 'A') && (cur[0] <= 'Z')) ||
1376                ((cur[0] >= 'a') && (cur[0] <= 'z')))
1377             cur++;
1378         return(cur[0] == 0);
1379     }
1380     nxt = cur;
1381     while (((nxt[0] >= 'A') && (nxt[0] <= 'Z')) ||
1382            ((nxt[0] >= 'a') && (nxt[0] <= 'z')))
1383            nxt++;
1384     if (nxt - cur >= 4) {
1385         /*
1386          * Reserved
1387          */
1388         if ((nxt - cur > 8) || (nxt[0] != 0))
1389             return(0);
1390         return(1);
1391     }
1392     if (nxt - cur < 2)
1393         return(0);
1394     /* we got an ISO 639 code */
1395     if (nxt[0] == 0)
1396         return(1);
1397     if (nxt[0] != '-')
1398         return(0);
1399
1400     nxt++;
1401     cur = nxt;
1402     /* now we can have extlang or script or region or variant */
1403     if ((nxt[0] >= '0') && (nxt[0] <= '9'))
1404         goto region_m49;
1405
1406     while (((nxt[0] >= 'A') && (nxt[0] <= 'Z')) ||
1407            ((nxt[0] >= 'a') && (nxt[0] <= 'z')))
1408            nxt++;
1409     if (nxt - cur == 4)
1410         goto script;
1411     if (nxt - cur == 2)
1412         goto region;
1413     if ((nxt - cur >= 5) && (nxt - cur <= 8))
1414         goto variant;
1415     if (nxt - cur != 3)
1416         return(0);
1417     /* we parsed an extlang */
1418     if (nxt[0] == 0)
1419         return(1);
1420     if (nxt[0] != '-')
1421         return(0);
1422
1423     nxt++;
1424     cur = nxt;
1425     /* now we can have script or region or variant */
1426     if ((nxt[0] >= '0') && (nxt[0] <= '9'))
1427         goto region_m49;
1428
1429     while (((nxt[0] >= 'A') && (nxt[0] <= 'Z')) ||
1430            ((nxt[0] >= 'a') && (nxt[0] <= 'z')))
1431            nxt++;
1432     if (nxt - cur == 2)
1433         goto region;
1434     if ((nxt - cur >= 5) && (nxt - cur <= 8))
1435         goto variant;
1436     if (nxt - cur != 4)
1437         return(0);
1438     /* we parsed a script */
1439 script:
1440     if (nxt[0] == 0)
1441         return(1);
1442     if (nxt[0] != '-')
1443         return(0);
1444
1445     nxt++;
1446     cur = nxt;
1447     /* now we can have region or variant */
1448     if ((nxt[0] >= '0') && (nxt[0] <= '9'))
1449         goto region_m49;
1450
1451     while (((nxt[0] >= 'A') && (nxt[0] <= 'Z')) ||
1452            ((nxt[0] >= 'a') && (nxt[0] <= 'z')))
1453            nxt++;
1454
1455     if ((nxt - cur >= 5) && (nxt - cur <= 8))
1456         goto variant;
1457     if (nxt - cur != 2)
1458         return(0);
1459     /* we parsed a region */
1460 region:
1461     if (nxt[0] == 0)
1462         return(1);
1463     if (nxt[0] != '-')
1464         return(0);
1465
1466     nxt++;
1467     cur = nxt;
1468     /* now we can just have a variant */
1469     while (((nxt[0] >= 'A') && (nxt[0] <= 'Z')) ||
1470            ((nxt[0] >= 'a') && (nxt[0] <= 'z')))
1471            nxt++;
1472
1473     if ((nxt - cur < 5) || (nxt - cur > 8))
1474         return(0);
1475
1476     /* we parsed a variant */
1477 variant:
1478     if (nxt[0] == 0)
1479         return(1);
1480     if (nxt[0] != '-')
1481         return(0);
1482     /* extensions and private use subtags not checked */
1483     return (1);
1484
1485 region_m49:
1486     if (((nxt[1] >= '0') && (nxt[1] <= '9')) &&
1487         ((nxt[2] >= '0') && (nxt[2] <= '9'))) {
1488         nxt += 3;
1489         goto region;
1490     }
1491     return(0);
1492 }
1493
1494 /************************************************************************
1495  *                                                                      *
1496  *              Parser stacks related functions and macros              *
1497  *                                                                      *
1498  ************************************************************************/
1499
1500 static xmlEntityPtr xmlParseStringEntityRef(xmlParserCtxtPtr ctxt,
1501                                             const xmlChar ** str);
1502
1503 #ifdef SAX2
1504 /**
1505  * nsPush:
1506  * @ctxt:  an XML parser context
1507  * @prefix:  the namespace prefix or NULL
1508  * @URL:  the namespace name
1509  *
1510  * Pushes a new parser namespace on top of the ns stack
1511  *
1512  * Returns -1 in case of error, -2 if the namespace should be discarded
1513  *         and the index in the stack otherwise.
1514  */
1515 static int
1516 nsPush(xmlParserCtxtPtr ctxt, const xmlChar *prefix, const xmlChar *URL)
1517 {
1518     if (ctxt->options & XML_PARSE_NSCLEAN) {
1519         int i;
1520         for (i = 0;i < ctxt->nsNr;i += 2) {
1521             if (ctxt->nsTab[i] == prefix) {
1522                 /* in scope */
1523                 if (ctxt->nsTab[i + 1] == URL)
1524                     return(-2);
1525                 /* out of scope keep it */
1526                 break;
1527             }
1528         }
1529     }
1530     if ((ctxt->nsMax == 0) || (ctxt->nsTab == NULL)) {
1531         ctxt->nsMax = 10;
1532         ctxt->nsNr = 0;
1533         ctxt->nsTab = (const xmlChar **)
1534                       xmlMalloc(ctxt->nsMax * sizeof(xmlChar *));
1535         if (ctxt->nsTab == NULL) {
1536             xmlErrMemory(ctxt, NULL);
1537             ctxt->nsMax = 0;
1538             return (-1);
1539         }
1540     } else if (ctxt->nsNr >= ctxt->nsMax) {
1541         const xmlChar ** tmp;
1542         ctxt->nsMax *= 2;
1543         tmp = (const xmlChar **) xmlRealloc((char *) ctxt->nsTab,
1544                                     ctxt->nsMax * sizeof(ctxt->nsTab[0]));
1545         if (tmp == NULL) {
1546             xmlErrMemory(ctxt, NULL);
1547             ctxt->nsMax /= 2;
1548             return (-1);
1549         }
1550         ctxt->nsTab = tmp;
1551     }
1552     ctxt->nsTab[ctxt->nsNr++] = prefix;
1553     ctxt->nsTab[ctxt->nsNr++] = URL;
1554     return (ctxt->nsNr);
1555 }
1556 /**
1557  * nsPop:
1558  * @ctxt: an XML parser context
1559  * @nr:  the number to pop
1560  *
1561  * Pops the top @nr parser prefix/namespace from the ns stack
1562  *
1563  * Returns the number of namespaces removed
1564  */
1565 static int
1566 nsPop(xmlParserCtxtPtr ctxt, int nr)
1567 {
1568     int i;
1569
1570     if (ctxt->nsTab == NULL) return(0);
1571     if (ctxt->nsNr < nr) {
1572         xmlGenericError(xmlGenericErrorContext, "Pbm popping %d NS\n", nr);
1573         nr = ctxt->nsNr;
1574     }
1575     if (ctxt->nsNr <= 0)
1576         return (0);
1577
1578     for (i = 0;i < nr;i++) {
1579          ctxt->nsNr--;
1580          ctxt->nsTab[ctxt->nsNr] = NULL;
1581     }
1582     return(nr);
1583 }
1584 #endif
1585
1586 static int
1587 xmlCtxtGrowAttrs(xmlParserCtxtPtr ctxt, int nr) {
1588     const xmlChar **atts;
1589     int *attallocs;
1590     int maxatts;
1591
1592     if (ctxt->atts == NULL) {
1593         maxatts = 55; /* allow for 10 attrs by default */
1594         atts = (const xmlChar **)
1595                xmlMalloc(maxatts * sizeof(xmlChar *));
1596         if (atts == NULL) goto mem_error;
1597         ctxt->atts = atts;
1598         attallocs = (int *) xmlMalloc((maxatts / 5) * sizeof(int));
1599         if (attallocs == NULL) goto mem_error;
1600         ctxt->attallocs = attallocs;
1601         ctxt->maxatts = maxatts;
1602     } else if (nr + 5 > ctxt->maxatts) {
1603         maxatts = (nr + 5) * 2;
1604         atts = (const xmlChar **) xmlRealloc((void *) ctxt->atts,
1605                                      maxatts * sizeof(const xmlChar *));
1606         if (atts == NULL) goto mem_error;
1607         ctxt->atts = atts;
1608         attallocs = (int *) xmlRealloc((void *) ctxt->attallocs,
1609                                      (maxatts / 5) * sizeof(int));
1610         if (attallocs == NULL) goto mem_error;
1611         ctxt->attallocs = attallocs;
1612         ctxt->maxatts = maxatts;
1613     }
1614     return(ctxt->maxatts);
1615 mem_error:
1616     xmlErrMemory(ctxt, NULL);
1617     return(-1);
1618 }
1619
1620 /**
1621  * inputPush:
1622  * @ctxt:  an XML parser context
1623  * @value:  the parser input
1624  *
1625  * Pushes a new parser input on top of the input stack
1626  *
1627  * Returns -1 in case of error, the index in the stack otherwise
1628  */
1629 int
1630 inputPush(xmlParserCtxtPtr ctxt, xmlParserInputPtr value)
1631 {
1632     if ((ctxt == NULL) || (value == NULL))
1633         return(-1);
1634     if (ctxt->inputNr >= ctxt->inputMax) {
1635         ctxt->inputMax *= 2;
1636         ctxt->inputTab =
1637             (xmlParserInputPtr *) xmlRealloc(ctxt->inputTab,
1638                                              ctxt->inputMax *
1639                                              sizeof(ctxt->inputTab[0]));
1640         if (ctxt->inputTab == NULL) {
1641             xmlErrMemory(ctxt, NULL);
1642             xmlFreeInputStream(value);
1643             ctxt->inputMax /= 2;
1644             value = NULL;
1645             return (-1);
1646         }
1647     }
1648     ctxt->inputTab[ctxt->inputNr] = value;
1649     ctxt->input = value;
1650     return (ctxt->inputNr++);
1651 }
1652 /**
1653  * inputPop:
1654  * @ctxt: an XML parser context
1655  *
1656  * Pops the top parser input from the input stack
1657  *
1658  * Returns the input just removed
1659  */
1660 xmlParserInputPtr
1661 inputPop(xmlParserCtxtPtr ctxt)
1662 {
1663     xmlParserInputPtr ret;
1664
1665     if (ctxt == NULL)
1666         return(NULL);
1667     if (ctxt->inputNr <= 0)
1668         return (NULL);
1669     ctxt->inputNr--;
1670     if (ctxt->inputNr > 0)
1671         ctxt->input = ctxt->inputTab[ctxt->inputNr - 1];
1672     else
1673         ctxt->input = NULL;
1674     ret = ctxt->inputTab[ctxt->inputNr];
1675     ctxt->inputTab[ctxt->inputNr] = NULL;
1676     return (ret);
1677 }
1678 /**
1679  * nodePush:
1680  * @ctxt:  an XML parser context
1681  * @value:  the element node
1682  *
1683  * Pushes a new element node on top of the node stack
1684  *
1685  * Returns -1 in case of error, the index in the stack otherwise
1686  */
1687 int
1688 nodePush(xmlParserCtxtPtr ctxt, xmlNodePtr value)
1689 {
1690     if (ctxt == NULL) return(0);
1691     if (ctxt->nodeNr >= ctxt->nodeMax) {
1692         xmlNodePtr *tmp;
1693
1694         tmp = (xmlNodePtr *) xmlRealloc(ctxt->nodeTab,
1695                                       ctxt->nodeMax * 2 *
1696                                       sizeof(ctxt->nodeTab[0]));
1697         if (tmp == NULL) {
1698             xmlErrMemory(ctxt, NULL);
1699             return (-1);
1700         }
1701         ctxt->nodeTab = tmp;
1702         ctxt->nodeMax *= 2;
1703     }
1704     if ((((unsigned int) ctxt->nodeNr) > xmlParserMaxDepth) &&
1705         ((ctxt->options & XML_PARSE_HUGE) == 0)) {
1706         xmlFatalErrMsgInt(ctxt, XML_ERR_INTERNAL_ERROR,
1707                  "Excessive depth in document: %d use XML_PARSE_HUGE option\n",
1708                           xmlParserMaxDepth);
1709         ctxt->instate = XML_PARSER_EOF;
1710         return(-1);
1711     }
1712     ctxt->nodeTab[ctxt->nodeNr] = value;
1713     ctxt->node = value;
1714     return (ctxt->nodeNr++);
1715 }
1716
1717 /**
1718  * nodePop:
1719  * @ctxt: an XML parser context
1720  *
1721  * Pops the top element node from the node stack
1722  *
1723  * Returns the node just removed
1724  */
1725 xmlNodePtr
1726 nodePop(xmlParserCtxtPtr ctxt)
1727 {
1728     xmlNodePtr ret;
1729
1730     if (ctxt == NULL) return(NULL);
1731     if (ctxt->nodeNr <= 0)
1732         return (NULL);
1733     ctxt->nodeNr--;
1734     if (ctxt->nodeNr > 0)
1735         ctxt->node = ctxt->nodeTab[ctxt->nodeNr - 1];
1736     else
1737         ctxt->node = NULL;
1738     ret = ctxt->nodeTab[ctxt->nodeNr];
1739     ctxt->nodeTab[ctxt->nodeNr] = NULL;
1740     return (ret);
1741 }
1742
1743 #ifdef LIBXML_PUSH_ENABLED
1744 /**
1745  * nameNsPush:
1746  * @ctxt:  an XML parser context
1747  * @value:  the element name
1748  * @prefix:  the element prefix
1749  * @URI:  the element namespace name
1750  *
1751  * Pushes a new element name/prefix/URL on top of the name stack
1752  *
1753  * Returns -1 in case of error, the index in the stack otherwise
1754  */
1755 static int
1756 nameNsPush(xmlParserCtxtPtr ctxt, const xmlChar * value,
1757            const xmlChar *prefix, const xmlChar *URI, int nsNr)
1758 {
1759     if (ctxt->nameNr >= ctxt->nameMax) {
1760         const xmlChar * *tmp;
1761         void **tmp2;
1762         ctxt->nameMax *= 2;
1763         tmp = (const xmlChar * *) xmlRealloc((xmlChar * *)ctxt->nameTab,
1764                                     ctxt->nameMax *
1765                                     sizeof(ctxt->nameTab[0]));
1766         if (tmp == NULL) {
1767             ctxt->nameMax /= 2;
1768             goto mem_error;
1769         }
1770         ctxt->nameTab = tmp;
1771         tmp2 = (void **) xmlRealloc((void * *)ctxt->pushTab,
1772                                     ctxt->nameMax * 3 *
1773                                     sizeof(ctxt->pushTab[0]));
1774         if (tmp2 == NULL) {
1775             ctxt->nameMax /= 2;
1776             goto mem_error;
1777         }
1778         ctxt->pushTab = tmp2;
1779     }
1780     ctxt->nameTab[ctxt->nameNr] = value;
1781     ctxt->name = value;
1782     ctxt->pushTab[ctxt->nameNr * 3] = (void *) prefix;
1783     ctxt->pushTab[ctxt->nameNr * 3 + 1] = (void *) URI;
1784     ctxt->pushTab[ctxt->nameNr * 3 + 2] = (void *) (long) nsNr;
1785     return (ctxt->nameNr++);
1786 mem_error:
1787     xmlErrMemory(ctxt, NULL);
1788     return (-1);
1789 }
1790 /**
1791  * nameNsPop:
1792  * @ctxt: an XML parser context
1793  *
1794  * Pops the top element/prefix/URI name from the name stack
1795  *
1796  * Returns the name just removed
1797  */
1798 static const xmlChar *
1799 nameNsPop(xmlParserCtxtPtr ctxt)
1800 {
1801     const xmlChar *ret;
1802
1803     if (ctxt->nameNr <= 0)
1804         return (NULL);
1805     ctxt->nameNr--;
1806     if (ctxt->nameNr > 0)
1807         ctxt->name = ctxt->nameTab[ctxt->nameNr - 1];
1808     else
1809         ctxt->name = NULL;
1810     ret = ctxt->nameTab[ctxt->nameNr];
1811     ctxt->nameTab[ctxt->nameNr] = NULL;
1812     return (ret);
1813 }
1814 #endif /* LIBXML_PUSH_ENABLED */
1815
1816 /**
1817  * namePush:
1818  * @ctxt:  an XML parser context
1819  * @value:  the element name
1820  *
1821  * Pushes a new element name on top of the name stack
1822  *
1823  * Returns -1 in case of error, the index in the stack otherwise
1824  */
1825 int
1826 namePush(xmlParserCtxtPtr ctxt, const xmlChar * value)
1827 {
1828     if (ctxt == NULL) return (-1);
1829
1830     if (ctxt->nameNr >= ctxt->nameMax) {
1831         const xmlChar * *tmp;
1832         tmp = (const xmlChar * *) xmlRealloc((xmlChar * *)ctxt->nameTab,
1833                                     ctxt->nameMax * 2 *
1834                                     sizeof(ctxt->nameTab[0]));
1835         if (tmp == NULL) {
1836             goto mem_error;
1837         }
1838         ctxt->nameTab = tmp;
1839         ctxt->nameMax *= 2;
1840     }
1841     ctxt->nameTab[ctxt->nameNr] = value;
1842     ctxt->name = value;
1843     return (ctxt->nameNr++);
1844 mem_error:
1845     xmlErrMemory(ctxt, NULL);
1846     return (-1);
1847 }
1848 /**
1849  * namePop:
1850  * @ctxt: an XML parser context
1851  *
1852  * Pops the top element name from the name stack
1853  *
1854  * Returns the name just removed
1855  */
1856 const xmlChar *
1857 namePop(xmlParserCtxtPtr ctxt)
1858 {
1859     const xmlChar *ret;
1860
1861     if ((ctxt == NULL) || (ctxt->nameNr <= 0))
1862         return (NULL);
1863     ctxt->nameNr--;
1864     if (ctxt->nameNr > 0)
1865         ctxt->name = ctxt->nameTab[ctxt->nameNr - 1];
1866     else
1867         ctxt->name = NULL;
1868     ret = ctxt->nameTab[ctxt->nameNr];
1869     ctxt->nameTab[ctxt->nameNr] = NULL;
1870     return (ret);
1871 }
1872
1873 static int spacePush(xmlParserCtxtPtr ctxt, int val) {
1874     if (ctxt->spaceNr >= ctxt->spaceMax) {
1875         int *tmp;
1876
1877         ctxt->spaceMax *= 2;
1878         tmp = (int *) xmlRealloc(ctxt->spaceTab,
1879                                  ctxt->spaceMax * sizeof(ctxt->spaceTab[0]));
1880         if (tmp == NULL) {
1881             xmlErrMemory(ctxt, NULL);
1882             ctxt->spaceMax /=2;
1883             return(-1);
1884         }
1885         ctxt->spaceTab = tmp;
1886     }
1887     ctxt->spaceTab[ctxt->spaceNr] = val;
1888     ctxt->space = &ctxt->spaceTab[ctxt->spaceNr];
1889     return(ctxt->spaceNr++);
1890 }
1891
1892 static int spacePop(xmlParserCtxtPtr ctxt) {
1893     int ret;
1894     if (ctxt->spaceNr <= 0) return(0);
1895     ctxt->spaceNr--;
1896     if (ctxt->spaceNr > 0)
1897         ctxt->space = &ctxt->spaceTab[ctxt->spaceNr - 1];
1898     else
1899         ctxt->space = &ctxt->spaceTab[0];
1900     ret = ctxt->spaceTab[ctxt->spaceNr];
1901     ctxt->spaceTab[ctxt->spaceNr] = -1;
1902     return(ret);
1903 }
1904
1905 /*
1906  * Macros for accessing the content. Those should be used only by the parser,
1907  * and not exported.
1908  *
1909  * Dirty macros, i.e. one often need to make assumption on the context to
1910  * use them
1911  *
1912  *   CUR_PTR return the current pointer to the xmlChar to be parsed.
1913  *           To be used with extreme caution since operations consuming
1914  *           characters may move the input buffer to a different location !
1915  *   CUR     returns the current xmlChar value, i.e. a 8 bit value if compiled
1916  *           This should be used internally by the parser
1917  *           only to compare to ASCII values otherwise it would break when
1918  *           running with UTF-8 encoding.
1919  *   RAW     same as CUR but in the input buffer, bypass any token
1920  *           extraction that may have been done
1921  *   NXT(n)  returns the n'th next xmlChar. Same as CUR is should be used only
1922  *           to compare on ASCII based substring.
1923  *   SKIP(n) Skip n xmlChar, and must also be used only to skip ASCII defined
1924  *           strings without newlines within the parser.
1925  *   NEXT1(l) Skip 1 xmlChar, and must also be used only to skip 1 non-newline ASCII
1926  *           defined char within the parser.
1927  * Clean macros, not dependent of an ASCII context, expect UTF-8 encoding
1928  *
1929  *   NEXT    Skip to the next character, this does the proper decoding
1930  *           in UTF-8 mode. It also pop-up unfinished entities on the fly.
1931  *   NEXTL(l) Skip the current unicode character of l xmlChars long.
1932  *   CUR_CHAR(l) returns the current unicode character (int), set l
1933  *           to the number of xmlChars used for the encoding [0-5].
1934  *   CUR_SCHAR  same but operate on a string instead of the context
1935  *   COPY_BUF  copy the current unicode char to the target buffer, increment
1936  *            the index
1937  *   GROW, SHRINK  handling of input buffers
1938  */
1939
1940 #define RAW (*ctxt->input->cur)
1941 #define CUR (*ctxt->input->cur)
1942 #define NXT(val) ctxt->input->cur[(val)]
1943 #define CUR_PTR ctxt->input->cur
1944
1945 #define CMP4( s, c1, c2, c3, c4 ) \
1946   ( ((unsigned char *) s)[ 0 ] == c1 && ((unsigned char *) s)[ 1 ] == c2 && \
1947     ((unsigned char *) s)[ 2 ] == c3 && ((unsigned char *) s)[ 3 ] == c4 )
1948 #define CMP5( s, c1, c2, c3, c4, c5 ) \
1949   ( CMP4( s, c1, c2, c3, c4 ) && ((unsigned char *) s)[ 4 ] == c5 )
1950 #define CMP6( s, c1, c2, c3, c4, c5, c6 ) \
1951   ( CMP5( s, c1, c2, c3, c4, c5 ) && ((unsigned char *) s)[ 5 ] == c6 )
1952 #define CMP7( s, c1, c2, c3, c4, c5, c6, c7 ) \
1953   ( CMP6( s, c1, c2, c3, c4, c5, c6 ) && ((unsigned char *) s)[ 6 ] == c7 )
1954 #define CMP8( s, c1, c2, c3, c4, c5, c6, c7, c8 ) \
1955   ( CMP7( s, c1, c2, c3, c4, c5, c6, c7 ) && ((unsigned char *) s)[ 7 ] == c8 )
1956 #define CMP9( s, c1, c2, c3, c4, c5, c6, c7, c8, c9 ) \
1957   ( CMP8( s, c1, c2, c3, c4, c5, c6, c7, c8 ) && \
1958     ((unsigned char *) s)[ 8 ] == c9 )
1959 #define CMP10( s, c1, c2, c3, c4, c5, c6, c7, c8, c9, c10 ) \
1960   ( CMP9( s, c1, c2, c3, c4, c5, c6, c7, c8, c9 ) && \
1961     ((unsigned char *) s)[ 9 ] == c10 )
1962
1963 #define SKIP(val) do {                                                  \
1964     ctxt->nbChars += (val),ctxt->input->cur += (val),ctxt->input->col+=(val);                   \
1965     if (*ctxt->input->cur == '%') xmlParserHandlePEReference(ctxt);     \
1966     if ((*ctxt->input->cur == 0) &&                                     \
1967         (xmlParserInputGrow(ctxt->input, INPUT_CHUNK) <= 0))            \
1968             xmlPopInput(ctxt);                                          \
1969   } while (0)
1970
1971 #define SKIPL(val) do {                                                 \
1972     int skipl;                                                          \
1973     for(skipl=0; skipl<val; skipl++) {                                  \
1974         if (*(ctxt->input->cur) == '\n') {                              \
1975         ctxt->input->line++; ctxt->input->col = 1;                      \
1976         } else ctxt->input->col++;                                      \
1977         ctxt->nbChars++;                                                \
1978         ctxt->input->cur++;                                             \
1979     }                                                                   \
1980     if (*ctxt->input->cur == '%') xmlParserHandlePEReference(ctxt);     \
1981     if ((*ctxt->input->cur == 0) &&                                     \
1982         (xmlParserInputGrow(ctxt->input, INPUT_CHUNK) <= 0))            \
1983             xmlPopInput(ctxt);                                          \
1984   } while (0)
1985
1986 #define SHRINK if ((ctxt->progressive == 0) &&                          \
1987                    (ctxt->input->cur - ctxt->input->base > 2 * INPUT_CHUNK) && \
1988                    (ctxt->input->end - ctxt->input->cur < 2 * INPUT_CHUNK)) \
1989         xmlSHRINK (ctxt);
1990
1991 static void xmlSHRINK (xmlParserCtxtPtr ctxt) {
1992     xmlParserInputShrink(ctxt->input);
1993     if ((*ctxt->input->cur == 0) &&
1994         (xmlParserInputGrow(ctxt->input, INPUT_CHUNK) <= 0))
1995             xmlPopInput(ctxt);
1996   }
1997
1998 #define GROW if ((ctxt->progressive == 0) &&                            \
1999                  (ctxt->input->end - ctxt->input->cur < INPUT_CHUNK))   \
2000         xmlGROW (ctxt);
2001
2002 static void xmlGROW (xmlParserCtxtPtr ctxt) {
2003     xmlParserInputGrow(ctxt->input, INPUT_CHUNK);
2004     if ((ctxt->input->cur != NULL) && (*ctxt->input->cur == 0) &&
2005         (xmlParserInputGrow(ctxt->input, INPUT_CHUNK) <= 0))
2006             xmlPopInput(ctxt);
2007 }
2008
2009 #define SKIP_BLANKS xmlSkipBlankChars(ctxt)
2010
2011 #define NEXT xmlNextChar(ctxt)
2012
2013 #define NEXT1 {                                                         \
2014         ctxt->input->col++;                                             \
2015         ctxt->input->cur++;                                             \
2016         ctxt->nbChars++;                                                \
2017         if (*ctxt->input->cur == 0)                                     \
2018             xmlParserInputGrow(ctxt->input, INPUT_CHUNK);               \
2019     }
2020
2021 #define NEXTL(l) do {                                                   \
2022     if (*(ctxt->input->cur) == '\n') {                                  \
2023         ctxt->input->line++; ctxt->input->col = 1;                      \
2024     } else ctxt->input->col++;                                          \
2025     ctxt->input->cur += l;                              \
2026     if (*ctxt->input->cur == '%') xmlParserHandlePEReference(ctxt);     \
2027   } while (0)
2028
2029 #define CUR_CHAR(l) xmlCurrentChar(ctxt, &l)
2030 #define CUR_SCHAR(s, l) xmlStringCurrentChar(ctxt, s, &l)
2031
2032 #define COPY_BUF(l,b,i,v)                                               \
2033     if (l == 1) b[i++] = (xmlChar) v;                                   \
2034     else i += xmlCopyCharMultiByte(&b[i],v)
2035
2036 /**
2037  * xmlSkipBlankChars:
2038  * @ctxt:  the XML parser context
2039  *
2040  * skip all blanks character found at that point in the input streams.
2041  * It pops up finished entities in the process if allowable at that point.
2042  *
2043  * Returns the number of space chars skipped
2044  */
2045
2046 int
2047 xmlSkipBlankChars(xmlParserCtxtPtr ctxt) {
2048     int res = 0;
2049
2050     /*
2051      * It's Okay to use CUR/NEXT here since all the blanks are on
2052      * the ASCII range.
2053      */
2054     if ((ctxt->inputNr == 1) && (ctxt->instate != XML_PARSER_DTD)) {
2055         const xmlChar *cur;
2056         /*
2057          * if we are in the document content, go really fast
2058          */
2059         cur = ctxt->input->cur;
2060         while (IS_BLANK_CH(*cur)) {
2061             if (*cur == '\n') {
2062                 ctxt->input->line++; ctxt->input->col = 1;
2063             }
2064             cur++;
2065             res++;
2066             if (*cur == 0) {
2067                 ctxt->input->cur = cur;
2068                 xmlParserInputGrow(ctxt->input, INPUT_CHUNK);
2069                 cur = ctxt->input->cur;
2070             }
2071         }
2072         ctxt->input->cur = cur;
2073     } else {
2074         int cur;
2075         do {
2076             cur = CUR;
2077             while (IS_BLANK_CH(cur)) { /* CHECKED tstblanks.xml */
2078                 NEXT;
2079                 cur = CUR;
2080                 res++;
2081             }
2082             while ((cur == 0) && (ctxt->inputNr > 1) &&
2083                    (ctxt->instate != XML_PARSER_COMMENT)) {
2084                 xmlPopInput(ctxt);
2085                 cur = CUR;
2086             }
2087             /*
2088              * Need to handle support of entities branching here
2089              */
2090             if (*ctxt->input->cur == '%') xmlParserHandlePEReference(ctxt);
2091         } while (IS_BLANK(cur)); /* CHECKED tstblanks.xml */
2092     }
2093     return(res);
2094 }
2095
2096 /************************************************************************
2097  *                                                                      *
2098  *              Commodity functions to handle entities                  *
2099  *                                                                      *
2100  ************************************************************************/
2101
2102 /**
2103  * xmlPopInput:
2104  * @ctxt:  an XML parser context
2105  *
2106  * xmlPopInput: the current input pointed by ctxt->input came to an end
2107  *          pop it and return the next char.
2108  *
2109  * Returns the current xmlChar in the parser context
2110  */
2111 xmlChar
2112 xmlPopInput(xmlParserCtxtPtr ctxt) {
2113     if ((ctxt == NULL) || (ctxt->inputNr <= 1)) return(0);
2114     if (xmlParserDebugEntities)
2115         xmlGenericError(xmlGenericErrorContext,
2116                 "Popping input %d\n", ctxt->inputNr);
2117     xmlFreeInputStream(inputPop(ctxt));
2118     if ((*ctxt->input->cur == 0) &&
2119         (xmlParserInputGrow(ctxt->input, INPUT_CHUNK) <= 0))
2120             return(xmlPopInput(ctxt));
2121     return(CUR);
2122 }
2123
2124 /**
2125  * xmlPushInput:
2126  * @ctxt:  an XML parser context
2127  * @input:  an XML parser input fragment (entity, XML fragment ...).
2128  *
2129  * xmlPushInput: switch to a new input stream which is stacked on top
2130  *               of the previous one(s).
2131  * Returns -1 in case of error or the index in the input stack
2132  */
2133 int
2134 xmlPushInput(xmlParserCtxtPtr ctxt, xmlParserInputPtr input) {
2135     int ret;
2136     if (input == NULL) return(-1);
2137
2138     if (xmlParserDebugEntities) {
2139         if ((ctxt->input != NULL) && (ctxt->input->filename))
2140             xmlGenericError(xmlGenericErrorContext,
2141                     "%s(%d): ", ctxt->input->filename,
2142                     ctxt->input->line);
2143         xmlGenericError(xmlGenericErrorContext,
2144                 "Pushing input %d : %.30s\n", ctxt->inputNr+1, input->cur);
2145     }
2146     ret = inputPush(ctxt, input);
2147     GROW;
2148     return(ret);
2149 }
2150
2151 /**
2152  * xmlParseCharRef:
2153  * @ctxt:  an XML parser context
2154  *
2155  * parse Reference declarations
2156  *
2157  * [66] CharRef ::= '&#' [0-9]+ ';' |
2158  *                  '&#x' [0-9a-fA-F]+ ';'
2159  *
2160  * [ WFC: Legal Character ]
2161  * Characters referred to using character references must match the
2162  * production for Char.
2163  *
2164  * Returns the value parsed (as an int), 0 in case of error
2165  */
2166 int
2167 xmlParseCharRef(xmlParserCtxtPtr ctxt) {
2168     unsigned int val = 0;
2169     int count = 0;
2170     unsigned int outofrange = 0;
2171
2172     /*
2173      * Using RAW/CUR/NEXT is okay since we are working on ASCII range here
2174      */
2175     if ((RAW == '&') && (NXT(1) == '#') &&
2176         (NXT(2) == 'x')) {
2177         SKIP(3);
2178         GROW;
2179         while (RAW != ';') { /* loop blocked by count */
2180             if (count++ > 20) {
2181                 count = 0;
2182                 GROW;
2183             }
2184             if ((RAW >= '0') && (RAW <= '9'))
2185                 val = val * 16 + (CUR - '0');
2186             else if ((RAW >= 'a') && (RAW <= 'f') && (count < 20))
2187                 val = val * 16 + (CUR - 'a') + 10;
2188             else if ((RAW >= 'A') && (RAW <= 'F') && (count < 20))
2189                 val = val * 16 + (CUR - 'A') + 10;
2190             else {
2191                 xmlFatalErr(ctxt, XML_ERR_INVALID_HEX_CHARREF, NULL);
2192                 val = 0;
2193                 break;
2194             }
2195             if (val > 0x10FFFF)
2196                 outofrange = val;
2197
2198             NEXT;
2199             count++;
2200         }
2201         if (RAW == ';') {
2202             /* on purpose to avoid reentrancy problems with NEXT and SKIP */
2203             ctxt->input->col++;
2204             ctxt->nbChars ++;
2205             ctxt->input->cur++;
2206         }
2207     } else if  ((RAW == '&') && (NXT(1) == '#')) {
2208         SKIP(2);
2209         GROW;
2210         while (RAW != ';') { /* loop blocked by count */
2211             if (count++ > 20) {
2212                 count = 0;
2213                 GROW;
2214             }
2215             if ((RAW >= '0') && (RAW <= '9'))
2216                 val = val * 10 + (CUR - '0');
2217             else {
2218                 xmlFatalErr(ctxt, XML_ERR_INVALID_DEC_CHARREF, NULL);
2219                 val = 0;
2220                 break;
2221             }
2222             if (val > 0x10FFFF)
2223                 outofrange = val;
2224
2225             NEXT;
2226             count++;
2227         }
2228         if (RAW == ';') {
2229             /* on purpose to avoid reentrancy problems with NEXT and SKIP */
2230             ctxt->input->col++;
2231             ctxt->nbChars ++;
2232             ctxt->input->cur++;
2233         }
2234     } else {
2235         xmlFatalErr(ctxt, XML_ERR_INVALID_CHARREF, NULL);
2236     }
2237
2238     /*
2239      * [ WFC: Legal Character ]
2240      * Characters referred to using character references must match the
2241      * production for Char.
2242      */
2243     if ((IS_CHAR(val) && (outofrange == 0))) {
2244         return(val);
2245     } else {
2246         xmlFatalErrMsgInt(ctxt, XML_ERR_INVALID_CHAR,
2247                           "xmlParseCharRef: invalid xmlChar value %d\n",
2248                           val);
2249     }
2250     return(0);
2251 }
2252
2253 /**
2254  * xmlParseStringCharRef:
2255  * @ctxt:  an XML parser context
2256  * @str:  a pointer to an index in the string
2257  *
2258  * parse Reference declarations, variant parsing from a string rather
2259  * than an an input flow.
2260  *
2261  * [66] CharRef ::= '&#' [0-9]+ ';' |
2262  *                  '&#x' [0-9a-fA-F]+ ';'
2263  *
2264  * [ WFC: Legal Character ]
2265  * Characters referred to using character references must match the
2266  * production for Char.
2267  *
2268  * Returns the value parsed (as an int), 0 in case of error, str will be
2269  *         updated to the current value of the index
2270  */
2271 static int
2272 xmlParseStringCharRef(xmlParserCtxtPtr ctxt, const xmlChar **str) {
2273     const xmlChar *ptr;
2274     xmlChar cur;
2275     unsigned int val = 0;
2276     unsigned int outofrange = 0;
2277
2278     if ((str == NULL) || (*str == NULL)) return(0);
2279     ptr = *str;
2280     cur = *ptr;
2281     if ((cur == '&') && (ptr[1] == '#') && (ptr[2] == 'x')) {
2282         ptr += 3;
2283         cur = *ptr;
2284         while (cur != ';') { /* Non input consuming loop */
2285             if ((cur >= '0') && (cur <= '9'))
2286                 val = val * 16 + (cur - '0');
2287             else if ((cur >= 'a') && (cur <= 'f'))
2288                 val = val * 16 + (cur - 'a') + 10;
2289             else if ((cur >= 'A') && (cur <= 'F'))
2290                 val = val * 16 + (cur - 'A') + 10;
2291             else {
2292                 xmlFatalErr(ctxt, XML_ERR_INVALID_HEX_CHARREF, NULL);
2293                 val = 0;
2294                 break;
2295             }
2296             if (val > 0x10FFFF)
2297                 outofrange = val;
2298
2299             ptr++;
2300             cur = *ptr;
2301         }
2302         if (cur == ';')
2303             ptr++;
2304     } else if  ((cur == '&') && (ptr[1] == '#')){
2305         ptr += 2;
2306         cur = *ptr;
2307         while (cur != ';') { /* Non input consuming loops */
2308             if ((cur >= '0') && (cur <= '9'))
2309                 val = val * 10 + (cur - '0');
2310             else {
2311                 xmlFatalErr(ctxt, XML_ERR_INVALID_DEC_CHARREF, NULL);
2312                 val = 0;
2313                 break;
2314             }
2315             if (val > 0x10FFFF)
2316                 outofrange = val;
2317
2318             ptr++;
2319             cur = *ptr;
2320         }
2321         if (cur == ';')
2322             ptr++;
2323     } else {
2324         xmlFatalErr(ctxt, XML_ERR_INVALID_CHARREF, NULL);
2325         return(0);
2326     }
2327     *str = ptr;
2328
2329     /*
2330      * [ WFC: Legal Character ]
2331      * Characters referred to using character references must match the
2332      * production for Char.
2333      */
2334     if ((IS_CHAR(val) && (outofrange == 0))) {
2335         return(val);
2336     } else {
2337         xmlFatalErrMsgInt(ctxt, XML_ERR_INVALID_CHAR,
2338                           "xmlParseStringCharRef: invalid xmlChar value %d\n",
2339                           val);
2340     }
2341     return(0);
2342 }
2343
2344 /**
2345  * xmlNewBlanksWrapperInputStream:
2346  * @ctxt:  an XML parser context
2347  * @entity:  an Entity pointer
2348  *
2349  * Create a new input stream for wrapping
2350  * blanks around a PEReference
2351  *
2352  * Returns the new input stream or NULL
2353  */
2354
2355 static void deallocblankswrapper (xmlChar *str) {xmlFree(str);}
2356
2357 static xmlParserInputPtr
2358 xmlNewBlanksWrapperInputStream(xmlParserCtxtPtr ctxt, xmlEntityPtr entity) {
2359     xmlParserInputPtr input;
2360     xmlChar *buffer;
2361     size_t length;
2362     if (entity == NULL) {
2363         xmlFatalErr(ctxt, XML_ERR_INTERNAL_ERROR,
2364                     "xmlNewBlanksWrapperInputStream entity\n");
2365         return(NULL);
2366     }
2367     if (xmlParserDebugEntities)
2368         xmlGenericError(xmlGenericErrorContext,
2369                 "new blanks wrapper for entity: %s\n", entity->name);
2370     input = xmlNewInputStream(ctxt);
2371     if (input == NULL) {
2372         return(NULL);
2373     }
2374     length = xmlStrlen(entity->name) + 5;
2375     buffer = xmlMallocAtomic(length);
2376     if (buffer == NULL) {
2377         xmlErrMemory(ctxt, NULL);
2378         xmlFree(input);
2379         return(NULL);
2380     }
2381     buffer [0] = ' ';
2382     buffer [1] = '%';
2383     buffer [length-3] = ';';
2384     buffer [length-2] = ' ';
2385     buffer [length-1] = 0;
2386     memcpy(buffer + 2, entity->name, length - 5);
2387     input->free = deallocblankswrapper;
2388     input->base = buffer;
2389     input->cur = buffer;
2390     input->length = length;
2391     input->end = &buffer[length];
2392     return(input);
2393 }
2394
2395 /**
2396  * xmlParserHandlePEReference:
2397  * @ctxt:  the parser context
2398  *
2399  * [69] PEReference ::= '%' Name ';'
2400  *
2401  * [ WFC: No Recursion ]
2402  * A parsed entity must not contain a recursive
2403  * reference to itself, either directly or indirectly.
2404  *
2405  * [ WFC: Entity Declared ]
2406  * In a document without any DTD, a document with only an internal DTD
2407  * subset which contains no parameter entity references, or a document
2408  * with "standalone='yes'", ...  ... The declaration of a parameter
2409  * entity must precede any reference to it...
2410  *
2411  * [ VC: Entity Declared ]
2412  * In a document with an external subset or external parameter entities
2413  * with "standalone='no'", ...  ... The declaration of a parameter entity
2414  * must precede any reference to it...
2415  *
2416  * [ WFC: In DTD ]
2417  * Parameter-entity references may only appear in the DTD.
2418  * NOTE: misleading but this is handled.
2419  *
2420  * A PEReference may have been detected in the current input stream
2421  * the handling is done accordingly to
2422  *      http://www.w3.org/TR/REC-xml#entproc
2423  * i.e.
2424  *   - Included in literal in entity values
2425  *   - Included as Parameter Entity reference within DTDs
2426  */
2427 void
2428 xmlParserHandlePEReference(xmlParserCtxtPtr ctxt) {
2429     const xmlChar *name;
2430     xmlEntityPtr entity = NULL;
2431     xmlParserInputPtr input;
2432
2433     if (RAW != '%') return;
2434     switch(ctxt->instate) {
2435         case XML_PARSER_CDATA_SECTION:
2436             return;
2437         case XML_PARSER_COMMENT:
2438             return;
2439         case XML_PARSER_START_TAG:
2440             return;
2441         case XML_PARSER_END_TAG:
2442             return;
2443         case XML_PARSER_EOF:
2444             xmlFatalErr(ctxt, XML_ERR_PEREF_AT_EOF, NULL);
2445             return;
2446         case XML_PARSER_PROLOG:
2447         case XML_PARSER_START:
2448         case XML_PARSER_MISC:
2449             xmlFatalErr(ctxt, XML_ERR_PEREF_IN_PROLOG, NULL);
2450             return;
2451         case XML_PARSER_ENTITY_DECL:
2452         case XML_PARSER_CONTENT:
2453         case XML_PARSER_ATTRIBUTE_VALUE:
2454         case XML_PARSER_PI:
2455         case XML_PARSER_SYSTEM_LITERAL:
2456         case XML_PARSER_PUBLIC_LITERAL:
2457             /* we just ignore it there */
2458             return;
2459         case XML_PARSER_EPILOG:
2460             xmlFatalErr(ctxt, XML_ERR_PEREF_IN_EPILOG, NULL);
2461             return;
2462         case XML_PARSER_ENTITY_VALUE:
2463             /*
2464              * NOTE: in the case of entity values, we don't do the
2465              *       substitution here since we need the literal
2466              *       entity value to be able to save the internal
2467              *       subset of the document.
2468              *       This will be handled by xmlStringDecodeEntities
2469              */
2470             return;
2471         case XML_PARSER_DTD:
2472             /*
2473              * [WFC: Well-Formedness Constraint: PEs in Internal Subset]
2474              * In the internal DTD subset, parameter-entity references
2475              * can occur only where markup declarations can occur, not
2476              * within markup declarations.
2477              * In that case this is handled in xmlParseMarkupDecl
2478              */
2479             if ((ctxt->external == 0) && (ctxt->inputNr == 1))
2480                 return;
2481             if (IS_BLANK_CH(NXT(1)) || NXT(1) == 0)
2482                 return;
2483             break;
2484         case XML_PARSER_IGNORE:
2485             return;
2486     }
2487
2488     NEXT;
2489     name = xmlParseName(ctxt);
2490     if (xmlParserDebugEntities)
2491         xmlGenericError(xmlGenericErrorContext,
2492                 "PEReference: %s\n", name);
2493     if (name == NULL) {
2494         xmlFatalErr(ctxt, XML_ERR_PEREF_NO_NAME, NULL);
2495     } else {
2496         if (RAW == ';') {
2497             NEXT;
2498             if ((ctxt->sax != NULL) && (ctxt->sax->getParameterEntity != NULL))
2499                 entity = ctxt->sax->getParameterEntity(ctxt->userData, name);
2500             if (entity == NULL) {
2501
2502                 /*
2503                  * [ WFC: Entity Declared ]
2504                  * In a document without any DTD, a document with only an
2505                  * internal DTD subset which contains no parameter entity
2506                  * references, or a document with "standalone='yes'", ...
2507                  * ... The declaration of a parameter entity must precede
2508                  * any reference to it...
2509                  */
2510                 if ((ctxt->standalone == 1) ||
2511                     ((ctxt->hasExternalSubset == 0) &&
2512                      (ctxt->hasPErefs == 0))) {
2513                     xmlFatalErrMsgStr(ctxt, XML_ERR_UNDECLARED_ENTITY,
2514                          "PEReference: %%%s; not found\n", name);
2515                 } else {
2516                     /*
2517                      * [ VC: Entity Declared ]
2518                      * In a document with an external subset or external
2519                      * parameter entities with "standalone='no'", ...
2520                      * ... The declaration of a parameter entity must precede
2521                      * any reference to it...
2522                      */
2523                     if ((ctxt->validate) && (ctxt->vctxt.error != NULL)) {
2524                         xmlValidityError(ctxt, XML_WAR_UNDECLARED_ENTITY,
2525                                          "PEReference: %%%s; not found\n",
2526                                          name, NULL);
2527                     } else
2528                         xmlWarningMsg(ctxt, XML_WAR_UNDECLARED_ENTITY,
2529                                       "PEReference: %%%s; not found\n",
2530                                       name, NULL);
2531                     ctxt->valid = 0;
2532                 }
2533             } else if (ctxt->input->free != deallocblankswrapper) {
2534                     input = xmlNewBlanksWrapperInputStream(ctxt, entity);
2535                     if (xmlPushInput(ctxt, input) < 0)
2536                         return;
2537             } else {
2538                 if ((entity->etype == XML_INTERNAL_PARAMETER_ENTITY) ||
2539                     (entity->etype == XML_EXTERNAL_PARAMETER_ENTITY)) {
2540                     xmlChar start[4];
2541                     xmlCharEncoding enc;
2542
2543                     /*
2544                      * handle the extra spaces added before and after
2545                      * c.f. http://www.w3.org/TR/REC-xml#as-PE
2546                      * this is done independently.
2547                      */
2548                     input = xmlNewEntityInputStream(ctxt, entity);
2549                     if (xmlPushInput(ctxt, input) < 0)
2550                         return;
2551
2552                     /*
2553                      * Get the 4 first bytes and decode the charset
2554                      * if enc != XML_CHAR_ENCODING_NONE
2555                      * plug some encoding conversion routines.
2556                      * Note that, since we may have some non-UTF8
2557                      * encoding (like UTF16, bug 135229), the 'length'
2558                      * is not known, but we can calculate based upon
2559                      * the amount of data in the buffer.
2560                      */
2561                     GROW
2562                     if ((ctxt->input->end - ctxt->input->cur)>=4) {
2563                         start[0] = RAW;
2564                         start[1] = NXT(1);
2565                         start[2] = NXT(2);
2566                         start[3] = NXT(3);
2567                         enc = xmlDetectCharEncoding(start, 4);
2568                         if (enc != XML_CHAR_ENCODING_NONE) {
2569                             xmlSwitchEncoding(ctxt, enc);
2570                         }
2571                     }
2572
2573                     if ((entity->etype == XML_EXTERNAL_PARAMETER_ENTITY) &&
2574                         (CMP5(CUR_PTR, '<', '?', 'x', 'm', 'l' )) &&
2575                         (IS_BLANK_CH(NXT(5)))) {
2576                         xmlParseTextDecl(ctxt);
2577                     }
2578                 } else {
2579                     xmlFatalErrMsgStr(ctxt, XML_ERR_ENTITY_IS_PARAMETER,
2580                              "PEReference: %s is not a parameter entity\n",
2581                                       name);
2582                 }
2583             }
2584         } else {
2585             xmlFatalErr(ctxt, XML_ERR_PEREF_SEMICOL_MISSING, NULL);
2586         }
2587     }
2588 }
2589
2590 /*
2591  * Macro used to grow the current buffer.
2592  */
2593 #define growBuffer(buffer, n) {                                         \
2594     xmlChar *tmp;                                                       \
2595     buffer##_size *= 2;                                                 \
2596     buffer##_size += n;                                                 \
2597     tmp = (xmlChar *)                                                   \
2598                 xmlRealloc(buffer, buffer##_size * sizeof(xmlChar));    \
2599     if (tmp == NULL) goto mem_error;                                    \
2600     buffer = tmp;                                                       \
2601 }
2602
2603 /**
2604  * xmlStringLenDecodeEntities:
2605  * @ctxt:  the parser context
2606  * @str:  the input string
2607  * @len: the string length
2608  * @what:  combination of XML_SUBSTITUTE_REF and XML_SUBSTITUTE_PEREF
2609  * @end:  an end marker xmlChar, 0 if none
2610  * @end2:  an end marker xmlChar, 0 if none
2611  * @end3:  an end marker xmlChar, 0 if none
2612  *
2613  * Takes a entity string content and process to do the adequate substitutions.
2614  *
2615  * [67] Reference ::= EntityRef | CharRef
2616  *
2617  * [69] PEReference ::= '%' Name ';'
2618  *
2619  * Returns A newly allocated string with the substitution done. The caller
2620  *      must deallocate it !
2621  */
2622 xmlChar *
2623 xmlStringLenDecodeEntities(xmlParserCtxtPtr ctxt, const xmlChar *str, int len,
2624                       int what, xmlChar end, xmlChar  end2, xmlChar end3) {
2625     xmlChar *buffer = NULL;
2626     int buffer_size = 0;
2627
2628     xmlChar *current = NULL;
2629     xmlChar *rep = NULL;
2630     const xmlChar *last;
2631     xmlEntityPtr ent;
2632     int c,l;
2633     int nbchars = 0;
2634
2635     if ((ctxt == NULL) || (str == NULL) || (len < 0))
2636         return(NULL);
2637     last = str + len;
2638
2639     if (((ctxt->depth > 40) &&
2640          ((ctxt->options & XML_PARSE_HUGE) == 0)) ||
2641         (ctxt->depth > 1024)) {
2642         xmlFatalErr(ctxt, XML_ERR_ENTITY_LOOP, NULL);
2643         return(NULL);
2644     }
2645
2646     /*
2647      * allocate a translation buffer.
2648      */
2649     buffer_size = XML_PARSER_BIG_BUFFER_SIZE;
2650     buffer = (xmlChar *) xmlMallocAtomic(buffer_size * sizeof(xmlChar));
2651     if (buffer == NULL) goto mem_error;
2652
2653     /*
2654      * OK loop until we reach one of the ending char or a size limit.
2655      * we are operating on already parsed values.
2656      */
2657     if (str < last)
2658         c = CUR_SCHAR(str, l);
2659     else
2660         c = 0;
2661     while ((c != 0) && (c != end) && /* non input consuming loop */
2662            (c != end2) && (c != end3)) {
2663
2664         if (c == 0) break;
2665         if ((c == '&') && (str[1] == '#')) {
2666             int val = xmlParseStringCharRef(ctxt, &str);
2667             if (val != 0) {
2668                 COPY_BUF(0,buffer,nbchars,val);
2669             }
2670             if (nbchars > buffer_size - XML_PARSER_BUFFER_SIZE) {
2671                 growBuffer(buffer, XML_PARSER_BUFFER_SIZE);
2672             }
2673         } else if ((c == '&') && (what & XML_SUBSTITUTE_REF)) {
2674             if (xmlParserDebugEntities)
2675                 xmlGenericError(xmlGenericErrorContext,
2676                         "String decoding Entity Reference: %.30s\n",
2677                         str);
2678             ent = xmlParseStringEntityRef(ctxt, &str);
2679             if ((ctxt->lastError.code == XML_ERR_ENTITY_LOOP) ||
2680                 (ctxt->lastError.code == XML_ERR_INTERNAL_ERROR))
2681                 goto int_error;
2682             if (ent != NULL)
2683                 ctxt->nbentities += ent->checked;
2684             if ((ent != NULL) &&
2685                 (ent->etype == XML_INTERNAL_PREDEFINED_ENTITY)) {
2686                 if (ent->content != NULL) {
2687                     COPY_BUF(0,buffer,nbchars,ent->content[0]);
2688                     if (nbchars > buffer_size - XML_PARSER_BUFFER_SIZE) {
2689                         growBuffer(buffer, XML_PARSER_BUFFER_SIZE);
2690                     }
2691                 } else {
2692                     xmlFatalErrMsg(ctxt, XML_ERR_INTERNAL_ERROR,
2693                             "predefined entity has no content\n");
2694                 }
2695             } else if ((ent != NULL) && (ent->content != NULL)) {
2696                 ctxt->depth++;
2697                 rep = xmlStringDecodeEntities(ctxt, ent->content, what,
2698                                               0, 0, 0);
2699                 ctxt->depth--;
2700
2701                 if (rep != NULL) {
2702                     current = rep;
2703                     while (*current != 0) { /* non input consuming loop */
2704                         buffer[nbchars++] = *current++;
2705                         if (nbchars >
2706                             buffer_size - XML_PARSER_BUFFER_SIZE) {
2707                             if (xmlParserEntityCheck(ctxt, nbchars, ent))
2708                                 goto int_error;
2709                             growBuffer(buffer, XML_PARSER_BUFFER_SIZE);
2710                         }
2711                     }
2712                     xmlFree(rep);
2713                     rep = NULL;
2714                 }
2715             } else if (ent != NULL) {
2716                 int i = xmlStrlen(ent->name);
2717                 const xmlChar *cur = ent->name;
2718
2719                 buffer[nbchars++] = '&';
2720                 if (nbchars > buffer_size - i - XML_PARSER_BUFFER_SIZE) {
2721                     growBuffer(buffer, i + XML_PARSER_BUFFER_SIZE);
2722                 }
2723                 for (;i > 0;i--)
2724                     buffer[nbchars++] = *cur++;
2725                 buffer[nbchars++] = ';';
2726             }
2727         } else if (c == '%' && (what & XML_SUBSTITUTE_PEREF)) {
2728             if (xmlParserDebugEntities)
2729                 xmlGenericError(xmlGenericErrorContext,
2730                         "String decoding PE Reference: %.30s\n", str);
2731             ent = xmlParseStringPEReference(ctxt, &str);
2732             if (ctxt->lastError.code == XML_ERR_ENTITY_LOOP)
2733                 goto int_error;
2734             if (ent != NULL)
2735                 ctxt->nbentities += ent->checked;
2736             if (ent != NULL) {
2737                 if (ent->content == NULL) {
2738                     xmlLoadEntityContent(ctxt, ent);
2739                 }
2740                 ctxt->depth++;
2741                 rep = xmlStringDecodeEntities(ctxt, ent->content, what,
2742                                               0, 0, 0);
2743                 ctxt->depth--;
2744                 if (rep != NULL) {
2745                     current = rep;
2746                     while (*current != 0) { /* non input consuming loop */
2747                         buffer[nbchars++] = *current++;
2748                         if (nbchars >
2749                             buffer_size - XML_PARSER_BUFFER_SIZE) {
2750                             if (xmlParserEntityCheck(ctxt, nbchars, ent))
2751                                 goto int_error;
2752                             growBuffer(buffer, XML_PARSER_BUFFER_SIZE);
2753                         }
2754                     }
2755                     xmlFree(rep);
2756                     rep = NULL;
2757                 }
2758             }
2759         } else {
2760             COPY_BUF(l,buffer,nbchars,c);
2761             str += l;
2762             if (nbchars > buffer_size - XML_PARSER_BUFFER_SIZE) {
2763               growBuffer(buffer, XML_PARSER_BUFFER_SIZE);
2764             }
2765         }
2766         if (str < last)
2767             c = CUR_SCHAR(str, l);
2768         else
2769             c = 0;
2770     }
2771     buffer[nbchars] = 0;
2772     return(buffer);
2773
2774 mem_error:
2775     xmlErrMemory(ctxt, NULL);
2776 int_error:
2777     if (rep != NULL)
2778         xmlFree(rep);
2779     if (buffer != NULL)
2780         xmlFree(buffer);
2781     return(NULL);
2782 }
2783
2784 /**
2785  * xmlStringDecodeEntities:
2786  * @ctxt:  the parser context
2787  * @str:  the input string
2788  * @what:  combination of XML_SUBSTITUTE_REF and XML_SUBSTITUTE_PEREF
2789  * @end:  an end marker xmlChar, 0 if none
2790  * @end2:  an end marker xmlChar, 0 if none
2791  * @end3:  an end marker xmlChar, 0 if none
2792  *
2793  * Takes a entity string content and process to do the adequate substitutions.
2794  *
2795  * [67] Reference ::= EntityRef | CharRef
2796  *
2797  * [69] PEReference ::= '%' Name ';'
2798  *
2799  * Returns A newly allocated string with the substitution done. The caller
2800  *      must deallocate it !
2801  */
2802 xmlChar *
2803 xmlStringDecodeEntities(xmlParserCtxtPtr ctxt, const xmlChar *str, int what,
2804                         xmlChar end, xmlChar  end2, xmlChar end3) {
2805     if ((ctxt == NULL) || (str == NULL)) return(NULL);
2806     return(xmlStringLenDecodeEntities(ctxt, str, xmlStrlen(str), what,
2807            end, end2, end3));
2808 }
2809
2810 /************************************************************************
2811  *                                                                      *
2812  *              Commodity functions, cleanup needed ?                   *
2813  *                                                                      *
2814  ************************************************************************/
2815
2816 /**
2817  * areBlanks:
2818  * @ctxt:  an XML parser context
2819  * @str:  a xmlChar *
2820  * @len:  the size of @str
2821  * @blank_chars: we know the chars are blanks
2822  *
2823  * Is this a sequence of blank chars that one can ignore ?
2824  *
2825  * Returns 1 if ignorable 0 otherwise.
2826  */
2827
2828 static int areBlanks(xmlParserCtxtPtr ctxt, const xmlChar *str, int len,
2829                      int blank_chars) {
2830     int i, ret;
2831     xmlNodePtr lastChild;
2832
2833     /*
2834      * Don't spend time trying to differentiate them, the same callback is
2835      * used !
2836      */
2837     if (ctxt->sax->ignorableWhitespace == ctxt->sax->characters)
2838         return(0);
2839
2840     /*
2841      * Check for xml:space value.
2842      */
2843     if ((ctxt->space == NULL) || (*(ctxt->space) == 1) ||
2844         (*(ctxt->space) == -2))
2845         return(0);
2846
2847     /*
2848      * Check that the string is made of blanks
2849      */
2850     if (blank_chars == 0) {
2851         for (i = 0;i < len;i++)
2852             if (!(IS_BLANK_CH(str[i]))) return(0);
2853     }
2854
2855     /*
2856      * Look if the element is mixed content in the DTD if available
2857      */
2858     if (ctxt->node == NULL) return(0);
2859     if (ctxt->myDoc != NULL) {
2860         ret = xmlIsMixedElement(ctxt->myDoc, ctxt->node->name);
2861         if (ret == 0) return(1);
2862         if (ret == 1) return(0);
2863     }
2864
2865     /*
2866      * Otherwise, heuristic :-\
2867      */
2868     if ((RAW != '<') && (RAW != 0xD)) return(0);
2869     if ((ctxt->node->children == NULL) &&
2870         (RAW == '<') && (NXT(1) == '/')) return(0);
2871
2872     lastChild = xmlGetLastChild(ctxt->node);
2873     if (lastChild == NULL) {
2874         if ((ctxt->node->type != XML_ELEMENT_NODE) &&
2875             (ctxt->node->content != NULL)) return(0);
2876     } else if (xmlNodeIsText(lastChild))
2877         return(0);
2878     else if ((ctxt->node->children != NULL) &&
2879              (xmlNodeIsText(ctxt->node->children)))
2880         return(0);
2881     return(1);
2882 }
2883
2884 /************************************************************************
2885  *                                                                      *
2886  *              Extra stuff for namespace support                       *
2887  *      Relates to http://www.w3.org/TR/WD-xml-names                    *
2888  *                                                                      *
2889  ************************************************************************/
2890
2891 /**
2892  * xmlSplitQName:
2893  * @ctxt:  an XML parser context
2894  * @name:  an XML parser context
2895  * @prefix:  a xmlChar **
2896  *
2897  * parse an UTF8 encoded XML qualified name string
2898  *
2899  * [NS 5] QName ::= (Prefix ':')? LocalPart
2900  *
2901  * [NS 6] Prefix ::= NCName
2902  *
2903  * [NS 7] LocalPart ::= NCName
2904  *
2905  * Returns the local part, and prefix is updated
2906  *   to get the Prefix if any.
2907  */
2908
2909 xmlChar *
2910 xmlSplitQName(xmlParserCtxtPtr ctxt, const xmlChar *name, xmlChar **prefix) {
2911     xmlChar buf[XML_MAX_NAMELEN + 5];
2912     xmlChar *buffer = NULL;
2913     int len = 0;
2914     int max = XML_MAX_NAMELEN;
2915     xmlChar *ret = NULL;
2916     const xmlChar *cur = name;
2917     int c;
2918
2919     if (prefix == NULL) return(NULL);
2920     *prefix = NULL;
2921
2922     if (cur == NULL) return(NULL);
2923
2924 #ifndef XML_XML_NAMESPACE
2925     /* xml: prefix is not really a namespace */
2926     if ((cur[0] == 'x') && (cur[1] == 'm') &&
2927         (cur[2] == 'l') && (cur[3] == ':'))
2928         return(xmlStrdup(name));
2929 #endif
2930
2931     /* nasty but well=formed */
2932     if (cur[0] == ':')
2933         return(xmlStrdup(name));
2934
2935     c = *cur++;
2936     while ((c != 0) && (c != ':') && (len < max)) { /* tested bigname.xml */
2937         buf[len++] = c;
2938         c = *cur++;
2939     }
2940     if (len >= max) {
2941         /*
2942          * Okay someone managed to make a huge name, so he's ready to pay
2943          * for the processing speed.
2944          */
2945         max = len * 2;
2946
2947         buffer = (xmlChar *) xmlMallocAtomic(max * sizeof(xmlChar));
2948         if (buffer == NULL) {
2949             xmlErrMemory(ctxt, NULL);
2950             return(NULL);
2951         }
2952         memcpy(buffer, buf, len);
2953         while ((c != 0) && (c != ':')) { /* tested bigname.xml */
2954             if (len + 10 > max) {
2955                 xmlChar *tmp;
2956
2957                 max *= 2;
2958                 tmp = (xmlChar *) xmlRealloc(buffer,
2959                                                 max * sizeof(xmlChar));
2960                 if (tmp == NULL) {
2961                     xmlFree(buffer);
2962                     xmlErrMemory(ctxt, NULL);
2963                     return(NULL);
2964                 }
2965                 buffer = tmp;
2966             }
2967             buffer[len++] = c;
2968             c = *cur++;
2969         }
2970         buffer[len] = 0;
2971     }
2972
2973     if ((c == ':') && (*cur == 0)) {
2974         if (buffer != NULL)
2975             xmlFree(buffer);
2976         *prefix = NULL;
2977         return(xmlStrdup(name));
2978     }
2979
2980     if (buffer == NULL)
2981         ret = xmlStrndup(buf, len);
2982     else {
2983         ret = buffer;
2984         buffer = NULL;
2985         max = XML_MAX_NAMELEN;
2986     }
2987
2988
2989     if (c == ':') {
2990         c = *cur;
2991         *prefix = ret;
2992         if (c == 0) {
2993             return(xmlStrndup(BAD_CAST "", 0));
2994         }
2995         len = 0;
2996
2997         /*
2998          * Check that the first character is proper to start
2999          * a new name
3000          */
3001         if (!(((c >= 0x61) && (c <= 0x7A)) ||
3002               ((c >= 0x41) && (c <= 0x5A)) ||
3003               (c == '_') || (c == ':'))) {
3004             int l;
3005             int first = CUR_SCHAR(cur, l);
3006
3007             if (!IS_LETTER(first) && (first != '_')) {
3008                 xmlFatalErrMsgStr(ctxt, XML_NS_ERR_QNAME,
3009                             "Name %s is not XML Namespace compliant\n",
3010                                   name);
3011             }
3012         }
3013         cur++;
3014
3015         while ((c != 0) && (len < max)) { /* tested bigname2.xml */
3016             buf[len++] = c;
3017             c = *cur++;
3018         }
3019         if (len >= max) {
3020             /*
3021              * Okay someone managed to make a huge name, so he's ready to pay
3022              * for the processing speed.
3023              */
3024             max = len * 2;
3025
3026             buffer = (xmlChar *) xmlMallocAtomic(max * sizeof(xmlChar));
3027             if (buffer == NULL) {
3028                 xmlErrMemory(ctxt, NULL);
3029                 return(NULL);
3030             }
3031             memcpy(buffer, buf, len);
3032             while (c != 0) { /* tested bigname2.xml */
3033                 if (len + 10 > max) {
3034                     xmlChar *tmp;
3035
3036                     max *= 2;
3037                     tmp = (xmlChar *) xmlRealloc(buffer,
3038                                                     max * sizeof(xmlChar));
3039                     if (tmp == NULL) {
3040                         xmlErrMemory(ctxt, NULL);
3041                         xmlFree(buffer);
3042                         return(NULL);
3043                     }
3044                     buffer = tmp;
3045                 }
3046                 buffer[len++] = c;
3047                 c = *cur++;
3048             }
3049             buffer[len] = 0;
3050         }
3051
3052         if (buffer == NULL)
3053             ret = xmlStrndup(buf, len);
3054         else {
3055             ret = buffer;
3056         }
3057     }
3058
3059     return(ret);
3060 }
3061
3062 /************************************************************************
3063  *                                                                      *
3064  *                      The parser itself                               *
3065  *      Relates to http://www.w3.org/TR/REC-xml                         *
3066  *                                                                      *
3067  ************************************************************************/
3068
3069 /************************************************************************
3070  *                                                                      *
3071  *      Routines to parse Name, NCName and NmToken                      *
3072  *                                                                      *
3073  ************************************************************************/
3074 #ifdef DEBUG
3075 static unsigned long nbParseName = 0;
3076 static unsigned long nbParseNmToken = 0;
3077 static unsigned long nbParseNCName = 0;
3078 static unsigned long nbParseNCNameComplex = 0;
3079 static unsigned long nbParseNameComplex = 0;
3080 static unsigned long nbParseStringName = 0;
3081 #endif
3082
3083 /*
3084  * The two following functions are related to the change of accepted
3085  * characters for Name and NmToken in the Revision 5 of XML-1.0
3086  * They correspond to the modified production [4] and the new production [4a]
3087  * changes in that revision. Also note that the macros used for the
3088  * productions Letter, Digit, CombiningChar and Extender are not needed
3089  * anymore.
3090  * We still keep compatibility to pre-revision5 parsing semantic if the
3091  * new XML_PARSE_OLD10 option is given to the parser.
3092  */
3093 static int
3094 xmlIsNameStartChar(xmlParserCtxtPtr ctxt, int c) {
3095     if ((ctxt->options & XML_PARSE_OLD10) == 0) {
3096         /*
3097          * Use the new checks of production [4] [4a] amd [5] of the
3098          * Update 5 of XML-1.0
3099          */
3100         if ((c != ' ') && (c != '>') && (c != '/') && /* accelerators */
3101             (((c >= 'a') && (c <= 'z')) ||
3102              ((c >= 'A') && (c <= 'Z')) ||
3103              (c == '_') || (c == ':') ||
3104              ((c >= 0xC0) && (c <= 0xD6)) ||
3105              ((c >= 0xD8) && (c <= 0xF6)) ||
3106              ((c >= 0xF8) && (c <= 0x2FF)) ||
3107              ((c >= 0x370) && (c <= 0x37D)) ||
3108              ((c >= 0x37F) && (c <= 0x1FFF)) ||
3109              ((c >= 0x200C) && (c <= 0x200D)) ||
3110              ((c >= 0x2070) && (c <= 0x218F)) ||
3111              ((c >= 0x2C00) && (c <= 0x2FEF)) ||
3112              ((c >= 0x3001) && (c <= 0xD7FF)) ||
3113              ((c >= 0xF900) && (c <= 0xFDCF)) ||
3114              ((c >= 0xFDF0) && (c <= 0xFFFD)) ||
3115              ((c >= 0x10000) && (c <= 0xEFFFF))))
3116             return(1);
3117     } else {
3118         if (IS_LETTER(c) || (c == '_') || (c == ':'))
3119             return(1);
3120     }
3121     return(0);
3122 }
3123
3124 static int
3125 xmlIsNameChar(xmlParserCtxtPtr ctxt, int c) {
3126     if ((ctxt->options & XML_PARSE_OLD10) == 0) {
3127         /*
3128          * Use the new checks of production [4] [4a] amd [5] of the
3129          * Update 5 of XML-1.0
3130          */
3131         if ((c != ' ') && (c != '>') && (c != '/') && /* accelerators */
3132             (((c >= 'a') && (c <= 'z')) ||
3133              ((c >= 'A') && (c <= 'Z')) ||
3134              ((c >= '0') && (c <= '9')) || /* !start */
3135              (c == '_') || (c == ':') ||
3136              (c == '-') || (c == '.') || (c == 0xB7) || /* !start */
3137              ((c >= 0xC0) && (c <= 0xD6)) ||
3138              ((c >= 0xD8) && (c <= 0xF6)) ||
3139              ((c >= 0xF8) && (c <= 0x2FF)) ||
3140              ((c >= 0x300) && (c <= 0x36F)) || /* !start */
3141              ((c >= 0x370) && (c <= 0x37D)) ||
3142              ((c >= 0x37F) && (c <= 0x1FFF)) ||
3143              ((c >= 0x200C) && (c <= 0x200D)) ||
3144              ((c >= 0x203F) && (c <= 0x2040)) || /* !start */
3145              ((c >= 0x2070) && (c <= 0x218F)) ||
3146              ((c >= 0x2C00) && (c <= 0x2FEF)) ||
3147              ((c >= 0x3001) && (c <= 0xD7FF)) ||
3148              ((c >= 0xF900) && (c <= 0xFDCF)) ||
3149              ((c >= 0xFDF0) && (c <= 0xFFFD)) ||
3150              ((c >= 0x10000) && (c <= 0xEFFFF))))
3151              return(1);
3152     } else {
3153         if ((IS_LETTER(c)) || (IS_DIGIT(c)) ||
3154             (c == '.') || (c == '-') ||
3155             (c == '_') || (c == ':') ||
3156             (IS_COMBINING(c)) ||
3157             (IS_EXTENDER(c)))
3158             return(1);
3159     }
3160     return(0);
3161 }
3162
3163 static xmlChar * xmlParseAttValueInternal(xmlParserCtxtPtr ctxt,
3164                                           int *len, int *alloc, int normalize);
3165
3166 static const xmlChar *
3167 xmlParseNameComplex(xmlParserCtxtPtr ctxt) {
3168     int len = 0, l;
3169     int c;
3170     int count = 0;
3171
3172 #ifdef DEBUG
3173     nbParseNameComplex++;
3174 #endif
3175
3176     /*
3177      * Handler for more complex cases
3178      */
3179     GROW;
3180     c = CUR_CHAR(l);
3181     if ((ctxt->options & XML_PARSE_OLD10) == 0) {
3182         /*
3183          * Use the new checks of production [4] [4a] amd [5] of the
3184          * Update 5 of XML-1.0
3185          */
3186         if ((c == ' ') || (c == '>') || (c == '/') || /* accelerators */
3187             (!(((c >= 'a') && (c <= 'z')) ||
3188                ((c >= 'A') && (c <= 'Z')) ||
3189                (c == '_') || (c == ':') ||
3190                ((c >= 0xC0) && (c <= 0xD6)) ||
3191                ((c >= 0xD8) && (c <= 0xF6)) ||
3192                ((c >= 0xF8) && (c <= 0x2FF)) ||
3193                ((c >= 0x370) && (c <= 0x37D)) ||
3194                ((c >= 0x37F) && (c <= 0x1FFF)) ||
3195                ((c >= 0x200C) && (c <= 0x200D)) ||
3196                ((c >= 0x2070) && (c <= 0x218F)) ||
3197                ((c >= 0x2C00) && (c <= 0x2FEF)) ||
3198                ((c >= 0x3001) && (c <= 0xD7FF)) ||
3199                ((c >= 0xF900) && (c <= 0xFDCF)) ||
3200                ((c >= 0xFDF0) && (c <= 0xFFFD)) ||
3201                ((c >= 0x10000) && (c <= 0xEFFFF))))) {
3202             return(NULL);
3203         }
3204         len += l;
3205         NEXTL(l);
3206         c = CUR_CHAR(l);
3207         while ((c != ' ') && (c != '>') && (c != '/') && /* accelerators */
3208                (((c >= 'a') && (c <= 'z')) ||
3209                 ((c >= 'A') && (c <= 'Z')) ||
3210                 ((c >= '0') && (c <= '9')) || /* !start */
3211                 (c == '_') || (c == ':') ||
3212                 (c == '-') || (c == '.') || (c == 0xB7) || /* !start */
3213                 ((c >= 0xC0) && (c <= 0xD6)) ||
3214                 ((c >= 0xD8) && (c <= 0xF6)) ||
3215                 ((c >= 0xF8) && (c <= 0x2FF)) ||
3216                 ((c >= 0x300) && (c <= 0x36F)) || /* !start */
3217                 ((c >= 0x370) && (c <= 0x37D)) ||
3218                 ((c >= 0x37F) && (c <= 0x1FFF)) ||
3219                 ((c >= 0x200C) && (c <= 0x200D)) ||
3220                 ((c >= 0x203F) && (c <= 0x2040)) || /* !start */
3221                 ((c >= 0x2070) && (c <= 0x218F)) ||
3222                 ((c >= 0x2C00) && (c <= 0x2FEF)) ||
3223                 ((c >= 0x3001) && (c <= 0xD7FF)) ||
3224                 ((c >= 0xF900) && (c <= 0xFDCF)) ||
3225                 ((c >= 0xFDF0) && (c <= 0xFFFD)) ||
3226                 ((c >= 0x10000) && (c <= 0xEFFFF))
3227                 )) {
3228             if (count++ > 100) {
3229                 count = 0;
3230                 GROW;
3231             }
3232             len += l;
3233             NEXTL(l);
3234             c = CUR_CHAR(l);
3235         }
3236     } else {
3237         if ((c == ' ') || (c == '>') || (c == '/') || /* accelerators */
3238             (!IS_LETTER(c) && (c != '_') &&
3239              (c != ':'))) {
3240             return(NULL);
3241         }
3242         len += l;
3243         NEXTL(l);
3244         c = CUR_CHAR(l);
3245
3246         while ((c != ' ') && (c != '>') && (c != '/') && /* test bigname.xml */
3247                ((IS_LETTER(c)) || (IS_DIGIT(c)) ||
3248                 (c == '.') || (c == '-') ||
3249                 (c == '_') || (c == ':') ||
3250                 (IS_COMBINING(c)) ||
3251                 (IS_EXTENDER(c)))) {
3252             if (count++ > 100) {
3253                 count = 0;
3254                 GROW;
3255             }
3256             len += l;
3257             NEXTL(l);
3258             c = CUR_CHAR(l);
3259         }
3260     }
3261     if ((*ctxt->input->cur == '\n') && (ctxt->input->cur[-1] == '\r'))
3262         return(xmlDictLookup(ctxt->dict, ctxt->input->cur - (len + 1), len));
3263     return(xmlDictLookup(ctxt->dict, ctxt->input->cur - len, len));
3264 }
3265
3266 /**
3267  * xmlParseName:
3268  * @ctxt:  an XML parser context
3269  *
3270  * parse an XML name.
3271  *
3272  * [4] NameChar ::= Letter | Digit | '.' | '-' | '_' | ':' |
3273  *                  CombiningChar | Extender
3274  *
3275  * [5] Name ::= (Letter | '_' | ':') (NameChar)*
3276  *
3277  * [6] Names ::= Name (#x20 Name)*
3278  *
3279  * Returns the Name parsed or NULL
3280  */
3281
3282 const xmlChar *
3283 xmlParseName(xmlParserCtxtPtr ctxt) {
3284     const xmlChar *in;
3285     const xmlChar *ret;
3286     int count = 0;
3287
3288     GROW;
3289
3290 #ifdef DEBUG
3291     nbParseName++;
3292 #endif
3293
3294     /*
3295      * Accelerator for simple ASCII names
3296      */
3297     in = ctxt->input->cur;
3298     if (((*in >= 0x61) && (*in <= 0x7A)) ||
3299         ((*in >= 0x41) && (*in <= 0x5A)) ||
3300         (*in == '_') || (*in == ':')) {
3301         in++;
3302         while (((*in >= 0x61) && (*in <= 0x7A)) ||
3303                ((*in >= 0x41) && (*in <= 0x5A)) ||
3304                ((*in >= 0x30) && (*in <= 0x39)) ||
3305                (*in == '_') || (*in == '-') ||
3306                (*in == ':') || (*in == '.'))
3307             in++;
3308         if ((*in > 0) && (*in < 0x80)) {
3309             count = in - ctxt->input->cur;
3310             ret = xmlDictLookup(ctxt->dict, ctxt->input->cur, count);
3311             ctxt->input->cur = in;
3312             ctxt->nbChars += count;
3313             ctxt->input->col += count;
3314             if (ret == NULL)
3315                 xmlErrMemory(ctxt, NULL);
3316             return(ret);
3317         }
3318     }
3319     /* accelerator for special cases */
3320     return(xmlParseNameComplex(ctxt));
3321 }
3322
3323 static const xmlChar *
3324 xmlParseNCNameComplex(xmlParserCtxtPtr ctxt) {
3325     int len = 0, l;
3326     int c;
3327     int count = 0;
3328
3329 #ifdef DEBUG
3330     nbParseNCNameComplex++;
3331 #endif
3332
3333     /*
3334      * Handler for more complex cases
3335      */
3336     GROW;
3337     c = CUR_CHAR(l);
3338     if ((c == ' ') || (c == '>') || (c == '/') || /* accelerators */
3339         (!xmlIsNameStartChar(ctxt, c) || (c == ':'))) {
3340         return(NULL);
3341     }
3342
3343     while ((c != ' ') && (c != '>') && (c != '/') && /* test bigname.xml */
3344            (xmlIsNameChar(ctxt, c) && (c != ':'))) {
3345         if (count++ > 100) {
3346             count = 0;
3347             GROW;
3348         }
3349         len += l;
3350         NEXTL(l);
3351         c = CUR_CHAR(l);
3352     }
3353     return(xmlDictLookup(ctxt->dict, ctxt->input->cur - len, len));
3354 }
3355
3356 /**
3357  * xmlParseNCName:
3358  * @ctxt:  an XML parser context
3359  * @len:  lenght of the string parsed
3360  *
3361  * parse an XML name.
3362  *
3363  * [4NS] NCNameChar ::= Letter | Digit | '.' | '-' | '_' |
3364  *                      CombiningChar | Extender
3365  *
3366  * [5NS] NCName ::= (Letter | '_') (NCNameChar)*
3367  *
3368  * Returns the Name parsed or NULL
3369  */
3370
3371 static const xmlChar *
3372 xmlParseNCName(xmlParserCtxtPtr ctxt) {
3373     const xmlChar *in;
3374     const xmlChar *ret;
3375     int count = 0;
3376
3377 #ifdef DEBUG
3378     nbParseNCName++;
3379 #endif
3380
3381     /*
3382      * Accelerator for simple ASCII names
3383      */
3384     in = ctxt->input->cur;
3385     if (((*in >= 0x61) && (*in <= 0x7A)) ||
3386         ((*in >= 0x41) && (*in <= 0x5A)) ||
3387         (*in == '_')) {
3388         in++;
3389         while (((*in >= 0x61) && (*in <= 0x7A)) ||
3390                ((*in >= 0x41) && (*in <= 0x5A)) ||
3391                ((*in >= 0x30) && (*in <= 0x39)) ||
3392                (*in == '_') || (*in == '-') ||
3393                (*in == '.'))
3394             in++;
3395         if ((*in > 0) && (*in < 0x80)) {
3396             count = in - ctxt->input->cur;
3397             ret = xmlDictLookup(ctxt->dict, ctxt->input->cur, count);
3398             ctxt->input->cur = in;
3399             ctxt->nbChars += count;
3400             ctxt->input->col += count;
3401             if (ret == NULL) {
3402                 xmlErrMemory(ctxt, NULL);
3403             }
3404             return(ret);
3405         }
3406     }
3407     return(xmlParseNCNameComplex(ctxt));
3408 }
3409
3410 /**
3411  * xmlParseNameAndCompare:
3412  * @ctxt:  an XML parser context
3413  *
3414  * parse an XML name and compares for match
3415  * (specialized for endtag parsing)
3416  *
3417  * Returns NULL for an illegal name, (xmlChar*) 1 for success
3418  * and the name for mismatch
3419  */
3420
3421 static const xmlChar *
3422 xmlParseNameAndCompare(xmlParserCtxtPtr ctxt, xmlChar const *other) {
3423     register const xmlChar *cmp = other;
3424     register const xmlChar *in;
3425     const xmlChar *ret;
3426
3427     GROW;
3428
3429     in = ctxt->input->cur;
3430     while (*in != 0 && *in == *cmp) {
3431         ++in;
3432         ++cmp;
3433         ctxt->input->col++;
3434     }
3435     if (*cmp == 0 && (*in == '>' || IS_BLANK_CH (*in))) {
3436         /* success */
3437         ctxt->input->cur = in;
3438         return (const xmlChar*) 1;
3439     }
3440     /* failure (or end of input buffer), check with full function */
3441     ret = xmlParseName (ctxt);
3442     /* strings coming from the dictionnary direct compare possible */
3443     if (ret == other) {
3444         return (const xmlChar*) 1;
3445     }
3446     return ret;
3447 }
3448
3449 /**
3450  * xmlParseStringName:
3451  * @ctxt:  an XML parser context
3452  * @str:  a pointer to the string pointer (IN/OUT)
3453  *
3454  * parse an XML name.
3455  *
3456  * [4] NameChar ::= Letter | Digit | '.' | '-' | '_' | ':' |
3457  *                  CombiningChar | Extender
3458  *
3459  * [5] Name ::= (Letter | '_' | ':') (NameChar)*
3460  *
3461  * [6] Names ::= Name (#x20 Name)*
3462  *
3463  * Returns the Name parsed or NULL. The @str pointer
3464  * is updated to the current location in the string.
3465  */
3466
3467 static xmlChar *
3468 xmlParseStringName(xmlParserCtxtPtr ctxt, const xmlChar** str) {
3469     xmlChar buf[XML_MAX_NAMELEN + 5];
3470     const xmlChar *cur = *str;
3471     int len = 0, l;
3472     int c;
3473
3474 #ifdef DEBUG
3475     nbParseStringName++;
3476 #endif
3477
3478     c = CUR_SCHAR(cur, l);
3479     if (!xmlIsNameStartChar(ctxt, c)) {
3480         return(NULL);
3481     }
3482
3483     COPY_BUF(l,buf,len,c);
3484     cur += l;
3485     c = CUR_SCHAR(cur, l);
3486     while (xmlIsNameChar(ctxt, c)) {
3487         COPY_BUF(l,buf,len,c);
3488         cur += l;
3489         c = CUR_SCHAR(cur, l);
3490         if (len >= XML_MAX_NAMELEN) { /* test bigentname.xml */
3491             /*
3492              * Okay someone managed to make a huge name, so he's ready to pay
3493              * for the processing speed.
3494              */
3495             xmlChar *buffer;
3496             int max = len * 2;
3497
3498             buffer = (xmlChar *) xmlMallocAtomic(max * sizeof(xmlChar));
3499             if (buffer == NULL) {
3500                 xmlErrMemory(ctxt, NULL);
3501                 return(NULL);
3502             }
3503             memcpy(buffer, buf, len);
3504             while (xmlIsNameChar(ctxt, c)) {
3505                 if (len + 10 > max) {
3506                     xmlChar *tmp;
3507                     max *= 2;
3508                     tmp = (xmlChar *) xmlRealloc(buffer,
3509                                                     max * sizeof(xmlChar));
3510                     if (tmp == NULL) {
3511                         xmlErrMemory(ctxt, NULL);
3512                         xmlFree(buffer);
3513                         return(NULL);
3514                     }
3515                     buffer = tmp;
3516                 }
3517                 COPY_BUF(l,buffer,len,c);
3518                 cur += l;
3519                 c = CUR_SCHAR(cur, l);
3520             }
3521             buffer[len] = 0;
3522             *str = cur;
3523             return(buffer);
3524         }
3525     }
3526     *str = cur;
3527     return(xmlStrndup(buf, len));
3528 }
3529
3530 /**
3531  * xmlParseNmtoken:
3532  * @ctxt:  an XML parser context
3533  *
3534  * parse an XML Nmtoken.
3535  *
3536  * [7] Nmtoken ::= (NameChar)+
3537  *
3538  * [8] Nmtokens ::= Nmtoken (#x20 Nmtoken)*
3539  *
3540  * Returns the Nmtoken parsed or NULL
3541  */
3542
3543 xmlChar *
3544 xmlParseNmtoken(xmlParserCtxtPtr ctxt) {
3545     xmlChar buf[XML_MAX_NAMELEN + 5];
3546     int len = 0, l;
3547     int c;
3548     int count = 0;
3549
3550 #ifdef DEBUG
3551     nbParseNmToken++;
3552 #endif
3553
3554     GROW;
3555     c = CUR_CHAR(l);
3556
3557     while (xmlIsNameChar(ctxt, c)) {
3558         if (count++ > 100) {
3559             count = 0;
3560             GROW;
3561         }
3562         COPY_BUF(l,buf,len,c);
3563         NEXTL(l);
3564         c = CUR_CHAR(l);
3565         if (len >= XML_MAX_NAMELEN) {
3566             /*
3567              * Okay someone managed to make a huge token, so he's ready to pay
3568              * for the processing speed.
3569              */
3570             xmlChar *buffer;
3571             int max = len * 2;
3572
3573             buffer = (xmlChar *) xmlMallocAtomic(max * sizeof(xmlChar));
3574             if (buffer == NULL) {
3575                 xmlErrMemory(ctxt, NULL);
3576                 return(NULL);
3577             }
3578             memcpy(buffer, buf, len);
3579             while (xmlIsNameChar(ctxt, c)) {
3580                 if (count++ > 100) {
3581                     count = 0;
3582                     GROW;
3583                 }
3584                 if (len + 10 > max) {
3585                     xmlChar *tmp;
3586
3587                     max *= 2;
3588                     tmp = (xmlChar *) xmlRealloc(buffer,
3589                                                     max * sizeof(xmlChar));
3590                     if (tmp == NULL) {
3591                         xmlErrMemory(ctxt, NULL);
3592                         xmlFree(buffer);
3593                         return(NULL);
3594                     }
3595                     buffer = tmp;
3596                 }
3597                 COPY_BUF(l,buffer,len,c);
3598                 NEXTL(l);
3599                 c = CUR_CHAR(l);
3600             }
3601             buffer[len] = 0;
3602             return(buffer);
3603         }
3604     }
3605     if (len == 0)
3606         return(NULL);
3607     return(xmlStrndup(buf, len));
3608 }
3609
3610 /**
3611  * xmlParseEntityValue:
3612  * @ctxt:  an XML parser context
3613  * @orig:  if non-NULL store a copy of the original entity value
3614  *
3615  * parse a value for ENTITY declarations
3616  *
3617  * [9] EntityValue ::= '"' ([^%&"] | PEReference | Reference)* '"' |
3618  *                     "'" ([^%&'] | PEReference | Reference)* "'"
3619  *
3620  * Returns the EntityValue parsed with reference substituted or NULL
3621  */
3622
3623 xmlChar *
3624 xmlParseEntityValue(xmlParserCtxtPtr ctxt, xmlChar **orig) {
3625     xmlChar *buf = NULL;
3626     int len = 0;
3627     int size = XML_PARSER_BUFFER_SIZE;
3628     int c, l;
3629     xmlChar stop;
3630     xmlChar *ret = NULL;
3631     const xmlChar *cur = NULL;
3632     xmlParserInputPtr input;
3633
3634     if (RAW == '"') stop = '"';
3635     else if (RAW == '\'') stop = '\'';
3636     else {
3637         xmlFatalErr(ctxt, XML_ERR_ENTITY_NOT_STARTED, NULL);
3638         return(NULL);
3639     }
3640     buf = (xmlChar *) xmlMallocAtomic(size * sizeof(xmlChar));
3641     if (buf == NULL) {
3642         xmlErrMemory(ctxt, NULL);
3643         return(NULL);
3644     }
3645
3646     /*
3647      * The content of the entity definition is copied in a buffer.
3648      */
3649
3650     ctxt->instate = XML_PARSER_ENTITY_VALUE;
3651     input = ctxt->input;
3652     GROW;
3653     NEXT;
3654     c = CUR_CHAR(l);
3655     /*
3656      * NOTE: 4.4.5 Included in Literal
3657      * When a parameter entity reference appears in a literal entity
3658      * value, ... a single or double quote character in the replacement
3659      * text is always treated as a normal data character and will not
3660      * terminate the literal.
3661      * In practice it means we stop the loop only when back at parsing
3662      * the initial entity and the quote is found
3663      */
3664     while ((IS_CHAR(c)) && ((c != stop) || /* checked */
3665            (ctxt->input != input))) {
3666         if (len + 5 >= size) {
3667             xmlChar *tmp;
3668
3669             size *= 2;
3670             tmp = (xmlChar *) xmlRealloc(buf, size * sizeof(xmlChar));
3671             if (tmp == NULL) {
3672                 xmlErrMemory(ctxt, NULL);
3673                 xmlFree(buf);
3674                 return(NULL);
3675             }
3676             buf = tmp;
3677         }
3678         COPY_BUF(l,buf,len,c);
3679         NEXTL(l);
3680         /*
3681          * Pop-up of finished entities.
3682          */
3683         while ((RAW == 0) && (ctxt->inputNr > 1)) /* non input consuming */
3684             xmlPopInput(ctxt);
3685
3686         GROW;
3687         c = CUR_CHAR(l);
3688         if (c == 0) {
3689             GROW;
3690             c = CUR_CHAR(l);
3691         }
3692     }
3693     buf[len] = 0;
3694
3695     /*
3696      * Raise problem w.r.t. '&' and '%' being used in non-entities
3697      * reference constructs. Note Charref will be handled in
3698      * xmlStringDecodeEntities()
3699      */
3700     cur = buf;
3701     while (*cur != 0) { /* non input consuming */
3702         if ((*cur == '%') || ((*cur == '&') && (cur[1] != '#'))) {
3703             xmlChar *name;
3704             xmlChar tmp = *cur;
3705
3706             cur++;
3707             name = xmlParseStringName(ctxt, &cur);
3708             if ((name == NULL) || (*cur != ';')) {
3709                 xmlFatalErrMsgInt(ctxt, XML_ERR_ENTITY_CHAR_ERROR,
3710             "EntityValue: '%c' forbidden except for entities references\n",
3711                                   tmp);
3712             }
3713             if ((tmp == '%') && (ctxt->inSubset == 1) &&
3714                 (ctxt->inputNr == 1)) {
3715                 xmlFatalErr(ctxt, XML_ERR_ENTITY_PE_INTERNAL, NULL);
3716             }
3717             if (name != NULL)
3718                 xmlFree(name);
3719             if (*cur == 0)
3720                 break;
3721         }
3722         cur++;
3723     }
3724
3725     /*
3726      * Then PEReference entities are substituted.
3727      */
3728     if (c != stop) {
3729         xmlFatalErr(ctxt, XML_ERR_ENTITY_NOT_FINISHED, NULL);
3730         xmlFree(buf);
3731     } else {
3732         NEXT;
3733         /*
3734          * NOTE: 4.4.7 Bypassed
3735          * When a general entity reference appears in the EntityValue in
3736          * an entity declaration, it is bypassed and left as is.
3737          * so XML_SUBSTITUTE_REF is not set here.
3738          */
3739         ret = xmlStringDecodeEntities(ctxt, buf, XML_SUBSTITUTE_PEREF,
3740                                       0, 0, 0);
3741         if (orig != NULL)
3742             *orig = buf;
3743         else
3744             xmlFree(buf);
3745     }
3746
3747     return(ret);
3748 }
3749
3750 /**
3751  * xmlParseAttValueComplex:
3752  * @ctxt:  an XML parser context
3753  * @len:   the resulting attribute len
3754  * @normalize:  wether to apply the inner normalization
3755  *
3756  * parse a value for an attribute, this is the fallback function
3757  * of xmlParseAttValue() when the attribute parsing requires handling
3758  * of non-ASCII characters, or normalization compaction.
3759  *
3760  * Returns the AttValue parsed or NULL. The value has to be freed by the caller.
3761  */
3762 static xmlChar *
3763 xmlParseAttValueComplex(xmlParserCtxtPtr ctxt, int *attlen, int normalize) {
3764     xmlChar limit = 0;
3765     xmlChar *buf = NULL;
3766     xmlChar *rep = NULL;
3767     int len = 0;
3768     int buf_size = 0;
3769     int c, l, in_space = 0;
3770     xmlChar *current = NULL;
3771     xmlEntityPtr ent;
3772
3773     if (NXT(0) == '"') {
3774         ctxt->instate = XML_PARSER_ATTRIBUTE_VALUE;
3775         limit = '"';
3776         NEXT;
3777     } else if (NXT(0) == '\'') {
3778         limit = '\'';
3779         ctxt->instate = XML_PARSER_ATTRIBUTE_VALUE;
3780         NEXT;
3781     } else {
3782         xmlFatalErr(ctxt, XML_ERR_ATTRIBUTE_NOT_STARTED, NULL);
3783         return(NULL);
3784     }
3785
3786     /*
3787      * allocate a translation buffer.
3788      */
3789     buf_size = XML_PARSER_BUFFER_SIZE;
3790     buf = (xmlChar *) xmlMallocAtomic(buf_size * sizeof(xmlChar));
3791     if (buf == NULL) goto mem_error;
3792
3793     /*
3794      * OK loop until we reach one of the ending char or a size limit.
3795      */
3796     c = CUR_CHAR(l);
3797     while ((NXT(0) != limit) && /* checked */
3798            (IS_CHAR(c)) && (c != '<')) {
3799         if (c == 0) break;
3800         if (c == '&') {
3801             in_space = 0;
3802             if (NXT(1) == '#') {
3803                 int val = xmlParseCharRef(ctxt);
3804
3805                 if (val == '&') {
3806                     if (ctxt->replaceEntities) {
3807                         if (len > buf_size - 10) {
3808                             growBuffer(buf, 10);
3809                         }
3810                         buf[len++] = '&';
3811                     } else {
3812                         /*
3813                          * The reparsing will be done in xmlStringGetNodeList()
3814                          * called by the attribute() function in SAX.c
3815                          */
3816                         if (len > buf_size - 10) {
3817                             growBuffer(buf, 10);
3818                         }
3819                         buf[len++] = '&';
3820                         buf[len++] = '#';
3821                         buf[len++] = '3';
3822                         buf[len++] = '8';
3823                         buf[len++] = ';';
3824                     }
3825                 } else if (val != 0) {
3826                     if (len > buf_size - 10) {
3827                         growBuffer(buf, 10);
3828                     }
3829                     len += xmlCopyChar(0, &buf[len], val);
3830                 }
3831             } else {
3832                 ent = xmlParseEntityRef(ctxt);
3833                 ctxt->nbentities++;
3834                 if (ent != NULL)
3835                     ctxt->nbentities += ent->owner;
3836                 if ((ent != NULL) &&
3837                     (ent->etype == XML_INTERNAL_PREDEFINED_ENTITY)) {
3838                     if (len > buf_size - 10) {
3839                         growBuffer(buf, 10);
3840                     }
3841                     if ((ctxt->replaceEntities == 0) &&
3842                         (ent->content[0] == '&')) {
3843                         buf[len++] = '&';
3844                         buf[len++] = '#';
3845                         buf[len++] = '3';
3846                         buf[len++] = '8';
3847                         buf[len++] = ';';
3848                     } else {
3849                         buf[len++] = ent->content[0];
3850                     }
3851                 } else if ((ent != NULL) &&
3852                            (ctxt->replaceEntities != 0)) {
3853                     if (ent->etype != XML_INTERNAL_PREDEFINED_ENTITY) {
3854                         rep = xmlStringDecodeEntities(ctxt, ent->content,
3855                                                       XML_SUBSTITUTE_REF,
3856                                                       0, 0, 0);
3857                         if (rep != NULL) {
3858                             current = rep;
3859                             while (*current != 0) { /* non input consuming */
3860                                 if ((*current == 0xD) || (*current == 0xA) ||
3861                                     (*current == 0x9)) {
3862                                     buf[len++] = 0x20;
3863                                     current++;
3864                                 } else
3865                                     buf[len++] = *current++;
3866                                 if (len > buf_size - 10) {
3867                                     growBuffer(buf, 10);
3868                                 }
3869                             }
3870                             xmlFree(rep);
3871                             rep = NULL;
3872                         }
3873                     } else {
3874                         if (len > buf_size - 10) {
3875                             growBuffer(buf, 10);
3876                         }
3877                         if (ent->content != NULL)
3878                             buf[len++] = ent->content[0];
3879                     }
3880                 } else if (ent != NULL) {
3881                     int i = xmlStrlen(ent->name);
3882                     const xmlChar *cur = ent->name;
3883
3884                     /*
3885                      * This may look absurd but is needed to detect
3886                      * entities problems
3887                      */
3888                     if ((ent->etype != XML_INTERNAL_PREDEFINED_ENTITY) &&
3889                         (ent->content != NULL)) {
3890                         rep = xmlStringDecodeEntities(ctxt, ent->content,
3891                                                   XML_SUBSTITUTE_REF, 0, 0, 0);
3892                         if (rep != NULL) {
3893                             xmlFree(rep);
3894                             rep = NULL;
3895                         }
3896                     }
3897
3898                     /*
3899                      * Just output the reference
3900                      */
3901                     buf[len++] = '&';
3902                     while (len > buf_size - i - 10) {
3903                         growBuffer(buf, i + 10);
3904                     }
3905                     for (;i > 0;i--)
3906                         buf[len++] = *cur++;
3907                     buf[len++] = ';';
3908                 }
3909             }
3910         } else {
3911             if ((c == 0x20) || (c == 0xD) || (c == 0xA) || (c == 0x9)) {
3912                 if ((len != 0) || (!normalize)) {
3913                     if ((!normalize) || (!in_space)) {
3914                         COPY_BUF(l,buf,len,0x20);
3915                         while (len > buf_size - 10) {
3916                             growBuffer(buf, 10);
3917                         }
3918                     }
3919                     in_space = 1;
3920                 }
3921             } else {
3922                 in_space = 0;
3923                 COPY_BUF(l,buf,len,c);
3924                 if (len > buf_size - 10) {
3925                     growBuffer(buf, 10);
3926                 }
3927             }
3928             NEXTL(l);
3929         }
3930         GROW;
3931         c = CUR_CHAR(l);
3932     }
3933     if ((in_space) && (normalize)) {
3934         while (buf[len - 1] == 0x20) len--;
3935     }
3936     buf[len] = 0;
3937     if (RAW == '<') {
3938         xmlFatalErr(ctxt, XML_ERR_LT_IN_ATTRIBUTE, NULL);
3939     } else if (RAW != limit) {
3940         if ((c != 0) && (!IS_CHAR(c))) {
3941             xmlFatalErrMsg(ctxt, XML_ERR_INVALID_CHAR,
3942                            "invalid character in attribute value\n");
3943         } else {
3944             xmlFatalErrMsg(ctxt, XML_ERR_ATTRIBUTE_NOT_FINISHED,
3945                            "AttValue: ' expected\n");
3946         }
3947     } else
3948         NEXT;
3949     if (attlen != NULL) *attlen = len;
3950     return(buf);
3951
3952 mem_error:
3953     xmlErrMemory(ctxt, NULL);
3954     if (buf != NULL)
3955         xmlFree(buf);
3956     if (rep != NULL)
3957         xmlFree(rep);
3958     return(NULL);
3959 }
3960
3961 /**
3962  * xmlParseAttValue:
3963  * @ctxt:  an XML parser context
3964  *
3965  * parse a value for an attribute
3966  * Note: the parser won't do substitution of entities here, this
3967  * will be handled later in xmlStringGetNodeList
3968  *
3969  * [10] AttValue ::= '"' ([^<&"] | Reference)* '"' |
3970  *                   "'" ([^<&'] | Reference)* "'"
3971  *
3972  * 3.3.3 Attribute-Value Normalization:
3973  * Before the value of an attribute is passed to the application or
3974  * checked for validity, the XML processor must normalize it as follows:
3975  * - a character reference is processed by appending the referenced
3976  *   character to the attribute value
3977  * - an entity reference is processed by recursively processing the
3978  *   replacement text of the entity
3979  * - a whitespace character (#x20, #xD, #xA, #x9) is processed by
3980  *   appending #x20 to the normalized value, except that only a single
3981  *   #x20 is appended for a "#xD#xA" sequence that is part of an external
3982  *   parsed entity or the literal entity value of an internal parsed entity
3983  * - other characters are processed by appending them to the normalized value
3984  * If the declared value is not CDATA, then the XML processor must further
3985  * process the normalized attribute value by discarding any leading and
3986  * trailing space (#x20) characters, and by replacing sequences of space
3987  * (#x20) characters by a single space (#x20) character.
3988  * All attributes for which no declaration has been read should be treated
3989  * by a non-validating parser as if declared CDATA.
3990  *
3991  * Returns the AttValue parsed or NULL. The value has to be freed by the caller.
3992  */
3993
3994
3995 xmlChar *
3996 xmlParseAttValue(xmlParserCtxtPtr ctxt) {
3997     if ((ctxt == NULL) || (ctxt->input == NULL)) return(NULL);
3998     return(xmlParseAttValueInternal(ctxt, NULL, NULL, 0));
3999 }
4000
4001 /**
4002  * xmlParseSystemLiteral:
4003  * @ctxt:  an XML parser context
4004  *
4005  * parse an XML Literal
4006  *
4007  * [11] SystemLiteral ::= ('"' [^"]* '"') | ("'" [^']* "'")
4008  *
4009  * Returns the SystemLiteral parsed or NULL
4010  */
4011
4012 xmlChar *
4013 xmlParseSystemLiteral(xmlParserCtxtPtr ctxt) {
4014     xmlChar *buf = NULL;
4015     int len = 0;
4016     int size = XML_PARSER_BUFFER_SIZE;
4017     int cur, l;
4018     xmlChar stop;
4019     int state = ctxt->instate;
4020     int count = 0;
4021
4022     SHRINK;
4023     if (RAW == '"') {
4024         NEXT;
4025         stop = '"';
4026     } else if (RAW == '\'') {
4027         NEXT;
4028         stop = '\'';
4029     } else {
4030         xmlFatalErr(ctxt, XML_ERR_LITERAL_NOT_STARTED, NULL);
4031         return(NULL);
4032     }
4033
4034     buf = (xmlChar *) xmlMallocAtomic(size * sizeof(xmlChar));
4035     if (buf == NULL) {
4036         xmlErrMemory(ctxt, NULL);
4037         return(NULL);
4038     }
4039     ctxt->instate = XML_PARSER_SYSTEM_LITERAL;
4040     cur = CUR_CHAR(l);
4041     while ((IS_CHAR(cur)) && (cur != stop)) { /* checked */
4042         if (len + 5 >= size) {
4043             xmlChar *tmp;
4044
4045             size *= 2;
4046             tmp = (xmlChar *) xmlRealloc(buf, size * sizeof(xmlChar));
4047             if (tmp == NULL) {
4048                 xmlFree(buf);
4049                 xmlErrMemory(ctxt, NULL);
4050                 ctxt->instate = (xmlParserInputState) state;
4051                 return(NULL);
4052             }
4053             buf = tmp;
4054         }
4055         count++;
4056         if (count > 50) {
4057             GROW;
4058             count = 0;
4059         }
4060         COPY_BUF(l,buf,len,cur);
4061         NEXTL(l);
4062         cur = CUR_CHAR(l);
4063         if (cur == 0) {
4064             GROW;
4065             SHRINK;
4066             cur = CUR_CHAR(l);
4067         }
4068     }
4069     buf[len] = 0;
4070     ctxt->instate = (xmlParserInputState) state;
4071     if (!IS_CHAR(cur)) {
4072         xmlFatalErr(ctxt, XML_ERR_LITERAL_NOT_FINISHED, NULL);
4073     } else {
4074         NEXT;
4075     }
4076     return(buf);
4077 }
4078
4079 /**
4080  * xmlParsePubidLiteral:
4081  * @ctxt:  an XML parser context
4082  *
4083  * parse an XML public literal
4084  *
4085  * [12] PubidLiteral ::= '"' PubidChar* '"' | "'" (PubidChar - "'")* "'"
4086  *
4087  * Returns the PubidLiteral parsed or NULL.
4088  */
4089
4090 xmlChar *
4091 xmlParsePubidLiteral(xmlParserCtxtPtr ctxt) {
4092     xmlChar *buf = NULL;
4093     int len = 0;
4094     int size = XML_PARSER_BUFFER_SIZE;
4095     xmlChar cur;
4096     xmlChar stop;
4097     int count = 0;
4098     xmlParserInputState oldstate = ctxt->instate;
4099
4100     SHRINK;
4101     if (RAW == '"') {
4102         NEXT;
4103         stop = '"';
4104     } else if (RAW == '\'') {
4105         NEXT;
4106         stop = '\'';
4107     } else {
4108         xmlFatalErr(ctxt, XML_ERR_LITERAL_NOT_STARTED, NULL);
4109         return(NULL);
4110     }
4111     buf = (xmlChar *) xmlMallocAtomic(size * sizeof(xmlChar));
4112     if (buf == NULL) {
4113         xmlErrMemory(ctxt, NULL);
4114         return(NULL);
4115     }
4116     ctxt->instate = XML_PARSER_PUBLIC_LITERAL;
4117     cur = CUR;
4118     while ((IS_PUBIDCHAR_CH(cur)) && (cur != stop)) { /* checked */
4119         if (len + 1 >= size) {
4120             xmlChar *tmp;
4121
4122             size *= 2;
4123             tmp = (xmlChar *) xmlRealloc(buf, size * sizeof(xmlChar));
4124             if (tmp == NULL) {
4125                 xmlErrMemory(ctxt, NULL);
4126                 xmlFree(buf);
4127                 return(NULL);
4128             }
4129             buf = tmp;
4130         }
4131         buf[len++] = cur;
4132         count++;
4133         if (count > 50) {
4134             GROW;
4135             count = 0;
4136         }
4137         NEXT;
4138         cur = CUR;
4139         if (cur == 0) {
4140             GROW;
4141             SHRINK;
4142             cur = CUR;
4143         }
4144     }
4145     buf[len] = 0;
4146     if (cur != stop) {
4147         xmlFatalErr(ctxt, XML_ERR_LITERAL_NOT_FINISHED, NULL);
4148     } else {
4149         NEXT;
4150     }
4151     ctxt->instate = oldstate;
4152     return(buf);
4153 }
4154
4155 static void xmlParseCharDataComplex(xmlParserCtxtPtr ctxt, int cdata);
4156
4157 /*
4158  * used for the test in the inner loop of the char data testing
4159  */
4160 static const unsigned char test_char_data[256] = {
4161     0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
4162     0x00, 0x09, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, /* 0x9, CR/LF separated */
4163     0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
4164     0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
4165     0x20, 0x21, 0x22, 0x23, 0x24, 0x25, 0x00, 0x27, /* & */
4166     0x28, 0x29, 0x2A, 0x2B, 0x2C, 0x2D, 0x2E, 0x2F,
4167     0x30, 0x31, 0x32, 0x33, 0x34, 0x35, 0x36, 0x37,
4168     0x38, 0x39, 0x3A, 0x3B, 0x00, 0x3D, 0x3E, 0x3F, /* < */
4169     0x40, 0x41, 0x42, 0x43, 0x44, 0x45, 0x46, 0x47,
4170     0x48, 0x49, 0x4A, 0x4B, 0x4C, 0x4D, 0x4E, 0x4F,
4171     0x50, 0x51, 0x52, 0x53, 0x54, 0x55, 0x56, 0x57,
4172     0x58, 0x59, 0x5A, 0x5B, 0x5C, 0x00, 0x5E, 0x5F, /* ] */
4173     0x60, 0x61, 0x62, 0x63, 0x64, 0x65, 0x66, 0x67,
4174     0x68, 0x69, 0x6A, 0x6B, 0x6C, 0x6D, 0x6E, 0x6F,
4175     0x70, 0x71, 0x72, 0x73, 0x74, 0x75, 0x76, 0x77,
4176     0x78, 0x79, 0x7A, 0x7B, 0x7C, 0x7D, 0x7E, 0x7F,
4177     0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, /* non-ascii */
4178     0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
4179     0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
4180     0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
4181     0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
4182     0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
4183     0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
4184     0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
4185     0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
4186     0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
4187     0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
4188     0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
4189     0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
4190     0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
4191     0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
4192     0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00
4193 };
4194
4195 /**
4196  * xmlParseCharData:
4197  * @ctxt:  an XML parser context
4198  * @cdata:  int indicating whether we are within a CDATA section
4199  *
4200  * parse a CharData section.
4201  * if we are within a CDATA section ']]>' marks an end of section.
4202  *
4203  * The right angle bracket (>) may be represented using the string "&gt;",
4204  * and must, for compatibility, be escaped using "&gt;" or a character
4205  * reference when it appears in the string "]]>" in content, when that
4206  * string is not marking the end of a CDATA section.
4207  *
4208  * [14] CharData ::= [^<&]* - ([^<&]* ']]>' [^<&]*)
4209  */
4210
4211 void
4212 xmlParseCharData(xmlParserCtxtPtr ctxt, int cdata) {
4213     const xmlChar *in;
4214     int nbchar = 0;
4215     int line = ctxt->input->line;
4216     int col = ctxt->input->col;
4217     int ccol;
4218
4219     SHRINK;
4220     GROW;
4221     /*
4222      * Accelerated common case where input don't need to be
4223      * modified before passing it to the handler.
4224      */
4225     if (!cdata) {
4226         in = ctxt->input->cur;
4227         do {
4228 get_more_space:
4229             while (*in == 0x20) { in++; ctxt->input->col++; }
4230             if (*in == 0xA) {
4231                 do {
4232                     ctxt->input->line++; ctxt->input->col = 1;
4233                     in++;
4234                 } while (*in == 0xA);
4235                 goto get_more_space;
4236             }
4237             if (*in == '<') {
4238                 nbchar = in - ctxt->input->cur;
4239                 if (nbchar > 0) {
4240                     const xmlChar *tmp = ctxt->input->cur;
4241                     ctxt->input->cur = in;
4242
4243                     if ((ctxt->sax != NULL) &&
4244                         (ctxt->sax->ignorableWhitespace !=
4245                          ctxt->sax->characters)) {
4246                         if (areBlanks(ctxt, tmp, nbchar, 1)) {
4247                             if (ctxt->sax->ignorableWhitespace != NULL)
4248                                 ctxt->sax->ignorableWhitespace(ctxt->userData,
4249                                                        tmp, nbchar);
4250                         } else {
4251                             if (ctxt->sax->characters != NULL)
4252                                 ctxt->sax->characters(ctxt->userData,
4253                                                       tmp, nbchar);
4254                             if (*ctxt->space == -1)
4255                                 *ctxt->space = -2;
4256                         }
4257                     } else if ((ctxt->sax != NULL) &&
4258                                (ctxt->sax->characters != NULL)) {
4259                         ctxt->sax->characters(ctxt->userData,
4260                                               tmp, nbchar);
4261                     }
4262                 }
4263                 return;
4264             }
4265
4266 get_more:
4267             ccol = ctxt->input->col;
4268             while (test_char_data[*in]) {
4269                 in++;
4270                 ccol++;
4271             }
4272             ctxt->input->col = ccol;
4273             if (*in == 0xA) {
4274                 do {
4275                     ctxt->input->line++; ctxt->input->col = 1;
4276                     in++;
4277                 } while (*in == 0xA);
4278                 goto get_more;
4279             }
4280             if (*in == ']') {
4281                 if ((in[1] == ']') && (in[2] == '>')) {
4282                     xmlFatalErr(ctxt, XML_ERR_MISPLACED_CDATA_END, NULL);
4283                     ctxt->input->cur = in;
4284                     return;
4285                 }
4286                 in++;
4287                 ctxt->input->col++;
4288                 goto get_more;
4289             }
4290             nbchar = in - ctxt->input->cur;
4291             if (nbchar > 0) {
4292                 if ((ctxt->sax != NULL) &&
4293                     (ctxt->sax->ignorableWhitespace !=
4294                      ctxt->sax->characters) &&
4295                     (IS_BLANK_CH(*ctxt->input->cur))) {
4296                     const xmlChar *tmp = ctxt->input->cur;
4297                     ctxt->input->cur = in;
4298
4299                     if (areBlanks(ctxt, tmp, nbchar, 0)) {
4300                         if (ctxt->sax->ignorableWhitespace != NULL)
4301                             ctxt->sax->ignorableWhitespace(ctxt->userData,
4302                                                            tmp, nbchar);
4303                     } else {
4304                         if (ctxt->sax->characters != NULL)
4305                             ctxt->sax->characters(ctxt->userData,
4306                                                   tmp, nbchar);
4307                         if (*ctxt->space == -1)
4308                             *ctxt->space = -2;
4309                     }
4310                     line = ctxt->input->line;
4311                     col = ctxt->input->col;
4312                 } else if (ctxt->sax != NULL) {
4313                     if (ctxt->sax->characters != NULL)
4314                         ctxt->sax->characters(ctxt->userData,
4315                                               ctxt->input->cur, nbchar);
4316                     line = ctxt->input->line;
4317                     col = ctxt->input->col;
4318                 }
4319                 /* something really bad happened in the SAX callback */
4320                 if (ctxt->instate != XML_PARSER_CONTENT)
4321                     return;
4322             }
4323             ctxt->input->cur = in;
4324             if (*in == 0xD) {
4325                 in++;
4326                 if (*in == 0xA) {
4327                     ctxt->input->cur = in;
4328                     in++;
4329                     ctxt->input->line++; ctxt->input->col = 1;
4330                     continue; /* while */
4331                 }
4332                 in--;
4333             }
4334             if (*in == '<') {
4335                 return;
4336             }
4337             if (*in == '&') {
4338                 return;
4339             }
4340             SHRINK;
4341             GROW;
4342             in = ctxt->input->cur;
4343         } while (((*in >= 0x20) && (*in <= 0x7F)) || (*in == 0x09));
4344         nbchar = 0;
4345     }
4346     ctxt->input->line = line;
4347     ctxt->input->col = col;
4348     xmlParseCharDataComplex(ctxt, cdata);
4349 }
4350
4351 /**
4352  * xmlParseCharDataComplex:
4353  * @ctxt:  an XML parser context
4354  * @cdata:  int indicating whether we are within a CDATA section
4355  *
4356  * parse a CharData section.this is the fallback function
4357  * of xmlParseCharData() when the parsing requires handling
4358  * of non-ASCII characters.
4359  */
4360 static void
4361 xmlParseCharDataComplex(xmlParserCtxtPtr ctxt, int cdata) {
4362     xmlChar buf[XML_PARSER_BIG_BUFFER_SIZE + 5];
4363     int nbchar = 0;
4364     int cur, l;
4365     int count = 0;
4366
4367     SHRINK;
4368     GROW;
4369     cur = CUR_CHAR(l);
4370     while ((cur != '<') && /* checked */
4371            (cur != '&') &&
4372            (IS_CHAR(cur))) /* test also done in xmlCurrentChar() */ {
4373         if ((cur == ']') && (NXT(1) == ']') &&
4374             (NXT(2) == '>')) {
4375             if (cdata) break;
4376             else {
4377                 xmlFatalErr(ctxt, XML_ERR_MISPLACED_CDATA_END, NULL);
4378             }
4379         }
4380         COPY_BUF(l,buf,nbchar,cur);
4381         if (nbchar >= XML_PARSER_BIG_BUFFER_SIZE) {
4382             buf[nbchar] = 0;
4383
4384             /*
4385              * OK the segment is to be consumed as chars.
4386              */
4387             if ((ctxt->sax != NULL) && (!ctxt->disableSAX)) {
4388                 if (areBlanks(ctxt, buf, nbchar, 0)) {
4389                     if (ctxt->sax->ignorableWhitespace != NULL)
4390                         ctxt->sax->ignorableWhitespace(ctxt->userData,
4391                                                        buf, nbchar);
4392                 } else {
4393                     if (ctxt->sax->characters != NULL)
4394                         ctxt->sax->characters(ctxt->userData, buf, nbchar);
4395                     if ((ctxt->sax->characters !=
4396                          ctxt->sax->ignorableWhitespace) &&
4397                         (*ctxt->space == -1))
4398                         *ctxt->space = -2;
4399                 }
4400             }
4401             nbchar = 0;
4402             /* something really bad happened in the SAX callback */
4403             if (ctxt->instate != XML_PARSER_CONTENT)
4404                 return;
4405         }
4406         count++;
4407         if (count > 50) {
4408             GROW;
4409             count = 0;
4410         }
4411         NEXTL(l);
4412         cur = CUR_CHAR(l);
4413     }
4414     if (nbchar != 0) {
4415         buf[nbchar] = 0;
4416         /*
4417          * OK the segment is to be consumed as chars.
4418          */
4419         if ((ctxt->sax != NULL) && (!ctxt->disableSAX)) {
4420             if (areBlanks(ctxt, buf, nbchar, 0)) {
4421                 if (ctxt->sax->ignorableWhitespace != NULL)
4422                     ctxt->sax->ignorableWhitespace(ctxt->userData, buf, nbchar);
4423             } else {
4424                 if (ctxt->sax->characters != NULL)
4425                     ctxt->sax->characters(ctxt->userData, buf, nbchar);
4426                 if ((ctxt->sax->characters != ctxt->sax->ignorableWhitespace) &&
4427                     (*ctxt->space == -1))
4428                     *ctxt->space = -2;
4429             }
4430         }
4431     }
4432     if ((cur != 0) && (!IS_CHAR(cur))) {
4433         /* Generate the error and skip the offending character */
4434         xmlFatalErrMsgInt(ctxt, XML_ERR_INVALID_CHAR,
4435                           "PCDATA invalid Char value %d\n",
4436                           cur);
4437         NEXTL(l);
4438     }
4439 }
4440
4441 /**
4442  * xmlParseExternalID:
4443  * @ctxt:  an XML parser context
4444  * @publicID:  a xmlChar** receiving PubidLiteral
4445  * @strict: indicate whether we should restrict parsing to only
4446  *          production [75], see NOTE below
4447  *
4448  * Parse an External ID or a Public ID
4449  *
4450  * NOTE: Productions [75] and [83] interact badly since [75] can generate
4451  *       'PUBLIC' S PubidLiteral S SystemLiteral
4452  *
4453  * [75] ExternalID ::= 'SYSTEM' S SystemLiteral
4454  *                   | 'PUBLIC' S PubidLiteral S SystemLiteral
4455  *
4456  * [83] PublicID ::= 'PUBLIC' S PubidLiteral
4457  *
4458  * Returns the function returns SystemLiteral and in the second
4459  *                case publicID receives PubidLiteral, is strict is off
4460  *                it is possible to return NULL and have publicID set.
4461  */
4462
4463 xmlChar *
4464 xmlParseExternalID(xmlParserCtxtPtr ctxt, xmlChar **publicID, int strict) {
4465     xmlChar *URI = NULL;
4466
4467     SHRINK;
4468
4469     *publicID = NULL;
4470     if (CMP6(CUR_PTR, 'S', 'Y', 'S', 'T', 'E', 'M')) {
4471         SKIP(6);
4472         if (!IS_BLANK_CH(CUR)) {
4473             xmlFatalErrMsg(ctxt, XML_ERR_SPACE_REQUIRED,
4474                            "Space required after 'SYSTEM'\n");
4475         }
4476         SKIP_BLANKS;
4477         URI = xmlParseSystemLiteral(ctxt);
4478         if (URI == NULL) {
4479             xmlFatalErr(ctxt, XML_ERR_URI_REQUIRED, NULL);
4480         }
4481     } else if (CMP6(CUR_PTR, 'P', 'U', 'B', 'L', 'I', 'C')) {
4482         SKIP(6);
4483         if (!IS_BLANK_CH(CUR)) {
4484             xmlFatalErrMsg(ctxt, XML_ERR_SPACE_REQUIRED,
4485                     "Space required after 'PUBLIC'\n");
4486         }
4487         SKIP_BLANKS;
4488         *publicID = xmlParsePubidLiteral(ctxt);
4489         if (*publicID == NULL) {
4490             xmlFatalErr(ctxt, XML_ERR_PUBID_REQUIRED, NULL);
4491         }
4492         if (strict) {
4493             /*
4494              * We don't handle [83] so "S SystemLiteral" is required.
4495              */
4496             if (!IS_BLANK_CH(CUR)) {
4497                 xmlFatalErrMsg(ctxt, XML_ERR_SPACE_REQUIRED,
4498                         "Space required after the Public Identifier\n");
4499             }
4500         } else {
4501             /*
4502              * We handle [83] so we return immediately, if
4503              * "S SystemLiteral" is not detected. From a purely parsing
4504              * point of view that's a nice mess.
4505              */
4506             const xmlChar *ptr;
4507             GROW;
4508
4509             ptr = CUR_PTR;
4510             if (!IS_BLANK_CH(*ptr)) return(NULL);
4511
4512             while (IS_BLANK_CH(*ptr)) ptr++; /* TODO: dangerous, fix ! */
4513             if ((*ptr != '\'') && (*ptr != '"')) return(NULL);
4514         }
4515         SKIP_BLANKS;
4516         URI = xmlParseSystemLiteral(ctxt);
4517         if (URI == NULL) {
4518             xmlFatalErr(ctxt, XML_ERR_URI_REQUIRED, NULL);
4519         }
4520     }
4521     return(URI);
4522 }
4523
4524 /**
4525  * xmlParseCommentComplex:
4526  * @ctxt:  an XML parser context
4527  * @buf:  the already parsed part of the buffer
4528  * @len:  number of bytes filles in the buffer
4529  * @size:  allocated size of the buffer
4530  *
4531  * Skip an XML (SGML) comment <!-- .... -->
4532  *  The spec says that "For compatibility, the string "--" (double-hyphen)
4533  *  must not occur within comments. "
4534  * This is the slow routine in case the accelerator for ascii didn't work
4535  *
4536  * [15] Comment ::= '<!--' ((Char - '-') | ('-' (Char - '-')))* '-->'
4537  */
4538 static void
4539 xmlParseCommentComplex(xmlParserCtxtPtr ctxt, xmlChar *buf, int len, int size) {
4540     int q, ql;
4541     int r, rl;
4542     int cur, l;
4543     int count = 0;
4544     int inputid;
4545
4546     inputid = ctxt->input->id;
4547
4548     if (buf == NULL) {
4549         len = 0;
4550         size = XML_PARSER_BUFFER_SIZE;
4551         buf = (xmlChar *) xmlMallocAtomic(size * sizeof(xmlChar));
4552         if (buf == NULL) {
4553             xmlErrMemory(ctxt, NULL);
4554             return;
4555         }
4556     }
4557     GROW;       /* Assure there's enough input data */
4558     q = CUR_CHAR(ql);
4559     if (q == 0)
4560         goto not_terminated;
4561     if (!IS_CHAR(q)) {
4562         xmlFatalErrMsgInt(ctxt, XML_ERR_INVALID_CHAR,
4563                           "xmlParseComment: invalid xmlChar value %d\n",
4564                           q);
4565         xmlFree (buf);
4566         return;
4567     }
4568     NEXTL(ql);
4569     r = CUR_CHAR(rl);
4570     if (r == 0)
4571         goto not_terminated;
4572     if (!IS_CHAR(r)) {
4573         xmlFatalErrMsgInt(ctxt, XML_ERR_INVALID_CHAR,
4574                           "xmlParseComment: invalid xmlChar value %d\n",
4575                           q);
4576         xmlFree (buf);
4577         return;
4578     }
4579     NEXTL(rl);
4580     cur = CUR_CHAR(l);
4581     if (cur == 0)
4582         goto not_terminated;
4583     while (IS_CHAR(cur) && /* checked */
4584            ((cur != '>') ||
4585             (r != '-') || (q != '-'))) {
4586         if ((r == '-') && (q == '-')) {
4587             xmlFatalErr(ctxt, XML_ERR_HYPHEN_IN_COMMENT, NULL);
4588         }
4589         if (len + 5 >= size) {
4590             xmlChar *new_buf;
4591             size *= 2;
4592             new_buf = (xmlChar *) xmlRealloc(buf, size * sizeof(xmlChar));
4593             if (new_buf == NULL) {
4594                 xmlFree (buf);
4595                 xmlErrMemory(ctxt, NULL);
4596                 return;
4597             }
4598             buf = new_buf;
4599         }
4600         COPY_BUF(ql,buf,len,q);
4601         q = r;
4602         ql = rl;
4603         r = cur;
4604         rl = l;
4605
4606         count++;
4607         if (count > 50) {
4608             GROW;
4609             count = 0;
4610         }
4611         NEXTL(l);
4612         cur = CUR_CHAR(l);
4613         if (cur == 0) {
4614             SHRINK;
4615             GROW;
4616             cur = CUR_CHAR(l);
4617         }
4618     }
4619     buf[len] = 0;
4620     if (cur == 0) {
4621         xmlFatalErrMsgStr(ctxt, XML_ERR_COMMENT_NOT_FINISHED,
4622                              "Comment not terminated \n<!--%.50s\n", buf);
4623     } else if (!IS_CHAR(cur)) {
4624         xmlFatalErrMsgInt(ctxt, XML_ERR_INVALID_CHAR,
4625                           "xmlParseComment: invalid xmlChar value %d\n",
4626                           cur);
4627     } else {
4628         if (inputid != ctxt->input->id) {
4629             xmlFatalErrMsg(ctxt, XML_ERR_ENTITY_BOUNDARY,
4630                 "Comment doesn't start and stop in the same entity\n");
4631         }
4632         NEXT;
4633         if ((ctxt->sax != NULL) && (ctxt->sax->comment != NULL) &&
4634             (!ctxt->disableSAX))
4635             ctxt->sax->comment(ctxt->userData, buf);
4636     }
4637     xmlFree(buf);
4638     return;
4639 not_terminated:
4640     xmlFatalErrMsgStr(ctxt, XML_ERR_COMMENT_NOT_FINISHED,
4641                          "Comment not terminated\n", NULL);
4642     xmlFree(buf);
4643     return;
4644 }
4645
4646 /**
4647  * xmlParseComment:
4648  * @ctxt:  an XML parser context
4649  *
4650  * Skip an XML (SGML) comment <!-- .... -->
4651  *  The spec says that "For compatibility, the string "--" (double-hyphen)
4652  *  must not occur within comments. "
4653  *
4654  * [15] Comment ::= '<!--' ((Char - '-') | ('-' (Char - '-')))* '-->'
4655  */
4656 void
4657 xmlParseComment(xmlParserCtxtPtr ctxt) {
4658     xmlChar *buf = NULL;
4659     int size = XML_PARSER_BUFFER_SIZE;
4660     int len = 0;
4661     xmlParserInputState state;
4662     const xmlChar *in;
4663     int nbchar = 0, ccol;
4664     int inputid;
4665
4666     /*
4667      * Check that there is a comment right here.
4668      */
4669     if ((RAW != '<') || (NXT(1) != '!') ||
4670         (NXT(2) != '-') || (NXT(3) != '-')) return;
4671     state = ctxt->instate;
4672     ctxt->instate = XML_PARSER_COMMENT;
4673     inputid = ctxt->input->id;
4674     SKIP(4);
4675     SHRINK;
4676     GROW;
4677
4678     /*
4679      * Accelerated common case where input don't need to be
4680      * modified before passing it to the handler.
4681      */
4682     in = ctxt->input->cur;
4683     do {
4684         if (*in == 0xA) {
4685             do {
4686                 ctxt->input->line++; ctxt->input->col = 1;
4687                 in++;
4688             } while (*in == 0xA);
4689         }
4690 get_more:
4691         ccol = ctxt->input->col;
4692         while (((*in > '-') && (*in <= 0x7F)) ||
4693                ((*in >= 0x20) && (*in < '-')) ||
4694                (*in == 0x09)) {
4695                     in++;
4696                     ccol++;
4697         }
4698         ctxt->input->col = ccol;
4699         if (*in == 0xA) {
4700             do {
4701                 ctxt->input->line++; ctxt->input->col = 1;
4702                 in++;
4703             } while (*in == 0xA);
4704             goto get_more;
4705         }
4706         nbchar = in - ctxt->input->cur;
4707         /*
4708          * save current set of data
4709          */
4710         if (nbchar > 0) {
4711             if ((ctxt->sax != NULL) &&
4712                 (ctxt->sax->comment != NULL)) {
4713                 if (buf == NULL) {
4714                     if ((*in == '-') && (in[1] == '-'))
4715                         size = nbchar + 1;
4716                     else
4717                         size = XML_PARSER_BUFFER_SIZE + nbchar;
4718                     buf = (xmlChar *) xmlMallocAtomic(size * sizeof(xmlChar));
4719                     if (buf == NULL) {
4720                         xmlErrMemory(ctxt, NULL);
4721                         ctxt->instate = state;
4722                         return;
4723                     }
4724                     len = 0;
4725                 } else if (len + nbchar + 1 >= size) {
4726                     xmlChar *new_buf;
4727                     size  += len + nbchar + XML_PARSER_BUFFER_SIZE;
4728                     new_buf = (xmlChar *) xmlRealloc(buf,
4729                                                      size * sizeof(xmlChar));
4730                     if (new_buf == NULL) {
4731                         xmlFree (buf);
4732                         xmlErrMemory(ctxt, NULL);
4733                         ctxt->instate = state;
4734                         return;
4735                     }
4736                     buf = new_buf;
4737                 }
4738                 memcpy(&buf[len], ctxt->input->cur, nbchar);
4739                 len += nbchar;
4740                 buf[len] = 0;
4741             }
4742         }
4743         ctxt->input->cur = in;
4744         if (*in == 0xA) {
4745             in++;
4746             ctxt->input->line++; ctxt->input->col = 1;
4747         }
4748         if (*in == 0xD) {
4749             in++;
4750             if (*in == 0xA) {
4751                 ctxt->input->cur = in;
4752                 in++;
4753                 ctxt->input->line++; ctxt->input->col = 1;
4754                 continue; /* while */
4755             }
4756             in--;
4757         }
4758         SHRINK;
4759         GROW;
4760         in = ctxt->input->cur;
4761         if (*in == '-') {
4762             if (in[1] == '-') {
4763                 if (in[2] == '>') {
4764                     if (ctxt->input->id != inputid) {
4765                         xmlFatalErrMsg(ctxt, XML_ERR_ENTITY_BOUNDARY,
4766                         "comment doesn't start and stop in the same entity\n");
4767                     }
4768                     SKIP(3);
4769                     if ((ctxt->sax != NULL) && (ctxt->sax->comment != NULL) &&
4770                         (!ctxt->disableSAX)) {
4771                         if (buf != NULL)
4772                             ctxt->sax->comment(ctxt->userData, buf);
4773                         else
4774                             ctxt->sax->comment(ctxt->userData, BAD_CAST "");
4775                     }
4776                     if (buf != NULL)
4777                         xmlFree(buf);
4778                     ctxt->instate = state;
4779                     return;
4780                 }
4781                 if (buf != NULL) {
4782                     xmlFatalErrMsgStr(ctxt, XML_ERR_HYPHEN_IN_COMMENT,
4783                                       "Double hyphen within comment: "
4784                                       "<!--%.50s\n",
4785                                       buf);
4786                 } else
4787                     xmlFatalErrMsgStr(ctxt, XML_ERR_HYPHEN_IN_COMMENT,
4788                                       "Double hyphen within comment\n", NULL);
4789                 in++;
4790                 ctxt->input->col++;
4791             }
4792             in++;
4793             ctxt->input->col++;
4794             goto get_more;
4795         }
4796     } while (((*in >= 0x20) && (*in <= 0x7F)) || (*in == 0x09));
4797     xmlParseCommentComplex(ctxt, buf, len, size);
4798     ctxt->instate = state;
4799     return;
4800 }
4801
4802
4803 /**
4804  * xmlParsePITarget:
4805  * @ctxt:  an XML parser context
4806  *
4807  * parse the name of a PI
4808  *
4809  * [17] PITarget ::= Name - (('X' | 'x') ('M' | 'm') ('L' | 'l'))
4810  *
4811  * Returns the PITarget name or NULL
4812  */
4813
4814 const xmlChar *
4815 xmlParsePITarget(xmlParserCtxtPtr ctxt) {
4816     const xmlChar *name;
4817
4818     name = xmlParseName(ctxt);
4819     if ((name != NULL) &&
4820         ((name[0] == 'x') || (name[0] == 'X')) &&
4821         ((name[1] == 'm') || (name[1] == 'M')) &&
4822         ((name[2] == 'l') || (name[2] == 'L'))) {
4823         int i;
4824         if ((name[0] == 'x') && (name[1] == 'm') &&
4825             (name[2] == 'l') && (name[3] == 0)) {
4826             xmlFatalErrMsg(ctxt, XML_ERR_RESERVED_XML_NAME,
4827                  "XML declaration allowed only at the start of the document\n");
4828             return(name);
4829         } else if (name[3] == 0) {
4830             xmlFatalErr(ctxt, XML_ERR_RESERVED_XML_NAME, NULL);
4831             return(name);
4832         }
4833         for (i = 0;;i++) {
4834             if (xmlW3CPIs[i] == NULL) break;
4835             if (xmlStrEqual(name, (const xmlChar *)xmlW3CPIs[i]))
4836                 return(name);
4837         }
4838         xmlWarningMsg(ctxt, XML_ERR_RESERVED_XML_NAME,
4839                       "xmlParsePITarget: invalid name prefix 'xml'\n",
4840                       NULL, NULL);
4841     }
4842     if ((name != NULL) && (xmlStrchr(name, ':') != NULL)) {
4843         xmlNsErr(ctxt, XML_NS_ERR_COLON,
4844                  "colon are forbidden from PI names '%s'\n", name, NULL, NULL);
4845     }
4846     return(name);
4847 }
4848
4849 #ifdef LIBXML_CATALOG_ENABLED
4850 /**
4851  * xmlParseCatalogPI:
4852  * @ctxt:  an XML parser context
4853  * @catalog:  the PI value string
4854  *
4855  * parse an XML Catalog Processing Instruction.
4856  *
4857  * <?oasis-xml-catalog catalog="http://example.com/catalog.xml"?>
4858  *
4859  * Occurs only if allowed by the user and if happening in the Misc
4860  * part of the document before any doctype informations
4861  * This will add the given catalog to the parsing context in order
4862  * to be used if there is a resolution need further down in the document
4863  */
4864
4865 static void
4866 xmlParseCatalogPI(xmlParserCtxtPtr ctxt, const xmlChar *catalog) {
4867     xmlChar *URL = NULL;
4868     const xmlChar *tmp, *base;
4869     xmlChar marker;
4870
4871     tmp = catalog;
4872     while (IS_BLANK_CH(*tmp)) tmp++;
4873     if (xmlStrncmp(tmp, BAD_CAST"catalog", 7))
4874         goto error;
4875     tmp += 7;
4876     while (IS_BLANK_CH(*tmp)) tmp++;
4877     if (*tmp != '=') {
4878         return;
4879     }
4880     tmp++;
4881     while (IS_BLANK_CH(*tmp)) tmp++;
4882     marker = *tmp;
4883     if ((marker != '\'') && (marker != '"'))
4884         goto error;
4885     tmp++;
4886     base = tmp;
4887     while ((*tmp != 0) && (*tmp != marker)) tmp++;
4888     if (*tmp == 0)
4889         goto error;
4890     URL = xmlStrndup(base, tmp - base);
4891     tmp++;
4892     while (IS_BLANK_CH(*tmp)) tmp++;
4893     if (*tmp != 0)
4894         goto error;
4895
4896     if (URL != NULL) {
4897         ctxt->catalogs = xmlCatalogAddLocal(ctxt->catalogs, URL);
4898         xmlFree(URL);
4899     }
4900     return;
4901
4902 error:
4903     xmlWarningMsg(ctxt, XML_WAR_CATALOG_PI,
4904                   "Catalog PI syntax error: %s\n",
4905                   catalog, NULL);
4906     if (URL != NULL)
4907         xmlFree(URL);
4908 }
4909 #endif
4910
4911 /**
4912  * xmlParsePI:
4913  * @ctxt:  an XML parser context
4914  *
4915  * parse an XML Processing Instruction.
4916  *
4917  * [16] PI ::= '<?' PITarget (S (Char* - (Char* '?>' Char*)))? '?>'
4918  *
4919  * The processing is transfered to SAX once parsed.
4920  */
4921
4922 void
4923 xmlParsePI(xmlParserCtxtPtr ctxt) {
4924     xmlChar *buf = NULL;
4925     int len = 0;
4926     int size = XML_PARSER_BUFFER_SIZE;
4927     int cur, l;
4928     const xmlChar *target;
4929     xmlParserInputState state;
4930     int count = 0;
4931
4932     if ((RAW == '<') && (NXT(1) == '?')) {
4933         xmlParserInputPtr input = ctxt->input;
4934         state = ctxt->instate;
4935         ctxt->instate = XML_PARSER_PI;
4936         /*
4937          * this is a Processing Instruction.
4938          */
4939         SKIP(2);
4940         SHRINK;
4941
4942         /*
4943          * Parse the target name and check for special support like
4944          * namespace.
4945          */
4946         target = xmlParsePITarget(ctxt);
4947         if (target != NULL) {
4948             if ((RAW == '?') && (NXT(1) == '>')) {
4949                 if (input != ctxt->input) {
4950                     xmlFatalErrMsg(ctxt, XML_ERR_ENTITY_BOUNDARY,
4951             "PI declaration doesn't start and stop in the same entity\n");
4952                 }
4953                 SKIP(2);
4954
4955                 /*
4956                  * SAX: PI detected.
4957                  */
4958                 if ((ctxt->sax) && (!ctxt->disableSAX) &&
4959                     (ctxt->sax->processingInstruction != NULL))
4960                     ctxt->sax->processingInstruction(ctxt->userData,
4961                                                      target, NULL);
4962                 if (ctxt->instate != XML_PARSER_EOF)
4963                     ctxt->instate = state;
4964                 return;
4965             }
4966             buf = (xmlChar *) xmlMallocAtomic(size * sizeof(xmlChar));
4967             if (buf == NULL) {
4968                 xmlErrMemory(ctxt, NULL);
4969                 ctxt->instate = state;
4970                 return;
4971             }
4972             cur = CUR;
4973             if (!IS_BLANK(cur)) {
4974                 xmlFatalErrMsgStr(ctxt, XML_ERR_SPACE_REQUIRED,
4975                           "ParsePI: PI %s space expected\n", target);
4976             }
4977             SKIP_BLANKS;
4978             cur = CUR_CHAR(l);
4979             while (IS_CHAR(cur) && /* checked */
4980                    ((cur != '?') || (NXT(1) != '>'))) {
4981                 if (len + 5 >= size) {
4982                     xmlChar *tmp;
4983
4984                     size *= 2;
4985                     tmp = (xmlChar *) xmlRealloc(buf, size * sizeof(xmlChar));
4986                     if (tmp == NULL) {
4987                         xmlErrMemory(ctxt, NULL);
4988                         xmlFree(buf);
4989                         ctxt->instate = state;
4990                         return;
4991                     }
4992                     buf = tmp;
4993                 }
4994                 count++;
4995                 if (count > 50) {
4996                     GROW;
4997                     count = 0;
4998                 }
4999                 COPY_BUF(l,buf,len,cur);
5000                 NEXTL(l);
5001                 cur = CUR_CHAR(l);
5002                 if (cur == 0) {
5003                     SHRINK;
5004                     GROW;
5005                     cur = CUR_CHAR(l);
5006                 }
5007             }
5008             buf[len] = 0;
5009             if (cur != '?') {
5010                 xmlFatalErrMsgStr(ctxt, XML_ERR_PI_NOT_FINISHED,
5011                       "ParsePI: PI %s never end ...\n", target);
5012             } else {
5013                 if (input != ctxt->input) {
5014                     xmlFatalErrMsg(ctxt, XML_ERR_SPACE_REQUIRED,
5015             "PI declaration doesn't start and stop in the same entity\n");
5016                 }
5017                 SKIP(2);
5018
5019 #ifdef LIBXML_CATALOG_ENABLED
5020                 if (((state == XML_PARSER_MISC) ||
5021                      (state == XML_PARSER_START)) &&
5022                     (xmlStrEqual(target, XML_CATALOG_PI))) {
5023                     xmlCatalogAllow allow = xmlCatalogGetDefaults();
5024                     if ((allow == XML_CATA_ALLOW_DOCUMENT) ||
5025                         (allow == XML_CATA_ALLOW_ALL))
5026                         xmlParseCatalogPI(ctxt, buf);
5027                 }
5028 #endif
5029
5030
5031                 /*
5032                  * SAX: PI detected.
5033                  */
5034                 if ((ctxt->sax) && (!ctxt->disableSAX) &&
5035                     (ctxt->sax->processingInstruction != NULL))
5036                     ctxt->sax->processingInstruction(ctxt->userData,
5037                                                      target, buf);
5038             }
5039             xmlFree(buf);
5040         } else {
5041             xmlFatalErr(ctxt, XML_ERR_PI_NOT_STARTED, NULL);
5042         }
5043         if (ctxt->instate != XML_PARSER_EOF)
5044             ctxt->instate = state;
5045     }
5046 }
5047
5048 /**
5049  * xmlParseNotationDecl:
5050  * @ctxt:  an XML parser context
5051  *
5052  * parse a notation declaration
5053  *
5054  * [82] NotationDecl ::= '<!NOTATION' S Name S (ExternalID |  PublicID) S? '>'
5055  *
5056  * Hence there is actually 3 choices:
5057  *     'PUBLIC' S PubidLiteral
5058  *     'PUBLIC' S PubidLiteral S SystemLiteral
5059  * and 'SYSTEM' S SystemLiteral
5060  *
5061  * See the NOTE on xmlParseExternalID().
5062  */
5063
5064 void
5065 xmlParseNotationDecl(xmlParserCtxtPtr ctxt) {
5066     const xmlChar *name;
5067     xmlChar *Pubid;
5068     xmlChar *Systemid;
5069
5070     if (CMP10(CUR_PTR, '<', '!', 'N', 'O', 'T', 'A', 'T', 'I', 'O', 'N')) {
5071         xmlParserInputPtr input = ctxt->input;
5072         SHRINK;
5073         SKIP(10);
5074         if (!IS_BLANK_CH(CUR)) {
5075             xmlFatalErrMsg(ctxt, XML_ERR_SPACE_REQUIRED,
5076                            "Space required after '<!NOTATION'\n");
5077             return;
5078         }
5079         SKIP_BLANKS;
5080
5081         name = xmlParseName(ctxt);
5082         if (name == NULL) {
5083             xmlFatalErr(ctxt, XML_ERR_NOTATION_NOT_STARTED, NULL);
5084             return;
5085         }
5086         if (!IS_BLANK_CH(CUR)) {
5087             xmlFatalErrMsg(ctxt, XML_ERR_SPACE_REQUIRED,
5088                      "Space required after the NOTATION name'\n");
5089             return;
5090         }
5091         if (xmlStrchr(name, ':') != NULL) {
5092             xmlNsErr(ctxt, XML_NS_ERR_COLON,
5093                      "colon are forbidden from notation names '%s'\n",
5094                      name, NULL, NULL);
5095         }
5096         SKIP_BLANKS;
5097
5098         /*
5099          * Parse the IDs.
5100          */
5101         Systemid = xmlParseExternalID(ctxt, &Pubid, 0);
5102         SKIP_BLANKS;
5103
5104         if (RAW == '>') {
5105             if (input != ctxt->input) {
5106                 xmlFatalErrMsg(ctxt, XML_ERR_SPACE_REQUIRED,
5107         "Notation declaration doesn't start and stop in the same entity\n");
5108             }
5109             NEXT;
5110             if ((ctxt->sax != NULL) && (!ctxt->disableSAX) &&
5111                 (ctxt->sax->notationDecl != NULL))
5112                 ctxt->sax->notationDecl(ctxt->userData, name, Pubid, Systemid);
5113         } else {
5114             xmlFatalErr(ctxt, XML_ERR_NOTATION_NOT_FINISHED, NULL);
5115         }
5116         if (Systemid != NULL) xmlFree(Systemid);
5117         if (Pubid != NULL) xmlFree(Pubid);
5118     }
5119 }
5120
5121 /**
5122  * xmlParseEntityDecl:
5123  * @ctxt:  an XML parser context
5124  *
5125  * parse <!ENTITY declarations
5126  *
5127  * [70] EntityDecl ::= GEDecl | PEDecl
5128  *
5129  * [71] GEDecl ::= '<!ENTITY' S Name S EntityDef S? '>'
5130  *
5131  * [72] PEDecl ::= '<!ENTITY' S '%' S Name S PEDef S? '>'
5132  *
5133  * [73] EntityDef ::= EntityValue | (ExternalID NDataDecl?)
5134  *
5135  * [74] PEDef ::= EntityValue | ExternalID
5136  *
5137  * [76] NDataDecl ::= S 'NDATA' S Name
5138  *
5139  * [ VC: Notation Declared ]
5140  * The Name must match the declared name of a notation.
5141  */
5142
5143 void
5144 xmlParseEntityDecl(xmlParserCtxtPtr ctxt) {
5145     const xmlChar *name = NULL;
5146     xmlChar *value = NULL;
5147     xmlChar *URI = NULL, *literal = NULL;
5148     const xmlChar *ndata = NULL;
5149     int isParameter = 0;
5150     xmlChar *orig = NULL;
5151     int skipped;
5152
5153     /* GROW; done in the caller */
5154     if (CMP8(CUR_PTR, '<', '!', 'E', 'N', 'T', 'I', 'T', 'Y')) {
5155         xmlParserInputPtr input = ctxt->input;
5156         SHRINK;
5157         SKIP(8);
5158         skipped = SKIP_BLANKS;
5159         if (skipped == 0) {
5160             xmlFatalErrMsg(ctxt, XML_ERR_SPACE_REQUIRED,
5161                            "Space required after '<!ENTITY'\n");
5162         }
5163
5164         if (RAW == '%') {
5165             NEXT;
5166             skipped = SKIP_BLANKS;
5167             if (skipped == 0) {
5168                 xmlFatalErrMsg(ctxt, XML_ERR_SPACE_REQUIRED,
5169                                "Space required after '%'\n");
5170             }
5171             isParameter = 1;
5172         }
5173
5174         name = xmlParseName(ctxt);
5175         if (name == NULL) {
5176             xmlFatalErrMsg(ctxt, XML_ERR_NAME_REQUIRED,
5177                            "xmlParseEntityDecl: no name\n");
5178             return;
5179         }
5180         if (xmlStrchr(name, ':') != NULL) {
5181             xmlNsErr(ctxt, XML_NS_ERR_COLON,
5182                      "colon are forbidden from entities names '%s'\n",
5183                      name, NULL, NULL);
5184         }
5185         skipped = SKIP_BLANKS;
5186         if (skipped == 0) {
5187             xmlFatalErrMsg(ctxt, XML_ERR_SPACE_REQUIRED,
5188                            "Space required after the entity name\n");
5189         }
5190
5191         ctxt->instate = XML_PARSER_ENTITY_DECL;
5192         /*
5193          * handle the various case of definitions...
5194          */
5195         if (isParameter) {
5196             if ((RAW == '"') || (RAW == '\'')) {
5197                 value = xmlParseEntityValue(ctxt, &orig);
5198                 if (value) {
5199                     if ((ctxt->sax != NULL) &&
5200                         (!ctxt->disableSAX) && (ctxt->sax->entityDecl != NULL))
5201                         ctxt->sax->entityDecl(ctxt->userData, name,
5202                                     XML_INTERNAL_PARAMETER_ENTITY,
5203                                     NULL, NULL, value);
5204                 }
5205             } else {
5206                 URI = xmlParseExternalID(ctxt, &literal, 1);
5207                 if ((URI == NULL) && (literal == NULL)) {
5208                     xmlFatalErr(ctxt, XML_ERR_VALUE_REQUIRED, NULL);
5209                 }
5210                 if (URI) {
5211                     xmlURIPtr uri;
5212
5213                     uri = xmlParseURI((const char *) URI);
5214                     if (uri == NULL) {
5215                         xmlErrMsgStr(ctxt, XML_ERR_INVALID_URI,
5216                                      "Invalid URI: %s\n", URI);
5217                         /*
5218                          * This really ought to be a well formedness error
5219                          * but the XML Core WG decided otherwise c.f. issue
5220                          * E26 of the XML erratas.
5221                          */
5222                     } else {
5223                         if (uri->fragment != NULL) {
5224                             /*
5225                              * Okay this is foolish to block those but not
5226                              * invalid URIs.
5227                              */
5228                             xmlFatalErr(ctxt, XML_ERR_URI_FRAGMENT, NULL);
5229                         } else {
5230                             if ((ctxt->sax != NULL) &&
5231                                 (!ctxt->disableSAX) &&
5232                                 (ctxt->sax->entityDecl != NULL))
5233                                 ctxt->sax->entityDecl(ctxt->userData, name,
5234                                             XML_EXTERNAL_PARAMETER_ENTITY,
5235                                             literal, URI, NULL);
5236                         }
5237                         xmlFreeURI(uri);
5238                     }
5239                 }
5240             }
5241         } else {
5242             if ((RAW == '"') || (RAW == '\'')) {
5243                 value = xmlParseEntityValue(ctxt, &orig);
5244                 if ((ctxt->sax != NULL) &&
5245                     (!ctxt->disableSAX) && (ctxt->sax->entityDecl != NULL))
5246                     ctxt->sax->entityDecl(ctxt->userData, name,
5247                                 XML_INTERNAL_GENERAL_ENTITY,
5248                                 NULL, NULL, value);
5249                 /*
5250                  * For expat compatibility in SAX mode.
5251                  */
5252                 if ((ctxt->myDoc == NULL) ||
5253                     (xmlStrEqual(ctxt->myDoc->version, SAX_COMPAT_MODE))) {
5254                     if (ctxt->myDoc == NULL) {
5255                         ctxt->myDoc = xmlNewDoc(SAX_COMPAT_MODE);
5256                         if (ctxt->myDoc == NULL) {
5257                             xmlErrMemory(ctxt, "New Doc failed");
5258                             return;
5259                         }
5260                         ctxt->myDoc->properties = XML_DOC_INTERNAL;
5261                     }
5262                     if (ctxt->myDoc->intSubset == NULL)
5263                         ctxt->myDoc->intSubset = xmlNewDtd(ctxt->myDoc,
5264                                             BAD_CAST "fake", NULL, NULL);
5265
5266                     xmlSAX2EntityDecl(ctxt, name, XML_INTERNAL_GENERAL_ENTITY,
5267                                       NULL, NULL, value);
5268                 }
5269             } else {
5270                 URI = xmlParseExternalID(ctxt, &literal, 1);
5271                 if ((URI == NULL) && (literal == NULL)) {
5272                     xmlFatalErr(ctxt, XML_ERR_VALUE_REQUIRED, NULL);
5273                 }
5274                 if (URI) {
5275                     xmlURIPtr uri;
5276
5277                     uri = xmlParseURI((const char *)URI);
5278                     if (uri == NULL) {
5279                         xmlErrMsgStr(ctxt, XML_ERR_INVALID_URI,
5280                                      "Invalid URI: %s\n", URI);
5281                         /*
5282                          * This really ought to be a well formedness error
5283                          * but the XML Core WG decided otherwise c.f. issue
5284                          * E26 of the XML erratas.
5285                          */
5286                     } else {
5287                         if (uri->fragment != NULL) {
5288                             /*
5289                              * Okay this is foolish to block those but not
5290                              * invalid URIs.
5291                              */
5292                             xmlFatalErr(ctxt, XML_ERR_URI_FRAGMENT, NULL);
5293                         }
5294                         xmlFreeURI(uri);
5295                     }
5296                 }
5297                 if ((RAW != '>') && (!IS_BLANK_CH(CUR))) {
5298                     xmlFatalErrMsg(ctxt, XML_ERR_SPACE_REQUIRED,
5299                                    "Space required before 'NDATA'\n");
5300                 }
5301                 SKIP_BLANKS;
5302                 if (CMP5(CUR_PTR, 'N', 'D', 'A', 'T', 'A')) {
5303                     SKIP(5);
5304                     if (!IS_BLANK_CH(CUR)) {
5305                         xmlFatalErrMsg(ctxt, XML_ERR_SPACE_REQUIRED,
5306                                        "Space required after 'NDATA'\n");
5307                     }
5308                     SKIP_BLANKS;
5309                     ndata = xmlParseName(ctxt);
5310                     if ((ctxt->sax != NULL) && (!ctxt->disableSAX) &&
5311                         (ctxt->sax->unparsedEntityDecl != NULL))
5312                         ctxt->sax->unparsedEntityDecl(ctxt->userData, name,
5313                                     literal, URI, ndata);
5314                 } else {
5315                     if ((ctxt->sax != NULL) &&
5316                         (!ctxt->disableSAX) && (ctxt->sax->entityDecl != NULL))
5317                         ctxt->sax->entityDecl(ctxt->userData, name,
5318                                     XML_EXTERNAL_GENERAL_PARSED_ENTITY,
5319                                     literal, URI, NULL);
5320                     /*
5321                      * For expat compatibility in SAX mode.
5322                      * assuming the entity repalcement was asked for
5323                      */
5324                     if ((ctxt->replaceEntities != 0) &&
5325                         ((ctxt->myDoc == NULL) ||
5326                         (xmlStrEqual(ctxt->myDoc->version, SAX_COMPAT_MODE)))) {
5327                         if (ctxt->myDoc == NULL) {
5328                             ctxt->myDoc = xmlNewDoc(SAX_COMPAT_MODE);
5329                             if (ctxt->myDoc == NULL) {
5330                                 xmlErrMemory(ctxt, "New Doc failed");
5331                                 return;
5332                             }
5333                             ctxt->myDoc->properties = XML_DOC_INTERNAL;
5334                         }
5335
5336                         if (ctxt->myDoc->intSubset == NULL)
5337                             ctxt->myDoc->intSubset = xmlNewDtd(ctxt->myDoc,
5338                                                 BAD_CAST "fake", NULL, NULL);
5339                         xmlSAX2EntityDecl(ctxt, name,
5340                                           XML_EXTERNAL_GENERAL_PARSED_ENTITY,
5341                                           literal, URI, NULL);
5342                     }
5343                 }
5344             }
5345         }
5346         SKIP_BLANKS;
5347         if (RAW != '>') {
5348             xmlFatalErrMsgStr(ctxt, XML_ERR_ENTITY_NOT_FINISHED,
5349                     "xmlParseEntityDecl: entity %s not terminated\n", name);
5350         } else {
5351             if (input != ctxt->input) {
5352                 xmlFatalErrMsg(ctxt, XML_ERR_ENTITY_BOUNDARY,
5353         "Entity declaration doesn't start and stop in the same entity\n");
5354             }
5355             NEXT;
5356         }
5357         if (orig != NULL) {
5358             /*
5359              * Ugly mechanism to save the raw entity value.
5360              */
5361             xmlEntityPtr cur = NULL;
5362
5363             if (isParameter) {
5364                 if ((ctxt->sax != NULL) &&
5365                     (ctxt->sax->getParameterEntity != NULL))
5366                     cur = ctxt->sax->getParameterEntity(ctxt->userData, name);
5367             } else {
5368                 if ((ctxt->sax != NULL) &&
5369                     (ctxt->sax->getEntity != NULL))
5370                     cur = ctxt->sax->getEntity(ctxt->userData, name);
5371                 if ((cur == NULL) && (ctxt->userData==ctxt)) {
5372                     cur = xmlSAX2GetEntity(ctxt, name);
5373                 }
5374             }
5375             if (cur != NULL) {
5376                 if (cur->orig != NULL)
5377                     xmlFree(orig);
5378                 else
5379                     cur->orig = orig;
5380             } else
5381                 xmlFree(orig);
5382         }
5383         if (value != NULL) xmlFree(value);
5384         if (URI != NULL) xmlFree(URI);
5385         if (literal != NULL) xmlFree(literal);
5386     }
5387 }
5388
5389 /**
5390  * xmlParseDefaultDecl:
5391  * @ctxt:  an XML parser context
5392  * @value:  Receive a possible fixed default value for the attribute
5393  *
5394  * Parse an attribute default declaration
5395  *
5396  * [60] DefaultDecl ::= '#REQUIRED' | '#IMPLIED' | (('#FIXED' S)? AttValue)
5397  *
5398  * [ VC: Required Attribute ]
5399  * if the default declaration is the keyword #REQUIRED, then the
5400  * attribute must be specified for all elements of the type in the
5401  * attribute-list declaration.
5402  *
5403  * [ VC: Attribute Default Legal ]
5404  * The declared default value must meet the lexical constraints of
5405  * the declared attribute type c.f. xmlValidateAttributeDecl()
5406  *
5407  * [ VC: Fixed Attribute Default ]
5408  * if an attribute has a default value declared with the #FIXED
5409  * keyword, instances of that attribute must match the default value.
5410  *
5411  * [ WFC: No < in Attribute Values ]
5412  * handled in xmlParseAttValue()
5413  *
5414  * returns: XML_ATTRIBUTE_NONE, XML_ATTRIBUTE_REQUIRED, XML_ATTRIBUTE_IMPLIED
5415  *          or XML_ATTRIBUTE_FIXED.
5416  */
5417
5418 int
5419 xmlParseDefaultDecl(xmlParserCtxtPtr ctxt, xmlChar **value) {
5420     int val;
5421     xmlChar *ret;
5422
5423     *value = NULL;
5424     if (CMP9(CUR_PTR, '#', 'R', 'E', 'Q', 'U', 'I', 'R', 'E', 'D')) {
5425         SKIP(9);
5426         return(XML_ATTRIBUTE_REQUIRED);
5427     }
5428     if (CMP8(CUR_PTR, '#', 'I', 'M', 'P', 'L', 'I', 'E', 'D')) {
5429         SKIP(8);
5430         return(XML_ATTRIBUTE_IMPLIED);
5431     }
5432     val = XML_ATTRIBUTE_NONE;
5433     if (CMP6(CUR_PTR, '#', 'F', 'I', 'X', 'E', 'D')) {
5434         SKIP(6);
5435         val = XML_ATTRIBUTE_FIXED;
5436         if (!IS_BLANK_CH(CUR)) {
5437             xmlFatalErrMsg(ctxt, XML_ERR_SPACE_REQUIRED,
5438                            "Space required after '#FIXED'\n");
5439         }
5440         SKIP_BLANKS;
5441     }
5442     ret = xmlParseAttValue(ctxt);
5443     ctxt->instate = XML_PARSER_DTD;
5444     if (ret == NULL) {
5445         xmlFatalErrMsg(ctxt, (xmlParserErrors)ctxt->errNo,
5446                        "Attribute default value declaration error\n");
5447     } else
5448         *value = ret;
5449     return(val);
5450 }
5451
5452 /**
5453  * xmlParseNotationType:
5454  * @ctxt:  an XML parser context
5455  *
5456  * parse an Notation attribute type.
5457  *
5458  * Note: the leading 'NOTATION' S part has already being parsed...
5459  *
5460  * [58] NotationType ::= 'NOTATION' S '(' S? Name (S? '|' S? Name)* S? ')'
5461  *
5462  * [ VC: Notation Attributes ]
5463  * Values of this type must match one of the notation names included
5464  * in the declaration; all notation names in the declaration must be declared.
5465  *
5466  * Returns: the notation attribute tree built while parsing
5467  */
5468
5469 xmlEnumerationPtr
5470 xmlParseNotationType(xmlParserCtxtPtr ctxt) {
5471     const xmlChar *name;
5472     xmlEnumerationPtr ret = NULL, last = NULL, cur, tmp;
5473
5474     if (RAW != '(') {
5475         xmlFatalErr(ctxt, XML_ERR_NOTATION_NOT_STARTED, NULL);
5476         return(NULL);
5477     }
5478     SHRINK;
5479     do {
5480         NEXT;
5481         SKIP_BLANKS;
5482         name = xmlParseName(ctxt);
5483         if (name == NULL) {
5484             xmlFatalErrMsg(ctxt, XML_ERR_NAME_REQUIRED,
5485                            "Name expected in NOTATION declaration\n");
5486             xmlFreeEnumeration(ret);
5487             return(NULL);
5488         }
5489         tmp = ret;
5490         while (tmp != NULL) {
5491             if (xmlStrEqual(name, tmp->name)) {
5492                 xmlValidityError(ctxt, XML_DTD_DUP_TOKEN,
5493           "standalone: attribute notation value token %s duplicated\n",
5494                                  name, NULL);
5495                 if (!xmlDictOwns(ctxt->dict, name))
5496                     xmlFree((xmlChar *) name);
5497                 break;
5498             }
5499             tmp = tmp->next;
5500         }
5501         if (tmp == NULL) {
5502             cur = xmlCreateEnumeration(name);
5503             if (cur == NULL) {
5504                 xmlFreeEnumeration(ret);
5505                 return(NULL);
5506             }
5507             if (last == NULL) ret = last = cur;
5508             else {
5509                 last->next = cur;
5510                 last = cur;
5511             }
5512         }
5513         SKIP_BLANKS;
5514     } while (RAW == '|');
5515     if (RAW != ')') {
5516         xmlFatalErr(ctxt, XML_ERR_NOTATION_NOT_FINISHED, NULL);
5517         xmlFreeEnumeration(ret);
5518         return(NULL);
5519     }
5520     NEXT;
5521     return(ret);
5522 }
5523
5524 /**
5525  * xmlParseEnumerationType:
5526  * @ctxt:  an XML parser context
5527  *
5528  * parse an Enumeration attribute type.
5529  *
5530  * [59] Enumeration ::= '(' S? Nmtoken (S? '|' S? Nmtoken)* S? ')'
5531  *
5532  * [ VC: Enumeration ]
5533  * Values of this type must match one of the Nmtoken tokens in
5534  * the declaration
5535  *
5536  * Returns: the enumeration attribute tree built while parsing
5537  */
5538
5539 xmlEnumerationPtr
5540 xmlParseEnumerationType(xmlParserCtxtPtr ctxt) {
5541     xmlChar *name;
5542     xmlEnumerationPtr ret = NULL, last = NULL, cur, tmp;
5543
5544     if (RAW != '(') {
5545         xmlFatalErr(ctxt, XML_ERR_ATTLIST_NOT_STARTED, NULL);
5546         return(NULL);
5547     }
5548     SHRINK;
5549     do {
5550         NEXT;
5551         SKIP_BLANKS;
5552         name = xmlParseNmtoken(ctxt);
5553         if (name == NULL) {
5554             xmlFatalErr(ctxt, XML_ERR_NMTOKEN_REQUIRED, NULL);
5555             return(ret);
5556         }
5557         tmp = ret;
5558         while (tmp != NULL) {
5559             if (xmlStrEqual(name, tmp->name)) {
5560                 xmlValidityError(ctxt, XML_DTD_DUP_TOKEN,
5561           "standalone: attribute enumeration value token %s duplicated\n",
5562                                  name, NULL);
5563                 if (!xmlDictOwns(ctxt->dict, name))
5564                     xmlFree(name);
5565                 break;
5566             }
5567             tmp = tmp->next;
5568         }
5569         if (tmp == NULL) {
5570             cur = xmlCreateEnumeration(name);
5571             if (!xmlDictOwns(ctxt->dict, name))
5572                 xmlFree(name);
5573             if (cur == NULL) {
5574                 xmlFreeEnumeration(ret);
5575                 return(NULL);
5576             }
5577             if (last == NULL) ret = last = cur;
5578             else {
5579                 last->next = cur;
5580                 last = cur;
5581             }
5582         }
5583         SKIP_BLANKS;
5584     } while (RAW == '|');
5585     if (RAW != ')') {
5586         xmlFatalErr(ctxt, XML_ERR_ATTLIST_NOT_FINISHED, NULL);
5587         return(ret);
5588     }
5589     NEXT;
5590     return(ret);
5591 }
5592
5593 /**
5594  * xmlParseEnumeratedType:
5595  * @ctxt:  an XML parser context
5596  * @tree:  the enumeration tree built while parsing
5597  *
5598  * parse an Enumerated attribute type.
5599  *
5600  * [57] EnumeratedType ::= NotationType | Enumeration
5601  *
5602  * [58] NotationType ::= 'NOTATION' S '(' S? Name (S? '|' S? Name)* S? ')'
5603  *
5604  *
5605  * Returns: XML_ATTRIBUTE_ENUMERATION or XML_ATTRIBUTE_NOTATION
5606  */
5607
5608 int
5609 xmlParseEnumeratedType(xmlParserCtxtPtr ctxt, xmlEnumerationPtr *tree) {
5610     if (CMP8(CUR_PTR, 'N', 'O', 'T', 'A', 'T', 'I', 'O', 'N')) {
5611         SKIP(8);
5612         if (!IS_BLANK_CH(CUR)) {
5613             xmlFatalErrMsg(ctxt, XML_ERR_SPACE_REQUIRED,
5614                            "Space required after 'NOTATION'\n");
5615             return(0);
5616         }
5617         SKIP_BLANKS;
5618         *tree = xmlParseNotationType(ctxt);
5619         if (*tree == NULL) return(0);
5620         return(XML_ATTRIBUTE_NOTATION);
5621     }
5622     *tree = xmlParseEnumerationType(ctxt);
5623     if (*tree == NULL) return(0);
5624     return(XML_ATTRIBUTE_ENUMERATION);
5625 }
5626
5627 /**
5628  * xmlParseAttributeType:
5629  * @ctxt:  an XML parser context
5630  * @tree:  the enumeration tree built while parsing
5631  *
5632  * parse the Attribute list def for an element
5633  *
5634  * [54] AttType ::= StringType | TokenizedType | EnumeratedType
5635  *
5636  * [55] StringType ::= 'CDATA'
5637  *
5638  * [56] TokenizedType ::= 'ID' | 'IDREF' | 'IDREFS' | 'ENTITY' |
5639  *                        'ENTITIES' | 'NMTOKEN' | 'NMTOKENS'
5640  *
5641  * Validity constraints for attribute values syntax are checked in
5642  * xmlValidateAttributeValue()
5643  *
5644  * [ VC: ID ]
5645  * Values of type ID must match the Name production. A name must not
5646  * appear more than once in an XML document as a value of this type;
5647  * i.e., ID values must uniquely identify the elements which bear them.
5648  *
5649  * [ VC: One ID per Element Type ]
5650  * No element type may have more than one ID attribute specified.
5651  *
5652  * [ VC: ID Attribute Default ]
5653  * An ID attribute must have a declared default of #IMPLIED or #REQUIRED.
5654  *
5655  * [ VC: IDREF ]
5656  * Values of type IDREF must match the Name production, and values
5657  * of type IDREFS must match Names; each IDREF Name must match the value
5658  * of an ID attribute on some element in the XML document; i.e. IDREF
5659  * values must match the value of some ID attribute.
5660  *
5661  * [ VC: Entity Name ]
5662  * Values of type ENTITY must match the Name production, values
5663  * of type ENTITIES must match Names; each Entity Name must match the
5664  * name of an unparsed entity declared in the DTD.
5665  *
5666  * [ VC: Name Token ]
5667  * Values of type NMTOKEN must match the Nmtoken production; values
5668  * of type NMTOKENS must match Nmtokens.
5669  *
5670  * Returns the attribute type
5671  */
5672 int
5673 xmlParseAttributeType(xmlParserCtxtPtr ctxt, xmlEnumerationPtr *tree) {
5674     SHRINK;
5675     if (CMP5(CUR_PTR, 'C', 'D', 'A', 'T', 'A')) {
5676         SKIP(5);
5677         return(XML_ATTRIBUTE_CDATA);
5678      } else if (CMP6(CUR_PTR, 'I', 'D', 'R', 'E', 'F', 'S')) {
5679         SKIP(6);
5680         return(XML_ATTRIBUTE_IDREFS);
5681      } else if (CMP5(CUR_PTR, 'I', 'D', 'R', 'E', 'F')) {
5682         SKIP(5);
5683         return(XML_ATTRIBUTE_IDREF);
5684      } else if ((RAW == 'I') && (NXT(1) == 'D')) {
5685         SKIP(2);
5686         return(XML_ATTRIBUTE_ID);
5687      } else if (CMP6(CUR_PTR, 'E', 'N', 'T', 'I', 'T', 'Y')) {
5688         SKIP(6);
5689         return(XML_ATTRIBUTE_ENTITY);
5690      } else if (CMP8(CUR_PTR, 'E', 'N', 'T', 'I', 'T', 'I', 'E', 'S')) {
5691         SKIP(8);
5692         return(XML_ATTRIBUTE_ENTITIES);
5693      } else if (CMP8(CUR_PTR, 'N', 'M', 'T', 'O', 'K', 'E', 'N', 'S')) {
5694         SKIP(8);
5695         return(XML_ATTRIBUTE_NMTOKENS);
5696      } else if (CMP7(CUR_PTR, 'N', 'M', 'T', 'O', 'K', 'E', 'N')) {
5697         SKIP(7);
5698         return(XML_ATTRIBUTE_NMTOKEN);
5699      }
5700      return(xmlParseEnumeratedType(ctxt, tree));
5701 }
5702
5703 /**
5704  * xmlParseAttributeListDecl:
5705  * @ctxt:  an XML parser context
5706  *
5707  * : parse the Attribute list def for an element
5708  *
5709  * [52] AttlistDecl ::= '<!ATTLIST' S Name AttDef* S? '>'
5710  *
5711  * [53] AttDef ::= S Name S AttType S DefaultDecl
5712  *
5713  */
5714 void
5715 xmlParseAttributeListDecl(xmlParserCtxtPtr ctxt) {
5716     const xmlChar *elemName;
5717     const xmlChar *attrName;
5718     xmlEnumerationPtr tree;
5719
5720     if (CMP9(CUR_PTR, '<', '!', 'A', 'T', 'T', 'L', 'I', 'S', 'T')) {
5721         xmlParserInputPtr input = ctxt->input;
5722
5723         SKIP(9);
5724         if (!IS_BLANK_CH(CUR)) {
5725             xmlFatalErrMsg(ctxt, XML_ERR_SPACE_REQUIRED,
5726                                  "Space required after '<!ATTLIST'\n");
5727         }
5728         SKIP_BLANKS;
5729         elemName = xmlParseName(ctxt);
5730         if (elemName == NULL) {
5731             xmlFatalErrMsg(ctxt, XML_ERR_NAME_REQUIRED,
5732                            "ATTLIST: no name for Element\n");
5733             return;
5734         }
5735         SKIP_BLANKS;
5736         GROW;
5737         while (RAW != '>') {
5738             const xmlChar *check = CUR_PTR;
5739             int type;
5740             int def;
5741             xmlChar *defaultValue = NULL;
5742
5743             GROW;
5744             tree = NULL;
5745             attrName = xmlParseName(ctxt);
5746             if (attrName == NULL) {
5747                 xmlFatalErrMsg(ctxt, XML_ERR_NAME_REQUIRED,
5748                                "ATTLIST: no name for Attribute\n");
5749                 break;
5750             }
5751             GROW;
5752             if (!IS_BLANK_CH(CUR)) {
5753                 xmlFatalErrMsg(ctxt, XML_ERR_SPACE_REQUIRED,
5754                         "Space required after the attribute name\n");
5755                 break;
5756             }
5757             SKIP_BLANKS;
5758
5759             type = xmlParseAttributeType(ctxt, &tree);
5760             if (type <= 0) {
5761                 break;
5762             }
5763
5764             GROW;
5765             if (!IS_BLANK_CH(CUR)) {
5766                 xmlFatalErrMsg(ctxt, XML_ERR_SPACE_REQUIRED,
5767                                "Space required after the attribute type\n");
5768                 if (tree != NULL)
5769                     xmlFreeEnumeration(tree);
5770                 break;
5771             }
5772             SKIP_BLANKS;
5773
5774             def = xmlParseDefaultDecl(ctxt, &defaultValue);
5775             if (def <= 0) {
5776                 if (defaultValue != NULL)
5777                     xmlFree(defaultValue);
5778                 if (tree != NULL)
5779                     xmlFreeEnumeration(tree);
5780                 break;
5781             }
5782             if ((type != XML_ATTRIBUTE_CDATA) && (defaultValue != NULL))
5783                 xmlAttrNormalizeSpace(defaultValue, defaultValue);
5784
5785             GROW;
5786             if (RAW != '>') {
5787                 if (!IS_BLANK_CH(CUR)) {
5788                     xmlFatalErrMsg(ctxt, XML_ERR_SPACE_REQUIRED,
5789                         "Space required after the attribute default value\n");
5790                     if (defaultValue != NULL)
5791                         xmlFree(defaultValue);
5792                     if (tree != NULL)
5793                         xmlFreeEnumeration(tree);
5794                     break;
5795                 }
5796                 SKIP_BLANKS;
5797             }
5798             if (check == CUR_PTR) {
5799                 xmlFatalErr(ctxt, XML_ERR_INTERNAL_ERROR,
5800                             "in xmlParseAttributeListDecl\n");
5801                 if (defaultValue != NULL)
5802                     xmlFree(defaultValue);
5803                 if (tree != NULL)
5804                     xmlFreeEnumeration(tree);
5805                 break;
5806             }
5807             if ((ctxt->sax != NULL) && (!ctxt->disableSAX) &&
5808                 (ctxt->sax->attributeDecl != NULL))
5809                 ctxt->sax->attributeDecl(ctxt->userData, elemName, attrName,
5810                                 type, def, defaultValue, tree);
5811             else if (tree != NULL)
5812                 xmlFreeEnumeration(tree);
5813
5814             if ((ctxt->sax2) && (defaultValue != NULL) &&
5815                 (def != XML_ATTRIBUTE_IMPLIED) &&
5816                 (def != XML_ATTRIBUTE_REQUIRED)) {
5817                 xmlAddDefAttrs(ctxt, elemName, attrName, defaultValue);
5818             }
5819             if (ctxt->sax2) {
5820                 xmlAddSpecialAttr(ctxt, elemName, attrName, type);
5821             }
5822             if (defaultValue != NULL)
5823                 xmlFree(defaultValue);
5824             GROW;
5825         }
5826         if (RAW == '>') {
5827             if (input != ctxt->input) {
5828                 xmlValidityError(ctxt, XML_ERR_ENTITY_BOUNDARY,
5829     "Attribute list declaration doesn't start and stop in the same entity\n",
5830                                  NULL, NULL);
5831             }
5832             NEXT;
5833         }
5834     }
5835 }
5836
5837 /**
5838  * xmlParseElementMixedContentDecl:
5839  * @ctxt:  an XML parser context
5840  * @inputchk:  the input used for the current entity, needed for boundary checks
5841  *
5842  * parse the declaration for a Mixed Element content
5843  * The leading '(' and spaces have been skipped in xmlParseElementContentDecl
5844  *
5845  * [51] Mixed ::= '(' S? '#PCDATA' (S? '|' S? Name)* S? ')*' |
5846  *                '(' S? '#PCDATA' S? ')'
5847  *
5848  * [ VC: Proper Group/PE Nesting ] applies to [51] too (see [49])
5849  *
5850  * [ VC: No Duplicate Types ]
5851  * The same name must not appear more than once in a single
5852  * mixed-content declaration.
5853  *
5854  * returns: the list of the xmlElementContentPtr describing the element choices
5855  */
5856 xmlElementContentPtr
5857 xmlParseElementMixedContentDecl(xmlParserCtxtPtr ctxt, int inputchk) {
5858     xmlElementContentPtr ret = NULL, cur = NULL, n;
5859     const xmlChar *elem = NULL;
5860
5861     GROW;
5862     if (CMP7(CUR_PTR, '#', 'P', 'C', 'D', 'A', 'T', 'A')) {
5863         SKIP(7);
5864         SKIP_BLANKS;
5865         SHRINK;
5866         if (RAW == ')') {
5867             if ((ctxt->validate) && (ctxt->input->id != inputchk)) {
5868                 xmlValidityError(ctxt, XML_ERR_ENTITY_BOUNDARY,
5869 "Element content declaration doesn't start and stop in the same entity\n",
5870                                  NULL, NULL);
5871             }
5872             NEXT;
5873             ret = xmlNewDocElementContent(ctxt->myDoc, NULL, XML_ELEMENT_CONTENT_PCDATA);
5874             if (ret == NULL)
5875                 return(NULL);
5876             if (RAW == '*') {
5877                 ret->ocur = XML_ELEMENT_CONTENT_MULT;
5878                 NEXT;
5879             }
5880             return(ret);
5881         }
5882         if ((RAW == '(') || (RAW == '|')) {
5883             ret = cur = xmlNewDocElementContent(ctxt->myDoc, NULL, XML_ELEMENT_CONTENT_PCDATA);
5884             if (ret == NULL) return(NULL);
5885         }
5886         while (RAW == '|') {
5887             NEXT;
5888             if (elem == NULL) {
5889                 ret = xmlNewDocElementContent(ctxt->myDoc, NULL, XML_ELEMENT_CONTENT_OR);
5890                 if (ret == NULL) return(NULL);
5891                 ret->c1 = cur;
5892                 if (cur != NULL)
5893                     cur->parent = ret;
5894                 cur = ret;
5895             } else {
5896                 n = xmlNewDocElementContent(ctxt->myDoc, NULL, XML_ELEMENT_CONTENT_OR);
5897                 if (n == NULL) return(NULL);
5898                 n->c1 = xmlNewDocElementContent(ctxt->myDoc, elem, XML_ELEMENT_CONTENT_ELEMENT);
5899                 if (n->c1 != NULL)
5900                     n->c1->parent = n;
5901                 cur->c2 = n;
5902                 if (n != NULL)
5903                     n->parent = cur;
5904                 cur = n;
5905             }
5906             SKIP_BLANKS;
5907             elem = xmlParseName(ctxt);
5908             if (elem == NULL) {
5909                 xmlFatalErrMsg(ctxt, XML_ERR_NAME_REQUIRED,
5910                         "xmlParseElementMixedContentDecl : Name expected\n");
5911                 xmlFreeDocElementContent(ctxt->myDoc, cur);
5912                 return(NULL);
5913             }
5914             SKIP_BLANKS;
5915             GROW;
5916         }
5917         if ((RAW == ')') && (NXT(1) == '*')) {
5918             if (elem != NULL) {
5919                 cur->c2 = xmlNewDocElementContent(ctxt->myDoc, elem,
5920                                                XML_ELEMENT_CONTENT_ELEMENT);
5921                 if (cur->c2 != NULL)
5922                     cur->c2->parent = cur;
5923             }
5924             if (ret != NULL)
5925                 ret->ocur = XML_ELEMENT_CONTENT_MULT;
5926             if ((ctxt->validate) && (ctxt->input->id != inputchk)) {
5927                 xmlValidityError(ctxt, XML_ERR_ENTITY_BOUNDARY,
5928 "Element content declaration doesn't start and stop in the same entity\n",
5929                                  NULL, NULL);
5930             }
5931             SKIP(2);
5932         } else {
5933             xmlFreeDocElementContent(ctxt->myDoc, ret);
5934             xmlFatalErr(ctxt, XML_ERR_MIXED_NOT_STARTED, NULL);
5935             return(NULL);
5936         }
5937
5938     } else {
5939         xmlFatalErr(ctxt, XML_ERR_PCDATA_REQUIRED, NULL);
5940     }
5941     return(ret);
5942 }
5943
5944 /**
5945  * xmlParseElementChildrenContentDeclPriv:
5946  * @ctxt:  an XML parser context
5947  * @inputchk:  the input used for the current entity, needed for boundary checks
5948  * @depth: the level of recursion
5949  *
5950  * parse the declaration for a Mixed Element content
5951  * The leading '(' and spaces have been skipped in xmlParseElementContentDecl
5952  *
5953  *
5954  * [47] children ::= (choice | seq) ('?' | '*' | '+')?
5955  *
5956  * [48] cp ::= (Name | choice | seq) ('?' | '*' | '+')?
5957  *
5958  * [49] choice ::= '(' S? cp ( S? '|' S? cp )* S? ')'
5959  *
5960  * [50] seq ::= '(' S? cp ( S? ',' S? cp )* S? ')'
5961  *
5962  * [ VC: Proper Group/PE Nesting ] applies to [49] and [50]
5963  * TODO Parameter-entity replacement text must be properly nested
5964  *      with parenthesized groups. That is to say, if either of the
5965  *      opening or closing parentheses in a choice, seq, or Mixed
5966  *      construct is contained in the replacement text for a parameter
5967  *      entity, both must be contained in the same replacement text. For
5968  *      interoperability, if a parameter-entity reference appears in a
5969  *      choice, seq, or Mixed construct, its replacement text should not
5970  *      be empty, and neither the first nor last non-blank character of
5971  *      the replacement text should be a connector (| or ,).
5972  *
5973  * Returns the tree of xmlElementContentPtr describing the element
5974  *          hierarchy.
5975  */
5976 static xmlElementContentPtr
5977 xmlParseElementChildrenContentDeclPriv(xmlParserCtxtPtr ctxt, int inputchk,
5978                                        int depth) {
5979     xmlElementContentPtr ret = NULL, cur = NULL, last = NULL, op = NULL;
5980     const xmlChar *elem;
5981     xmlChar type = 0;
5982
5983     if (((depth > 128) && ((ctxt->options & XML_PARSE_HUGE) == 0)) ||
5984         (depth >  2048)) {
5985         xmlFatalErrMsgInt(ctxt, XML_ERR_ELEMCONTENT_NOT_FINISHED,
5986 "xmlParseElementChildrenContentDecl : depth %d too deep, use XML_PARSE_HUGE\n",
5987                           depth);
5988         return(NULL);
5989     }
5990     SKIP_BLANKS;
5991     GROW;
5992     if (RAW == '(') {
5993         int inputid = ctxt->input->id;
5994
5995         /* Recurse on first child */
5996         NEXT;
5997         SKIP_BLANKS;
5998         cur = ret = xmlParseElementChildrenContentDeclPriv(ctxt, inputid,
5999                                                            depth + 1);
6000         SKIP_BLANKS;
6001         GROW;
6002     } else {
6003         elem = xmlParseName(ctxt);
6004         if (elem == NULL) {
6005             xmlFatalErr(ctxt, XML_ERR_ELEMCONTENT_NOT_STARTED, NULL);
6006             return(NULL);
6007         }
6008         cur = ret = xmlNewDocElementContent(ctxt->myDoc, elem, XML_ELEMENT_CONTENT_ELEMENT);
6009         if (cur == NULL) {
6010             xmlErrMemory(ctxt, NULL);
6011             return(NULL);
6012         }
6013         GROW;
6014         if (RAW == '?') {
6015             cur->ocur = XML_ELEMENT_CONTENT_OPT;
6016             NEXT;
6017         } else if (RAW == '*') {
6018             cur->ocur = XML_ELEMENT_CONTENT_MULT;
6019             NEXT;
6020         } else if (RAW == '+') {
6021             cur->ocur = XML_ELEMENT_CONTENT_PLUS;
6022             NEXT;
6023         } else {
6024             cur->ocur = XML_ELEMENT_CONTENT_ONCE;
6025         }
6026         GROW;
6027     }
6028     SKIP_BLANKS;
6029     SHRINK;
6030     while (RAW != ')') {
6031         /*
6032          * Each loop we parse one separator and one element.
6033          */
6034         if (RAW == ',') {
6035             if (type == 0) type = CUR;
6036
6037             /*
6038              * Detect "Name | Name , Name" error
6039              */
6040             else if (type != CUR) {
6041                 xmlFatalErrMsgInt(ctxt, XML_ERR_SEPARATOR_REQUIRED,
6042                     "xmlParseElementChildrenContentDecl : '%c' expected\n",
6043                                   type);
6044                 if ((last != NULL) && (last != ret))
6045                     xmlFreeDocElementContent(ctxt->myDoc, last);
6046                 if (ret != NULL)
6047                     xmlFreeDocElementContent(ctxt->myDoc, ret);
6048                 return(NULL);
6049             }
6050             NEXT;
6051
6052             op = xmlNewDocElementContent(ctxt->myDoc, NULL, XML_ELEMENT_CONTENT_SEQ);
6053             if (op == NULL) {
6054                 if ((last != NULL) && (last != ret))
6055                     xmlFreeDocElementContent(ctxt->myDoc, last);
6056                 xmlFreeDocElementContent(ctxt->myDoc, ret);
6057                 return(NULL);
6058             }
6059             if (last == NULL) {
6060                 op->c1 = ret;
6061                 if (ret != NULL)
6062                     ret->parent = op;
6063                 ret = cur = op;
6064             } else {
6065                 cur->c2 = op;
6066                 if (op != NULL)
6067                     op->parent = cur;
6068                 op->c1 = last;
6069                 if (last != NULL)
6070                     last->parent = op;
6071                 cur =op;
6072                 last = NULL;
6073             }
6074         } else if (RAW == '|') {
6075             if (type == 0) type = CUR;
6076
6077             /*
6078              * Detect "Name , Name | Name" error
6079              */
6080             else if (type != CUR) {
6081                 xmlFatalErrMsgInt(ctxt, XML_ERR_SEPARATOR_REQUIRED,
6082                     "xmlParseElementChildrenContentDecl : '%c' expected\n",
6083                                   type);
6084                 if ((last != NULL) && (last != ret))
6085                     xmlFreeDocElementContent(ctxt->myDoc, last);
6086                 if (ret != NULL)
6087                     xmlFreeDocElementContent(ctxt->myDoc, ret);
6088                 return(NULL);
6089             }
6090             NEXT;
6091
6092             op = xmlNewDocElementContent(ctxt->myDoc, NULL, XML_ELEMENT_CONTENT_OR);
6093             if (op == NULL) {
6094                 if ((last != NULL) && (last != ret))
6095                     xmlFreeDocElementContent(ctxt->myDoc, last);
6096                 if (ret != NULL)
6097                     xmlFreeDocElementContent(ctxt->myDoc, ret);
6098                 return(NULL);
6099             }
6100             if (last == NULL) {
6101                 op->c1 = ret;
6102                 if (ret != NULL)
6103                     ret->parent = op;
6104                 ret = cur = op;
6105             } else {
6106                 cur->c2 = op;
6107                 if (op != NULL)
6108                     op->parent = cur;
6109                 op->c1 = last;
6110                 if (last != NULL)
6111                     last->parent = op;
6112                 cur =op;
6113                 last = NULL;
6114             }
6115         } else {
6116             xmlFatalErr(ctxt, XML_ERR_ELEMCONTENT_NOT_FINISHED, NULL);
6117             if ((last != NULL) && (last != ret))
6118                 xmlFreeDocElementContent(ctxt->myDoc, last);
6119             if (ret != NULL)
6120                 xmlFreeDocElementContent(ctxt->myDoc, ret);
6121             return(NULL);
6122         }
6123         GROW;
6124         SKIP_BLANKS;
6125         GROW;
6126         if (RAW == '(') {
6127             int inputid = ctxt->input->id;
6128             /* Recurse on second child */
6129             NEXT;
6130             SKIP_BLANKS;
6131             last = xmlParseElementChildrenContentDeclPriv(ctxt, inputid,
6132                                                           depth + 1);
6133             SKIP_BLANKS;
6134         } else {
6135             elem = xmlParseName(ctxt);
6136             if (elem == NULL) {
6137                 xmlFatalErr(ctxt, XML_ERR_ELEMCONTENT_NOT_STARTED, NULL);
6138                 if (ret != NULL)
6139                     xmlFreeDocElementContent(ctxt->myDoc, ret);
6140                 return(NULL);
6141             }
6142             last = xmlNewDocElementContent(ctxt->myDoc, elem, XML_ELEMENT_CONTENT_ELEMENT);
6143             if (last == NULL) {
6144                 if (ret != NULL)
6145                     xmlFreeDocElementContent(ctxt->myDoc, ret);
6146                 return(NULL);
6147             }
6148             if (RAW == '?') {
6149                 last->ocur = XML_ELEMENT_CONTENT_OPT;
6150                 NEXT;
6151             } else if (RAW == '*') {
6152                 last->ocur = XML_ELEMENT_CONTENT_MULT;
6153                 NEXT;
6154             } else if (RAW == '+') {
6155                 last->ocur = XML_ELEMENT_CONTENT_PLUS;
6156                 NEXT;
6157             } else {
6158                 last->ocur = XML_ELEMENT_CONTENT_ONCE;
6159             }
6160         }
6161         SKIP_BLANKS;
6162         GROW;
6163     }
6164     if ((cur != NULL) && (last != NULL)) {
6165         cur->c2 = last;
6166         if (last != NULL)
6167             last->parent = cur;
6168     }
6169     if ((ctxt->validate) && (ctxt->input->id != inputchk)) {
6170         xmlValidityError(ctxt, XML_ERR_ENTITY_BOUNDARY,
6171 "Element content declaration doesn't start and stop in the same entity\n",
6172                          NULL, NULL);
6173     }
6174     NEXT;
6175     if (RAW == '?') {
6176         if (ret != NULL) {
6177             if ((ret->ocur == XML_ELEMENT_CONTENT_PLUS) ||
6178                 (ret->ocur == XML_ELEMENT_CONTENT_MULT))
6179                 ret->ocur = XML_ELEMENT_CONTENT_MULT;
6180             else
6181                 ret->ocur = XML_ELEMENT_CONTENT_OPT;
6182         }
6183         NEXT;
6184     } else if (RAW == '*') {
6185         if (ret != NULL) {
6186             ret->ocur = XML_ELEMENT_CONTENT_MULT;
6187             cur = ret;
6188             /*
6189              * Some normalization:
6190              * (a | b* | c?)* == (a | b | c)*
6191              */
6192             while ((cur != NULL) && (cur->type == XML_ELEMENT_CONTENT_OR)) {
6193                 if ((cur->c1 != NULL) &&
6194                     ((cur->c1->ocur == XML_ELEMENT_CONTENT_OPT) ||
6195                      (cur->c1->ocur == XML_ELEMENT_CONTENT_MULT)))
6196                     cur->c1->ocur = XML_ELEMENT_CONTENT_ONCE;
6197                 if ((cur->c2 != NULL) &&
6198                     ((cur->c2->ocur == XML_ELEMENT_CONTENT_OPT) ||
6199                      (cur->c2->ocur == XML_ELEMENT_CONTENT_MULT)))
6200                     cur->c2->ocur = XML_ELEMENT_CONTENT_ONCE;
6201                 cur = cur->c2;
6202             }
6203         }
6204         NEXT;
6205     } else if (RAW == '+') {
6206         if (ret != NULL) {
6207             int found = 0;
6208
6209             if ((ret->ocur == XML_ELEMENT_CONTENT_OPT) ||
6210                 (ret->ocur == XML_ELEMENT_CONTENT_MULT))
6211                 ret->ocur = XML_ELEMENT_CONTENT_MULT;
6212             else
6213                 ret->ocur = XML_ELEMENT_CONTENT_PLUS;
6214             /*
6215              * Some normalization:
6216              * (a | b*)+ == (a | b)*
6217              * (a | b?)+ == (a | b)*
6218              */
6219             while ((cur != NULL) && (cur->type == XML_ELEMENT_CONTENT_OR)) {
6220                 if ((cur->c1 != NULL) &&
6221                     ((cur->c1->ocur == XML_ELEMENT_CONTENT_OPT) ||
6222                      (cur->c1->ocur == XML_ELEMENT_CONTENT_MULT))) {
6223                     cur->c1->ocur = XML_ELEMENT_CONTENT_ONCE;
6224                     found = 1;
6225                 }
6226                 if ((cur->c2 != NULL) &&
6227                     ((cur->c2->ocur == XML_ELEMENT_CONTENT_OPT) ||
6228                      (cur->c2->ocur == XML_ELEMENT_CONTENT_MULT))) {
6229                     cur->c2->ocur = XML_ELEMENT_CONTENT_ONCE;
6230                     found = 1;
6231                 }
6232                 cur = cur->c2;
6233             }
6234             if (found)
6235                 ret->ocur = XML_ELEMENT_CONTENT_MULT;
6236         }
6237         NEXT;
6238     }
6239     return(ret);
6240 }
6241
6242 /**
6243  * xmlParseElementChildrenContentDecl:
6244  * @ctxt:  an XML parser context
6245  * @inputchk:  the input used for the current entity, needed for boundary checks
6246  *
6247  * parse the declaration for a Mixed Element content
6248  * The leading '(' and spaces have been skipped in xmlParseElementContentDecl
6249  *
6250  * [47] children ::= (choice | seq) ('?' | '*' | '+')?
6251  *
6252  * [48] cp ::= (Name | choice | seq) ('?' | '*' | '+')?
6253  *
6254  * [49] choice ::= '(' S? cp ( S? '|' S? cp )* S? ')'
6255  *
6256  * [50] seq ::= '(' S? cp ( S? ',' S? cp )* S? ')'
6257  *
6258  * [ VC: Proper Group/PE Nesting ] applies to [49] and [50]
6259  * TODO Parameter-entity replacement text must be properly nested
6260  *      with parenthesized groups. That is to say, if either of the
6261  *      opening or closing parentheses in a choice, seq, or Mixed
6262  *      construct is contained in the replacement text for a parameter
6263  *      entity, both must be contained in the same replacement text. For
6264  *      interoperability, if a parameter-entity reference appears in a
6265  *      choice, seq, or Mixed construct, its replacement text should not
6266  *      be empty, and neither the first nor last non-blank character of
6267  *      the replacement text should be a connector (| or ,).
6268  *
6269  * Returns the tree of xmlElementContentPtr describing the element
6270  *          hierarchy.
6271  */
6272 xmlElementContentPtr
6273 xmlParseElementChildrenContentDecl(xmlParserCtxtPtr ctxt, int inputchk) {
6274     /* stub left for API/ABI compat */
6275     return(xmlParseElementChildrenContentDeclPriv(ctxt, inputchk, 1));
6276 }
6277
6278 /**
6279  * xmlParseElementContentDecl:
6280  * @ctxt:  an XML parser context
6281  * @name:  the name of the element being defined.
6282  * @result:  the Element Content pointer will be stored here if any
6283  *
6284  * parse the declaration for an Element content either Mixed or Children,
6285  * the cases EMPTY and ANY are handled directly in xmlParseElementDecl
6286  *
6287  * [46] contentspec ::= 'EMPTY' | 'ANY' | Mixed | children
6288  *
6289  * returns: the type of element content XML_ELEMENT_TYPE_xxx
6290  */
6291
6292 int
6293 xmlParseElementContentDecl(xmlParserCtxtPtr ctxt, const xmlChar *name,
6294                            xmlElementContentPtr *result) {
6295
6296     xmlElementContentPtr tree = NULL;
6297     int inputid = ctxt->input->id;
6298     int res;
6299
6300     *result = NULL;
6301
6302     if (RAW != '(') {
6303         xmlFatalErrMsgStr(ctxt, XML_ERR_ELEMCONTENT_NOT_STARTED,
6304                 "xmlParseElementContentDecl : %s '(' expected\n", name);
6305         return(-1);
6306     }
6307     NEXT;
6308     GROW;
6309     SKIP_BLANKS;
6310     if (CMP7(CUR_PTR, '#', 'P', 'C', 'D', 'A', 'T', 'A')) {
6311         tree = xmlParseElementMixedContentDecl(ctxt, inputid);
6312         res = XML_ELEMENT_TYPE_MIXED;
6313     } else {
6314         tree = xmlParseElementChildrenContentDeclPriv(ctxt, inputid, 1);
6315         res = XML_ELEMENT_TYPE_ELEMENT;
6316     }
6317     SKIP_BLANKS;
6318     *result = tree;
6319     return(res);
6320 }
6321
6322 /**
6323  * xmlParseElementDecl:
6324  * @ctxt:  an XML parser context
6325  *
6326  * parse an Element declaration.
6327  *
6328  * [45] elementdecl ::= '<!ELEMENT' S Name S contentspec S? '>'
6329  *
6330  * [ VC: Unique Element Type Declaration ]
6331  * No element type may be declared more than once
6332  *
6333  * Returns the type of the element, or -1 in case of error
6334  */
6335 int
6336 xmlParseElementDecl(xmlParserCtxtPtr ctxt) {
6337     const xmlChar *name;
6338     int ret = -1;
6339     xmlElementContentPtr content  = NULL;
6340
6341     /* GROW; done in the caller */
6342     if (CMP9(CUR_PTR, '<', '!', 'E', 'L', 'E', 'M', 'E', 'N', 'T')) {
6343         xmlParserInputPtr input = ctxt->input;
6344
6345         SKIP(9);
6346         if (!IS_BLANK_CH(CUR)) {
6347             xmlFatalErrMsg(ctxt, XML_ERR_SPACE_REQUIRED,
6348                            "Space required after 'ELEMENT'\n");
6349         }
6350         SKIP_BLANKS;
6351         name = xmlParseName(ctxt);
6352         if (name == NULL) {
6353             xmlFatalErrMsg(ctxt, XML_ERR_NAME_REQUIRED,
6354                            "xmlParseElementDecl: no name for Element\n");
6355             return(-1);
6356         }
6357         while ((RAW == 0) && (ctxt->inputNr > 1))
6358             xmlPopInput(ctxt);
6359         if (!IS_BLANK_CH(CUR)) {
6360             xmlFatalErrMsg(ctxt, XML_ERR_SPACE_REQUIRED,
6361                            "Space required after the element name\n");
6362         }
6363         SKIP_BLANKS;
6364         if (CMP5(CUR_PTR, 'E', 'M', 'P', 'T', 'Y')) {
6365             SKIP(5);
6366             /*
6367              * Element must always be empty.
6368              */
6369             ret = XML_ELEMENT_TYPE_EMPTY;
6370         } else if ((RAW == 'A') && (NXT(1) == 'N') &&
6371                    (NXT(2) == 'Y')) {
6372             SKIP(3);
6373             /*
6374              * Element is a generic container.
6375              */
6376             ret = XML_ELEMENT_TYPE_ANY;
6377         } else if (RAW == '(') {
6378             ret = xmlParseElementContentDecl(ctxt, name, &content);
6379         } else {
6380             /*
6381              * [ WFC: PEs in Internal Subset ] error handling.
6382              */
6383             if ((RAW == '%') && (ctxt->external == 0) &&
6384                 (ctxt->inputNr == 1)) {
6385                 xmlFatalErrMsg(ctxt, XML_ERR_PEREF_IN_INT_SUBSET,
6386           "PEReference: forbidden within markup decl in internal subset\n");
6387             } else {
6388                 xmlFatalErrMsg(ctxt, XML_ERR_ELEMCONTENT_NOT_STARTED,
6389                       "xmlParseElementDecl: 'EMPTY', 'ANY' or '(' expected\n");
6390             }
6391             return(-1);
6392         }
6393
6394         SKIP_BLANKS;
6395         /*
6396          * Pop-up of finished entities.
6397          */
6398         while ((RAW == 0) && (ctxt->inputNr > 1))
6399             xmlPopInput(ctxt);
6400         SKIP_BLANKS;
6401
6402         if (RAW != '>') {
6403             xmlFatalErr(ctxt, XML_ERR_GT_REQUIRED, NULL);
6404             if (content != NULL) {
6405                 xmlFreeDocElementContent(ctxt->myDoc, content);
6406             }
6407         } else {
6408             if (input != ctxt->input) {
6409                 xmlFatalErrMsg(ctxt, XML_ERR_ENTITY_BOUNDARY,
6410     "Element declaration doesn't start and stop in the same entity\n");
6411             }
6412
6413             NEXT;
6414             if ((ctxt->sax != NULL) && (!ctxt->disableSAX) &&
6415                 (ctxt->sax->elementDecl != NULL)) {
6416                 if (content != NULL)
6417                     content->parent = NULL;
6418                 ctxt->sax->elementDecl(ctxt->userData, name, ret,
6419                                        content);
6420                 if ((content != NULL) && (content->parent == NULL)) {
6421                     /*
6422                      * this is a trick: if xmlAddElementDecl is called,
6423                      * instead of copying the full tree it is plugged directly
6424                      * if called from the parser. Avoid duplicating the
6425                      * interfaces or change the API/ABI
6426                      */
6427                     xmlFreeDocElementContent(ctxt->myDoc, content);
6428                 }
6429             } else if (content != NULL) {
6430                 xmlFreeDocElementContent(ctxt->myDoc, content);
6431             }
6432         }
6433     }
6434     return(ret);
6435 }
6436
6437 /**
6438  * xmlParseConditionalSections
6439  * @ctxt:  an XML parser context
6440  *
6441  * [61] conditionalSect ::= includeSect | ignoreSect
6442  * [62] includeSect ::= '<![' S? 'INCLUDE' S? '[' extSubsetDecl ']]>'
6443  * [63] ignoreSect ::= '<![' S? 'IGNORE' S? '[' ignoreSectContents* ']]>'
6444  * [64] ignoreSectContents ::= Ignore ('<![' ignoreSectContents ']]>' Ignore)*
6445  * [65] Ignore ::= Char* - (Char* ('<![' | ']]>') Char*)
6446  */
6447
6448 static void
6449 xmlParseConditionalSections(xmlParserCtxtPtr ctxt) {
6450     int id = ctxt->input->id;
6451
6452     SKIP(3);
6453     SKIP_BLANKS;
6454     if (CMP7(CUR_PTR, 'I', 'N', 'C', 'L', 'U', 'D', 'E')) {
6455         SKIP(7);
6456         SKIP_BLANKS;
6457         if (RAW != '[') {
6458             xmlFatalErr(ctxt, XML_ERR_CONDSEC_INVALID, NULL);
6459         } else {
6460             if (ctxt->input->id != id) {
6461                 xmlValidityError(ctxt, XML_ERR_ENTITY_BOUNDARY,
6462             "All markup of the conditional section is not in the same entity\n",
6463                                      NULL, NULL);
6464             }
6465             NEXT;
6466         }
6467         if (xmlParserDebugEntities) {
6468             if ((ctxt->input != NULL) && (ctxt->input->filename))
6469                 xmlGenericError(xmlGenericErrorContext,
6470                         "%s(%d): ", ctxt->input->filename,
6471                         ctxt->input->line);
6472             xmlGenericError(xmlGenericErrorContext,
6473                     "Entering INCLUDE Conditional Section\n");
6474         }
6475
6476         while ((RAW != 0) && ((RAW != ']') || (NXT(1) != ']') ||
6477                (NXT(2) != '>'))) {
6478             const xmlChar *check = CUR_PTR;
6479             unsigned int cons = ctxt->input->consumed;
6480
6481             if ((RAW == '<') && (NXT(1) == '!') && (NXT(2) == '[')) {
6482                 xmlParseConditionalSections(ctxt);
6483             } else if (IS_BLANK_CH(CUR)) {
6484                 NEXT;
6485             } else if (RAW == '%') {
6486                 xmlParsePEReference(ctxt);
6487             } else
6488                 xmlParseMarkupDecl(ctxt);
6489
6490             /*
6491              * Pop-up of finished entities.
6492              */
6493             while ((RAW == 0) && (ctxt->inputNr > 1))
6494                 xmlPopInput(ctxt);
6495
6496             if ((CUR_PTR == check) && (cons == ctxt->input->consumed)) {
6497                 xmlFatalErr(ctxt, XML_ERR_EXT_SUBSET_NOT_FINISHED, NULL);
6498                 break;
6499             }
6500         }
6501         if (xmlParserDebugEntities) {
6502             if ((ctxt->input != NULL) && (ctxt->input->filename))
6503                 xmlGenericError(xmlGenericErrorContext,
6504                         "%s(%d): ", ctxt->input->filename,
6505                         ctxt->input->line);
6506             xmlGenericError(xmlGenericErrorContext,
6507                     "Leaving INCLUDE Conditional Section\n");
6508         }
6509
6510     } else if (CMP6(CUR_PTR, 'I', 'G', 'N', 'O', 'R', 'E')) {
6511         int state;
6512         xmlParserInputState instate;
6513         int depth = 0;
6514
6515         SKIP(6);
6516         SKIP_BLANKS;
6517         if (RAW != '[') {
6518             xmlFatalErr(ctxt, XML_ERR_CONDSEC_INVALID, NULL);
6519         } else {
6520             if (ctxt->input->id != id) {
6521                 xmlValidityError(ctxt, XML_ERR_ENTITY_BOUNDARY,
6522             "All markup of the conditional section is not in the same entity\n",
6523                                      NULL, NULL);
6524             }
6525             NEXT;
6526         }
6527         if (xmlParserDebugEntities) {
6528             if ((ctxt->input != NULL) && (ctxt->input->filename))
6529                 xmlGenericError(xmlGenericErrorContext,
6530                         "%s(%d): ", ctxt->input->filename,
6531                         ctxt->input->line);
6532             xmlGenericError(xmlGenericErrorContext,
6533                     "Entering IGNORE Conditional Section\n");
6534         }
6535
6536         /*
6537          * Parse up to the end of the conditional section
6538          * But disable SAX event generating DTD building in the meantime
6539          */
6540         state = ctxt->disableSAX;
6541         instate = ctxt->instate;
6542         if (ctxt->recovery == 0) ctxt->disableSAX = 1;
6543         ctxt->instate = XML_PARSER_IGNORE;
6544
6545         while ((depth >= 0) && (RAW != 0)) {
6546           if ((RAW == '<') && (NXT(1) == '!') && (NXT(2) == '[')) {
6547             depth++;
6548             SKIP(3);
6549             continue;
6550           }
6551           if ((RAW == ']') && (NXT(1) == ']') && (NXT(2) == '>')) {
6552             if (--depth >= 0) SKIP(3);
6553             continue;
6554           }
6555           NEXT;
6556           continue;
6557         }
6558
6559         ctxt->disableSAX = state;
6560         ctxt->instate = instate;
6561
6562         if (xmlParserDebugEntities) {
6563             if ((ctxt->input != NULL) && (ctxt->input->filename))
6564                 xmlGenericError(xmlGenericErrorContext,
6565                         "%s(%d): ", ctxt->input->filename,
6566                         ctxt->input->line);
6567             xmlGenericError(xmlGenericErrorContext,
6568                     "Leaving IGNORE Conditional Section\n");
6569         }
6570
6571     } else {
6572         xmlFatalErr(ctxt, XML_ERR_CONDSEC_INVALID_KEYWORD, NULL);
6573     }
6574
6575     if (RAW == 0)
6576         SHRINK;
6577
6578     if (RAW == 0) {
6579         xmlFatalErr(ctxt, XML_ERR_CONDSEC_NOT_FINISHED, NULL);
6580     } else {
6581         if (ctxt->input->id != id) {
6582             xmlValidityError(ctxt, XML_ERR_ENTITY_BOUNDARY,
6583         "All markup of the conditional section is not in the same entity\n",
6584                                  NULL, NULL);
6585         }
6586         SKIP(3);
6587     }
6588 }
6589
6590 /**
6591  * xmlParseMarkupDecl:
6592  * @ctxt:  an XML parser context
6593  *
6594  * parse Markup declarations
6595  *
6596  * [29] markupdecl ::= elementdecl | AttlistDecl | EntityDecl |
6597  *                     NotationDecl | PI | Comment
6598  *
6599  * [ VC: Proper Declaration/PE Nesting ]
6600  * Parameter-entity replacement text must be properly nested with
6601  * markup declarations. That is to say, if either the first character
6602  * or the last character of a markup declaration (markupdecl above) is
6603  * contained in the replacement text for a parameter-entity reference,
6604  * both must be contained in the same replacement text.
6605  *
6606  * [ WFC: PEs in Internal Subset ]
6607  * In the internal DTD subset, parameter-entity references can occur
6608  * only where markup declarations can occur, not within markup declarations.
6609  * (This does not apply to references that occur in external parameter
6610  * entities or to the external subset.)
6611  */
6612 void
6613 xmlParseMarkupDecl(xmlParserCtxtPtr ctxt) {
6614     GROW;
6615     if (CUR == '<') {
6616         if (NXT(1) == '!') {
6617             switch (NXT(2)) {
6618                 case 'E':
6619                     if (NXT(3) == 'L')
6620                         xmlParseElementDecl(ctxt);
6621                     else if (NXT(3) == 'N')
6622                         xmlParseEntityDecl(ctxt);
6623                     break;
6624                 case 'A':
6625                     xmlParseAttributeListDecl(ctxt);
6626                     break;
6627                 case 'N':
6628                     xmlParseNotationDecl(ctxt);
6629                     break;
6630                 case '-':
6631                     xmlParseComment(ctxt);
6632                     break;
6633                 default:
6634                     /* there is an error but it will be detected later */
6635                     break;
6636             }
6637         } else if (NXT(1) == '?') {
6638             xmlParsePI(ctxt);
6639         }
6640     }
6641     /*
6642      * This is only for internal subset. On external entities,
6643      * the replacement is done before parsing stage
6644      */
6645     if ((ctxt->external == 0) && (ctxt->inputNr == 1))
6646         xmlParsePEReference(ctxt);
6647
6648     /*
6649      * Conditional sections are allowed from entities included
6650      * by PE References in the internal subset.
6651      */
6652     if ((ctxt->external == 0) && (ctxt->inputNr > 1)) {
6653         if ((RAW == '<') && (NXT(1) == '!') && (NXT(2) == '[')) {
6654             xmlParseConditionalSections(ctxt);
6655         }
6656     }
6657
6658     ctxt->instate = XML_PARSER_DTD;
6659 }
6660
6661 /**
6662  * xmlParseTextDecl:
6663  * @ctxt:  an XML parser context
6664  *
6665  * parse an XML declaration header for external entities
6666  *
6667  * [77] TextDecl ::= '<?xml' VersionInfo? EncodingDecl S? '?>'
6668  */
6669
6670 void
6671 xmlParseTextDecl(xmlParserCtxtPtr ctxt) {
6672     xmlChar *version;
6673     const xmlChar *encoding;
6674
6675     /*
6676      * We know that '<?xml' is here.
6677      */
6678     if ((CMP5(CUR_PTR, '<', '?', 'x', 'm', 'l')) && (IS_BLANK_CH(NXT(5)))) {
6679         SKIP(5);
6680     } else {
6681         xmlFatalErr(ctxt, XML_ERR_XMLDECL_NOT_STARTED, NULL);
6682         return;
6683     }
6684
6685     if (!IS_BLANK_CH(CUR)) {
6686         xmlFatalErrMsg(ctxt, XML_ERR_SPACE_REQUIRED,
6687                        "Space needed after '<?xml'\n");
6688     }
6689     SKIP_BLANKS;
6690
6691     /*
6692      * We may have the VersionInfo here.
6693      */
6694     version = xmlParseVersionInfo(ctxt);
6695     if (version == NULL)
6696         version = xmlCharStrdup(XML_DEFAULT_VERSION);
6697     else {
6698         if (!IS_BLANK_CH(CUR)) {
6699             xmlFatalErrMsg(ctxt, XML_ERR_SPACE_REQUIRED,
6700                            "Space needed here\n");
6701         }
6702     }
6703     ctxt->input->version = version;
6704
6705     /*
6706      * We must have the encoding declaration
6707      */
6708     encoding = xmlParseEncodingDecl(ctxt);
6709     if (ctxt->errNo == XML_ERR_UNSUPPORTED_ENCODING) {
6710         /*
6711          * The XML REC instructs us to stop parsing right here
6712          */
6713         return;
6714     }
6715     if ((encoding == NULL) && (ctxt->errNo == XML_ERR_OK)) {
6716         xmlFatalErrMsg(ctxt, XML_ERR_MISSING_ENCODING,
6717                        "Missing encoding in text declaration\n");
6718     }
6719
6720     SKIP_BLANKS;
6721     if ((RAW == '?') && (NXT(1) == '>')) {
6722         SKIP(2);
6723     } else if (RAW == '>') {
6724         /* Deprecated old WD ... */
6725         xmlFatalErr(ctxt, XML_ERR_XMLDECL_NOT_FINISHED, NULL);
6726         NEXT;
6727     } else {
6728         xmlFatalErr(ctxt, XML_ERR_XMLDECL_NOT_FINISHED, NULL);
6729         MOVETO_ENDTAG(CUR_PTR);
6730         NEXT;
6731     }
6732 }
6733
6734 /**
6735  * xmlParseExternalSubset:
6736  * @ctxt:  an XML parser context
6737  * @ExternalID: the external identifier
6738  * @SystemID: the system identifier (or URL)
6739  *
6740  * parse Markup declarations from an external subset
6741  *
6742  * [30] extSubset ::= textDecl? extSubsetDecl
6743  *
6744  * [31] extSubsetDecl ::= (markupdecl | conditionalSect | PEReference | S) *
6745  */
6746 void
6747 xmlParseExternalSubset(xmlParserCtxtPtr ctxt, const xmlChar *ExternalID,
6748                        const xmlChar *SystemID) {
6749     xmlDetectSAX2(ctxt);
6750     GROW;
6751
6752     if ((ctxt->encoding == NULL) &&
6753         (ctxt->input->end - ctxt->input->cur >= 4)) {
6754         xmlChar start[4];
6755         xmlCharEncoding enc;
6756
6757         start[0] = RAW;
6758         start[1] = NXT(1);
6759         start[2] = NXT(2);
6760         start[3] = NXT(3);
6761         enc = xmlDetectCharEncoding(start, 4);
6762         if (enc != XML_CHAR_ENCODING_NONE)
6763             xmlSwitchEncoding(ctxt, enc);
6764     }
6765
6766     if (CMP5(CUR_PTR, '<', '?', 'x', 'm', 'l')) {
6767         xmlParseTextDecl(ctxt);
6768         if (ctxt->errNo == XML_ERR_UNSUPPORTED_ENCODING) {
6769             /*
6770              * The XML REC instructs us to stop parsing right here
6771              */
6772             ctxt->instate = XML_PARSER_EOF;
6773             return;
6774         }
6775     }
6776     if (ctxt->myDoc == NULL) {
6777         ctxt->myDoc = xmlNewDoc(BAD_CAST "1.0");
6778         if (ctxt->myDoc == NULL) {
6779             xmlErrMemory(ctxt, "New Doc failed");
6780             return;
6781         }
6782         ctxt->myDoc->properties = XML_DOC_INTERNAL;
6783     }
6784     if ((ctxt->myDoc != NULL) && (ctxt->myDoc->intSubset == NULL))
6785         xmlCreateIntSubset(ctxt->myDoc, NULL, ExternalID, SystemID);
6786
6787     ctxt->instate = XML_PARSER_DTD;
6788     ctxt->external = 1;
6789     while (((RAW == '<') && (NXT(1) == '?')) ||
6790            ((RAW == '<') && (NXT(1) == '!')) ||
6791            (RAW == '%') || IS_BLANK_CH(CUR)) {
6792         const xmlChar *check = CUR_PTR;
6793         unsigned int cons = ctxt->input->consumed;
6794
6795         GROW;
6796         if ((RAW == '<') && (NXT(1) == '!') && (NXT(2) == '[')) {
6797             xmlParseConditionalSections(ctxt);
6798         } else if (IS_BLANK_CH(CUR)) {
6799             NEXT;
6800         } else if (RAW == '%') {
6801             xmlParsePEReference(ctxt);
6802         } else
6803             xmlParseMarkupDecl(ctxt);
6804
6805         /*
6806          * Pop-up of finished entities.
6807          */
6808         while ((RAW == 0) && (ctxt->inputNr > 1))
6809             xmlPopInput(ctxt);
6810
6811         if ((CUR_PTR == check) && (cons == ctxt->input->consumed)) {
6812             xmlFatalErr(ctxt, XML_ERR_EXT_SUBSET_NOT_FINISHED, NULL);
6813             break;
6814         }
6815     }
6816
6817     if (RAW != 0) {
6818         xmlFatalErr(ctxt, XML_ERR_EXT_SUBSET_NOT_FINISHED, NULL);
6819     }
6820
6821 }
6822
6823 /**
6824  * xmlParseReference:
6825  * @ctxt:  an XML parser context
6826  *
6827  * parse and handle entity references in content, depending on the SAX
6828  * interface, this may end-up in a call to character() if this is a
6829  * CharRef, a predefined entity, if there is no reference() callback.
6830  * or if the parser was asked to switch to that mode.
6831  *
6832  * [67] Reference ::= EntityRef | CharRef
6833  */
6834 void
6835 xmlParseReference(xmlParserCtxtPtr ctxt) {
6836     xmlEntityPtr ent;
6837     xmlChar *val;
6838     int was_checked;
6839     xmlNodePtr list = NULL;
6840     xmlParserErrors ret = XML_ERR_OK;
6841
6842
6843     if (RAW != '&')
6844         return;
6845
6846     /*
6847      * Simple case of a CharRef
6848      */
6849     if (NXT(1) == '#') {
6850         int i = 0;
6851         xmlChar out[10];
6852         int hex = NXT(2);
6853         int value = xmlParseCharRef(ctxt);
6854
6855         if (value == 0)
6856             return;
6857         if (ctxt->charset != XML_CHAR_ENCODING_UTF8) {
6858             /*
6859              * So we are using non-UTF-8 buffers
6860              * Check that the char fit on 8bits, if not
6861              * generate a CharRef.
6862              */
6863             if (value <= 0xFF) {
6864                 out[0] = value;
6865                 out[1] = 0;
6866                 if ((ctxt->sax != NULL) && (ctxt->sax->characters != NULL) &&
6867                     (!ctxt->disableSAX))
6868                     ctxt->sax->characters(ctxt->userData, out, 1);
6869             } else {
6870                 if ((hex == 'x') || (hex == 'X'))
6871                     snprintf((char *)out, sizeof(out), "#x%X", value);
6872                 else
6873                     snprintf((char *)out, sizeof(out), "#%d", value);
6874                 if ((ctxt->sax != NULL) && (ctxt->sax->reference != NULL) &&
6875                     (!ctxt->disableSAX))
6876                     ctxt->sax->reference(ctxt->userData, out);
6877             }
6878         } else {
6879             /*
6880              * Just encode the value in UTF-8
6881              */
6882             COPY_BUF(0 ,out, i, value);
6883             out[i] = 0;
6884             if ((ctxt->sax != NULL) && (ctxt->sax->characters != NULL) &&
6885                 (!ctxt->disableSAX))
6886                 ctxt->sax->characters(ctxt->userData, out, i);
6887         }
6888         return;
6889     }
6890
6891     /*
6892      * We are seeing an entity reference
6893      */
6894     ent = xmlParseEntityRef(ctxt);
6895     if (ent == NULL) return;
6896     if (!ctxt->wellFormed)
6897         return;
6898     was_checked = ent->checked;
6899
6900     /* special case of predefined entities */
6901     if ((ent->name == NULL) ||
6902         (ent->etype == XML_INTERNAL_PREDEFINED_ENTITY)) {
6903         val = ent->content;
6904         if (val == NULL) return;
6905         /*
6906          * inline the entity.
6907          */
6908         if ((ctxt->sax != NULL) && (ctxt->sax->characters != NULL) &&
6909             (!ctxt->disableSAX))
6910             ctxt->sax->characters(ctxt->userData, val, xmlStrlen(val));
6911         return;
6912     }
6913
6914     /*
6915      * The first reference to the entity trigger a parsing phase
6916      * where the ent->children is filled with the result from
6917      * the parsing.
6918      */
6919     if (ent->checked == 0) {
6920         unsigned long oldnbent = ctxt->nbentities;
6921
6922         /*
6923          * This is a bit hackish but this seems the best
6924          * way to make sure both SAX and DOM entity support
6925          * behaves okay.
6926          */
6927         void *user_data;
6928         if (ctxt->userData == ctxt)
6929             user_data = NULL;
6930         else
6931             user_data = ctxt->userData;
6932
6933         /*
6934          * Check that this entity is well formed
6935          * 4.3.2: An internal general parsed entity is well-formed
6936          * if its replacement text matches the production labeled
6937          * content.
6938          */
6939         if (ent->etype == XML_INTERNAL_GENERAL_ENTITY) {
6940             ctxt->depth++;
6941             ret = xmlParseBalancedChunkMemoryInternal(ctxt, ent->content,
6942                                                       user_data, &list);
6943             ctxt->depth--;
6944
6945         } else if (ent->etype == XML_EXTERNAL_GENERAL_PARSED_ENTITY) {
6946             ctxt->depth++;
6947             ret = xmlParseExternalEntityPrivate(ctxt->myDoc, ctxt, ctxt->sax,
6948                                            user_data, ctxt->depth, ent->URI,
6949                                            ent->ExternalID, &list);
6950             ctxt->depth--;
6951         } else {
6952             ret = XML_ERR_ENTITY_PE_INTERNAL;
6953             xmlErrMsgStr(ctxt, XML_ERR_INTERNAL_ERROR,
6954                          "invalid entity type found\n", NULL);
6955         }
6956
6957         /*
6958          * Store the number of entities needing parsing for this entity
6959          * content and do checkings
6960          */
6961         ent->checked = ctxt->nbentities - oldnbent;
6962         if (ret == XML_ERR_ENTITY_LOOP) {
6963             xmlFatalErr(ctxt, XML_ERR_ENTITY_LOOP, NULL);
6964             xmlFreeNodeList(list);
6965             return;
6966         }
6967         if (xmlParserEntityCheck(ctxt, 0, ent)) {
6968             xmlFreeNodeList(list);
6969             return;
6970         }
6971
6972         if ((ret == XML_ERR_OK) && (list != NULL)) {
6973             if (((ent->etype == XML_INTERNAL_GENERAL_ENTITY) ||
6974              (ent->etype == XML_EXTERNAL_GENERAL_PARSED_ENTITY))&&
6975                 (ent->children == NULL)) {
6976                 ent->children = list;
6977                 if (ctxt->replaceEntities) {
6978                     /*
6979                      * Prune it directly in the generated document
6980                      * except for single text nodes.
6981                      */
6982                     if (((list->type == XML_TEXT_NODE) &&
6983                          (list->next == NULL)) ||
6984                         (ctxt->parseMode == XML_PARSE_READER)) {
6985                         list->parent = (xmlNodePtr) ent;
6986                         list = NULL;
6987                         ent->owner = 1;
6988                     } else {
6989                         ent->owner = 0;
6990                         while (list != NULL) {
6991                             list->parent = (xmlNodePtr) ctxt->node;
6992                             list->doc = ctxt->myDoc;
6993                             if (list->next == NULL)
6994                                 ent->last = list;
6995                             list = list->next;
6996                         }
6997                         list = ent->children;
6998 #ifdef LIBXML_LEGACY_ENABLED
6999                         if (ent->etype == XML_EXTERNAL_GENERAL_PARSED_ENTITY)
7000                           xmlAddEntityReference(ent, list, NULL);
7001 #endif /* LIBXML_LEGACY_ENABLED */
7002                     }
7003                 } else {
7004                     ent->owner = 1;
7005                     while (list != NULL) {
7006                         list->parent = (xmlNodePtr) ent;
7007                         xmlSetTreeDoc(list, ent->doc);
7008                         if (list->next == NULL)
7009                             ent->last = list;
7010                         list = list->next;
7011                     }
7012                 }
7013             } else {
7014                 xmlFreeNodeList(list);
7015                 list = NULL;
7016             }
7017         } else if ((ret != XML_ERR_OK) &&
7018                    (ret != XML_WAR_UNDECLARED_ENTITY)) {
7019             xmlFatalErrMsgStr(ctxt, XML_ERR_UNDECLARED_ENTITY,
7020                      "Entity '%s' failed to parse\n", ent->name);
7021         } else if (list != NULL) {
7022             xmlFreeNodeList(list);
7023             list = NULL;
7024         }
7025         if (ent->checked == 0)
7026             ent->checked = 1;
7027     } else if (ent->checked != 1) {
7028         ctxt->nbentities += ent->checked;
7029     }
7030
7031     /*
7032      * Now that the entity content has been gathered
7033      * provide it to the application, this can take different forms based
7034      * on the parsing modes.
7035      */
7036     if (ent->children == NULL) {
7037         /*
7038          * Probably running in SAX mode and the callbacks don't
7039          * build the entity content. So unless we already went
7040          * though parsing for first checking go though the entity
7041          * content to generate callbacks associated to the entity
7042          */
7043         if (was_checked != 0) {
7044             void *user_data;
7045             /*
7046              * This is a bit hackish but this seems the best
7047              * way to make sure both SAX and DOM entity support
7048              * behaves okay.
7049              */
7050             if (ctxt->userData == ctxt)
7051                 user_data = NULL;
7052             else
7053                 user_data = ctxt->userData;
7054
7055             if (ent->etype == XML_INTERNAL_GENERAL_ENTITY) {
7056                 ctxt->depth++;
7057                 ret = xmlParseBalancedChunkMemoryInternal(ctxt,
7058                                    ent->content, user_data, NULL);
7059                 ctxt->depth--;
7060             } else if (ent->etype ==
7061                        XML_EXTERNAL_GENERAL_PARSED_ENTITY) {
7062                 ctxt->depth++;
7063                 ret = xmlParseExternalEntityPrivate(ctxt->myDoc, ctxt,
7064                            ctxt->sax, user_data, ctxt->depth,
7065                            ent->URI, ent->ExternalID, NULL);
7066                 ctxt->depth--;
7067             } else {
7068                 ret = XML_ERR_ENTITY_PE_INTERNAL;
7069                 xmlErrMsgStr(ctxt, XML_ERR_INTERNAL_ERROR,
7070                              "invalid entity type found\n", NULL);
7071             }
7072             if (ret == XML_ERR_ENTITY_LOOP) {
7073                 xmlFatalErr(ctxt, XML_ERR_ENTITY_LOOP, NULL);
7074                 return;
7075             }
7076         }
7077         if ((ctxt->sax != NULL) && (ctxt->sax->reference != NULL) &&
7078             (ctxt->replaceEntities == 0) && (!ctxt->disableSAX)) {
7079             /*
7080              * Entity reference callback comes second, it's somewhat
7081              * superfluous but a compatibility to historical behaviour
7082              */
7083             ctxt->sax->reference(ctxt->userData, ent->name);
7084         }
7085         return;
7086     }
7087
7088     /*
7089      * If we didn't get any children for the entity being built
7090      */
7091     if ((ctxt->sax != NULL) && (ctxt->sax->reference != NULL) &&
7092         (ctxt->replaceEntities == 0) && (!ctxt->disableSAX)) {
7093         /*
7094          * Create a node.
7095          */
7096         ctxt->sax->reference(ctxt->userData, ent->name);
7097         return;
7098     }
7099
7100     if ((ctxt->replaceEntities) || (ent->children == NULL))  {
7101         /*
7102          * There is a problem on the handling of _private for entities
7103          * (bug 155816): Should we copy the content of the field from
7104          * the entity (possibly overwriting some value set by the user
7105          * when a copy is created), should we leave it alone, or should
7106          * we try to take care of different situations?  The problem
7107          * is exacerbated by the usage of this field by the xmlReader.
7108          * To fix this bug, we look at _private on the created node
7109          * and, if it's NULL, we copy in whatever was in the entity.
7110          * If it's not NULL we leave it alone.  This is somewhat of a
7111          * hack - maybe we should have further tests to determine
7112          * what to do.
7113          */
7114         if ((ctxt->node != NULL) && (ent->children != NULL)) {
7115             /*
7116              * Seems we are generating the DOM content, do
7117              * a simple tree copy for all references except the first
7118              * In the first occurrence list contains the replacement.
7119              * progressive == 2 means we are operating on the Reader
7120              * and since nodes are discarded we must copy all the time.
7121              */
7122             if (((list == NULL) && (ent->owner == 0)) ||
7123                 (ctxt->parseMode == XML_PARSE_READER)) {
7124                 xmlNodePtr nw = NULL, cur, firstChild = NULL;
7125
7126                 /*
7127                  * when operating on a reader, the entities definitions
7128                  * are always owning the entities subtree.
7129                 if (ctxt->parseMode == XML_PARSE_READER)
7130                     ent->owner = 1;
7131                  */
7132
7133                 cur = ent->children;
7134                 while (cur != NULL) {
7135                     nw = xmlDocCopyNode(cur, ctxt->myDoc, 1);
7136                     if (nw != NULL) {
7137                         if (nw->_private == NULL)
7138                             nw->_private = cur->_private;
7139                         if (firstChild == NULL){
7140                             firstChild = nw;
7141                         }
7142                         nw = xmlAddChild(ctxt->node, nw);
7143                     }
7144                     if (cur == ent->last) {
7145                         /*
7146                          * needed to detect some strange empty
7147                          * node cases in the reader tests
7148                          */
7149                         if ((ctxt->parseMode == XML_PARSE_READER) &&
7150                             (nw != NULL) &&
7151                             (nw->type == XML_ELEMENT_NODE) &&
7152                             (nw->children == NULL))
7153                             nw->extra = 1;
7154
7155                         break;
7156                     }
7157                     cur = cur->next;
7158                 }
7159 #ifdef LIBXML_LEGACY_ENABLED
7160                 if (ent->etype == XML_EXTERNAL_GENERAL_PARSED_ENTITY)
7161                   xmlAddEntityReference(ent, firstChild, nw);
7162 #endif /* LIBXML_LEGACY_ENABLED */
7163             } else if (list == NULL) {
7164                 xmlNodePtr nw = NULL, cur, next, last,
7165                            firstChild = NULL;
7166                 /*
7167                  * Copy the entity child list and make it the new
7168                  * entity child list. The goal is to make sure any
7169                  * ID or REF referenced will be the one from the
7170                  * document content and not the entity copy.
7171                  */
7172                 cur = ent->children;
7173                 ent->children = NULL;
7174                 last = ent->last;
7175                 ent->last = NULL;
7176                 while (cur != NULL) {
7177                     next = cur->next;
7178                     cur->next = NULL;
7179                     cur->parent = NULL;
7180                     nw = xmlDocCopyNode(cur, ctxt->myDoc, 1);
7181                     if (nw != NULL) {
7182                         if (nw->_private == NULL)
7183                             nw->_private = cur->_private;
7184                         if (firstChild == NULL){
7185                             firstChild = cur;
7186                         }
7187                         xmlAddChild((xmlNodePtr) ent, nw);
7188                         xmlAddChild(ctxt->node, cur);
7189                     }
7190                     if (cur == last)
7191                         break;
7192                     cur = next;
7193                 }
7194                 if (ent->owner == 0)
7195                     ent->owner = 1;
7196 #ifdef LIBXML_LEGACY_ENABLED
7197                 if (ent->etype == XML_EXTERNAL_GENERAL_PARSED_ENTITY)
7198                   xmlAddEntityReference(ent, firstChild, nw);
7199 #endif /* LIBXML_LEGACY_ENABLED */
7200             } else {
7201                 const xmlChar *nbktext;
7202
7203                 /*
7204                  * the name change is to avoid coalescing of the
7205                  * node with a possible previous text one which
7206                  * would make ent->children a dangling pointer
7207                  */
7208                 nbktext = xmlDictLookup(ctxt->dict, BAD_CAST "nbktext",
7209                                         -1);
7210                 if (ent->children->type == XML_TEXT_NODE)
7211                     ent->children->name = nbktext;
7212                 if ((ent->last != ent->children) &&
7213                     (ent->last->type == XML_TEXT_NODE))
7214                     ent->last->name = nbktext;
7215                 xmlAddChildList(ctxt->node, ent->children);
7216             }
7217
7218             /*
7219              * This is to avoid a nasty side effect, see
7220              * characters() in SAX.c
7221              */
7222             ctxt->nodemem = 0;
7223             ctxt->nodelen = 0;
7224             return;
7225         }
7226     }
7227 }
7228
7229 /**
7230  * xmlParseEntityRef:
7231  * @ctxt:  an XML parser context
7232  *
7233  * parse ENTITY references declarations
7234  *
7235  * [68] EntityRef ::= '&' Name ';'
7236  *
7237  * [ WFC: Entity Declared ]
7238  * In a document without any DTD, a document with only an internal DTD
7239  * subset which contains no parameter entity references, or a document
7240  * with "standalone='yes'", the Name given in the entity reference
7241  * must match that in an entity declaration, except that well-formed
7242  * documents need not declare any of the following entities: amp, lt,
7243  * gt, apos, quot.  The declaration of a parameter entity must precede
7244  * any reference to it.  Similarly, the declaration of a general entity
7245  * must precede any reference to it which appears in a default value in an
7246  * attribute-list declaration. Note that if entities are declared in the
7247  * external subset or in external parameter entities, a non-validating
7248  * processor is not obligated to read and process their declarations;
7249  * for such documents, the rule that an entity must be declared is a
7250  * well-formedness constraint only if standalone='yes'.
7251  *
7252  * [ WFC: Parsed Entity ]
7253  * An entity reference must not contain the name of an unparsed entity
7254  *
7255  * Returns the xmlEntityPtr if found, or NULL otherwise.
7256  */
7257 xmlEntityPtr
7258 xmlParseEntityRef(xmlParserCtxtPtr ctxt) {
7259     const xmlChar *name;
7260     xmlEntityPtr ent = NULL;
7261
7262     GROW;
7263
7264     if (RAW != '&')
7265         return(NULL);
7266     NEXT;
7267     name = xmlParseName(ctxt);
7268     if (name == NULL) {
7269         xmlFatalErrMsg(ctxt, XML_ERR_NAME_REQUIRED,
7270                        "xmlParseEntityRef: no name\n");
7271         return(NULL);
7272     }
7273     if (RAW != ';') {
7274         xmlFatalErr(ctxt, XML_ERR_ENTITYREF_SEMICOL_MISSING, NULL);
7275         return(NULL);
7276     }
7277     NEXT;
7278
7279     /*
7280      * Predefined entites override any extra definition
7281      */
7282     if ((ctxt->options & XML_PARSE_OLDSAX) == 0) {
7283         ent = xmlGetPredefinedEntity(name);
7284         if (ent != NULL)
7285             return(ent);
7286     }
7287
7288     /*
7289      * Increate the number of entity references parsed
7290      */
7291     ctxt->nbentities++;
7292
7293     /*
7294      * Ask first SAX for entity resolution, otherwise try the
7295      * entities which may have stored in the parser context.
7296      */
7297     if (ctxt->sax != NULL) {
7298         if (ctxt->sax->getEntity != NULL)
7299             ent = ctxt->sax->getEntity(ctxt->userData, name);
7300         if ((ctxt->wellFormed == 1 ) && (ent == NULL) &&
7301             (ctxt->options & XML_PARSE_OLDSAX))
7302             ent = xmlGetPredefinedEntity(name);
7303         if ((ctxt->wellFormed == 1 ) && (ent == NULL) &&
7304             (ctxt->userData==ctxt)) {
7305             ent = xmlSAX2GetEntity(ctxt, name);
7306         }
7307     }
7308     /*
7309      * [ WFC: Entity Declared ]
7310      * In a document without any DTD, a document with only an
7311      * internal DTD subset which contains no parameter entity
7312      * references, or a document with "standalone='yes'", the
7313      * Name given in the entity reference must match that in an
7314      * entity declaration, except that well-formed documents
7315      * need not declare any of the following entities: amp, lt,
7316      * gt, apos, quot.
7317      * The declaration of a parameter entity must precede any
7318      * reference to it.
7319      * Similarly, the declaration of a general entity must
7320      * precede any reference to it which appears in a default
7321      * value in an attribute-list declaration. Note that if
7322      * entities are declared in the external subset or in
7323      * external parameter entities, a non-validating processor
7324      * is not obligated to read and process their declarations;
7325      * for such documents, the rule that an entity must be
7326      * declared is a well-formedness constraint only if
7327      * standalone='yes'.
7328      */
7329     if (ent == NULL) {
7330         if ((ctxt->standalone == 1) ||
7331             ((ctxt->hasExternalSubset == 0) &&
7332              (ctxt->hasPErefs == 0))) {
7333             xmlFatalErrMsgStr(ctxt, XML_ERR_UNDECLARED_ENTITY,
7334                      "Entity '%s' not defined\n", name);
7335         } else {
7336             xmlErrMsgStr(ctxt, XML_WAR_UNDECLARED_ENTITY,
7337                      "Entity '%s' not defined\n", name);
7338             if ((ctxt->inSubset == 0) &&
7339                 (ctxt->sax != NULL) &&
7340                 (ctxt->sax->reference != NULL)) {
7341                 ctxt->sax->reference(ctxt->userData, name);
7342             }
7343         }
7344         ctxt->valid = 0;
7345     }
7346
7347     /*
7348      * [ WFC: Parsed Entity ]
7349      * An entity reference must not contain the name of an
7350      * unparsed entity
7351      */
7352     else if (ent->etype == XML_EXTERNAL_GENERAL_UNPARSED_ENTITY) {
7353         xmlFatalErrMsgStr(ctxt, XML_ERR_UNPARSED_ENTITY,
7354                  "Entity reference to unparsed entity %s\n", name);
7355     }
7356
7357     /*
7358      * [ WFC: No External Entity References ]
7359      * Attribute values cannot contain direct or indirect
7360      * entity references to external entities.
7361      */
7362     else if ((ctxt->instate == XML_PARSER_ATTRIBUTE_VALUE) &&
7363              (ent->etype == XML_EXTERNAL_GENERAL_PARSED_ENTITY)) {
7364         xmlFatalErrMsgStr(ctxt, XML_ERR_ENTITY_IS_EXTERNAL,
7365              "Attribute references external entity '%s'\n", name);
7366     }
7367     /*
7368      * [ WFC: No < in Attribute Values ]
7369      * The replacement text of any entity referred to directly or
7370      * indirectly in an attribute value (other than "&lt;") must
7371      * not contain a <.
7372      */
7373     else if ((ctxt->instate == XML_PARSER_ATTRIBUTE_VALUE) &&
7374              (ent != NULL) && (ent->content != NULL) &&
7375              (ent->etype != XML_INTERNAL_PREDEFINED_ENTITY) &&
7376              (xmlStrchr(ent->content, '<'))) {
7377         xmlFatalErrMsgStr(ctxt, XML_ERR_LT_IN_ATTRIBUTE,
7378     "'<' in entity '%s' is not allowed in attributes values\n", name);
7379     }
7380
7381     /*
7382      * Internal check, no parameter entities here ...
7383      */
7384     else {
7385         switch (ent->etype) {
7386             case XML_INTERNAL_PARAMETER_ENTITY:
7387             case XML_EXTERNAL_PARAMETER_ENTITY:
7388             xmlFatalErrMsgStr(ctxt, XML_ERR_ENTITY_IS_PARAMETER,
7389              "Attempt to reference the parameter entity '%s'\n",
7390                               name);
7391             break;
7392             default:
7393             break;
7394         }
7395     }
7396
7397     /*
7398      * [ WFC: No Recursion ]
7399      * A parsed entity must not contain a recursive reference
7400      * to itself, either directly or indirectly.
7401      * Done somewhere else
7402      */
7403     return(ent);
7404 }
7405
7406 /**
7407  * xmlParseStringEntityRef:
7408  * @ctxt:  an XML parser context
7409  * @str:  a pointer to an index in the string
7410  *
7411  * parse ENTITY references declarations, but this version parses it from
7412  * a string value.
7413  *
7414  * [68] EntityRef ::= '&' Name ';'
7415  *
7416  * [ WFC: Entity Declared ]
7417  * In a document without any DTD, a document with only an internal DTD
7418  * subset which contains no parameter entity references, or a document
7419  * with "standalone='yes'", the Name given in the entity reference
7420  * must match that in an entity declaration, except that well-formed
7421  * documents need not declare any of the following entities: amp, lt,
7422  * gt, apos, quot.  The declaration of a parameter entity must precede
7423  * any reference to it.  Similarly, the declaration of a general entity
7424  * must precede any reference to it which appears in a default value in an
7425  * attribute-list declaration. Note that if entities are declared in the
7426  * external subset or in external parameter entities, a non-validating
7427  * processor is not obligated to read and process their declarations;
7428  * for such documents, the rule that an entity must be declared is a
7429  * well-formedness constraint only if standalone='yes'.
7430  *
7431  * [ WFC: Parsed Entity ]
7432  * An entity reference must not contain the name of an unparsed entity
7433  *
7434  * Returns the xmlEntityPtr if found, or NULL otherwise. The str pointer
7435  * is updated to the current location in the string.
7436  */
7437 static xmlEntityPtr
7438 xmlParseStringEntityRef(xmlParserCtxtPtr ctxt, const xmlChar ** str) {
7439     xmlChar *name;
7440     const xmlChar *ptr;
7441     xmlChar cur;
7442     xmlEntityPtr ent = NULL;
7443
7444     if ((str == NULL) || (*str == NULL))
7445         return(NULL);
7446     ptr = *str;
7447     cur = *ptr;
7448     if (cur != '&')
7449         return(NULL);
7450
7451     ptr++;
7452     name = xmlParseStringName(ctxt, &ptr);
7453     if (name == NULL) {
7454         xmlFatalErrMsg(ctxt, XML_ERR_NAME_REQUIRED,
7455                        "xmlParseStringEntityRef: no name\n");
7456         *str = ptr;
7457         return(NULL);
7458     }
7459     if (*ptr != ';') {
7460         xmlFatalErr(ctxt, XML_ERR_ENTITYREF_SEMICOL_MISSING, NULL);
7461         xmlFree(name);
7462         *str = ptr;
7463         return(NULL);
7464     }
7465     ptr++;
7466
7467
7468     /*
7469      * Predefined entites override any extra definition
7470      */
7471     if ((ctxt->options & XML_PARSE_OLDSAX) == 0) {
7472         ent = xmlGetPredefinedEntity(name);
7473         if (ent != NULL) {
7474             xmlFree(name);
7475             *str = ptr;
7476             return(ent);
7477         }
7478     }
7479
7480     /*
7481      * Increate the number of entity references parsed
7482      */
7483     ctxt->nbentities++;
7484
7485     /*
7486      * Ask first SAX for entity resolution, otherwise try the
7487      * entities which may have stored in the parser context.
7488      */
7489     if (ctxt->sax != NULL) {
7490         if (ctxt->sax->getEntity != NULL)
7491             ent = ctxt->sax->getEntity(ctxt->userData, name);
7492         if ((ent == NULL) && (ctxt->options & XML_PARSE_OLDSAX))
7493             ent = xmlGetPredefinedEntity(name);
7494         if ((ent == NULL) && (ctxt->userData==ctxt)) {
7495             ent = xmlSAX2GetEntity(ctxt, name);
7496         }
7497     }
7498
7499     /*
7500      * [ WFC: Entity Declared ]
7501      * In a document without any DTD, a document with only an
7502      * internal DTD subset which contains no parameter entity
7503      * references, or a document with "standalone='yes'", the
7504      * Name given in the entity reference must match that in an
7505      * entity declaration, except that well-formed documents
7506      * need not declare any of the following entities: amp, lt,
7507      * gt, apos, quot.
7508      * The declaration of a parameter entity must precede any
7509      * reference to it.
7510      * Similarly, the declaration of a general entity must
7511      * precede any reference to it which appears in a default
7512      * value in an attribute-list declaration. Note that if
7513      * entities are declared in the external subset or in
7514      * external parameter entities, a non-validating processor
7515      * is not obligated to read and process their declarations;
7516      * for such documents, the rule that an entity must be
7517      * declared is a well-formedness constraint only if
7518      * standalone='yes'.
7519      */
7520     if (ent == NULL) {
7521         if ((ctxt->standalone == 1) ||
7522             ((ctxt->hasExternalSubset == 0) &&
7523              (ctxt->hasPErefs == 0))) {
7524             xmlFatalErrMsgStr(ctxt, XML_ERR_UNDECLARED_ENTITY,
7525                      "Entity '%s' not defined\n", name);
7526         } else {
7527             xmlErrMsgStr(ctxt, XML_WAR_UNDECLARED_ENTITY,
7528                           "Entity '%s' not defined\n",
7529                           name);
7530         }
7531         /* TODO ? check regressions ctxt->valid = 0; */
7532     }
7533
7534     /*
7535      * [ WFC: Parsed Entity ]
7536      * An entity reference must not contain the name of an
7537      * unparsed entity
7538      */
7539     else if (ent->etype == XML_EXTERNAL_GENERAL_UNPARSED_ENTITY) {
7540         xmlFatalErrMsgStr(ctxt, XML_ERR_UNPARSED_ENTITY,
7541                  "Entity reference to unparsed entity %s\n", name);
7542     }
7543
7544     /*
7545      * [ WFC: No External Entity References ]
7546      * Attribute values cannot contain direct or indirect
7547      * entity references to external entities.
7548      */
7549     else if ((ctxt->instate == XML_PARSER_ATTRIBUTE_VALUE) &&
7550              (ent->etype == XML_EXTERNAL_GENERAL_PARSED_ENTITY)) {
7551         xmlFatalErrMsgStr(ctxt, XML_ERR_ENTITY_IS_EXTERNAL,
7552          "Attribute references external entity '%s'\n", name);
7553     }
7554     /*
7555      * [ WFC: No < in Attribute Values ]
7556      * The replacement text of any entity referred to directly or
7557      * indirectly in an attribute value (other than "&lt;") must
7558      * not contain a <.
7559      */
7560     else if ((ctxt->instate == XML_PARSER_ATTRIBUTE_VALUE) &&
7561              (ent != NULL) && (ent->content != NULL) &&
7562              (ent->etype != XML_INTERNAL_PREDEFINED_ENTITY) &&
7563              (xmlStrchr(ent->content, '<'))) {
7564         xmlFatalErrMsgStr(ctxt, XML_ERR_LT_IN_ATTRIBUTE,
7565      "'<' in entity '%s' is not allowed in attributes values\n",
7566                           name);
7567     }
7568
7569     /*
7570      * Internal check, no parameter entities here ...
7571      */
7572     else {
7573         switch (ent->etype) {
7574             case XML_INTERNAL_PARAMETER_ENTITY:
7575             case XML_EXTERNAL_PARAMETER_ENTITY:
7576                 xmlFatalErrMsgStr(ctxt, XML_ERR_ENTITY_IS_PARAMETER,
7577              "Attempt to reference the parameter entity '%s'\n",
7578                                   name);
7579             break;
7580             default:
7581             break;
7582         }
7583     }
7584
7585     /*
7586      * [ WFC: No Recursion ]
7587      * A parsed entity must not contain a recursive reference
7588      * to itself, either directly or indirectly.
7589      * Done somewhere else
7590      */
7591
7592     xmlFree(name);
7593     *str = ptr;
7594     return(ent);
7595 }
7596
7597 /**
7598  * xmlParsePEReference:
7599  * @ctxt:  an XML parser context
7600  *
7601  * parse PEReference declarations
7602  * The entity content is handled directly by pushing it's content as
7603  * a new input stream.
7604  *
7605  * [69] PEReference ::= '%' Name ';'
7606  *
7607  * [ WFC: No Recursion ]
7608  * A parsed entity must not contain a recursive
7609  * reference to itself, either directly or indirectly.
7610  *
7611  * [ WFC: Entity Declared ]
7612  * In a document without any DTD, a document with only an internal DTD
7613  * subset which contains no parameter entity references, or a document
7614  * with "standalone='yes'", ...  ... The declaration of a parameter
7615  * entity must precede any reference to it...
7616  *
7617  * [ VC: Entity Declared ]
7618  * In a document with an external subset or external parameter entities
7619  * with "standalone='no'", ...  ... The declaration of a parameter entity
7620  * must precede any reference to it...
7621  *
7622  * [ WFC: In DTD ]
7623  * Parameter-entity references may only appear in the DTD.
7624  * NOTE: misleading but this is handled.
7625  */
7626 void
7627 xmlParsePEReference(xmlParserCtxtPtr ctxt)
7628 {
7629     const xmlChar *name;
7630     xmlEntityPtr entity = NULL;
7631     xmlParserInputPtr input;
7632
7633     if (RAW != '%')
7634         return;
7635     NEXT;
7636     name = xmlParseName(ctxt);
7637     if (name == NULL) {
7638         xmlFatalErrMsg(ctxt, XML_ERR_NAME_REQUIRED,
7639                        "xmlParsePEReference: no name\n");
7640         return;
7641     }
7642     if (RAW != ';') {
7643         xmlFatalErr(ctxt, XML_ERR_ENTITYREF_SEMICOL_MISSING, NULL);
7644         return;
7645     }
7646
7647     NEXT;
7648
7649     /*
7650      * Increate the number of entity references parsed
7651      */
7652     ctxt->nbentities++;
7653
7654     /*
7655      * Request the entity from SAX
7656      */
7657     if ((ctxt->sax != NULL) &&
7658         (ctxt->sax->getParameterEntity != NULL))
7659         entity = ctxt->sax->getParameterEntity(ctxt->userData,
7660                                                name);
7661     if (entity == NULL) {
7662         /*
7663          * [ WFC: Entity Declared ]
7664          * In a document without any DTD, a document with only an
7665          * internal DTD subset which contains no parameter entity
7666          * references, or a document with "standalone='yes'", ...
7667          * ... The declaration of a parameter entity must precede
7668          * any reference to it...
7669          */
7670         if ((ctxt->standalone == 1) ||
7671             ((ctxt->hasExternalSubset == 0) &&
7672              (ctxt->hasPErefs == 0))) {
7673             xmlFatalErrMsgStr(ctxt, XML_ERR_UNDECLARED_ENTITY,
7674                               "PEReference: %%%s; not found\n",
7675                               name);
7676         } else {
7677             /*
7678              * [ VC: Entity Declared ]
7679              * In a document with an external subset or external
7680              * parameter entities with "standalone='no'", ...
7681              * ... The declaration of a parameter entity must
7682              * precede any reference to it...
7683              */
7684             xmlWarningMsg(ctxt, XML_WAR_UNDECLARED_ENTITY,
7685                           "PEReference: %%%s; not found\n",
7686                           name, NULL);
7687             ctxt->valid = 0;
7688         }
7689     } else {
7690         /*
7691          * Internal checking in case the entity quest barfed
7692          */
7693         if ((entity->etype != XML_INTERNAL_PARAMETER_ENTITY) &&
7694             (entity->etype != XML_EXTERNAL_PARAMETER_ENTITY)) {
7695             xmlWarningMsg(ctxt, XML_WAR_UNDECLARED_ENTITY,
7696                   "Internal: %%%s; is not a parameter entity\n",
7697                           name, NULL);
7698         } else if (ctxt->input->free != deallocblankswrapper) {
7699             input = xmlNewBlanksWrapperInputStream(ctxt, entity);
7700             if (xmlPushInput(ctxt, input) < 0)
7701                 return;
7702         } else {
7703             /*
7704              * TODO !!!
7705              * handle the extra spaces added before and after
7706              * c.f. http://www.w3.org/TR/REC-xml#as-PE
7707              */
7708             input = xmlNewEntityInputStream(ctxt, entity);
7709             if (xmlPushInput(ctxt, input) < 0)
7710                 return;
7711             if ((entity->etype == XML_EXTERNAL_PARAMETER_ENTITY) &&
7712                 (CMP5(CUR_PTR, '<', '?', 'x', 'm', 'l')) &&
7713                 (IS_BLANK_CH(NXT(5)))) {
7714                 xmlParseTextDecl(ctxt);
7715                 if (ctxt->errNo ==
7716                     XML_ERR_UNSUPPORTED_ENCODING) {
7717                     /*
7718                      * The XML REC instructs us to stop parsing
7719                      * right here
7720                      */
7721                     ctxt->instate = XML_PARSER_EOF;
7722                     return;
7723                 }
7724             }
7725         }
7726     }
7727     ctxt->hasPErefs = 1;
7728 }
7729
7730 /**
7731  * xmlLoadEntityContent:
7732  * @ctxt:  an XML parser context
7733  * @entity: an unloaded system entity
7734  *
7735  * Load the original content of the given system entity from the
7736  * ExternalID/SystemID given. This is to be used for Included in Literal
7737  * http://www.w3.org/TR/REC-xml/#inliteral processing of entities references
7738  *
7739  * Returns 0 in case of success and -1 in case of failure
7740  */
7741 static int
7742 xmlLoadEntityContent(xmlParserCtxtPtr ctxt, xmlEntityPtr entity) {
7743     xmlParserInputPtr input;
7744     xmlBufferPtr buf;
7745     int l, c;
7746     int count = 0;
7747
7748     if ((ctxt == NULL) || (entity == NULL) ||
7749         ((entity->etype != XML_EXTERNAL_PARAMETER_ENTITY) &&
7750          (entity->etype != XML_EXTERNAL_GENERAL_PARSED_ENTITY)) ||
7751         (entity->content != NULL)) {
7752         xmlFatalErr(ctxt, XML_ERR_INTERNAL_ERROR,
7753                     "xmlLoadEntityContent parameter error");
7754         return(-1);
7755     }
7756
7757     if (xmlParserDebugEntities)
7758         xmlGenericError(xmlGenericErrorContext,
7759                 "Reading %s entity content input\n", entity->name);
7760
7761     buf = xmlBufferCreate();
7762     if (buf == NULL) {
7763         xmlFatalErr(ctxt, XML_ERR_INTERNAL_ERROR,
7764                     "xmlLoadEntityContent parameter error");
7765         return(-1);
7766     }
7767
7768     input = xmlNewEntityInputStream(ctxt, entity);
7769     if (input == NULL) {
7770         xmlFatalErr(ctxt, XML_ERR_INTERNAL_ERROR,
7771                     "xmlLoadEntityContent input error");
7772         xmlBufferFree(buf);
7773         return(-1);
7774     }
7775
7776     /*
7777      * Push the entity as the current input, read char by char
7778      * saving to the buffer until the end of the entity or an error
7779      */
7780     if (xmlPushInput(ctxt, input) < 0) {
7781         xmlBufferFree(buf);
7782         return(-1);
7783     }
7784
7785     GROW;
7786     c = CUR_CHAR(l);
7787     while ((ctxt->input == input) && (ctxt->input->cur < ctxt->input->end) &&
7788            (IS_CHAR(c))) {
7789         xmlBufferAdd(buf, ctxt->input->cur, l);
7790         if (count++ > 100) {
7791             count = 0;
7792             GROW;
7793         }
7794         NEXTL(l);
7795         c = CUR_CHAR(l);
7796     }
7797
7798     if ((ctxt->input == input) && (ctxt->input->cur >= ctxt->input->end)) {
7799         xmlPopInput(ctxt);
7800     } else if (!IS_CHAR(c)) {
7801         xmlFatalErrMsgInt(ctxt, XML_ERR_INVALID_CHAR,
7802                           "xmlLoadEntityContent: invalid char value %d\n",
7803                           c);
7804         xmlBufferFree(buf);
7805         return(-1);
7806     }
7807     entity->content = buf->content;
7808     buf->content = NULL;
7809     xmlBufferFree(buf);
7810
7811     return(0);
7812 }
7813
7814 /**
7815  * xmlParseStringPEReference:
7816  * @ctxt:  an XML parser context
7817  * @str:  a pointer to an index in the string
7818  *
7819  * parse PEReference declarations
7820  *
7821  * [69] PEReference ::= '%' Name ';'
7822  *
7823  * [ WFC: No Recursion ]
7824  * A parsed entity must not contain a recursive
7825  * reference to itself, either directly or indirectly.
7826  *
7827  * [ WFC: Entity Declared ]
7828  * In a document without any DTD, a document with only an internal DTD
7829  * subset which contains no parameter entity references, or a document
7830  * with "standalone='yes'", ...  ... The declaration of a parameter
7831  * entity must precede any reference to it...
7832  *
7833  * [ VC: Entity Declared ]
7834  * In a document with an external subset or external parameter entities
7835  * with "standalone='no'", ...  ... The declaration of a parameter entity
7836  * must precede any reference to it...
7837  *
7838  * [ WFC: In DTD ]
7839  * Parameter-entity references may only appear in the DTD.
7840  * NOTE: misleading but this is handled.
7841  *
7842  * Returns the string of the entity content.
7843  *         str is updated to the current value of the index
7844  */
7845 static xmlEntityPtr
7846 xmlParseStringPEReference(xmlParserCtxtPtr ctxt, const xmlChar **str) {
7847     const xmlChar *ptr;
7848     xmlChar cur;
7849     xmlChar *name;
7850     xmlEntityPtr entity = NULL;
7851
7852     if ((str == NULL) || (*str == NULL)) return(NULL);
7853     ptr = *str;
7854     cur = *ptr;
7855     if (cur != '%')
7856         return(NULL);
7857     ptr++;
7858     name = xmlParseStringName(ctxt, &ptr);
7859     if (name == NULL) {
7860         xmlFatalErrMsg(ctxt, XML_ERR_NAME_REQUIRED,
7861                        "xmlParseStringPEReference: no name\n");
7862         *str = ptr;
7863         return(NULL);
7864     }
7865     cur = *ptr;
7866     if (cur != ';') {
7867         xmlFatalErr(ctxt, XML_ERR_ENTITYREF_SEMICOL_MISSING, NULL);
7868         xmlFree(name);
7869         *str = ptr;
7870         return(NULL);
7871     }
7872     ptr++;
7873
7874     /*
7875      * Increate the number of entity references parsed
7876      */
7877     ctxt->nbentities++;
7878
7879     /*
7880      * Request the entity from SAX
7881      */
7882     if ((ctxt->sax != NULL) &&
7883         (ctxt->sax->getParameterEntity != NULL))
7884         entity = ctxt->sax->getParameterEntity(ctxt->userData,
7885                                                name);
7886     if (entity == NULL) {
7887         /*
7888          * [ WFC: Entity Declared ]
7889          * In a document without any DTD, a document with only an
7890          * internal DTD subset which contains no parameter entity
7891          * references, or a document with "standalone='yes'", ...
7892          * ... The declaration of a parameter entity must precede
7893          * any reference to it...
7894          */
7895         if ((ctxt->standalone == 1) ||
7896             ((ctxt->hasExternalSubset == 0) && (ctxt->hasPErefs == 0))) {
7897             xmlFatalErrMsgStr(ctxt, XML_ERR_UNDECLARED_ENTITY,
7898                  "PEReference: %%%s; not found\n", name);
7899         } else {
7900             /*
7901              * [ VC: Entity Declared ]
7902              * In a document with an external subset or external
7903              * parameter entities with "standalone='no'", ...
7904              * ... The declaration of a parameter entity must
7905              * precede any reference to it...
7906              */
7907             xmlWarningMsg(ctxt, XML_WAR_UNDECLARED_ENTITY,
7908                           "PEReference: %%%s; not found\n",
7909                           name, NULL);
7910             ctxt->valid = 0;
7911         }
7912     } else {
7913         /*
7914          * Internal checking in case the entity quest barfed
7915          */
7916         if ((entity->etype != XML_INTERNAL_PARAMETER_ENTITY) &&
7917             (entity->etype != XML_EXTERNAL_PARAMETER_ENTITY)) {
7918             xmlWarningMsg(ctxt, XML_WAR_UNDECLARED_ENTITY,
7919                           "%%%s; is not a parameter entity\n",
7920                           name, NULL);
7921         }
7922     }
7923     ctxt->hasPErefs = 1;
7924     xmlFree(name);
7925     *str = ptr;
7926     return(entity);
7927 }
7928
7929 /**
7930  * xmlParseDocTypeDecl:
7931  * @ctxt:  an XML parser context
7932  *
7933  * parse a DOCTYPE declaration
7934  *
7935  * [28] doctypedecl ::= '<!DOCTYPE' S Name (S ExternalID)? S?
7936  *                      ('[' (markupdecl | PEReference | S)* ']' S?)? '>'
7937  *
7938  * [ VC: Root Element Type ]
7939  * The Name in the document type declaration must match the element
7940  * type of the root element.
7941  */
7942
7943 void
7944 xmlParseDocTypeDecl(xmlParserCtxtPtr ctxt) {
7945     const xmlChar *name = NULL;
7946     xmlChar *ExternalID = NULL;
7947     xmlChar *URI = NULL;
7948
7949     /*
7950      * We know that '<!DOCTYPE' has been detected.
7951      */
7952     SKIP(9);
7953
7954     SKIP_BLANKS;
7955
7956     /*
7957      * Parse the DOCTYPE name.
7958      */
7959     name = xmlParseName(ctxt);
7960     if (name == NULL) {
7961         xmlFatalErrMsg(ctxt, XML_ERR_NAME_REQUIRED,
7962                        "xmlParseDocTypeDecl : no DOCTYPE name !\n");
7963     }
7964     ctxt->intSubName = name;
7965
7966     SKIP_BLANKS;
7967
7968     /*
7969      * Check for SystemID and ExternalID
7970      */
7971     URI = xmlParseExternalID(ctxt, &ExternalID, 1);
7972
7973     if ((URI != NULL) || (ExternalID != NULL)) {
7974         ctxt->hasExternalSubset = 1;
7975     }
7976     ctxt->extSubURI = URI;
7977     ctxt->extSubSystem = ExternalID;
7978
7979     SKIP_BLANKS;
7980
7981     /*
7982      * Create and update the internal subset.
7983      */
7984     if ((ctxt->sax != NULL) && (ctxt->sax->internalSubset != NULL) &&
7985         (!ctxt->disableSAX))
7986         ctxt->sax->internalSubset(ctxt->userData, name, ExternalID, URI);
7987
7988     /*
7989      * Is there any internal subset declarations ?
7990      * they are handled separately in xmlParseInternalSubset()
7991      */
7992     if (RAW == '[')
7993         return;
7994
7995     /*
7996      * We should be at the end of the DOCTYPE declaration.
7997      */
7998     if (RAW != '>') {
7999         xmlFatalErr(ctxt, XML_ERR_DOCTYPE_NOT_FINISHED, NULL);
8000     }
8001     NEXT;
8002 }
8003
8004 /**
8005  * xmlParseInternalSubset:
8006  * @ctxt:  an XML parser context
8007  *
8008  * parse the internal subset declaration
8009  *
8010  * [28 end] ('[' (markupdecl | PEReference | S)* ']' S?)? '>'
8011  */
8012
8013 static void
8014 xmlParseInternalSubset(xmlParserCtxtPtr ctxt) {
8015     /*
8016      * Is there any DTD definition ?
8017      */
8018     if (RAW == '[') {
8019         ctxt->instate = XML_PARSER_DTD;
8020         NEXT;
8021         /*
8022          * Parse the succession of Markup declarations and
8023          * PEReferences.
8024          * Subsequence (markupdecl | PEReference | S)*
8025          */
8026         while (RAW != ']') {
8027             const xmlChar *check = CUR_PTR;
8028             unsigned int cons = ctxt->input->consumed;
8029
8030             SKIP_BLANKS;
8031             xmlParseMarkupDecl(ctxt);
8032             xmlParsePEReference(ctxt);
8033
8034             /*
8035              * Pop-up of finished entities.
8036              */
8037             while ((RAW == 0) && (ctxt->inputNr > 1))
8038                 xmlPopInput(ctxt);
8039
8040             if ((CUR_PTR == check) && (cons == ctxt->input->consumed)) {
8041                 xmlFatalErr(ctxt, XML_ERR_INTERNAL_ERROR,
8042              "xmlParseInternalSubset: error detected in Markup declaration\n");
8043                 break;
8044             }
8045         }
8046         if (RAW == ']') {
8047             NEXT;
8048             SKIP_BLANKS;
8049         }
8050     }
8051
8052     /*
8053      * We should be at the end of the DOCTYPE declaration.
8054      */
8055     if (RAW != '>') {
8056         xmlFatalErr(ctxt, XML_ERR_DOCTYPE_NOT_FINISHED, NULL);
8057     }
8058     NEXT;
8059 }
8060
8061 #ifdef LIBXML_SAX1_ENABLED
8062 /**
8063  * xmlParseAttribute:
8064  * @ctxt:  an XML parser context
8065  * @value:  a xmlChar ** used to store the value of the attribute
8066  *
8067  * parse an attribute
8068  *
8069  * [41] Attribute ::= Name Eq AttValue
8070  *
8071  * [ WFC: No External Entity References ]
8072  * Attribute values cannot contain direct or indirect entity references
8073  * to external entities.
8074  *
8075  * [ WFC: No < in Attribute Values ]
8076  * The replacement text of any entity referred to directly or indirectly in
8077  * an attribute value (other than "&lt;") must not contain a <.
8078  *
8079  * [ VC: Attribute Value Type ]
8080  * The attribute must have been declared; the value must be of the type
8081  * declared for it.
8082  *
8083  * [25] Eq ::= S? '=' S?
8084  *
8085  * With namespace:
8086  *
8087  * [NS 11] Attribute ::= QName Eq AttValue
8088  *
8089  * Also the case QName == xmlns:??? is handled independently as a namespace
8090  * definition.
8091  *
8092  * Returns the attribute name, and the value in *value.
8093  */
8094
8095 const xmlChar *
8096 xmlParseAttribute(xmlParserCtxtPtr ctxt, xmlChar **value) {
8097     const xmlChar *name;
8098     xmlChar *val;
8099
8100     *value = NULL;
8101     GROW;
8102     name = xmlParseName(ctxt);
8103     if (name == NULL) {
8104         xmlFatalErrMsg(ctxt, XML_ERR_NAME_REQUIRED,
8105                        "error parsing attribute name\n");
8106         return(NULL);
8107     }
8108
8109     /*
8110      * read the value
8111      */
8112     SKIP_BLANKS;
8113     if (RAW == '=') {
8114         NEXT;
8115         SKIP_BLANKS;
8116         val = xmlParseAttValue(ctxt);
8117         ctxt->instate = XML_PARSER_CONTENT;
8118     } else {
8119         xmlFatalErrMsgStr(ctxt, XML_ERR_ATTRIBUTE_WITHOUT_VALUE,
8120                "Specification mandate value for attribute %s\n", name);
8121         return(NULL);
8122     }
8123
8124     /*
8125      * Check that xml:lang conforms to the specification
8126      * No more registered as an error, just generate a warning now
8127      * since this was deprecated in XML second edition
8128      */
8129     if ((ctxt->pedantic) && (xmlStrEqual(name, BAD_CAST "xml:lang"))) {
8130         if (!xmlCheckLanguageID(val)) {
8131             xmlWarningMsg(ctxt, XML_WAR_LANG_VALUE,
8132                           "Malformed value for xml:lang : %s\n",
8133                           val, NULL);
8134         }
8135     }
8136
8137     /*
8138      * Check that xml:space conforms to the specification
8139      */
8140     if (xmlStrEqual(name, BAD_CAST "xml:space")) {
8141         if (xmlStrEqual(val, BAD_CAST "default"))
8142             *(ctxt->space) = 0;
8143         else if (xmlStrEqual(val, BAD_CAST "preserve"))
8144             *(ctxt->space) = 1;
8145         else {
8146                 xmlWarningMsg(ctxt, XML_WAR_SPACE_VALUE,
8147 "Invalid value \"%s\" for xml:space : \"default\" or \"preserve\" expected\n",
8148                                  val, NULL);
8149         }
8150     }
8151
8152     *value = val;
8153     return(name);
8154 }
8155
8156 /**
8157  * xmlParseStartTag:
8158  * @ctxt:  an XML parser context
8159  *
8160  * parse a start of tag either for rule element or
8161  * EmptyElement. In both case we don't parse the tag closing chars.
8162  *
8163  * [40] STag ::= '<' Name (S Attribute)* S? '>'
8164  *
8165  * [ WFC: Unique Att Spec ]
8166  * No attribute name may appear more than once in the same start-tag or
8167  * empty-element tag.
8168  *
8169  * [44] EmptyElemTag ::= '<' Name (S Attribute)* S? '/>'
8170  *
8171  * [ WFC: Unique Att Spec ]
8172  * No attribute name may appear more than once in the same start-tag or
8173  * empty-element tag.
8174  *
8175  * With namespace:
8176  *
8177  * [NS 8] STag ::= '<' QName (S Attribute)* S? '>'
8178  *
8179  * [NS 10] EmptyElement ::= '<' QName (S Attribute)* S? '/>'
8180  *
8181  * Returns the element name parsed
8182  */
8183
8184 const xmlChar *
8185 xmlParseStartTag(xmlParserCtxtPtr ctxt) {
8186     const xmlChar *name;
8187     const xmlChar *attname;
8188     xmlChar *attvalue;
8189     const xmlChar **atts = ctxt->atts;
8190     int nbatts = 0;
8191     int maxatts = ctxt->maxatts;
8192     int i;
8193
8194     if (RAW != '<') return(NULL);
8195     NEXT1;
8196
8197     name = xmlParseName(ctxt);
8198     if (name == NULL) {
8199         xmlFatalErrMsg(ctxt, XML_ERR_NAME_REQUIRED,
8200              "xmlParseStartTag: invalid element name\n");
8201         return(NULL);
8202     }
8203
8204     /*
8205      * Now parse the attributes, it ends up with the ending
8206      *
8207      * (S Attribute)* S?
8208      */
8209     SKIP_BLANKS;
8210     GROW;
8211
8212     while ((RAW != '>') &&
8213            ((RAW != '/') || (NXT(1) != '>')) &&
8214            (IS_BYTE_CHAR(RAW))) {
8215         const xmlChar *q = CUR_PTR;
8216         unsigned int cons = ctxt->input->consumed;
8217
8218         attname = xmlParseAttribute(ctxt, &attvalue);
8219         if ((attname != NULL) && (attvalue != NULL)) {
8220             /*
8221              * [ WFC: Unique Att Spec ]
8222              * No attribute name may appear more than once in the same
8223              * start-tag or empty-element tag.
8224              */
8225             for (i = 0; i < nbatts;i += 2) {
8226                 if (xmlStrEqual(atts[i], attname)) {
8227                     xmlErrAttributeDup(ctxt, NULL, attname);
8228                     xmlFree(attvalue);
8229                     goto failed;
8230                 }
8231             }
8232             /*
8233              * Add the pair to atts
8234              */
8235             if (atts == NULL) {
8236                 maxatts = 22; /* allow for 10 attrs by default */
8237                 atts = (const xmlChar **)
8238                        xmlMalloc(maxatts * sizeof(xmlChar *));
8239                 if (atts == NULL) {
8240                     xmlErrMemory(ctxt, NULL);
8241                     if (attvalue != NULL)
8242                         xmlFree(attvalue);
8243                     goto failed;
8244                 }
8245                 ctxt->atts = atts;
8246                 ctxt->maxatts = maxatts;
8247             } else if (nbatts + 4 > maxatts) {
8248                 const xmlChar **n;
8249
8250                 maxatts *= 2;
8251                 n = (const xmlChar **) xmlRealloc((void *) atts,
8252                                              maxatts * sizeof(const xmlChar *));
8253                 if (n == NULL) {
8254                     xmlErrMemory(ctxt, NULL);
8255                     if (attvalue != NULL)
8256                         xmlFree(attvalue);
8257                     goto failed;
8258                 }
8259                 atts = n;
8260                 ctxt->atts = atts;
8261                 ctxt->maxatts = maxatts;
8262             }
8263             atts[nbatts++] = attname;
8264             atts[nbatts++] = attvalue;
8265             atts[nbatts] = NULL;
8266             atts[nbatts + 1] = NULL;
8267         } else {
8268             if (attvalue != NULL)
8269                 xmlFree(attvalue);
8270         }
8271
8272 failed:
8273
8274         GROW
8275         if ((RAW == '>') || (((RAW == '/') && (NXT(1) == '>'))))
8276             break;
8277         if (!IS_BLANK_CH(RAW)) {
8278             xmlFatalErrMsg(ctxt, XML_ERR_SPACE_REQUIRED,
8279                            "attributes construct error\n");
8280         }
8281         SKIP_BLANKS;
8282         if ((cons == ctxt->input->consumed) && (q == CUR_PTR) &&
8283             (attname == NULL) && (attvalue == NULL)) {
8284             xmlFatalErrMsg(ctxt, XML_ERR_INTERNAL_ERROR,
8285                            "xmlParseStartTag: problem parsing attributes\n");
8286             break;
8287         }
8288         SHRINK;
8289         GROW;
8290     }
8291
8292     /*
8293      * SAX: Start of Element !
8294      */
8295     if ((ctxt->sax != NULL) && (ctxt->sax->startElement != NULL) &&
8296         (!ctxt->disableSAX)) {
8297         if (nbatts > 0)
8298             ctxt->sax->startElement(ctxt->userData, name, atts);
8299         else
8300             ctxt->sax->startElement(ctxt->userData, name, NULL);
8301     }
8302
8303     if (atts != NULL) {
8304         /* Free only the content strings */
8305         for (i = 1;i < nbatts;i+=2)
8306             if (atts[i] != NULL)
8307                xmlFree((xmlChar *) atts[i]);
8308     }
8309     return(name);
8310 }
8311
8312 /**
8313  * xmlParseEndTag1:
8314  * @ctxt:  an XML parser context
8315  * @line:  line of the start tag
8316  * @nsNr:  number of namespaces on the start tag
8317  *
8318  * parse an end of tag
8319  *
8320  * [42] ETag ::= '</' Name S? '>'
8321  *
8322  * With namespace
8323  *
8324  * [NS 9] ETag ::= '</' QName S? '>'
8325  */
8326
8327 static void
8328 xmlParseEndTag1(xmlParserCtxtPtr ctxt, int line) {
8329     const xmlChar *name;
8330
8331     GROW;
8332     if ((RAW != '<') || (NXT(1) != '/')) {
8333         xmlFatalErrMsg(ctxt, XML_ERR_LTSLASH_REQUIRED,
8334                        "xmlParseEndTag: '</' not found\n");
8335         return;
8336     }
8337     SKIP(2);
8338
8339     name = xmlParseNameAndCompare(ctxt,ctxt->name);
8340
8341     /*
8342      * We should definitely be at the ending "S? '>'" part
8343      */
8344     GROW;
8345     SKIP_BLANKS;
8346     if ((!IS_BYTE_CHAR(RAW)) || (RAW != '>')) {
8347         xmlFatalErr(ctxt, XML_ERR_GT_REQUIRED, NULL);
8348     } else
8349         NEXT1;
8350
8351     /*
8352      * [ WFC: Element Type Match ]
8353      * The Name in an element's end-tag must match the element type in the
8354      * start-tag.
8355      *
8356      */
8357     if (name != (xmlChar*)1) {
8358         if (name == NULL) name = BAD_CAST "unparseable";
8359         xmlFatalErrMsgStrIntStr(ctxt, XML_ERR_TAG_NAME_MISMATCH,
8360                      "Opening and ending tag mismatch: %s line %d and %s\n",
8361                                 ctxt->name, line, name);
8362     }
8363
8364     /*
8365      * SAX: End of Tag
8366      */
8367     if ((ctxt->sax != NULL) && (ctxt->sax->endElement != NULL) &&
8368         (!ctxt->disableSAX))
8369         ctxt->sax->endElement(ctxt->userData, ctxt->name);
8370
8371     namePop(ctxt);
8372     spacePop(ctxt);
8373     return;
8374 }
8375
8376 /**
8377  * xmlParseEndTag:
8378  * @ctxt:  an XML parser context
8379  *
8380  * parse an end of tag
8381  *
8382  * [42] ETag ::= '</' Name S? '>'
8383  *
8384  * With namespace
8385  *
8386  * [NS 9] ETag ::= '</' QName S? '>'
8387  */
8388
8389 void
8390 xmlParseEndTag(xmlParserCtxtPtr ctxt) {
8391     xmlParseEndTag1(ctxt, 0);
8392 }
8393 #endif /* LIBXML_SAX1_ENABLED */
8394
8395 /************************************************************************
8396  *                                                                      *
8397  *                    SAX 2 specific operations                         *
8398  *                                                                      *
8399  ************************************************************************/
8400
8401 /*
8402  * xmlGetNamespace:
8403  * @ctxt:  an XML parser context
8404  * @prefix:  the prefix to lookup
8405  *
8406  * Lookup the namespace name for the @prefix (which ca be NULL)
8407  * The prefix must come from the @ctxt->dict dictionnary
8408  *
8409  * Returns the namespace name or NULL if not bound
8410  */
8411 static const xmlChar *
8412 xmlGetNamespace(xmlParserCtxtPtr ctxt, const xmlChar *prefix) {
8413     int i;
8414
8415     if (prefix == ctxt->str_xml) return(ctxt->str_xml_ns);
8416     for (i = ctxt->nsNr - 2;i >= 0;i-=2)
8417         if (ctxt->nsTab[i] == prefix) {
8418             if ((prefix == NULL) && (*ctxt->nsTab[i + 1] == 0))
8419                 return(NULL);
8420             return(ctxt->nsTab[i + 1]);
8421         }
8422     return(NULL);
8423 }
8424
8425 /**
8426  * xmlParseQName:
8427  * @ctxt:  an XML parser context
8428  * @prefix:  pointer to store the prefix part
8429  *
8430  * parse an XML Namespace QName
8431  *
8432  * [6]  QName  ::= (Prefix ':')? LocalPart
8433  * [7]  Prefix  ::= NCName
8434  * [8]  LocalPart  ::= NCName
8435  *
8436  * Returns the Name parsed or NULL
8437  */
8438
8439 static const xmlChar *
8440 xmlParseQName(xmlParserCtxtPtr ctxt, const xmlChar **prefix) {
8441     const xmlChar *l, *p;
8442
8443     GROW;
8444
8445     l = xmlParseNCName(ctxt);
8446     if (l == NULL) {
8447         if (CUR == ':') {
8448             l = xmlParseName(ctxt);
8449             if (l != NULL) {
8450                 xmlNsErr(ctxt, XML_NS_ERR_QNAME,
8451                          "Failed to parse QName '%s'\n", l, NULL, NULL);
8452                 *prefix = NULL;
8453                 return(l);
8454             }
8455         }
8456         return(NULL);
8457     }
8458     if (CUR == ':') {
8459         NEXT;
8460         p = l;
8461         l = xmlParseNCName(ctxt);
8462         if (l == NULL) {
8463             xmlChar *tmp;
8464
8465             xmlNsErr(ctxt, XML_NS_ERR_QNAME,
8466                      "Failed to parse QName '%s:'\n", p, NULL, NULL);
8467             l = xmlParseNmtoken(ctxt);
8468             if (l == NULL)
8469                 tmp = xmlBuildQName(BAD_CAST "", p, NULL, 0);
8470             else {
8471                 tmp = xmlBuildQName(l, p, NULL, 0);
8472                 xmlFree((char *)l);
8473             }
8474             p = xmlDictLookup(ctxt->dict, tmp, -1);
8475             if (tmp != NULL) xmlFree(tmp);
8476             *prefix = NULL;
8477             return(p);
8478         }
8479         if (CUR == ':') {
8480             xmlChar *tmp;
8481
8482             xmlNsErr(ctxt, XML_NS_ERR_QNAME,
8483                      "Failed to parse QName '%s:%s:'\n", p, l, NULL);
8484             NEXT;
8485             tmp = (xmlChar *) xmlParseName(ctxt);
8486             if (tmp != NULL) {
8487                 tmp = xmlBuildQName(tmp, l, NULL, 0);
8488                 l = xmlDictLookup(ctxt->dict, tmp, -1);
8489                 if (tmp != NULL) xmlFree(tmp);
8490                 *prefix = p;
8491                 return(l);
8492             }
8493             tmp = xmlBuildQName(BAD_CAST "", l, NULL, 0);
8494             l = xmlDictLookup(ctxt->dict, tmp, -1);
8495             if (tmp != NULL) xmlFree(tmp);
8496             *prefix = p;
8497             return(l);
8498         }
8499         *prefix = p;
8500     } else
8501         *prefix = NULL;
8502     return(l);
8503 }
8504
8505 /**
8506  * xmlParseQNameAndCompare:
8507  * @ctxt:  an XML parser context
8508  * @name:  the localname
8509  * @prefix:  the prefix, if any.
8510  *
8511  * parse an XML name and compares for match
8512  * (specialized for endtag parsing)
8513  *
8514  * Returns NULL for an illegal name, (xmlChar*) 1 for success
8515  * and the name for mismatch
8516  */
8517
8518 static const xmlChar *
8519 xmlParseQNameAndCompare(xmlParserCtxtPtr ctxt, xmlChar const *name,
8520                         xmlChar const *prefix) {
8521     const xmlChar *cmp;
8522     const xmlChar *in;
8523     const xmlChar *ret;
8524     const xmlChar *prefix2;
8525
8526     if (prefix == NULL) return(xmlParseNameAndCompare(ctxt, name));
8527
8528     GROW;
8529     in = ctxt->input->cur;
8530
8531     cmp = prefix;
8532     while (*in != 0 && *in == *cmp) {
8533         ++in;
8534         ++cmp;
8535     }
8536     if ((*cmp == 0) && (*in == ':')) {
8537         in++;
8538         cmp = name;
8539         while (*in != 0 && *in == *cmp) {
8540             ++in;
8541             ++cmp;
8542         }
8543         if (*cmp == 0 && (*in == '>' || IS_BLANK_CH (*in))) {
8544             /* success */
8545             ctxt->input->cur = in;
8546             return((const xmlChar*) 1);
8547         }
8548     }
8549     /*
8550      * all strings coms from the dictionary, equality can be done directly
8551      */
8552     ret = xmlParseQName (ctxt, &prefix2);
8553     if ((ret == name) && (prefix == prefix2))
8554         return((const xmlChar*) 1);
8555     return ret;
8556 }
8557
8558 /**
8559  * xmlParseAttValueInternal:
8560  * @ctxt:  an XML parser context
8561  * @len:  attribute len result
8562  * @alloc:  whether the attribute was reallocated as a new string
8563  * @normalize:  if 1 then further non-CDATA normalization must be done
8564  *
8565  * parse a value for an attribute.
8566  * NOTE: if no normalization is needed, the routine will return pointers
8567  *       directly from the data buffer.
8568  *
8569  * 3.3.3 Attribute-Value Normalization:
8570  * Before the value of an attribute is passed to the application or
8571  * checked for validity, the XML processor must normalize it as follows:
8572  * - a character reference is processed by appending the referenced
8573  *   character to the attribute value
8574  * - an entity reference is processed by recursively processing the
8575  *   replacement text of the entity
8576  * - a whitespace character (#x20, #xD, #xA, #x9) is processed by
8577  *   appending #x20 to the normalized value, except that only a single
8578  *   #x20 is appended for a "#xD#xA" sequence that is part of an external
8579  *   parsed entity or the literal entity value of an internal parsed entity
8580  * - other characters are processed by appending them to the normalized value
8581  * If the declared value is not CDATA, then the XML processor must further
8582  * process the normalized attribute value by discarding any leading and
8583  * trailing space (#x20) characters, and by replacing sequences of space
8584  * (#x20) characters by a single space (#x20) character.
8585  * All attributes for which no declaration has been read should be treated
8586  * by a non-validating parser as if declared CDATA.
8587  *
8588  * Returns the AttValue parsed or NULL. The value has to be freed by the
8589  *     caller if it was copied, this can be detected by val[*len] == 0.
8590  */
8591
8592 static xmlChar *
8593 xmlParseAttValueInternal(xmlParserCtxtPtr ctxt, int *len, int *alloc,
8594                          int normalize)
8595 {
8596     xmlChar limit = 0;
8597     const xmlChar *in = NULL, *start, *end, *last;
8598     xmlChar *ret = NULL;
8599
8600     GROW;
8601     in = (xmlChar *) CUR_PTR;
8602     if (*in != '"' && *in != '\'') {
8603         xmlFatalErr(ctxt, XML_ERR_ATTRIBUTE_NOT_STARTED, NULL);
8604         return (NULL);
8605     }
8606     ctxt->instate = XML_PARSER_ATTRIBUTE_VALUE;
8607
8608     /*
8609      * try to handle in this routine the most common case where no
8610      * allocation of a new string is required and where content is
8611      * pure ASCII.
8612      */
8613     limit = *in++;
8614     end = ctxt->input->end;
8615     start = in;
8616     if (in >= end) {
8617         const xmlChar *oldbase = ctxt->input->base;
8618         GROW;
8619         if (oldbase != ctxt->input->base) {
8620             long delta = ctxt->input->base - oldbase;
8621             start = start + delta;
8622             in = in + delta;
8623         }
8624         end = ctxt->input->end;
8625     }
8626     if (normalize) {
8627         /*
8628          * Skip any leading spaces
8629          */
8630         while ((in < end) && (*in != limit) &&
8631                ((*in == 0x20) || (*in == 0x9) ||
8632                 (*in == 0xA) || (*in == 0xD))) {
8633             in++;
8634             start = in;
8635             if (in >= end) {
8636                 const xmlChar *oldbase = ctxt->input->base;
8637                 GROW;
8638                 if (oldbase != ctxt->input->base) {
8639                     long delta = ctxt->input->base - oldbase;
8640                     start = start + delta;
8641                     in = in + delta;
8642                 }
8643                 end = ctxt->input->end;
8644             }
8645         }
8646         while ((in < end) && (*in != limit) && (*in >= 0x20) &&
8647                (*in <= 0x7f) && (*in != '&') && (*in != '<')) {
8648             if ((*in++ == 0x20) && (*in == 0x20)) break;
8649             if (in >= end) {
8650                 const xmlChar *oldbase = ctxt->input->base;
8651                 GROW;
8652                 if (oldbase != ctxt->input->base) {
8653                     long delta = ctxt->input->base - oldbase;
8654                     start = start + delta;
8655                     in = in + delta;
8656                 }
8657                 end = ctxt->input->end;
8658             }
8659         }
8660         last = in;
8661         /*
8662          * skip the trailing blanks
8663          */
8664         while ((last[-1] == 0x20) && (last > start)) last--;
8665         while ((in < end) && (*in != limit) &&
8666                ((*in == 0x20) || (*in == 0x9) ||
8667                 (*in == 0xA) || (*in == 0xD))) {
8668             in++;
8669             if (in >= end) {
8670                 const xmlChar *oldbase = ctxt->input->base;
8671                 GROW;
8672                 if (oldbase != ctxt->input->base) {
8673                     long delta = ctxt->input->base - oldbase;
8674                     start = start + delta;
8675                     in = in + delta;
8676                     last = last + delta;
8677                 }
8678                 end = ctxt->input->end;
8679             }
8680         }
8681         if (*in != limit) goto need_complex;
8682     } else {
8683         while ((in < end) && (*in != limit) && (*in >= 0x20) &&
8684                (*in <= 0x7f) && (*in != '&') && (*in != '<')) {
8685             in++;
8686             if (in >= end) {
8687                 const xmlChar *oldbase = ctxt->input->base;
8688                 GROW;
8689                 if (oldbase != ctxt->input->base) {
8690                     long delta = ctxt->input->base - oldbase;
8691                     start = start + delta;
8692                     in = in + delta;
8693                 }
8694                 end = ctxt->input->end;
8695             }
8696         }
8697         last = in;
8698         if (*in != limit) goto need_complex;
8699     }
8700     in++;
8701     if (len != NULL) {
8702         *len = last - start;
8703         ret = (xmlChar *) start;
8704     } else {
8705         if (alloc) *alloc = 1;
8706         ret = xmlStrndup(start, last - start);
8707     }
8708     CUR_PTR = in;
8709     if (alloc) *alloc = 0;
8710     return ret;
8711 need_complex:
8712     if (alloc) *alloc = 1;
8713     return xmlParseAttValueComplex(ctxt, len, normalize);
8714 }
8715
8716 /**
8717  * xmlParseAttribute2:
8718  * @ctxt:  an XML parser context
8719  * @pref:  the element prefix
8720  * @elem:  the element name
8721  * @prefix:  a xmlChar ** used to store the value of the attribute prefix
8722  * @value:  a xmlChar ** used to store the value of the attribute
8723  * @len:  an int * to save the length of the attribute
8724  * @alloc:  an int * to indicate if the attribute was allocated
8725  *
8726  * parse an attribute in the new SAX2 framework.
8727  *
8728  * Returns the attribute name, and the value in *value, .
8729  */
8730
8731 static const xmlChar *
8732 xmlParseAttribute2(xmlParserCtxtPtr ctxt,
8733                    const xmlChar * pref, const xmlChar * elem,
8734                    const xmlChar ** prefix, xmlChar ** value,
8735                    int *len, int *alloc)
8736 {
8737     const xmlChar *name;
8738     xmlChar *val, *internal_val = NULL;
8739     int normalize = 0;
8740
8741     *value = NULL;
8742     GROW;
8743     name = xmlParseQName(ctxt, prefix);
8744     if (name == NULL) {
8745         xmlFatalErrMsg(ctxt, XML_ERR_NAME_REQUIRED,
8746                        "error parsing attribute name\n");
8747         return (NULL);
8748     }
8749
8750     /*
8751      * get the type if needed
8752      */
8753     if (ctxt->attsSpecial != NULL) {
8754         int type;
8755
8756         type = (int) (long) xmlHashQLookup2(ctxt->attsSpecial,
8757                                             pref, elem, *prefix, name);
8758         if (type != 0)
8759             normalize = 1;
8760     }
8761
8762     /*
8763      * read the value
8764      */
8765     SKIP_BLANKS;
8766     if (RAW == '=') {
8767         NEXT;
8768         SKIP_BLANKS;
8769         val = xmlParseAttValueInternal(ctxt, len, alloc, normalize);
8770         if (normalize) {
8771             /*
8772              * Sometimes a second normalisation pass for spaces is needed
8773              * but that only happens if charrefs or entities refernces
8774              * have been used in the attribute value, i.e. the attribute
8775              * value have been extracted in an allocated string already.
8776              */
8777             if (*alloc) {
8778                 const xmlChar *val2;
8779
8780                 val2 = xmlAttrNormalizeSpace2(ctxt, val, len);
8781                 if ((val2 != NULL) && (val2 != val)) {
8782                     xmlFree(val);
8783                     val = (xmlChar *) val2;
8784                 }
8785             }
8786         }
8787         ctxt->instate = XML_PARSER_CONTENT;
8788     } else {
8789         xmlFatalErrMsgStr(ctxt, XML_ERR_ATTRIBUTE_WITHOUT_VALUE,
8790                           "Specification mandate value for attribute %s\n",
8791                           name);
8792         return (NULL);
8793     }
8794
8795     if (*prefix == ctxt->str_xml) {
8796         /*
8797          * Check that xml:lang conforms to the specification
8798          * No more registered as an error, just generate a warning now
8799          * since this was deprecated in XML second edition
8800          */
8801         if ((ctxt->pedantic) && (xmlStrEqual(name, BAD_CAST "lang"))) {
8802             internal_val = xmlStrndup(val, *len);
8803             if (!xmlCheckLanguageID(internal_val)) {
8804                 xmlWarningMsg(ctxt, XML_WAR_LANG_VALUE,
8805                               "Malformed value for xml:lang : %s\n",
8806                               internal_val, NULL);
8807             }
8808         }
8809
8810         /*
8811          * Check that xml:space conforms to the specification
8812          */
8813         if (xmlStrEqual(name, BAD_CAST "space")) {
8814             internal_val = xmlStrndup(val, *len);
8815             if (xmlStrEqual(internal_val, BAD_CAST "default"))
8816                 *(ctxt->space) = 0;
8817             else if (xmlStrEqual(internal_val, BAD_CAST "preserve"))
8818                 *(ctxt->space) = 1;
8819             else {
8820                 xmlWarningMsg(ctxt, XML_WAR_SPACE_VALUE,
8821                               "Invalid value \"%s\" for xml:space : \"default\" or \"preserve\" expected\n",
8822                               internal_val, NULL);
8823             }
8824         }
8825         if (internal_val) {
8826             xmlFree(internal_val);
8827         }
8828     }
8829
8830     *value = val;
8831     return (name);
8832 }
8833 /**
8834  * xmlParseStartTag2:
8835  * @ctxt:  an XML parser context
8836  *
8837  * parse a start of tag either for rule element or
8838  * EmptyElement. In both case we don't parse the tag closing chars.
8839  * This routine is called when running SAX2 parsing
8840  *
8841  * [40] STag ::= '<' Name (S Attribute)* S? '>'
8842  *
8843  * [ WFC: Unique Att Spec ]
8844  * No attribute name may appear more than once in the same start-tag or
8845  * empty-element tag.
8846  *
8847  * [44] EmptyElemTag ::= '<' Name (S Attribute)* S? '/>'
8848  *
8849  * [ WFC: Unique Att Spec ]
8850  * No attribute name may appear more than once in the same start-tag or
8851  * empty-element tag.
8852  *
8853  * With namespace:
8854  *
8855  * [NS 8] STag ::= '<' QName (S Attribute)* S? '>'
8856  *
8857  * [NS 10] EmptyElement ::= '<' QName (S Attribute)* S? '/>'
8858  *
8859  * Returns the element name parsed
8860  */
8861
8862 static const xmlChar *
8863 xmlParseStartTag2(xmlParserCtxtPtr ctxt, const xmlChar **pref,
8864                   const xmlChar **URI, int *tlen) {
8865     const xmlChar *localname;
8866     const xmlChar *prefix;
8867     const xmlChar *attname;
8868     const xmlChar *aprefix;
8869     const xmlChar *nsname;
8870     xmlChar *attvalue;
8871     const xmlChar **atts = ctxt->atts;
8872     int maxatts = ctxt->maxatts;
8873     int nratts, nbatts, nbdef;
8874     int i, j, nbNs, attval, oldline, oldcol;
8875     const xmlChar *base;
8876     unsigned long cur;
8877     int nsNr = ctxt->nsNr;
8878
8879     if (RAW != '<') return(NULL);
8880     NEXT1;
8881
8882     /*
8883      * NOTE: it is crucial with the SAX2 API to never call SHRINK beyond that
8884      *       point since the attribute values may be stored as pointers to
8885      *       the buffer and calling SHRINK would destroy them !
8886      *       The Shrinking is only possible once the full set of attribute
8887      *       callbacks have been done.
8888      */
8889 reparse:
8890     SHRINK;
8891     base = ctxt->input->base;
8892     cur = ctxt->input->cur - ctxt->input->base;
8893     oldline = ctxt->input->line;
8894     oldcol = ctxt->input->col;
8895     nbatts = 0;
8896     nratts = 0;
8897     nbdef = 0;
8898     nbNs = 0;
8899     attval = 0;
8900     /* Forget any namespaces added during an earlier parse of this element. */
8901     ctxt->nsNr = nsNr;
8902
8903     localname = xmlParseQName(ctxt, &prefix);
8904     if (localname == NULL) {
8905         xmlFatalErrMsg(ctxt, XML_ERR_NAME_REQUIRED,
8906                        "StartTag: invalid element name\n");
8907         return(NULL);
8908     }
8909     *tlen = ctxt->input->cur - ctxt->input->base - cur;
8910
8911     /*
8912      * Now parse the attributes, it ends up with the ending
8913      *
8914      * (S Attribute)* S?
8915      */
8916     SKIP_BLANKS;
8917     GROW;
8918     if (ctxt->input->base != base) goto base_changed;
8919
8920     while ((RAW != '>') &&
8921            ((RAW != '/') || (NXT(1) != '>')) &&
8922            (IS_BYTE_CHAR(RAW))) {
8923         const xmlChar *q = CUR_PTR;
8924         unsigned int cons = ctxt->input->consumed;
8925         int len = -1, alloc = 0;
8926
8927         attname = xmlParseAttribute2(ctxt, prefix, localname,
8928                                      &aprefix, &attvalue, &len, &alloc);
8929         if (ctxt->input->base != base) {
8930             if ((attvalue != NULL) && (alloc != 0))
8931                 xmlFree(attvalue);
8932             attvalue = NULL;
8933             goto base_changed;
8934         }
8935         if ((attname != NULL) && (attvalue != NULL)) {
8936             if (len < 0) len = xmlStrlen(attvalue);
8937             if ((attname == ctxt->str_xmlns) && (aprefix == NULL)) {
8938                 const xmlChar *URL = xmlDictLookup(ctxt->dict, attvalue, len);
8939                 xmlURIPtr uri;
8940
8941                 if (*URL != 0) {
8942                     uri = xmlParseURI((const char *) URL);
8943                     if (uri == NULL) {
8944                         xmlNsErr(ctxt, XML_WAR_NS_URI,
8945                                  "xmlns: '%s' is not a valid URI\n",
8946                                            URL, NULL, NULL);
8947                     } else {
8948                         if (uri->scheme == NULL) {
8949                             xmlNsWarn(ctxt, XML_WAR_NS_URI_RELATIVE,
8950                                       "xmlns: URI %s is not absolute\n",
8951                                       URL, NULL, NULL);
8952                         }
8953                         xmlFreeURI(uri);
8954                     }
8955                     if (URL == ctxt->str_xml_ns) {
8956                         if (attname != ctxt->str_xml) {
8957                             xmlNsErr(ctxt, XML_NS_ERR_XML_NAMESPACE,
8958                          "xml namespace URI cannot be the default namespace\n",
8959                                      NULL, NULL, NULL);
8960                         }
8961                         goto skip_default_ns;
8962                     }
8963                     if ((len == 29) &&
8964                         (xmlStrEqual(URL,
8965                                  BAD_CAST "http://www.w3.org/2000/xmlns/"))) {
8966                         xmlNsErr(ctxt, XML_NS_ERR_XML_NAMESPACE,
8967                              "reuse of the xmlns namespace name is forbidden\n",
8968                                  NULL, NULL, NULL);
8969                         goto skip_default_ns;
8970                     }
8971                 }
8972                 /*
8973                  * check that it's not a defined namespace
8974                  */
8975                 for (j = 1;j <= nbNs;j++)
8976                     if (ctxt->nsTab[ctxt->nsNr - 2 * j] == NULL)
8977                         break;
8978                 if (j <= nbNs)
8979                     xmlErrAttributeDup(ctxt, NULL, attname);
8980                 else
8981                     if (nsPush(ctxt, NULL, URL) > 0) nbNs++;
8982 skip_default_ns:
8983                 if (alloc != 0) xmlFree(attvalue);
8984                 SKIP_BLANKS;
8985                 continue;
8986             }
8987             if (aprefix == ctxt->str_xmlns) {
8988                 const xmlChar *URL = xmlDictLookup(ctxt->dict, attvalue, len);
8989                 xmlURIPtr uri;
8990
8991                 if (attname == ctxt->str_xml) {
8992                     if (URL != ctxt->str_xml_ns) {
8993                         xmlNsErr(ctxt, XML_NS_ERR_XML_NAMESPACE,
8994                                  "xml namespace prefix mapped to wrong URI\n",
8995                                  NULL, NULL, NULL);
8996                     }
8997                     /*
8998                      * Do not keep a namespace definition node
8999                      */
9000                     goto skip_ns;
9001                 }
9002                 if (URL == ctxt->str_xml_ns) {
9003                     if (attname != ctxt->str_xml) {
9004                         xmlNsErr(ctxt, XML_NS_ERR_XML_NAMESPACE,
9005                                  "xml namespace URI mapped to wrong prefix\n",
9006                                  NULL, NULL, NULL);
9007                     }
9008                     goto skip_ns;
9009                 }
9010                 if (attname == ctxt->str_xmlns) {
9011                     xmlNsErr(ctxt, XML_NS_ERR_XML_NAMESPACE,
9012                              "redefinition of the xmlns prefix is forbidden\n",
9013                              NULL, NULL, NULL);
9014                     goto skip_ns;
9015                 }
9016                 if ((len == 29) &&
9017                     (xmlStrEqual(URL,
9018                                  BAD_CAST "http://www.w3.org/2000/xmlns/"))) {
9019                     xmlNsErr(ctxt, XML_NS_ERR_XML_NAMESPACE,
9020                              "reuse of the xmlns namespace name is forbidden\n",
9021                              NULL, NULL, NULL);
9022                     goto skip_ns;
9023                 }
9024                 if ((URL == NULL) || (URL[0] == 0)) {
9025                     xmlNsErr(ctxt, XML_NS_ERR_XML_NAMESPACE,
9026                              "xmlns:%s: Empty XML namespace is not allowed\n",
9027                                   attname, NULL, NULL);
9028                     goto skip_ns;
9029                 } else {
9030                     uri = xmlParseURI((const char *) URL);
9031                     if (uri == NULL) {
9032                         xmlNsErr(ctxt, XML_WAR_NS_URI,
9033                              "xmlns:%s: '%s' is not a valid URI\n",
9034                                            attname, URL, NULL);
9035                     } else {
9036                         if ((ctxt->pedantic) && (uri->scheme == NULL)) {
9037                             xmlNsWarn(ctxt, XML_WAR_NS_URI_RELATIVE,
9038                                       "xmlns:%s: URI %s is not absolute\n",
9039                                       attname, URL, NULL);
9040                         }
9041                         xmlFreeURI(uri);
9042                     }
9043                 }
9044
9045                 /*
9046                  * check that it's not a defined namespace
9047                  */
9048                 for (j = 1;j <= nbNs;j++)
9049                     if (ctxt->nsTab[ctxt->nsNr - 2 * j] == attname)
9050                         break;
9051                 if (j <= nbNs)
9052                     xmlErrAttributeDup(ctxt, aprefix, attname);
9053                 else
9054                     if (nsPush(ctxt, attname, URL) > 0) nbNs++;
9055 skip_ns:
9056                 if (alloc != 0) xmlFree(attvalue);
9057                 SKIP_BLANKS;
9058                 if (ctxt->input->base != base) goto base_changed;
9059                 continue;
9060             }
9061
9062             /*
9063              * Add the pair to atts
9064              */
9065             if ((atts == NULL) || (nbatts + 5 > maxatts)) {
9066                 if (xmlCtxtGrowAttrs(ctxt, nbatts + 5) < 0) {
9067                     if (attvalue[len] == 0)
9068                         xmlFree(attvalue);
9069                     goto failed;
9070                 }
9071                 maxatts = ctxt->maxatts;
9072                 atts = ctxt->atts;
9073             }
9074             ctxt->attallocs[nratts++] = alloc;
9075             atts[nbatts++] = attname;
9076             atts[nbatts++] = aprefix;
9077             atts[nbatts++] = NULL; /* the URI will be fetched later */
9078             atts[nbatts++] = attvalue;
9079             attvalue += len;
9080             atts[nbatts++] = attvalue;
9081             /*
9082              * tag if some deallocation is needed
9083              */
9084             if (alloc != 0) attval = 1;
9085         } else {
9086             if ((attvalue != NULL) && (attvalue[len] == 0))
9087                 xmlFree(attvalue);
9088         }
9089
9090 failed:
9091
9092         GROW
9093         if (ctxt->input->base != base) goto base_changed;
9094         if ((RAW == '>') || (((RAW == '/') && (NXT(1) == '>'))))
9095             break;
9096         if (!IS_BLANK_CH(RAW)) {
9097             xmlFatalErrMsg(ctxt, XML_ERR_SPACE_REQUIRED,
9098                            "attributes construct error\n");
9099             break;
9100         }
9101         SKIP_BLANKS;
9102         if ((cons == ctxt->input->consumed) && (q == CUR_PTR) &&
9103             (attname == NULL) && (attvalue == NULL)) {
9104             xmlFatalErr(ctxt, XML_ERR_INTERNAL_ERROR,
9105                  "xmlParseStartTag: problem parsing attributes\n");
9106             break;
9107         }
9108         GROW;
9109         if (ctxt->input->base != base) goto base_changed;
9110     }
9111
9112     /*
9113      * The attributes defaulting
9114      */
9115     if (ctxt->attsDefault != NULL) {
9116         xmlDefAttrsPtr defaults;
9117
9118         defaults = xmlHashLookup2(ctxt->attsDefault, localname, prefix);
9119         if (defaults != NULL) {
9120             for (i = 0;i < defaults->nbAttrs;i++) {
9121                 attname = defaults->values[5 * i];
9122                 aprefix = defaults->values[5 * i + 1];
9123
9124                 /*
9125                  * special work for namespaces defaulted defs
9126                  */
9127                 if ((attname == ctxt->str_xmlns) && (aprefix == NULL)) {
9128                     /*
9129                      * check that it's not a defined namespace
9130                      */
9131                     for (j = 1;j <= nbNs;j++)
9132                         if (ctxt->nsTab[ctxt->nsNr - 2 * j] == NULL)
9133                             break;
9134                     if (j <= nbNs) continue;
9135
9136                     nsname = xmlGetNamespace(ctxt, NULL);
9137                     if (nsname != defaults->values[5 * i + 2]) {
9138                         if (nsPush(ctxt, NULL,
9139                                    defaults->values[5 * i + 2]) > 0)
9140                             nbNs++;
9141                     }
9142                 } else if (aprefix == ctxt->str_xmlns) {
9143                     /*
9144                      * check that it's not a defined namespace
9145                      */
9146                     for (j = 1;j <= nbNs;j++)
9147                         if (ctxt->nsTab[ctxt->nsNr - 2 * j] == attname)
9148                             break;
9149                     if (j <= nbNs) continue;
9150
9151                     nsname = xmlGetNamespace(ctxt, attname);
9152                     if (nsname != defaults->values[2]) {
9153                         if (nsPush(ctxt, attname,
9154                                    defaults->values[5 * i + 2]) > 0)
9155                             nbNs++;
9156                     }
9157                 } else {
9158                     /*
9159                      * check that it's not a defined attribute
9160                      */
9161                     for (j = 0;j < nbatts;j+=5) {
9162                         if ((attname == atts[j]) && (aprefix == atts[j+1]))
9163                             break;
9164                     }
9165                     if (j < nbatts) continue;
9166
9167                     if ((atts == NULL) || (nbatts + 5 > maxatts)) {
9168                         if (xmlCtxtGrowAttrs(ctxt, nbatts + 5) < 0) {
9169                             return(NULL);
9170                         }
9171                         maxatts = ctxt->maxatts;
9172                         atts = ctxt->atts;
9173                     }
9174                     atts[nbatts++] = attname;
9175                     atts[nbatts++] = aprefix;
9176                     if (aprefix == NULL)
9177                         atts[nbatts++] = NULL;
9178                     else
9179                         atts[nbatts++] = xmlGetNamespace(ctxt, aprefix);
9180                     atts[nbatts++] = defaults->values[5 * i + 2];
9181                     atts[nbatts++] = defaults->values[5 * i + 3];
9182                     if ((ctxt->standalone == 1) &&
9183                         (defaults->values[5 * i + 4] != NULL)) {
9184                         xmlValidityError(ctxt, XML_DTD_STANDALONE_DEFAULTED,
9185           "standalone: attribute %s on %s defaulted from external subset\n",
9186                                          attname, localname);
9187                     }
9188                     nbdef++;
9189                 }
9190             }
9191         }
9192     }
9193
9194     /*
9195      * The attributes checkings
9196      */
9197     for (i = 0; i < nbatts;i += 5) {
9198         /*
9199         * The default namespace does not apply to attribute names.
9200         */
9201         if (atts[i + 1] != NULL) {
9202             nsname = xmlGetNamespace(ctxt, atts[i + 1]);
9203             if (nsname == NULL) {
9204                 xmlNsErr(ctxt, XML_NS_ERR_UNDEFINED_NAMESPACE,
9205                     "Namespace prefix %s for %s on %s is not defined\n",
9206                     atts[i + 1], atts[i], localname);
9207             }
9208             atts[i + 2] = nsname;
9209         } else
9210             nsname = NULL;
9211         /*
9212          * [ WFC: Unique Att Spec ]
9213          * No attribute name may appear more than once in the same
9214          * start-tag or empty-element tag.
9215          * As extended by the Namespace in XML REC.
9216          */
9217         for (j = 0; j < i;j += 5) {
9218             if (atts[i] == atts[j]) {
9219                 if (atts[i+1] == atts[j+1]) {
9220                     xmlErrAttributeDup(ctxt, atts[i+1], atts[i]);
9221                     break;
9222                 }
9223                 if ((nsname != NULL) && (atts[j + 2] == nsname)) {
9224                     xmlNsErr(ctxt, XML_NS_ERR_ATTRIBUTE_REDEFINED,
9225                              "Namespaced Attribute %s in '%s' redefined\n",
9226                              atts[i], nsname, NULL);
9227                     break;
9228                 }
9229             }
9230         }
9231     }
9232
9233     nsname = xmlGetNamespace(ctxt, prefix);
9234     if ((prefix != NULL) && (nsname == NULL)) {
9235         xmlNsErr(ctxt, XML_NS_ERR_UNDEFINED_NAMESPACE,
9236                  "Namespace prefix %s on %s is not defined\n",
9237                  prefix, localname, NULL);
9238     }
9239     *pref = prefix;
9240     *URI = nsname;
9241
9242     /*
9243      * SAX: Start of Element !
9244      */
9245     if ((ctxt->sax != NULL) && (ctxt->sax->startElementNs != NULL) &&
9246         (!ctxt->disableSAX)) {
9247         if (nbNs > 0)
9248             ctxt->sax->startElementNs(ctxt->userData, localname, prefix,
9249                           nsname, nbNs, &ctxt->nsTab[ctxt->nsNr - 2 * nbNs],
9250                           nbatts / 5, nbdef, atts);
9251         else
9252             ctxt->sax->startElementNs(ctxt->userData, localname, prefix,
9253                           nsname, 0, NULL, nbatts / 5, nbdef, atts);
9254     }
9255
9256     /*
9257      * Free up attribute allocated strings if needed
9258      */
9259     if (attval != 0) {
9260         for (i = 3,j = 0; j < nratts;i += 5,j++)
9261             if ((ctxt->attallocs[j] != 0) && (atts[i] != NULL))
9262                 xmlFree((xmlChar *) atts[i]);
9263     }
9264
9265     return(localname);
9266
9267 base_changed:
9268     /*
9269      * the attribute strings are valid iif the base didn't changed
9270      */
9271     if (attval != 0) {
9272         for (i = 3,j = 0; j < nratts;i += 5,j++)
9273             if ((ctxt->attallocs[j] != 0) && (atts[i] != NULL))
9274                 xmlFree((xmlChar *) atts[i]);
9275     }
9276     ctxt->input->cur = ctxt->input->base + cur;
9277     ctxt->input->line = oldline;
9278     ctxt->input->col = oldcol;
9279     if (ctxt->wellFormed == 1) {
9280         goto reparse;
9281     }
9282     return(NULL);
9283 }
9284
9285 /**
9286  * xmlParseEndTag2:
9287  * @ctxt:  an XML parser context
9288  * @line:  line of the start tag
9289  * @nsNr:  number of namespaces on the start tag
9290  *
9291  * parse an end of tag
9292  *
9293  * [42] ETag ::= '</' Name S? '>'
9294  *
9295  * With namespace
9296  *
9297  * [NS 9] ETag ::= '</' QName S? '>'
9298  */
9299
9300 static void
9301 xmlParseEndTag2(xmlParserCtxtPtr ctxt, const xmlChar *prefix,
9302                 const xmlChar *URI, int line, int nsNr, int tlen) {
9303     const xmlChar *name;
9304
9305     GROW;
9306     if ((RAW != '<') || (NXT(1) != '/')) {
9307         xmlFatalErr(ctxt, XML_ERR_LTSLASH_REQUIRED, NULL);
9308         return;
9309     }
9310     SKIP(2);
9311
9312     if ((tlen > 0) && (xmlStrncmp(ctxt->input->cur, ctxt->name, tlen) == 0)) {
9313         if (ctxt->input->cur[tlen] == '>') {
9314             ctxt->input->cur += tlen + 1;
9315             goto done;
9316         }
9317         ctxt->input->cur += tlen;
9318         name = (xmlChar*)1;
9319     } else {
9320         if (prefix == NULL)
9321             name = xmlParseNameAndCompare(ctxt, ctxt->name);
9322         else
9323             name = xmlParseQNameAndCompare(ctxt, ctxt->name, prefix);
9324     }
9325
9326     /*
9327      * We should definitely be at the ending "S? '>'" part
9328      */
9329     GROW;
9330     SKIP_BLANKS;
9331     if ((!IS_BYTE_CHAR(RAW)) || (RAW != '>')) {
9332         xmlFatalErr(ctxt, XML_ERR_GT_REQUIRED, NULL);
9333     } else
9334         NEXT1;
9335
9336     /*
9337      * [ WFC: Element Type Match ]
9338      * The Name in an element's end-tag must match the element type in the
9339      * start-tag.
9340      *
9341      */
9342     if (name != (xmlChar*)1) {
9343         if (name == NULL) name = BAD_CAST "unparseable";
9344         if ((line == 0) && (ctxt->node != NULL))
9345             line = ctxt->node->line;
9346         xmlFatalErrMsgStrIntStr(ctxt, XML_ERR_TAG_NAME_MISMATCH,
9347                      "Opening and ending tag mismatch: %s line %d and %s\n",
9348                                 ctxt->name, line, name);
9349     }
9350
9351     /*
9352      * SAX: End of Tag
9353      */
9354 done:
9355     if ((ctxt->sax != NULL) && (ctxt->sax->endElementNs != NULL) &&
9356         (!ctxt->disableSAX))
9357         ctxt->sax->endElementNs(ctxt->userData, ctxt->name, prefix, URI);
9358
9359     spacePop(ctxt);
9360     if (nsNr != 0)
9361         nsPop(ctxt, nsNr);
9362     return;
9363 }
9364
9365 /**
9366  * xmlParseCDSect:
9367  * @ctxt:  an XML parser context
9368  *
9369  * Parse escaped pure raw content.
9370  *
9371  * [18] CDSect ::= CDStart CData CDEnd
9372  *
9373  * [19] CDStart ::= '<![CDATA['
9374  *
9375  * [20] Data ::= (Char* - (Char* ']]>' Char*))
9376  *
9377  * [21] CDEnd ::= ']]>'
9378  */
9379 void
9380 xmlParseCDSect(xmlParserCtxtPtr ctxt) {
9381     xmlChar *buf = NULL;
9382     int len = 0;
9383     int size = XML_PARSER_BUFFER_SIZE;
9384     int r, rl;
9385     int s, sl;
9386     int cur, l;
9387     int count = 0;
9388
9389     /* Check 2.6.0 was NXT(0) not RAW */
9390     if (CMP9(CUR_PTR, '<', '!', '[', 'C', 'D', 'A', 'T', 'A', '[')) {
9391         SKIP(9);
9392     } else
9393         return;
9394
9395     ctxt->instate = XML_PARSER_CDATA_SECTION;
9396     r = CUR_CHAR(rl);
9397     if (!IS_CHAR(r)) {
9398         xmlFatalErr(ctxt, XML_ERR_CDATA_NOT_FINISHED, NULL);
9399         ctxt->instate = XML_PARSER_CONTENT;
9400         return;
9401     }
9402     NEXTL(rl);
9403     s = CUR_CHAR(sl);
9404     if (!IS_CHAR(s)) {
9405         xmlFatalErr(ctxt, XML_ERR_CDATA_NOT_FINISHED, NULL);
9406         ctxt->instate = XML_PARSER_CONTENT;
9407         return;
9408     }
9409     NEXTL(sl);
9410     cur = CUR_CHAR(l);
9411     buf = (xmlChar *) xmlMallocAtomic(size * sizeof(xmlChar));
9412     if (buf == NULL) {
9413         xmlErrMemory(ctxt, NULL);
9414         return;
9415     }
9416     while (IS_CHAR(cur) &&
9417            ((r != ']') || (s != ']') || (cur != '>'))) {
9418         if (len + 5 >= size) {
9419             xmlChar *tmp;
9420
9421             size *= 2;
9422             tmp = (xmlChar *) xmlRealloc(buf, size * sizeof(xmlChar));
9423             if (tmp == NULL) {
9424                 xmlFree(buf);
9425                 xmlErrMemory(ctxt, NULL);
9426                 return;
9427             }
9428             buf = tmp;
9429         }
9430         COPY_BUF(rl,buf,len,r);
9431         r = s;
9432         rl = sl;
9433         s = cur;
9434         sl = l;
9435         count++;
9436         if (count > 50) {
9437             GROW;
9438             count = 0;
9439         }
9440         NEXTL(l);
9441         cur = CUR_CHAR(l);
9442     }
9443     buf[len] = 0;
9444     ctxt->instate = XML_PARSER_CONTENT;
9445     if (cur != '>') {
9446         xmlFatalErrMsgStr(ctxt, XML_ERR_CDATA_NOT_FINISHED,
9447                              "CData section not finished\n%.50s\n", buf);
9448         xmlFree(buf);
9449         return;
9450     }
9451     NEXTL(l);
9452
9453     /*
9454      * OK the buffer is to be consumed as cdata.
9455      */
9456     if ((ctxt->sax != NULL) && (!ctxt->disableSAX)) {
9457         if (ctxt->sax->cdataBlock != NULL)
9458             ctxt->sax->cdataBlock(ctxt->userData, buf, len);
9459         else if (ctxt->sax->characters != NULL)
9460             ctxt->sax->characters(ctxt->userData, buf, len);
9461     }
9462     xmlFree(buf);
9463 }
9464
9465 /**
9466  * xmlParseContent:
9467  * @ctxt:  an XML parser context
9468  *
9469  * Parse a content:
9470  *
9471  * [43] content ::= (element | CharData | Reference | CDSect | PI | Comment)*
9472  */
9473
9474 void
9475 xmlParseContent(xmlParserCtxtPtr ctxt) {
9476     GROW;
9477     while ((RAW != 0) &&
9478            ((RAW != '<') || (NXT(1) != '/')) &&
9479            (ctxt->instate != XML_PARSER_EOF)) {
9480         const xmlChar *test = CUR_PTR;
9481         unsigned int cons = ctxt->input->consumed;
9482         const xmlChar *cur = ctxt->input->cur;
9483
9484         /*
9485          * First case : a Processing Instruction.
9486          */
9487         if ((*cur == '<') && (cur[1] == '?')) {
9488             xmlParsePI(ctxt);
9489         }
9490
9491         /*
9492          * Second case : a CDSection
9493          */
9494         /* 2.6.0 test was *cur not RAW */
9495         else if (CMP9(CUR_PTR, '<', '!', '[', 'C', 'D', 'A', 'T', 'A', '[')) {
9496             xmlParseCDSect(ctxt);
9497         }
9498
9499         /*
9500          * Third case :  a comment
9501          */
9502         else if ((*cur == '<') && (NXT(1) == '!') &&
9503                  (NXT(2) == '-') && (NXT(3) == '-')) {
9504             xmlParseComment(ctxt);
9505             ctxt->instate = XML_PARSER_CONTENT;
9506         }
9507
9508         /*
9509          * Fourth case :  a sub-element.
9510          */
9511         else if (*cur == '<') {
9512             xmlParseElement(ctxt);
9513         }
9514
9515         /*
9516          * Fifth case : a reference. If if has not been resolved,
9517          *    parsing returns it's Name, create the node
9518          */
9519
9520         else if (*cur == '&') {
9521             xmlParseReference(ctxt);
9522         }
9523
9524         /*
9525          * Last case, text. Note that References are handled directly.
9526          */
9527         else {
9528             xmlParseCharData(ctxt, 0);
9529         }
9530
9531         GROW;
9532         /*
9533          * Pop-up of finished entities.
9534          */
9535         while ((RAW == 0) && (ctxt->inputNr > 1))
9536             xmlPopInput(ctxt);
9537         SHRINK;
9538
9539         if ((cons == ctxt->input->consumed) && (test == CUR_PTR)) {
9540             xmlFatalErr(ctxt, XML_ERR_INTERNAL_ERROR,
9541                         "detected an error in element content\n");
9542             ctxt->instate = XML_PARSER_EOF;
9543             break;
9544         }
9545     }
9546 }
9547
9548 /**
9549  * xmlParseElement:
9550  * @ctxt:  an XML parser context
9551  *
9552  * parse an XML element, this is highly recursive
9553  *
9554  * [39] element ::= EmptyElemTag | STag content ETag
9555  *
9556  * [ WFC: Element Type Match ]
9557  * The Name in an element's end-tag must match the element type in the
9558  * start-tag.
9559  *
9560  */
9561
9562 void
9563 xmlParseElement(xmlParserCtxtPtr ctxt) {
9564     const xmlChar *name;
9565     const xmlChar *prefix = NULL;
9566     const xmlChar *URI = NULL;
9567     xmlParserNodeInfo node_info;
9568     int line, tlen = 0;
9569     xmlNodePtr ret;
9570     int nsNr = ctxt->nsNr;
9571
9572     if (((unsigned int) ctxt->nameNr > xmlParserMaxDepth) &&
9573         ((ctxt->options & XML_PARSE_HUGE) == 0)) {
9574         xmlFatalErrMsgInt(ctxt, XML_ERR_INTERNAL_ERROR,
9575                  "Excessive depth in document: %d use XML_PARSE_HUGE option\n",
9576                           xmlParserMaxDepth);
9577         ctxt->instate = XML_PARSER_EOF;
9578         return;
9579     }
9580
9581     /* Capture start position */
9582     if (ctxt->record_info) {
9583         node_info.begin_pos = ctxt->input->consumed +
9584                           (CUR_PTR - ctxt->input->base);
9585         node_info.begin_line = ctxt->input->line;
9586     }
9587
9588     if (ctxt->spaceNr == 0)
9589         spacePush(ctxt, -1);
9590     else if (*ctxt->space == -2)
9591         spacePush(ctxt, -1);
9592     else
9593         spacePush(ctxt, *ctxt->space);
9594
9595     line = ctxt->input->line;
9596 #ifdef LIBXML_SAX1_ENABLED
9597     if (ctxt->sax2)
9598 #endif /* LIBXML_SAX1_ENABLED */
9599         name = xmlParseStartTag2(ctxt, &prefix, &URI, &tlen);
9600 #ifdef LIBXML_SAX1_ENABLED
9601     else
9602         name = xmlParseStartTag(ctxt);
9603 #endif /* LIBXML_SAX1_ENABLED */
9604     if (ctxt->instate == XML_PARSER_EOF)
9605         return;
9606     if (name == NULL) {
9607         spacePop(ctxt);
9608         return;
9609     }
9610     namePush(ctxt, name);
9611     ret = ctxt->node;
9612
9613 #ifdef LIBXML_VALID_ENABLED
9614     /*
9615      * [ VC: Root Element Type ]
9616      * The Name in the document type declaration must match the element
9617      * type of the root element.
9618      */
9619     if (ctxt->validate && ctxt->wellFormed && ctxt->myDoc &&
9620         ctxt->node && (ctxt->node == ctxt->myDoc->children))
9621         ctxt->valid &= xmlValidateRoot(&ctxt->vctxt, ctxt->myDoc);
9622 #endif /* LIBXML_VALID_ENABLED */
9623
9624     /*
9625      * Check for an Empty Element.
9626      */
9627     if ((RAW == '/') && (NXT(1) == '>')) {
9628         SKIP(2);
9629         if (ctxt->sax2) {
9630             if ((ctxt->sax != NULL) && (ctxt->sax->endElementNs != NULL) &&
9631                 (!ctxt->disableSAX))
9632                 ctxt->sax->endElementNs(ctxt->userData, name, prefix, URI);
9633 #ifdef LIBXML_SAX1_ENABLED
9634         } else {
9635             if ((ctxt->sax != NULL) && (ctxt->sax->endElement != NULL) &&
9636                 (!ctxt->disableSAX))
9637                 ctxt->sax->endElement(ctxt->userData, name);
9638 #endif /* LIBXML_SAX1_ENABLED */
9639         }
9640         namePop(ctxt);
9641         spacePop(ctxt);
9642         if (nsNr != ctxt->nsNr)
9643             nsPop(ctxt, ctxt->nsNr - nsNr);
9644         if ( ret != NULL && ctxt->record_info ) {
9645            node_info.end_pos = ctxt->input->consumed +
9646                               (CUR_PTR - ctxt->input->base);
9647            node_info.end_line = ctxt->input->line;
9648            node_info.node = ret;
9649            xmlParserAddNodeInfo(ctxt, &node_info);
9650         }
9651         return;
9652     }
9653     if (RAW == '>') {
9654         NEXT1;
9655     } else {
9656         xmlFatalErrMsgStrIntStr(ctxt, XML_ERR_GT_REQUIRED,
9657                      "Couldn't find end of Start Tag %s line %d\n",
9658                                 name, line, NULL);
9659
9660         /*
9661          * end of parsing of this node.
9662          */
9663         nodePop(ctxt);
9664         namePop(ctxt);
9665         spacePop(ctxt);
9666         if (nsNr != ctxt->nsNr)
9667             nsPop(ctxt, ctxt->nsNr - nsNr);
9668
9669         /*
9670          * Capture end position and add node
9671          */
9672         if ( ret != NULL && ctxt->record_info ) {
9673            node_info.end_pos = ctxt->input->consumed +
9674                               (CUR_PTR - ctxt->input->base);
9675            node_info.end_line = ctxt->input->line;
9676            node_info.node = ret;
9677            xmlParserAddNodeInfo(ctxt, &node_info);
9678         }
9679         return;
9680     }
9681
9682     /*
9683      * Parse the content of the element:
9684      */
9685     xmlParseContent(ctxt);
9686     if (!IS_BYTE_CHAR(RAW)) {
9687         xmlFatalErrMsgStrIntStr(ctxt, XML_ERR_TAG_NOT_FINISHED,
9688          "Premature end of data in tag %s line %d\n",
9689                                 name, line, NULL);
9690
9691         /*
9692          * end of parsing of this node.
9693          */
9694         nodePop(ctxt);
9695         namePop(ctxt);
9696         spacePop(ctxt);
9697         if (nsNr != ctxt->nsNr)
9698             nsPop(ctxt, ctxt->nsNr - nsNr);
9699         return;
9700     }
9701
9702     /*
9703      * parse the end of tag: '</' should be here.
9704      */
9705     if (ctxt->sax2) {
9706         xmlParseEndTag2(ctxt, prefix, URI, line, ctxt->nsNr - nsNr, tlen);
9707         namePop(ctxt);
9708     }
9709 #ifdef LIBXML_SAX1_ENABLED
9710       else
9711         xmlParseEndTag1(ctxt, line);
9712 #endif /* LIBXML_SAX1_ENABLED */
9713
9714     /*
9715      * Capture end position and add node
9716      */
9717     if ( ret != NULL && ctxt->record_info ) {
9718        node_info.end_pos = ctxt->input->consumed +
9719                           (CUR_PTR - ctxt->input->base);
9720        node_info.end_line = ctxt->input->line;
9721        node_info.node = ret;
9722        xmlParserAddNodeInfo(ctxt, &node_info);
9723     }
9724 }
9725
9726 /**
9727  * xmlParseVersionNum:
9728  * @ctxt:  an XML parser context
9729  *
9730  * parse the XML version value.
9731  *
9732  * [26] VersionNum ::= '1.' [0-9]+
9733  *
9734  * In practice allow [0-9].[0-9]+ at that level
9735  *
9736  * Returns the string giving the XML version number, or NULL
9737  */
9738 xmlChar *
9739 xmlParseVersionNum(xmlParserCtxtPtr ctxt) {
9740     xmlChar *buf = NULL;
9741     int len = 0;
9742     int size = 10;
9743     xmlChar cur;
9744
9745     buf = (xmlChar *) xmlMallocAtomic(size * sizeof(xmlChar));
9746     if (buf == NULL) {
9747         xmlErrMemory(ctxt, NULL);
9748         return(NULL);
9749     }
9750     cur = CUR;
9751     if (!((cur >= '0') && (cur <= '9'))) {
9752         xmlFree(buf);
9753         return(NULL);
9754     }
9755     buf[len++] = cur;
9756     NEXT;
9757     cur=CUR;
9758     if (cur != '.') {
9759         xmlFree(buf);
9760         return(NULL);
9761     }
9762     buf[len++] = cur;
9763     NEXT;
9764     cur=CUR;
9765     while ((cur >= '0') && (cur <= '9')) {
9766         if (len + 1 >= size) {
9767             xmlChar *tmp;
9768
9769             size *= 2;
9770             tmp = (xmlChar *) xmlRealloc(buf, size * sizeof(xmlChar));
9771             if (tmp == NULL) {
9772                 xmlFree(buf);
9773                 xmlErrMemory(ctxt, NULL);
9774                 return(NULL);
9775             }
9776             buf = tmp;
9777         }
9778         buf[len++] = cur;
9779         NEXT;
9780         cur=CUR;
9781     }
9782     buf[len] = 0;
9783     return(buf);
9784 }
9785
9786 /**
9787  * xmlParseVersionInfo:
9788  * @ctxt:  an XML parser context
9789  *
9790  * parse the XML version.
9791  *
9792  * [24] VersionInfo ::= S 'version' Eq (' VersionNum ' | " VersionNum ")
9793  *
9794  * [25] Eq ::= S? '=' S?
9795  *
9796  * Returns the version string, e.g. "1.0"
9797  */
9798
9799 xmlChar *
9800 xmlParseVersionInfo(xmlParserCtxtPtr ctxt) {
9801     xmlChar *version = NULL;
9802
9803     if (CMP7(CUR_PTR, 'v', 'e', 'r', 's', 'i', 'o', 'n')) {
9804         SKIP(7);
9805         SKIP_BLANKS;
9806         if (RAW != '=') {
9807             xmlFatalErr(ctxt, XML_ERR_EQUAL_REQUIRED, NULL);
9808             return(NULL);
9809         }
9810         NEXT;
9811         SKIP_BLANKS;
9812         if (RAW == '"') {
9813             NEXT;
9814             version = xmlParseVersionNum(ctxt);
9815             if (RAW != '"') {
9816                 xmlFatalErr(ctxt, XML_ERR_STRING_NOT_CLOSED, NULL);
9817             } else
9818                 NEXT;
9819         } else if (RAW == '\''){
9820             NEXT;
9821             version = xmlParseVersionNum(ctxt);
9822             if (RAW != '\'') {
9823                 xmlFatalErr(ctxt, XML_ERR_STRING_NOT_CLOSED, NULL);
9824             } else
9825                 NEXT;
9826         } else {
9827             xmlFatalErr(ctxt, XML_ERR_STRING_NOT_STARTED, NULL);
9828         }
9829     }
9830     return(version);
9831 }
9832
9833 /**
9834  * xmlParseEncName:
9835  * @ctxt:  an XML parser context
9836  *
9837  * parse the XML encoding name
9838  *
9839  * [81] EncName ::= [A-Za-z] ([A-Za-z0-9._] | '-')*
9840  *
9841  * Returns the encoding name value or NULL
9842  */
9843 xmlChar *
9844 xmlParseEncName(xmlParserCtxtPtr ctxt) {
9845     xmlChar *buf = NULL;
9846     int len = 0;
9847     int size = 10;
9848     xmlChar cur;
9849
9850     cur = CUR;
9851     if (((cur >= 'a') && (cur <= 'z')) ||
9852         ((cur >= 'A') && (cur <= 'Z'))) {
9853         buf = (xmlChar *) xmlMallocAtomic(size * sizeof(xmlChar));
9854         if (buf == NULL) {
9855             xmlErrMemory(ctxt, NULL);
9856             return(NULL);
9857         }
9858
9859         buf[len++] = cur;
9860         NEXT;
9861         cur = CUR;
9862         while (((cur >= 'a') && (cur <= 'z')) ||
9863                ((cur >= 'A') && (cur <= 'Z')) ||
9864                ((cur >= '0') && (cur <= '9')) ||
9865                (cur == '.') || (cur == '_') ||
9866                (cur == '-')) {
9867             if (len + 1 >= size) {
9868                 xmlChar *tmp;
9869
9870                 size *= 2;
9871                 tmp = (xmlChar *) xmlRealloc(buf, size * sizeof(xmlChar));
9872                 if (tmp == NULL) {
9873                     xmlErrMemory(ctxt, NULL);
9874                     xmlFree(buf);
9875                     return(NULL);
9876                 }
9877                 buf = tmp;
9878             }
9879             buf[len++] = cur;
9880             NEXT;
9881             cur = CUR;
9882             if (cur == 0) {
9883                 SHRINK;
9884                 GROW;
9885                 cur = CUR;
9886             }
9887         }
9888         buf[len] = 0;
9889     } else {
9890         xmlFatalErr(ctxt, XML_ERR_ENCODING_NAME, NULL);
9891     }
9892     return(buf);
9893 }
9894
9895 /**
9896  * xmlParseEncodingDecl:
9897  * @ctxt:  an XML parser context
9898  *
9899  * parse the XML encoding declaration
9900  *
9901  * [80] EncodingDecl ::= S 'encoding' Eq ('"' EncName '"' |  "'" EncName "'")
9902  *
9903  * this setups the conversion filters.
9904  *
9905  * Returns the encoding value or NULL
9906  */
9907
9908 const xmlChar *
9909 xmlParseEncodingDecl(xmlParserCtxtPtr ctxt) {
9910     xmlChar *encoding = NULL;
9911
9912     SKIP_BLANKS;
9913     if (CMP8(CUR_PTR, 'e', 'n', 'c', 'o', 'd', 'i', 'n', 'g')) {
9914         SKIP(8);
9915         SKIP_BLANKS;
9916         if (RAW != '=') {
9917             xmlFatalErr(ctxt, XML_ERR_EQUAL_REQUIRED, NULL);
9918             return(NULL);
9919         }
9920         NEXT;
9921         SKIP_BLANKS;
9922         if (RAW == '"') {
9923             NEXT;
9924             encoding = xmlParseEncName(ctxt);
9925             if (RAW != '"') {
9926                 xmlFatalErr(ctxt, XML_ERR_STRING_NOT_CLOSED, NULL);
9927             } else
9928                 NEXT;
9929         } else if (RAW == '\''){
9930             NEXT;
9931             encoding = xmlParseEncName(ctxt);
9932             if (RAW != '\'') {
9933                 xmlFatalErr(ctxt, XML_ERR_STRING_NOT_CLOSED, NULL);
9934             } else
9935                 NEXT;
9936         } else {
9937             xmlFatalErr(ctxt, XML_ERR_STRING_NOT_STARTED, NULL);
9938         }
9939
9940         /*
9941          * Non standard parsing, allowing the user to ignore encoding
9942          */
9943         if (ctxt->options & XML_PARSE_IGNORE_ENC)
9944             return(encoding);
9945
9946         /*
9947          * UTF-16 encoding stwich has already taken place at this stage,
9948          * more over the little-endian/big-endian selection is already done
9949          */
9950         if ((encoding != NULL) &&
9951             ((!xmlStrcasecmp(encoding, BAD_CAST "UTF-16")) ||
9952              (!xmlStrcasecmp(encoding, BAD_CAST "UTF16")))) {
9953             /*
9954              * If no encoding was passed to the parser, that we are
9955              * using UTF-16 and no decoder is present i.e. the
9956              * document is apparently UTF-8 compatible, then raise an
9957              * encoding mismatch fatal error
9958              */
9959             if ((ctxt->encoding == NULL) &&
9960                 (ctxt->input->buf != NULL) &&
9961                 (ctxt->input->buf->encoder == NULL)) {
9962                 xmlFatalErrMsg(ctxt, XML_ERR_INVALID_ENCODING,
9963                   "Document labelled UTF-16 but has UTF-8 content\n");
9964             }
9965             if (ctxt->encoding != NULL)
9966                 xmlFree((xmlChar *) ctxt->encoding);
9967             ctxt->encoding = encoding;
9968         }
9969         /*
9970          * UTF-8 encoding is handled natively
9971          */
9972         else if ((encoding != NULL) &&
9973             ((!xmlStrcasecmp(encoding, BAD_CAST "UTF-8")) ||
9974              (!xmlStrcasecmp(encoding, BAD_CAST "UTF8")))) {
9975             if (ctxt->encoding != NULL)
9976                 xmlFree((xmlChar *) ctxt->encoding);
9977             ctxt->encoding = encoding;
9978         }
9979         else if (encoding != NULL) {
9980             xmlCharEncodingHandlerPtr handler;
9981
9982             if (ctxt->input->encoding != NULL)
9983                 xmlFree((xmlChar *) ctxt->input->encoding);
9984             ctxt->input->encoding = encoding;
9985
9986             handler = xmlFindCharEncodingHandler((const char *) encoding);
9987             if (handler != NULL) {
9988                 xmlSwitchToEncoding(ctxt, handler);
9989             } else {
9990                 xmlFatalErrMsgStr(ctxt, XML_ERR_UNSUPPORTED_ENCODING,
9991                         "Unsupported encoding %s\n", encoding);
9992                 return(NULL);
9993             }
9994         }
9995     }
9996     return(encoding);
9997 }
9998
9999 /**
10000  * xmlParseSDDecl:
10001  * @ctxt:  an XML parser context
10002  *
10003  * parse the XML standalone declaration
10004  *
10005  * [32] SDDecl ::= S 'standalone' Eq
10006  *                 (("'" ('yes' | 'no') "'") | ('"' ('yes' | 'no')'"'))
10007  *
10008  * [ VC: Standalone Document Declaration ]
10009  * TODO The standalone document declaration must have the value "no"
10010  * if any external markup declarations contain declarations of:
10011  *  - attributes with default values, if elements to which these
10012  *    attributes apply appear in the document without specifications
10013  *    of values for these attributes, or
10014  *  - entities (other than amp, lt, gt, apos, quot), if references
10015  *    to those entities appear in the document, or
10016  *  - attributes with values subject to normalization, where the
10017  *    attribute appears in the document with a value which will change
10018  *    as a result of normalization, or
10019  *  - element types with element content, if white space occurs directly
10020  *    within any instance of those types.
10021  *
10022  * Returns:
10023  *   1 if standalone="yes"
10024  *   0 if standalone="no"
10025  *  -2 if standalone attribute is missing or invalid
10026  *        (A standalone value of -2 means that the XML declaration was found,
10027  *         but no value was specified for the standalone attribute).
10028  */
10029
10030 int
10031 xmlParseSDDecl(xmlParserCtxtPtr ctxt) {
10032     int standalone = -2;
10033
10034     SKIP_BLANKS;
10035     if (CMP10(CUR_PTR, 's', 't', 'a', 'n', 'd', 'a', 'l', 'o', 'n', 'e')) {
10036         SKIP(10);
10037         SKIP_BLANKS;
10038         if (RAW != '=') {
10039             xmlFatalErr(ctxt, XML_ERR_EQUAL_REQUIRED, NULL);
10040             return(standalone);
10041         }
10042         NEXT;
10043         SKIP_BLANKS;
10044         if (RAW == '\''){
10045             NEXT;
10046             if ((RAW == 'n') && (NXT(1) == 'o')) {
10047                 standalone = 0;
10048                 SKIP(2);
10049             } else if ((RAW == 'y') && (NXT(1) == 'e') &&
10050                        (NXT(2) == 's')) {
10051                 standalone = 1;
10052                 SKIP(3);
10053             } else {
10054                 xmlFatalErr(ctxt, XML_ERR_STANDALONE_VALUE, NULL);
10055             }
10056             if (RAW != '\'') {
10057                 xmlFatalErr(ctxt, XML_ERR_STRING_NOT_CLOSED, NULL);
10058             } else
10059                 NEXT;
10060         } else if (RAW == '"'){
10061             NEXT;
10062             if ((RAW == 'n') && (NXT(1) == 'o')) {
10063                 standalone = 0;
10064                 SKIP(2);
10065             } else if ((RAW == 'y') && (NXT(1) == 'e') &&
10066                        (NXT(2) == 's')) {
10067                 standalone = 1;
10068                 SKIP(3);
10069             } else {
10070                 xmlFatalErr(ctxt, XML_ERR_STANDALONE_VALUE, NULL);
10071             }
10072             if (RAW != '"') {
10073                 xmlFatalErr(ctxt, XML_ERR_STRING_NOT_CLOSED, NULL);
10074             } else
10075                 NEXT;
10076         } else {
10077             xmlFatalErr(ctxt, XML_ERR_STRING_NOT_STARTED, NULL);
10078         }
10079     }
10080     return(standalone);
10081 }
10082
10083 /**
10084  * xmlParseXMLDecl:
10085  * @ctxt:  an XML parser context
10086  *
10087  * parse an XML declaration header
10088  *
10089  * [23] XMLDecl ::= '<?xml' VersionInfo EncodingDecl? SDDecl? S? '?>'
10090  */
10091
10092 void
10093 xmlParseXMLDecl(xmlParserCtxtPtr ctxt) {
10094     xmlChar *version;
10095
10096     /*
10097      * This value for standalone indicates that the document has an
10098      * XML declaration but it does not have a standalone attribute.
10099      * It will be overwritten later if a standalone attribute is found.
10100      */
10101     ctxt->input->standalone = -2;
10102
10103     /*
10104      * We know that '<?xml' is here.
10105      */
10106     SKIP(5);
10107
10108     if (!IS_BLANK_CH(RAW)) {
10109         xmlFatalErrMsg(ctxt, XML_ERR_SPACE_REQUIRED,
10110                        "Blank needed after '<?xml'\n");
10111     }
10112     SKIP_BLANKS;
10113
10114     /*
10115      * We must have the VersionInfo here.
10116      */
10117     version = xmlParseVersionInfo(ctxt);
10118     if (version == NULL) {
10119         xmlFatalErr(ctxt, XML_ERR_VERSION_MISSING, NULL);
10120     } else {
10121         if (!xmlStrEqual(version, (const xmlChar *) XML_DEFAULT_VERSION)) {
10122             /*
10123              * Changed here for XML-1.0 5th edition
10124              */
10125             if (ctxt->options & XML_PARSE_OLD10) {
10126                 xmlFatalErrMsgStr(ctxt, XML_ERR_UNKNOWN_VERSION,
10127                                   "Unsupported version '%s'\n",
10128                                   version);
10129             } else {
10130                 if ((version[0] == '1') && ((version[1] == '.'))) {
10131                     xmlWarningMsg(ctxt, XML_WAR_UNKNOWN_VERSION,
10132                                   "Unsupported version '%s'\n",
10133                                   version, NULL);
10134                 } else {
10135                     xmlFatalErrMsgStr(ctxt, XML_ERR_UNKNOWN_VERSION,
10136                                       "Unsupported version '%s'\n",
10137                                       version);
10138                 }
10139             }
10140         }
10141         if (ctxt->version != NULL)
10142             xmlFree((void *) ctxt->version);
10143         ctxt->version = version;
10144     }
10145
10146     /*
10147      * We may have the encoding declaration
10148      */
10149     if (!IS_BLANK_CH(RAW)) {
10150         if ((RAW == '?') && (NXT(1) == '>')) {
10151             SKIP(2);
10152             return;
10153         }
10154         xmlFatalErrMsg(ctxt, XML_ERR_SPACE_REQUIRED, "Blank needed here\n");
10155     }
10156     xmlParseEncodingDecl(ctxt);
10157     if (ctxt->errNo == XML_ERR_UNSUPPORTED_ENCODING) {
10158         /*
10159          * The XML REC instructs us to stop parsing right here
10160          */
10161         return;
10162     }
10163
10164     /*
10165      * We may have the standalone status.
10166      */
10167     if ((ctxt->input->encoding != NULL) && (!IS_BLANK_CH(RAW))) {
10168         if ((RAW == '?') && (NXT(1) == '>')) {
10169             SKIP(2);
10170             return;
10171         }
10172         xmlFatalErrMsg(ctxt, XML_ERR_SPACE_REQUIRED, "Blank needed here\n");
10173     }
10174
10175     /*
10176      * We can grow the input buffer freely at that point
10177      */
10178     GROW;
10179
10180     SKIP_BLANKS;
10181     ctxt->input->standalone = xmlParseSDDecl(ctxt);
10182
10183     SKIP_BLANKS;
10184     if ((RAW == '?') && (NXT(1) == '>')) {
10185         SKIP(2);
10186     } else if (RAW == '>') {
10187         /* Deprecated old WD ... */
10188         xmlFatalErr(ctxt, XML_ERR_XMLDECL_NOT_FINISHED, NULL);
10189         NEXT;
10190     } else {
10191         xmlFatalErr(ctxt, XML_ERR_XMLDECL_NOT_FINISHED, NULL);
10192         MOVETO_ENDTAG(CUR_PTR);
10193         NEXT;
10194     }
10195 }
10196
10197 /**
10198  * xmlParseMisc:
10199  * @ctxt:  an XML parser context
10200  *
10201  * parse an XML Misc* optional field.
10202  *
10203  * [27] Misc ::= Comment | PI |  S
10204  */
10205
10206 void
10207 xmlParseMisc(xmlParserCtxtPtr ctxt) {
10208     while (((RAW == '<') && (NXT(1) == '?')) ||
10209            (CMP4(CUR_PTR, '<', '!', '-', '-')) ||
10210            IS_BLANK_CH(CUR)) {
10211         if ((RAW == '<') && (NXT(1) == '?')) {
10212             xmlParsePI(ctxt);
10213         } else if (IS_BLANK_CH(CUR)) {
10214             NEXT;
10215         } else
10216             xmlParseComment(ctxt);
10217     }
10218 }
10219
10220 /**
10221  * xmlParseDocument:
10222  * @ctxt:  an XML parser context
10223  *
10224  * parse an XML document (and build a tree if using the standard SAX
10225  * interface).
10226  *
10227  * [1] document ::= prolog element Misc*
10228  *
10229  * [22] prolog ::= XMLDecl? Misc* (doctypedecl Misc*)?
10230  *
10231  * Returns 0, -1 in case of error. the parser context is augmented
10232  *                as a result of the parsing.
10233  */
10234
10235 int
10236 xmlParseDocument(xmlParserCtxtPtr ctxt) {
10237     xmlChar start[4];
10238     xmlCharEncoding enc;
10239
10240     xmlInitParser();
10241
10242     if ((ctxt == NULL) || (ctxt->input == NULL))
10243         return(-1);
10244
10245     GROW;
10246
10247     /*
10248      * SAX: detecting the level.
10249      */
10250     xmlDetectSAX2(ctxt);
10251
10252     /*
10253      * SAX: beginning of the document processing.
10254      */
10255     if ((ctxt->sax) && (ctxt->sax->setDocumentLocator))
10256         ctxt->sax->setDocumentLocator(ctxt->userData, &xmlDefaultSAXLocator);
10257
10258     if ((ctxt->encoding == NULL) &&
10259         ((ctxt->input->end - ctxt->input->cur) >= 4)) {
10260         /*
10261          * Get the 4 first bytes and decode the charset
10262          * if enc != XML_CHAR_ENCODING_NONE
10263          * plug some encoding conversion routines.
10264          */
10265         start[0] = RAW;
10266         start[1] = NXT(1);
10267         start[2] = NXT(2);
10268         start[3] = NXT(3);
10269         enc = xmlDetectCharEncoding(&start[0], 4);
10270         if (enc != XML_CHAR_ENCODING_NONE) {
10271             xmlSwitchEncoding(ctxt, enc);
10272         }
10273     }
10274
10275
10276     if (CUR == 0) {
10277         xmlFatalErr(ctxt, XML_ERR_DOCUMENT_EMPTY, NULL);
10278     }
10279
10280     /*
10281      * Check for the XMLDecl in the Prolog.
10282      * do not GROW here to avoid the detected encoder to decode more
10283      * than just the first line, unless the amount of data is really
10284      * too small to hold "<?xml version="1.0" encoding="foo"
10285      */
10286     if ((ctxt->input->end - ctxt->input->cur) < 35) {
10287        GROW;
10288     }
10289     if ((CMP5(CUR_PTR, '<', '?', 'x', 'm', 'l')) && (IS_BLANK_CH(NXT(5)))) {
10290
10291         /*
10292          * Note that we will switch encoding on the fly.
10293          */
10294         xmlParseXMLDecl(ctxt);
10295         if (ctxt->errNo == XML_ERR_UNSUPPORTED_ENCODING) {
10296             /*
10297              * The XML REC instructs us to stop parsing right here
10298              */
10299             return(-1);
10300         }
10301         ctxt->standalone = ctxt->input->standalone;
10302         SKIP_BLANKS;
10303     } else {
10304         ctxt->version = xmlCharStrdup(XML_DEFAULT_VERSION);
10305     }
10306     if ((ctxt->sax) && (ctxt->sax->startDocument) && (!ctxt->disableSAX))
10307         ctxt->sax->startDocument(ctxt->userData);
10308
10309     /*
10310      * The Misc part of the Prolog
10311      */
10312     GROW;
10313     xmlParseMisc(ctxt);
10314
10315     /*
10316      * Then possibly doc type declaration(s) and more Misc
10317      * (doctypedecl Misc*)?
10318      */
10319     GROW;
10320     if (CMP9(CUR_PTR, '<', '!', 'D', 'O', 'C', 'T', 'Y', 'P', 'E')) {
10321
10322         ctxt->inSubset = 1;
10323         xmlParseDocTypeDecl(ctxt);
10324         if (RAW == '[') {
10325             ctxt->instate = XML_PARSER_DTD;
10326             xmlParseInternalSubset(ctxt);
10327         }
10328
10329         /*
10330          * Create and update the external subset.
10331          */
10332         ctxt->inSubset = 2;
10333         if ((ctxt->sax != NULL) && (ctxt->sax->externalSubset != NULL) &&
10334             (!ctxt->disableSAX))
10335             ctxt->sax->externalSubset(ctxt->userData, ctxt->intSubName,
10336                                       ctxt->extSubSystem, ctxt->extSubURI);
10337         ctxt->inSubset = 0;
10338
10339         xmlCleanSpecialAttr(ctxt);
10340
10341         ctxt->instate = XML_PARSER_PROLOG;
10342         xmlParseMisc(ctxt);
10343     }
10344
10345     /*
10346      * Time to start parsing the tree itself
10347      */
10348     GROW;
10349     if (RAW != '<') {
10350         xmlFatalErrMsg(ctxt, XML_ERR_DOCUMENT_EMPTY,
10351                        "Start tag expected, '<' not found\n");
10352     } else {
10353         ctxt->instate = XML_PARSER_CONTENT;
10354         xmlParseElement(ctxt);
10355         ctxt->instate = XML_PARSER_EPILOG;
10356
10357
10358         /*
10359          * The Misc part at the end
10360          */
10361         xmlParseMisc(ctxt);
10362
10363         if (RAW != 0) {
10364             xmlFatalErr(ctxt, XML_ERR_DOCUMENT_END, NULL);
10365         }
10366         ctxt->instate = XML_PARSER_EOF;
10367     }
10368
10369     /*
10370      * SAX: end of the document processing.
10371      */
10372     if ((ctxt->sax) && (ctxt->sax->endDocument != NULL))
10373         ctxt->sax->endDocument(ctxt->userData);
10374
10375     /*
10376      * Remove locally kept entity definitions if the tree was not built
10377      */
10378     if ((ctxt->myDoc != NULL) &&
10379         (xmlStrEqual(ctxt->myDoc->version, SAX_COMPAT_MODE))) {
10380         xmlFreeDoc(ctxt->myDoc);
10381         ctxt->myDoc = NULL;
10382     }
10383
10384     if ((ctxt->wellFormed) && (ctxt->myDoc != NULL)) {
10385         ctxt->myDoc->properties |= XML_DOC_WELLFORMED;
10386         if (ctxt->valid)
10387             ctxt->myDoc->properties |= XML_DOC_DTDVALID;
10388         if (ctxt->nsWellFormed)
10389             ctxt->myDoc->properties |= XML_DOC_NSVALID;
10390         if (ctxt->options & XML_PARSE_OLD10)
10391             ctxt->myDoc->properties |= XML_DOC_OLD10;
10392     }
10393     if (! ctxt->wellFormed) {
10394         ctxt->valid = 0;
10395         return(-1);
10396     }
10397     return(0);
10398 }
10399
10400 /**
10401  * xmlParseExtParsedEnt:
10402  * @ctxt:  an XML parser context
10403  *
10404  * parse a general parsed entity
10405  * An external general parsed entity is well-formed if it matches the
10406  * production labeled extParsedEnt.
10407  *
10408  * [78] extParsedEnt ::= TextDecl? content
10409  *
10410  * Returns 0, -1 in case of error. the parser context is augmented
10411  *                as a result of the parsing.
10412  */
10413
10414 int
10415 xmlParseExtParsedEnt(xmlParserCtxtPtr ctxt) {
10416     xmlChar start[4];
10417     xmlCharEncoding enc;
10418
10419     if ((ctxt == NULL) || (ctxt->input == NULL))
10420         return(-1);
10421
10422     xmlDefaultSAXHandlerInit();
10423
10424     xmlDetectSAX2(ctxt);
10425
10426     GROW;
10427
10428     /*
10429      * SAX: beginning of the document processing.
10430      */
10431     if ((ctxt->sax) && (ctxt->sax->setDocumentLocator))
10432         ctxt->sax->setDocumentLocator(ctxt->userData, &xmlDefaultSAXLocator);
10433
10434     /*
10435      * Get the 4 first bytes and decode the charset
10436      * if enc != XML_CHAR_ENCODING_NONE
10437      * plug some encoding conversion routines.
10438      */
10439     if ((ctxt->input->end - ctxt->input->cur) >= 4) {
10440         start[0] = RAW;
10441         start[1] = NXT(1);
10442         start[2] = NXT(2);
10443         start[3] = NXT(3);
10444         enc = xmlDetectCharEncoding(start, 4);
10445         if (enc != XML_CHAR_ENCODING_NONE) {
10446             xmlSwitchEncoding(ctxt, enc);
10447         }
10448     }
10449
10450
10451     if (CUR == 0) {
10452         xmlFatalErr(ctxt, XML_ERR_DOCUMENT_EMPTY, NULL);
10453     }
10454
10455     /*
10456      * Check for the XMLDecl in the Prolog.
10457      */
10458     GROW;
10459     if ((CMP5(CUR_PTR, '<', '?', 'x', 'm', 'l')) && (IS_BLANK_CH(NXT(5)))) {
10460
10461         /*
10462          * Note that we will switch encoding on the fly.
10463          */
10464         xmlParseXMLDecl(ctxt);
10465         if (ctxt->errNo == XML_ERR_UNSUPPORTED_ENCODING) {
10466             /*
10467              * The XML REC instructs us to stop parsing right here
10468              */
10469             return(-1);
10470         }
10471         SKIP_BLANKS;
10472     } else {
10473         ctxt->version = xmlCharStrdup(XML_DEFAULT_VERSION);
10474     }
10475     if ((ctxt->sax) && (ctxt->sax->startDocument) && (!ctxt->disableSAX))
10476         ctxt->sax->startDocument(ctxt->userData);
10477
10478     /*
10479      * Doing validity checking on chunk doesn't make sense
10480      */
10481     ctxt->instate = XML_PARSER_CONTENT;
10482     ctxt->validate = 0;
10483     ctxt->loadsubset = 0;
10484     ctxt->depth = 0;
10485
10486     xmlParseContent(ctxt);
10487
10488     if ((RAW == '<') && (NXT(1) == '/')) {
10489         xmlFatalErr(ctxt, XML_ERR_NOT_WELL_BALANCED, NULL);
10490     } else if (RAW != 0) {
10491         xmlFatalErr(ctxt, XML_ERR_EXTRA_CONTENT, NULL);
10492     }
10493
10494     /*
10495      * SAX: end of the document processing.
10496      */
10497     if ((ctxt->sax) && (ctxt->sax->endDocument != NULL))
10498         ctxt->sax->endDocument(ctxt->userData);
10499
10500     if (! ctxt->wellFormed) return(-1);
10501     return(0);
10502 }
10503
10504 #ifdef LIBXML_PUSH_ENABLED
10505 /************************************************************************
10506  *                                                                      *
10507  *              Progressive parsing interfaces                          *
10508  *                                                                      *
10509  ************************************************************************/
10510
10511 /**
10512  * xmlParseLookupSequence:
10513  * @ctxt:  an XML parser context
10514  * @first:  the first char to lookup
10515  * @next:  the next char to lookup or zero
10516  * @third:  the next char to lookup or zero
10517  *
10518  * Try to find if a sequence (first, next, third) or  just (first next) or
10519  * (first) is available in the input stream.
10520  * This function has a side effect of (possibly) incrementing ctxt->checkIndex
10521  * to avoid rescanning sequences of bytes, it DOES change the state of the
10522  * parser, do not use liberally.
10523  *
10524  * Returns the index to the current parsing point if the full sequence
10525  *      is available, -1 otherwise.
10526  */
10527 static int
10528 xmlParseLookupSequence(xmlParserCtxtPtr ctxt, xmlChar first,
10529                        xmlChar next, xmlChar third) {
10530     int base, len;
10531     xmlParserInputPtr in;
10532     const xmlChar *buf;
10533
10534     in = ctxt->input;
10535     if (in == NULL) return(-1);
10536     base = in->cur - in->base;
10537     if (base < 0) return(-1);
10538     if (ctxt->checkIndex > base)
10539         base = ctxt->checkIndex;
10540     if (in->buf == NULL) {
10541         buf = in->base;
10542         len = in->length;
10543     } else {
10544         buf = in->buf->buffer->content;
10545         len = in->buf->buffer->use;
10546     }
10547     /* take into account the sequence length */
10548     if (third) len -= 2;
10549     else if (next) len --;
10550     for (;base < len;base++) {
10551         if (buf[base] == first) {
10552             if (third != 0) {
10553                 if ((buf[base + 1] != next) ||
10554                     (buf[base + 2] != third)) continue;
10555             } else if (next != 0) {
10556                 if (buf[base + 1] != next) continue;
10557             }
10558             ctxt->checkIndex = 0;
10559 #ifdef DEBUG_PUSH
10560             if (next == 0)
10561                 xmlGenericError(xmlGenericErrorContext,
10562                         "PP: lookup '%c' found at %d\n",
10563                         first, base);
10564             else if (third == 0)
10565                 xmlGenericError(xmlGenericErrorContext,
10566                         "PP: lookup '%c%c' found at %d\n",
10567                         first, next, base);
10568             else
10569                 xmlGenericError(xmlGenericErrorContext,
10570                         "PP: lookup '%c%c%c' found at %d\n",
10571                         first, next, third, base);
10572 #endif
10573             return(base - (in->cur - in->base));
10574         }
10575     }
10576     ctxt->checkIndex = base;
10577 #ifdef DEBUG_PUSH
10578     if (next == 0)
10579         xmlGenericError(xmlGenericErrorContext,
10580                 "PP: lookup '%c' failed\n", first);
10581     else if (third == 0)
10582         xmlGenericError(xmlGenericErrorContext,
10583                 "PP: lookup '%c%c' failed\n", first, next);
10584     else
10585         xmlGenericError(xmlGenericErrorContext,
10586                 "PP: lookup '%c%c%c' failed\n", first, next, third);
10587 #endif
10588     return(-1);
10589 }
10590
10591 /**
10592  * xmlParseGetLasts:
10593  * @ctxt:  an XML parser context
10594  * @lastlt:  pointer to store the last '<' from the input
10595  * @lastgt:  pointer to store the last '>' from the input
10596  *
10597  * Lookup the last < and > in the current chunk
10598  */
10599 static void
10600 xmlParseGetLasts(xmlParserCtxtPtr ctxt, const xmlChar **lastlt,
10601                  const xmlChar **lastgt) {
10602     const xmlChar *tmp;
10603
10604     if ((ctxt == NULL) || (lastlt == NULL) || (lastgt == NULL)) {
10605         xmlGenericError(xmlGenericErrorContext,
10606                     "Internal error: xmlParseGetLasts\n");
10607         return;
10608     }
10609     if ((ctxt->progressive != 0) && (ctxt->inputNr == 1)) {
10610         tmp = ctxt->input->end;
10611         tmp--;
10612         while ((tmp >= ctxt->input->base) && (*tmp != '<')) tmp--;
10613         if (tmp < ctxt->input->base) {
10614             *lastlt = NULL;
10615             *lastgt = NULL;
10616         } else {
10617             *lastlt = tmp;
10618             tmp++;
10619             while ((tmp < ctxt->input->end) && (*tmp != '>')) {
10620                 if (*tmp == '\'') {
10621                     tmp++;
10622                     while ((tmp < ctxt->input->end) && (*tmp != '\'')) tmp++;
10623                     if (tmp < ctxt->input->end) tmp++;
10624                 } else if (*tmp == '"') {
10625                     tmp++;
10626                     while ((tmp < ctxt->input->end) && (*tmp != '"')) tmp++;
10627                     if (tmp < ctxt->input->end) tmp++;
10628                 } else
10629                     tmp++;
10630             }
10631             if (tmp < ctxt->input->end)
10632                 *lastgt = tmp;
10633             else {
10634                 tmp = *lastlt;
10635                 tmp--;
10636                 while ((tmp >= ctxt->input->base) && (*tmp != '>')) tmp--;
10637                 if (tmp >= ctxt->input->base)
10638                     *lastgt = tmp;
10639                 else
10640                     *lastgt = NULL;
10641             }
10642         }
10643     } else {
10644         *lastlt = NULL;
10645         *lastgt = NULL;
10646     }
10647 }
10648 /**
10649  * xmlCheckCdataPush:
10650  * @cur: pointer to the bock of characters
10651  * @len: length of the block in bytes
10652  *
10653  * Check that the block of characters is okay as SCdata content [20]
10654  *
10655  * Returns the number of bytes to pass if okay, a negative index where an
10656  *         UTF-8 error occured otherwise
10657  */
10658 static int
10659 xmlCheckCdataPush(const xmlChar *utf, int len) {
10660     int ix;
10661     unsigned char c;
10662     int codepoint;
10663
10664     if ((utf == NULL) || (len <= 0))
10665         return(0);
10666
10667     for (ix = 0; ix < len;) {      /* string is 0-terminated */
10668         c = utf[ix];
10669         if ((c & 0x80) == 0x00) {       /* 1-byte code, starts with 10 */
10670             if (c >= 0x20)
10671                 ix++;
10672             else if ((c == 0xA) || (c == 0xD) || (c == 0x9))
10673                 ix++;
10674             else
10675                 return(-ix);
10676         } else if ((c & 0xe0) == 0xc0) {/* 2-byte code, starts with 110 */
10677             if (ix + 2 > len) return(ix);
10678             if ((utf[ix+1] & 0xc0 ) != 0x80)
10679                 return(-ix);
10680             codepoint = (utf[ix] & 0x1f) << 6;
10681             codepoint |= utf[ix+1] & 0x3f;
10682             if (!xmlIsCharQ(codepoint))
10683                 return(-ix);
10684             ix += 2;
10685         } else if ((c & 0xf0) == 0xe0) {/* 3-byte code, starts with 1110 */
10686             if (ix + 3 > len) return(ix);
10687             if (((utf[ix+1] & 0xc0) != 0x80) ||
10688                 ((utf[ix+2] & 0xc0) != 0x80))
10689                     return(-ix);
10690             codepoint = (utf[ix] & 0xf) << 12;
10691             codepoint |= (utf[ix+1] & 0x3f) << 6;
10692             codepoint |= utf[ix+2] & 0x3f;
10693             if (!xmlIsCharQ(codepoint))
10694                 return(-ix);
10695             ix += 3;
10696         } else if ((c & 0xf8) == 0xf0) {/* 4-byte code, starts with 11110 */
10697             if (ix + 4 > len) return(ix);
10698             if (((utf[ix+1] & 0xc0) != 0x80) ||
10699                 ((utf[ix+2] & 0xc0) != 0x80) ||
10700                 ((utf[ix+3] & 0xc0) != 0x80))
10701                     return(-ix);
10702             codepoint = (utf[ix] & 0x7) << 18;
10703             codepoint |= (utf[ix+1] & 0x3f) << 12;
10704             codepoint |= (utf[ix+2] & 0x3f) << 6;
10705             codepoint |= utf[ix+3] & 0x3f;
10706             if (!xmlIsCharQ(codepoint))
10707                 return(-ix);
10708             ix += 4;
10709         } else                          /* unknown encoding */
10710             return(-ix);
10711       }
10712       return(ix);
10713 }
10714
10715 /**
10716  * xmlParseTryOrFinish:
10717  * @ctxt:  an XML parser context
10718  * @terminate:  last chunk indicator
10719  *
10720  * Try to progress on parsing
10721  *
10722  * Returns zero if no parsing was possible
10723  */
10724 static int
10725 xmlParseTryOrFinish(xmlParserCtxtPtr ctxt, int terminate) {
10726     int ret = 0;
10727     int avail, tlen;
10728     xmlChar cur, next;
10729     const xmlChar *lastlt, *lastgt;
10730
10731     if (ctxt->input == NULL)
10732         return(0);
10733
10734 #ifdef DEBUG_PUSH
10735     switch (ctxt->instate) {
10736         case XML_PARSER_EOF:
10737             xmlGenericError(xmlGenericErrorContext,
10738                     "PP: try EOF\n"); break;
10739         case XML_PARSER_START:
10740             xmlGenericError(xmlGenericErrorContext,
10741                     "PP: try START\n"); break;
10742         case XML_PARSER_MISC:
10743             xmlGenericError(xmlGenericErrorContext,
10744                     "PP: try MISC\n");break;
10745         case XML_PARSER_COMMENT:
10746             xmlGenericError(xmlGenericErrorContext,
10747                     "PP: try COMMENT\n");break;
10748         case XML_PARSER_PROLOG:
10749             xmlGenericError(xmlGenericErrorContext,
10750                     "PP: try PROLOG\n");break;
10751         case XML_PARSER_START_TAG:
10752             xmlGenericError(xmlGenericErrorContext,
10753                     "PP: try START_TAG\n");break;
10754         case XML_PARSER_CONTENT:
10755             xmlGenericError(xmlGenericErrorContext,
10756                     "PP: try CONTENT\n");break;
10757         case XML_PARSER_CDATA_SECTION:
10758             xmlGenericError(xmlGenericErrorContext,
10759                     "PP: try CDATA_SECTION\n");break;
10760         case XML_PARSER_END_TAG:
10761             xmlGenericError(xmlGenericErrorContext,
10762                     "PP: try END_TAG\n");break;
10763         case XML_PARSER_ENTITY_DECL:
10764             xmlGenericError(xmlGenericErrorContext,
10765                     "PP: try ENTITY_DECL\n");break;
10766         case XML_PARSER_ENTITY_VALUE:
10767             xmlGenericError(xmlGenericErrorContext,
10768                     "PP: try ENTITY_VALUE\n");break;
10769         case XML_PARSER_ATTRIBUTE_VALUE:
10770             xmlGenericError(xmlGenericErrorContext,
10771                     "PP: try ATTRIBUTE_VALUE\n");break;
10772         case XML_PARSER_DTD:
10773             xmlGenericError(xmlGenericErrorContext,
10774                     "PP: try DTD\n");break;
10775         case XML_PARSER_EPILOG:
10776             xmlGenericError(xmlGenericErrorContext,
10777                     "PP: try EPILOG\n");break;
10778         case XML_PARSER_PI:
10779             xmlGenericError(xmlGenericErrorContext,
10780                     "PP: try PI\n");break;
10781         case XML_PARSER_IGNORE:
10782             xmlGenericError(xmlGenericErrorContext,
10783                     "PP: try IGNORE\n");break;
10784     }
10785 #endif
10786
10787     if ((ctxt->input != NULL) &&
10788         (ctxt->input->cur - ctxt->input->base > 4096)) {
10789         xmlSHRINK(ctxt);
10790         ctxt->checkIndex = 0;
10791     }
10792     xmlParseGetLasts(ctxt, &lastlt, &lastgt);
10793
10794     while (1) {
10795         if ((ctxt->errNo != XML_ERR_OK) && (ctxt->disableSAX == 1))
10796             return(0);
10797
10798
10799         /*
10800          * Pop-up of finished entities.
10801          */
10802         while ((RAW == 0) && (ctxt->inputNr > 1))
10803             xmlPopInput(ctxt);
10804
10805         if (ctxt->input == NULL) break;
10806         if (ctxt->input->buf == NULL)
10807             avail = ctxt->input->length -
10808                     (ctxt->input->cur - ctxt->input->base);
10809         else {
10810             /*
10811              * If we are operating on converted input, try to flush
10812              * remainng chars to avoid them stalling in the non-converted
10813              * buffer.
10814              */
10815             if ((ctxt->input->buf->raw != NULL) &&
10816                 (ctxt->input->buf->raw->use > 0)) {
10817                 int base = ctxt->input->base -
10818                            ctxt->input->buf->buffer->content;
10819                 int current = ctxt->input->cur - ctxt->input->base;
10820
10821                 xmlParserInputBufferPush(ctxt->input->buf, 0, "");
10822                 ctxt->input->base = ctxt->input->buf->buffer->content + base;
10823                 ctxt->input->cur = ctxt->input->base + current;
10824                 ctxt->input->end =
10825                     &ctxt->input->buf->buffer->content[
10826                                        ctxt->input->buf->buffer->use];
10827             }
10828             avail = ctxt->input->buf->buffer->use -
10829                     (ctxt->input->cur - ctxt->input->base);
10830         }
10831         if (avail < 1)
10832             goto done;
10833         switch (ctxt->instate) {
10834             case XML_PARSER_EOF:
10835                 /*
10836                  * Document parsing is done !
10837                  */
10838                 goto done;
10839             case XML_PARSER_START:
10840                 if (ctxt->charset == XML_CHAR_ENCODING_NONE) {
10841                     xmlChar start[4];
10842                     xmlCharEncoding enc;
10843
10844                     /*
10845                      * Very first chars read from the document flow.
10846                      */
10847                     if (avail < 4)
10848                         goto done;
10849
10850                     /*
10851                      * Get the 4 first bytes and decode the charset
10852                      * if enc != XML_CHAR_ENCODING_NONE
10853                      * plug some encoding conversion routines,
10854                      * else xmlSwitchEncoding will set to (default)
10855                      * UTF8.
10856                      */
10857                     start[0] = RAW;
10858                     start[1] = NXT(1);
10859                     start[2] = NXT(2);
10860                     start[3] = NXT(3);
10861                     enc = xmlDetectCharEncoding(start, 4);
10862                     xmlSwitchEncoding(ctxt, enc);
10863                     break;
10864                 }
10865
10866                 if (avail < 2)
10867                     goto done;
10868                 cur = ctxt->input->cur[0];
10869                 next = ctxt->input->cur[1];
10870                 if (cur == 0) {
10871                     if ((ctxt->sax) && (ctxt->sax->setDocumentLocator))
10872                         ctxt->sax->setDocumentLocator(ctxt->userData,
10873                                                       &xmlDefaultSAXLocator);
10874                     xmlFatalErr(ctxt, XML_ERR_DOCUMENT_EMPTY, NULL);
10875                     ctxt->instate = XML_PARSER_EOF;
10876 #ifdef DEBUG_PUSH
10877                     xmlGenericError(xmlGenericErrorContext,
10878                             "PP: entering EOF\n");
10879 #endif
10880                     if ((ctxt->sax) && (ctxt->sax->endDocument != NULL))
10881                         ctxt->sax->endDocument(ctxt->userData);
10882                     goto done;
10883                 }
10884                 if ((cur == '<') && (next == '?')) {
10885                     /* PI or XML decl */
10886                     if (avail < 5) return(ret);
10887                     if ((!terminate) &&
10888                         (xmlParseLookupSequence(ctxt, '?', '>', 0) < 0))
10889                         return(ret);
10890                     if ((ctxt->sax) && (ctxt->sax->setDocumentLocator))
10891                         ctxt->sax->setDocumentLocator(ctxt->userData,
10892                                                       &xmlDefaultSAXLocator);
10893                     if ((ctxt->input->cur[2] == 'x') &&
10894                         (ctxt->input->cur[3] == 'm') &&
10895                         (ctxt->input->cur[4] == 'l') &&
10896                         (IS_BLANK_CH(ctxt->input->cur[5]))) {
10897                         ret += 5;
10898 #ifdef DEBUG_PUSH
10899                         xmlGenericError(xmlGenericErrorContext,
10900                                 "PP: Parsing XML Decl\n");
10901 #endif
10902                         xmlParseXMLDecl(ctxt);
10903                         if (ctxt->errNo == XML_ERR_UNSUPPORTED_ENCODING) {
10904                             /*
10905                              * The XML REC instructs us to stop parsing right
10906                              * here
10907                              */
10908                             ctxt->instate = XML_PARSER_EOF;
10909                             return(0);
10910                         }
10911                         ctxt->standalone = ctxt->input->standalone;
10912                         if ((ctxt->encoding == NULL) &&
10913                             (ctxt->input->encoding != NULL))
10914                             ctxt->encoding = xmlStrdup(ctxt->input->encoding);
10915                         if ((ctxt->sax) && (ctxt->sax->startDocument) &&
10916                             (!ctxt->disableSAX))
10917                             ctxt->sax->startDocument(ctxt->userData);
10918                         ctxt->instate = XML_PARSER_MISC;
10919 #ifdef DEBUG_PUSH
10920                         xmlGenericError(xmlGenericErrorContext,
10921                                 "PP: entering MISC\n");
10922 #endif
10923                     } else {
10924                         ctxt->version = xmlCharStrdup(XML_DEFAULT_VERSION);
10925                         if ((ctxt->sax) && (ctxt->sax->startDocument) &&
10926                             (!ctxt->disableSAX))
10927                             ctxt->sax->startDocument(ctxt->userData);
10928                         ctxt->instate = XML_PARSER_MISC;
10929 #ifdef DEBUG_PUSH
10930                         xmlGenericError(xmlGenericErrorContext,
10931                                 "PP: entering MISC\n");
10932 #endif
10933                     }
10934                 } else {
10935                     if ((ctxt->sax) && (ctxt->sax->setDocumentLocator))
10936                         ctxt->sax->setDocumentLocator(ctxt->userData,
10937                                                       &xmlDefaultSAXLocator);
10938                     ctxt->version = xmlCharStrdup(XML_DEFAULT_VERSION);
10939                     if (ctxt->version == NULL) {
10940                         xmlErrMemory(ctxt, NULL);
10941                         break;
10942                     }
10943                     if ((ctxt->sax) && (ctxt->sax->startDocument) &&
10944                         (!ctxt->disableSAX))
10945                         ctxt->sax->startDocument(ctxt->userData);
10946                     ctxt->instate = XML_PARSER_MISC;
10947 #ifdef DEBUG_PUSH
10948                     xmlGenericError(xmlGenericErrorContext,
10949                             "PP: entering MISC\n");
10950 #endif
10951                 }
10952                 break;
10953             case XML_PARSER_START_TAG: {
10954                 const xmlChar *name;
10955                 const xmlChar *prefix = NULL;
10956                 const xmlChar *URI = NULL;
10957                 int nsNr = ctxt->nsNr;
10958
10959                 if ((avail < 2) && (ctxt->inputNr == 1))
10960                     goto done;
10961                 cur = ctxt->input->cur[0];
10962                 if (cur != '<') {
10963                     xmlFatalErr(ctxt, XML_ERR_DOCUMENT_EMPTY, NULL);
10964                     ctxt->instate = XML_PARSER_EOF;
10965                     if ((ctxt->sax) && (ctxt->sax->endDocument != NULL))
10966                         ctxt->sax->endDocument(ctxt->userData);
10967                     goto done;
10968                 }
10969                 if (!terminate) {
10970                     if (ctxt->progressive) {
10971                         /* > can be found unescaped in attribute values */
10972                         if ((lastgt == NULL) || (ctxt->input->cur >= lastgt))
10973                             goto done;
10974                     } else if (xmlParseLookupSequence(ctxt, '>', 0, 0) < 0) {
10975                         goto done;
10976                     }
10977                 }
10978                 if (ctxt->spaceNr == 0)
10979                     spacePush(ctxt, -1);
10980                 else if (*ctxt->space == -2)
10981                     spacePush(ctxt, -1);
10982                 else
10983                     spacePush(ctxt, *ctxt->space);
10984 #ifdef LIBXML_SAX1_ENABLED
10985                 if (ctxt->sax2)
10986 #endif /* LIBXML_SAX1_ENABLED */
10987                     name = xmlParseStartTag2(ctxt, &prefix, &URI, &tlen);
10988 #ifdef LIBXML_SAX1_ENABLED
10989                 else
10990                     name = xmlParseStartTag(ctxt);
10991 #endif /* LIBXML_SAX1_ENABLED */
10992                 if (ctxt->instate == XML_PARSER_EOF)
10993                     goto done;
10994                 if (name == NULL) {
10995                     spacePop(ctxt);
10996                     ctxt->instate = XML_PARSER_EOF;
10997                     if ((ctxt->sax) && (ctxt->sax->endDocument != NULL))
10998                         ctxt->sax->endDocument(ctxt->userData);
10999                     goto done;
11000                 }
11001 #ifdef LIBXML_VALID_ENABLED
11002                 /*
11003                  * [ VC: Root Element Type ]
11004                  * The Name in the document type declaration must match
11005                  * the element type of the root element.
11006                  */
11007                 if (ctxt->validate && ctxt->wellFormed && ctxt->myDoc &&
11008                     ctxt->node && (ctxt->node == ctxt->myDoc->children))
11009                     ctxt->valid &= xmlValidateRoot(&ctxt->vctxt, ctxt->myDoc);
11010 #endif /* LIBXML_VALID_ENABLED */
11011
11012                 /*
11013                  * Check for an Empty Element.
11014                  */
11015                 if ((RAW == '/') && (NXT(1) == '>')) {
11016                     SKIP(2);
11017
11018                     if (ctxt->sax2) {
11019                         if ((ctxt->sax != NULL) &&
11020                             (ctxt->sax->endElementNs != NULL) &&
11021                             (!ctxt->disableSAX))
11022                             ctxt->sax->endElementNs(ctxt->userData, name,
11023                                                     prefix, URI);
11024                         if (ctxt->nsNr - nsNr > 0)
11025                             nsPop(ctxt, ctxt->nsNr - nsNr);
11026 #ifdef LIBXML_SAX1_ENABLED
11027                     } else {
11028                         if ((ctxt->sax != NULL) &&
11029                             (ctxt->sax->endElement != NULL) &&
11030                             (!ctxt->disableSAX))
11031                             ctxt->sax->endElement(ctxt->userData, name);
11032 #endif /* LIBXML_SAX1_ENABLED */
11033                     }
11034                     spacePop(ctxt);
11035                     if (ctxt->nameNr == 0) {
11036                         ctxt->instate = XML_PARSER_EPILOG;
11037                     } else {
11038                         ctxt->instate = XML_PARSER_CONTENT;
11039                     }
11040                     break;
11041                 }
11042                 if (RAW == '>') {
11043                     NEXT;
11044                 } else {
11045                     xmlFatalErrMsgStr(ctxt, XML_ERR_GT_REQUIRED,
11046                                          "Couldn't find end of Start Tag %s\n",
11047                                          name);
11048                     nodePop(ctxt);
11049                     spacePop(ctxt);
11050                 }
11051                 if (ctxt->sax2)
11052                     nameNsPush(ctxt, name, prefix, URI, ctxt->nsNr - nsNr);
11053 #ifdef LIBXML_SAX1_ENABLED
11054                 else
11055                     namePush(ctxt, name);
11056 #endif /* LIBXML_SAX1_ENABLED */
11057
11058                 ctxt->instate = XML_PARSER_CONTENT;
11059                 break;
11060             }
11061             case XML_PARSER_CONTENT: {
11062                 const xmlChar *test;
11063                 unsigned int cons;
11064                 if ((avail < 2) && (ctxt->inputNr == 1))
11065                     goto done;
11066                 cur = ctxt->input->cur[0];
11067                 next = ctxt->input->cur[1];
11068
11069                 test = CUR_PTR;
11070                 cons = ctxt->input->consumed;
11071                 if ((cur == '<') && (next == '/')) {
11072                     ctxt->instate = XML_PARSER_END_TAG;
11073                     break;
11074                 } else if ((cur == '<') && (next == '?')) {
11075                     if ((!terminate) &&
11076                         (xmlParseLookupSequence(ctxt, '?', '>', 0) < 0))
11077                         goto done;
11078                     xmlParsePI(ctxt);
11079                 } else if ((cur == '<') && (next != '!')) {
11080                     ctxt->instate = XML_PARSER_START_TAG;
11081                     break;
11082                 } else if ((cur == '<') && (next == '!') &&
11083                            (ctxt->input->cur[2] == '-') &&
11084                            (ctxt->input->cur[3] == '-')) {
11085                     int term;
11086
11087                     if (avail < 4)
11088                         goto done;
11089                     ctxt->input->cur += 4;
11090                     term = xmlParseLookupSequence(ctxt, '-', '-', '>');
11091                     ctxt->input->cur -= 4;
11092                     if ((!terminate) && (term < 0))
11093                         goto done;
11094                     xmlParseComment(ctxt);
11095                     ctxt->instate = XML_PARSER_CONTENT;
11096                 } else if ((cur == '<') && (ctxt->input->cur[1] == '!') &&
11097                     (ctxt->input->cur[2] == '[') &&
11098                     (ctxt->input->cur[3] == 'C') &&
11099                     (ctxt->input->cur[4] == 'D') &&
11100                     (ctxt->input->cur[5] == 'A') &&
11101                     (ctxt->input->cur[6] == 'T') &&
11102                     (ctxt->input->cur[7] == 'A') &&
11103                     (ctxt->input->cur[8] == '[')) {
11104                     SKIP(9);
11105                     ctxt->instate = XML_PARSER_CDATA_SECTION;
11106                     break;
11107                 } else if ((cur == '<') && (next == '!') &&
11108                            (avail < 9)) {
11109                     goto done;
11110                 } else if (cur == '&') {
11111                     if ((!terminate) &&
11112                         (xmlParseLookupSequence(ctxt, ';', 0, 0) < 0))
11113                         goto done;
11114                     xmlParseReference(ctxt);
11115                 } else {
11116                     /* TODO Avoid the extra copy, handle directly !!! */
11117                     /*
11118                      * Goal of the following test is:
11119                      *  - minimize calls to the SAX 'character' callback
11120                      *    when they are mergeable
11121                      *  - handle an problem for isBlank when we only parse
11122                      *    a sequence of blank chars and the next one is
11123                      *    not available to check against '<' presence.
11124                      *  - tries to homogenize the differences in SAX
11125                      *    callbacks between the push and pull versions
11126                      *    of the parser.
11127                      */
11128                     if ((ctxt->inputNr == 1) &&
11129                         (avail < XML_PARSER_BIG_BUFFER_SIZE)) {
11130                         if (!terminate) {
11131                             if (ctxt->progressive) {
11132                                 if ((lastlt == NULL) ||
11133                                     (ctxt->input->cur > lastlt))
11134                                     goto done;
11135                             } else if (xmlParseLookupSequence(ctxt,
11136                                                               '<', 0, 0) < 0) {
11137                                 goto done;
11138                             }
11139                         }
11140                     }
11141                     ctxt->checkIndex = 0;
11142                     xmlParseCharData(ctxt, 0);
11143                 }
11144                 /*
11145                  * Pop-up of finished entities.
11146                  */
11147                 while ((RAW == 0) && (ctxt->inputNr > 1))
11148                     xmlPopInput(ctxt);
11149                 if ((cons == ctxt->input->consumed) && (test == CUR_PTR)) {
11150                     xmlFatalErr(ctxt, XML_ERR_INTERNAL_ERROR,
11151                                 "detected an error in element content\n");
11152                     ctxt->instate = XML_PARSER_EOF;
11153                     break;
11154                 }
11155                 break;
11156             }
11157             case XML_PARSER_END_TAG:
11158                 if (avail < 2)
11159                     goto done;
11160                 if (!terminate) {
11161                     if (ctxt->progressive) {
11162                         /* > can be found unescaped in attribute values */
11163                         if ((lastgt == NULL) || (ctxt->input->cur >= lastgt))
11164                             goto done;
11165                     } else if (xmlParseLookupSequence(ctxt, '>', 0, 0) < 0) {
11166                         goto done;
11167                     }
11168                 }
11169                 if (ctxt->sax2) {
11170                     xmlParseEndTag2(ctxt,
11171                            (void *) ctxt->pushTab[ctxt->nameNr * 3 - 3],
11172                            (void *) ctxt->pushTab[ctxt->nameNr * 3 - 2], 0,
11173                        (int) (long) ctxt->pushTab[ctxt->nameNr * 3 - 1], 0);
11174                     nameNsPop(ctxt);
11175                 }
11176 #ifdef LIBXML_SAX1_ENABLED
11177                   else
11178                     xmlParseEndTag1(ctxt, 0);
11179 #endif /* LIBXML_SAX1_ENABLED */
11180                 if (ctxt->instate == XML_PARSER_EOF) {
11181                     /* Nothing */
11182                 } else if (ctxt->nameNr == 0) {
11183                     ctxt->instate = XML_PARSER_EPILOG;
11184                 } else {
11185                     ctxt->instate = XML_PARSER_CONTENT;
11186                 }
11187                 break;
11188             case XML_PARSER_CDATA_SECTION: {
11189                 /*
11190                  * The Push mode need to have the SAX callback for
11191                  * cdataBlock merge back contiguous callbacks.
11192                  */
11193                 int base;
11194
11195                 base = xmlParseLookupSequence(ctxt, ']', ']', '>');
11196                 if (base < 0) {
11197                     if (avail >= XML_PARSER_BIG_BUFFER_SIZE + 2) {
11198                         int tmp;
11199
11200                         tmp = xmlCheckCdataPush(ctxt->input->cur,
11201                                                 XML_PARSER_BIG_BUFFER_SIZE);
11202                         if (tmp < 0) {
11203                             tmp = -tmp;
11204                             ctxt->input->cur += tmp;
11205                             goto encoding_error;
11206                         }
11207                         if ((ctxt->sax != NULL) && (!ctxt->disableSAX)) {
11208                             if (ctxt->sax->cdataBlock != NULL)
11209                                 ctxt->sax->cdataBlock(ctxt->userData,
11210                                                       ctxt->input->cur, tmp);
11211                             else if (ctxt->sax->characters != NULL)
11212                                 ctxt->sax->characters(ctxt->userData,
11213                                                       ctxt->input->cur, tmp);
11214                         }
11215                         SKIPL(tmp);
11216                         ctxt->checkIndex = 0;
11217                     }
11218                     goto done;
11219                 } else {
11220                     int tmp;
11221
11222                     tmp = xmlCheckCdataPush(ctxt->input->cur, base);
11223                     if ((tmp < 0) || (tmp != base)) {
11224                         tmp = -tmp;
11225                         ctxt->input->cur += tmp;
11226                         goto encoding_error;
11227                     }
11228                     if ((ctxt->sax != NULL) && (base == 0) &&
11229                         (ctxt->sax->cdataBlock != NULL) &&
11230                         (!ctxt->disableSAX)) {
11231                         /*
11232                          * Special case to provide identical behaviour
11233                          * between pull and push parsers on enpty CDATA
11234                          * sections
11235                          */
11236                          if ((ctxt->input->cur - ctxt->input->base >= 9) &&
11237                              (!strncmp((const char *)&ctxt->input->cur[-9],
11238                                        "<![CDATA[", 9)))
11239                              ctxt->sax->cdataBlock(ctxt->userData,
11240                                                    BAD_CAST "", 0);
11241                     } else if ((ctxt->sax != NULL) && (base > 0) &&
11242                         (!ctxt->disableSAX)) {
11243                         if (ctxt->sax->cdataBlock != NULL)
11244                             ctxt->sax->cdataBlock(ctxt->userData,
11245                                                   ctxt->input->cur, base);
11246                         else if (ctxt->sax->characters != NULL)
11247                             ctxt->sax->characters(ctxt->userData,
11248                                                   ctxt->input->cur, base);
11249                     }
11250                     SKIPL(base + 3);
11251                     ctxt->checkIndex = 0;
11252                     ctxt->instate = XML_PARSER_CONTENT;
11253 #ifdef DEBUG_PUSH
11254                     xmlGenericError(xmlGenericErrorContext,
11255                             "PP: entering CONTENT\n");
11256 #endif
11257                 }
11258                 break;
11259             }
11260             case XML_PARSER_MISC:
11261                 SKIP_BLANKS;
11262                 if (ctxt->input->buf == NULL)
11263                     avail = ctxt->input->length -
11264                             (ctxt->input->cur - ctxt->input->base);
11265                 else
11266                     avail = ctxt->input->buf->buffer->use -
11267                             (ctxt->input->cur - ctxt->input->base);
11268                 if (avail < 2)
11269                     goto done;
11270                 cur = ctxt->input->cur[0];
11271                 next = ctxt->input->cur[1];
11272                 if ((cur == '<') && (next == '?')) {
11273                     if ((!terminate) &&
11274                         (xmlParseLookupSequence(ctxt, '?', '>', 0) < 0))
11275                         goto done;
11276 #ifdef DEBUG_PUSH
11277                     xmlGenericError(xmlGenericErrorContext,
11278                             "PP: Parsing PI\n");
11279 #endif
11280                     xmlParsePI(ctxt);
11281                     ctxt->checkIndex = 0;
11282                 } else if ((cur == '<') && (next == '!') &&
11283                     (ctxt->input->cur[2] == '-') &&
11284                     (ctxt->input->cur[3] == '-')) {
11285                     if ((!terminate) &&
11286                         (xmlParseLookupSequence(ctxt, '-', '-', '>') < 0))
11287                         goto done;
11288 #ifdef DEBUG_PUSH
11289                     xmlGenericError(xmlGenericErrorContext,
11290                             "PP: Parsing Comment\n");
11291 #endif
11292                     xmlParseComment(ctxt);
11293                     ctxt->instate = XML_PARSER_MISC;
11294                     ctxt->checkIndex = 0;
11295                 } else if ((cur == '<') && (next == '!') &&
11296                     (ctxt->input->cur[2] == 'D') &&
11297                     (ctxt->input->cur[3] == 'O') &&
11298                     (ctxt->input->cur[4] == 'C') &&
11299                     (ctxt->input->cur[5] == 'T') &&
11300                     (ctxt->input->cur[6] == 'Y') &&
11301                     (ctxt->input->cur[7] == 'P') &&
11302                     (ctxt->input->cur[8] == 'E')) {
11303                     if ((!terminate) &&
11304                         (xmlParseLookupSequence(ctxt, '>', 0, 0) < 0))
11305                         goto done;
11306 #ifdef DEBUG_PUSH
11307                     xmlGenericError(xmlGenericErrorContext,
11308                             "PP: Parsing internal subset\n");
11309 #endif
11310                     ctxt->inSubset = 1;
11311                     xmlParseDocTypeDecl(ctxt);
11312                     if (RAW == '[') {
11313                         ctxt->instate = XML_PARSER_DTD;
11314 #ifdef DEBUG_PUSH
11315                         xmlGenericError(xmlGenericErrorContext,
11316                                 "PP: entering DTD\n");
11317 #endif
11318                     } else {
11319                         /*
11320                          * Create and update the external subset.
11321                          */
11322                         ctxt->inSubset = 2;
11323                         if ((ctxt->sax != NULL) && (!ctxt->disableSAX) &&
11324                             (ctxt->sax->externalSubset != NULL))
11325                             ctxt->sax->externalSubset(ctxt->userData,
11326                                     ctxt->intSubName, ctxt->extSubSystem,
11327                                     ctxt->extSubURI);
11328                         ctxt->inSubset = 0;
11329                         xmlCleanSpecialAttr(ctxt);
11330                         ctxt->instate = XML_PARSER_PROLOG;
11331 #ifdef DEBUG_PUSH
11332                         xmlGenericError(xmlGenericErrorContext,
11333                                 "PP: entering PROLOG\n");
11334 #endif
11335                     }
11336                 } else if ((cur == '<') && (next == '!') &&
11337                            (avail < 9)) {
11338                     goto done;
11339                 } else {
11340                     ctxt->instate = XML_PARSER_START_TAG;
11341                     ctxt->progressive = 1;
11342                     xmlParseGetLasts(ctxt, &lastlt, &lastgt);
11343 #ifdef DEBUG_PUSH
11344                     xmlGenericError(xmlGenericErrorContext,
11345                             "PP: entering START_TAG\n");
11346 #endif
11347                 }
11348                 break;
11349             case XML_PARSER_PROLOG:
11350                 SKIP_BLANKS;
11351                 if (ctxt->input->buf == NULL)
11352                     avail = ctxt->input->length - (ctxt->input->cur - ctxt->input->base);
11353                 else
11354                     avail = ctxt->input->buf->buffer->use - (ctxt->input->cur - ctxt->input->base);
11355                 if (avail < 2)
11356                     goto done;
11357                 cur = ctxt->input->cur[0];
11358                 next = ctxt->input->cur[1];
11359                 if ((cur == '<') && (next == '?')) {
11360                     if ((!terminate) &&
11361                         (xmlParseLookupSequence(ctxt, '?', '>', 0) < 0))
11362                         goto done;
11363 #ifdef DEBUG_PUSH
11364                     xmlGenericError(xmlGenericErrorContext,
11365                             "PP: Parsing PI\n");
11366 #endif
11367                     xmlParsePI(ctxt);
11368                 } else if ((cur == '<') && (next == '!') &&
11369                     (ctxt->input->cur[2] == '-') && (ctxt->input->cur[3] == '-')) {
11370                     if ((!terminate) &&
11371                         (xmlParseLookupSequence(ctxt, '-', '-', '>') < 0))
11372                         goto done;
11373 #ifdef DEBUG_PUSH
11374                     xmlGenericError(xmlGenericErrorContext,
11375                             "PP: Parsing Comment\n");
11376 #endif
11377                     xmlParseComment(ctxt);
11378                     ctxt->instate = XML_PARSER_PROLOG;
11379                 } else if ((cur == '<') && (next == '!') &&
11380                            (avail < 4)) {
11381                     goto done;
11382                 } else {
11383                     ctxt->instate = XML_PARSER_START_TAG;
11384                     if (ctxt->progressive == 0)
11385                         ctxt->progressive = 1;
11386                     xmlParseGetLasts(ctxt, &lastlt, &lastgt);
11387 #ifdef DEBUG_PUSH
11388                     xmlGenericError(xmlGenericErrorContext,
11389                             "PP: entering START_TAG\n");
11390 #endif
11391                 }
11392                 break;
11393             case XML_PARSER_EPILOG:
11394                 SKIP_BLANKS;
11395                 if (ctxt->input->buf == NULL)
11396                     avail = ctxt->input->length - (ctxt->input->cur - ctxt->input->base);
11397                 else
11398                     avail = ctxt->input->buf->buffer->use - (ctxt->input->cur - ctxt->input->base);
11399                 if (avail < 2)
11400                     goto done;
11401                 cur = ctxt->input->cur[0];
11402                 next = ctxt->input->cur[1];
11403                 if ((cur == '<') && (next == '?')) {
11404                     if ((!terminate) &&
11405                         (xmlParseLookupSequence(ctxt, '?', '>', 0) < 0))
11406                         goto done;
11407 #ifdef DEBUG_PUSH
11408                     xmlGenericError(xmlGenericErrorContext,
11409                             "PP: Parsing PI\n");
11410 #endif
11411                     xmlParsePI(ctxt);
11412                     ctxt->instate = XML_PARSER_EPILOG;
11413                 } else if ((cur == '<') && (next == '!') &&
11414                     (ctxt->input->cur[2] == '-') && (ctxt->input->cur[3] == '-')) {
11415                     if ((!terminate) &&
11416                         (xmlParseLookupSequence(ctxt, '-', '-', '>') < 0))
11417                         goto done;
11418 #ifdef DEBUG_PUSH
11419                     xmlGenericError(xmlGenericErrorContext,
11420                             "PP: Parsing Comment\n");
11421 #endif
11422                     xmlParseComment(ctxt);
11423                     ctxt->instate = XML_PARSER_EPILOG;
11424                 } else if ((cur == '<') && (next == '!') &&
11425                            (avail < 4)) {
11426                     goto done;
11427                 } else {
11428                     xmlFatalErr(ctxt, XML_ERR_DOCUMENT_END, NULL);
11429                     ctxt->instate = XML_PARSER_EOF;
11430 #ifdef DEBUG_PUSH
11431                     xmlGenericError(xmlGenericErrorContext,
11432                             "PP: entering EOF\n");
11433 #endif
11434                     if ((ctxt->sax) && (ctxt->sax->endDocument != NULL))
11435                         ctxt->sax->endDocument(ctxt->userData);
11436                     goto done;
11437                 }
11438                 break;
11439             case XML_PARSER_DTD: {
11440                 /*
11441                  * Sorry but progressive parsing of the internal subset
11442                  * is not expected to be supported. We first check that
11443                  * the full content of the internal subset is available and
11444                  * the parsing is launched only at that point.
11445                  * Internal subset ends up with "']' S? '>'" in an unescaped
11446                  * section and not in a ']]>' sequence which are conditional
11447                  * sections (whoever argued to keep that crap in XML deserve
11448                  * a place in hell !).
11449                  */
11450                 int base, i;
11451                 xmlChar *buf;
11452                 xmlChar quote = 0;
11453
11454                 base = ctxt->input->cur - ctxt->input->base;
11455                 if (base < 0) return(0);
11456                 if (ctxt->checkIndex > base)
11457                     base = ctxt->checkIndex;
11458                 buf = ctxt->input->buf->buffer->content;
11459                 for (;(unsigned int) base < ctxt->input->buf->buffer->use;
11460                      base++) {
11461                     if (quote != 0) {
11462                         if (buf[base] == quote)
11463                             quote = 0;
11464                         continue;
11465                     }
11466                     if ((quote == 0) && (buf[base] == '<')) {
11467                         int found  = 0;
11468                         /* special handling of comments */
11469                         if (((unsigned int) base + 4 <
11470                              ctxt->input->buf->buffer->use) &&
11471                             (buf[base + 1] == '!') &&
11472                             (buf[base + 2] == '-') &&
11473                             (buf[base + 3] == '-')) {
11474                             for (;(unsigned int) base + 3 <
11475                                   ctxt->input->buf->buffer->use; base++) {
11476                                 if ((buf[base] == '-') &&
11477                                     (buf[base + 1] == '-') &&
11478                                     (buf[base + 2] == '>')) {
11479                                     found = 1;
11480                                     base += 2;
11481                                     break;
11482                                 }
11483                             }
11484                             if (!found) {
11485 #if 0
11486                                 fprintf(stderr, "unfinished comment\n");
11487 #endif
11488                                 break; /* for */
11489                             }
11490                             continue;
11491                         }
11492                     }
11493                     if (buf[base] == '"') {
11494                         quote = '"';
11495                         continue;
11496                     }
11497                     if (buf[base] == '\'') {
11498                         quote = '\'';
11499                         continue;
11500                     }
11501                     if (buf[base] == ']') {
11502 #if 0
11503                         fprintf(stderr, "%c%c%c%c: ", buf[base],
11504                                 buf[base + 1], buf[base + 2], buf[base + 3]);
11505 #endif
11506                         if ((unsigned int) base +1 >=
11507                             ctxt->input->buf->buffer->use)
11508                             break;
11509                         if (buf[base + 1] == ']') {
11510                             /* conditional crap, skip both ']' ! */
11511                             base++;
11512                             continue;
11513                         }
11514                         for (i = 1;
11515                      (unsigned int) base + i < ctxt->input->buf->buffer->use;
11516                              i++) {
11517                             if (buf[base + i] == '>') {
11518 #if 0
11519                                 fprintf(stderr, "found\n");
11520 #endif
11521                                 goto found_end_int_subset;
11522                             }
11523                             if (!IS_BLANK_CH(buf[base + i])) {
11524 #if 0
11525                                 fprintf(stderr, "not found\n");
11526 #endif
11527                                 goto not_end_of_int_subset;
11528                             }
11529                         }
11530 #if 0
11531                         fprintf(stderr, "end of stream\n");
11532 #endif
11533                         break;
11534
11535                     }
11536 not_end_of_int_subset:
11537                     continue; /* for */
11538                 }
11539                 /*
11540                  * We didn't found the end of the Internal subset
11541                  */
11542 #ifdef DEBUG_PUSH
11543                 if (next == 0)
11544                     xmlGenericError(xmlGenericErrorContext,
11545                             "PP: lookup of int subset end filed\n");
11546 #endif
11547                 goto done;
11548
11549 found_end_int_subset:
11550                 xmlParseInternalSubset(ctxt);
11551                 ctxt->inSubset = 2;
11552                 if ((ctxt->sax != NULL) && (!ctxt->disableSAX) &&
11553                     (ctxt->sax->externalSubset != NULL))
11554                     ctxt->sax->externalSubset(ctxt->userData, ctxt->intSubName,
11555                             ctxt->extSubSystem, ctxt->extSubURI);
11556                 ctxt->inSubset = 0;
11557                 xmlCleanSpecialAttr(ctxt);
11558                 ctxt->instate = XML_PARSER_PROLOG;
11559                 ctxt->checkIndex = 0;
11560 #ifdef DEBUG_PUSH
11561                 xmlGenericError(xmlGenericErrorContext,
11562                         "PP: entering PROLOG\n");
11563 #endif
11564                 break;
11565             }
11566             case XML_PARSER_COMMENT:
11567                 xmlGenericError(xmlGenericErrorContext,
11568                         "PP: internal error, state == COMMENT\n");
11569                 ctxt->instate = XML_PARSER_CONTENT;
11570 #ifdef DEBUG_PUSH
11571                 xmlGenericError(xmlGenericErrorContext,
11572                         "PP: entering CONTENT\n");
11573 #endif
11574                 break;
11575             case XML_PARSER_IGNORE:
11576                 xmlGenericError(xmlGenericErrorContext,
11577                         "PP: internal error, state == IGNORE");
11578                 ctxt->instate = XML_PARSER_DTD;
11579 #ifdef DEBUG_PUSH
11580                 xmlGenericError(xmlGenericErrorContext,
11581                         "PP: entering DTD\n");
11582 #endif
11583                 break;
11584             case XML_PARSER_PI:
11585                 xmlGenericError(xmlGenericErrorContext,
11586                         "PP: internal error, state == PI\n");
11587                 ctxt->instate = XML_PARSER_CONTENT;
11588 #ifdef DEBUG_PUSH
11589                 xmlGenericError(xmlGenericErrorContext,
11590                         "PP: entering CONTENT\n");
11591 #endif
11592                 break;
11593             case XML_PARSER_ENTITY_DECL:
11594                 xmlGenericError(xmlGenericErrorContext,
11595                         "PP: internal error, state == ENTITY_DECL\n");
11596                 ctxt->instate = XML_PARSER_DTD;
11597 #ifdef DEBUG_PUSH
11598                 xmlGenericError(xmlGenericErrorContext,
11599                         "PP: entering DTD\n");
11600 #endif
11601                 break;
11602             case XML_PARSER_ENTITY_VALUE:
11603                 xmlGenericError(xmlGenericErrorContext,
11604                         "PP: internal error, state == ENTITY_VALUE\n");
11605                 ctxt->instate = XML_PARSER_CONTENT;
11606 #ifdef DEBUG_PUSH
11607                 xmlGenericError(xmlGenericErrorContext,
11608                         "PP: entering DTD\n");
11609 #endif
11610                 break;
11611             case XML_PARSER_ATTRIBUTE_VALUE:
11612                 xmlGenericError(xmlGenericErrorContext,
11613                         "PP: internal error, state == ATTRIBUTE_VALUE\n");
11614                 ctxt->instate = XML_PARSER_START_TAG;
11615 #ifdef DEBUG_PUSH
11616                 xmlGenericError(xmlGenericErrorContext,
11617                         "PP: entering START_TAG\n");
11618 #endif
11619                 break;
11620             case XML_PARSER_SYSTEM_LITERAL:
11621                 xmlGenericError(xmlGenericErrorContext,
11622                         "PP: internal error, state == SYSTEM_LITERAL\n");
11623                 ctxt->instate = XML_PARSER_START_TAG;
11624 #ifdef DEBUG_PUSH
11625                 xmlGenericError(xmlGenericErrorContext,
11626                         "PP: entering START_TAG\n");
11627 #endif
11628                 break;
11629             case XML_PARSER_PUBLIC_LITERAL:
11630                 xmlGenericError(xmlGenericErrorContext,
11631                         "PP: internal error, state == PUBLIC_LITERAL\n");
11632                 ctxt->instate = XML_PARSER_START_TAG;
11633 #ifdef DEBUG_PUSH
11634                 xmlGenericError(xmlGenericErrorContext,
11635                         "PP: entering START_TAG\n");
11636 #endif
11637                 break;
11638         }
11639     }
11640 done:
11641 #ifdef DEBUG_PUSH
11642     xmlGenericError(xmlGenericErrorContext, "PP: done %d\n", ret);
11643 #endif
11644     return(ret);
11645 encoding_error:
11646     {
11647         char buffer[150];
11648
11649         snprintf(buffer, 149, "Bytes: 0x%02X 0x%02X 0x%02X 0x%02X\n",
11650                         ctxt->input->cur[0], ctxt->input->cur[1],
11651                         ctxt->input->cur[2], ctxt->input->cur[3]);
11652         __xmlErrEncoding(ctxt, XML_ERR_INVALID_CHAR,
11653                      "Input is not proper UTF-8, indicate encoding !\n%s",
11654                      BAD_CAST buffer, NULL);
11655     }
11656     return(0);
11657 }
11658
11659 /**
11660  * xmlParseChunk:
11661  * @ctxt:  an XML parser context
11662  * @chunk:  an char array
11663  * @size:  the size in byte of the chunk
11664  * @terminate:  last chunk indicator
11665  *
11666  * Parse a Chunk of memory
11667  *
11668  * Returns zero if no error, the xmlParserErrors otherwise.
11669  */
11670 int
11671 xmlParseChunk(xmlParserCtxtPtr ctxt, const char *chunk, int size,
11672               int terminate) {
11673     int end_in_lf = 0;
11674     int remain = 0;
11675
11676     if (ctxt == NULL)
11677         return(XML_ERR_INTERNAL_ERROR);
11678     if ((ctxt->errNo != XML_ERR_OK) && (ctxt->disableSAX == 1))
11679         return(ctxt->errNo);
11680     if (ctxt->instate == XML_PARSER_START)
11681         xmlDetectSAX2(ctxt);
11682     if ((size > 0) && (chunk != NULL) && (!terminate) &&
11683         (chunk[size - 1] == '\r')) {
11684         end_in_lf = 1;
11685         size--;
11686     }
11687
11688 xmldecl_done:
11689
11690     if ((size > 0) && (chunk != NULL) && (ctxt->input != NULL) &&
11691         (ctxt->input->buf != NULL) && (ctxt->instate != XML_PARSER_EOF))  {
11692         int base = ctxt->input->base - ctxt->input->buf->buffer->content;
11693         int cur = ctxt->input->cur - ctxt->input->base;
11694         int res;
11695
11696         /*
11697          * Specific handling if we autodetected an encoding, we should not
11698          * push more than the first line ... which depend on the encoding
11699          * And only push the rest once the final encoding was detected
11700          */
11701         if ((ctxt->instate == XML_PARSER_START) && (ctxt->input != NULL) &&
11702             (ctxt->input->buf != NULL) && (ctxt->input->buf->encoder != NULL)) {
11703             unsigned int len = 45;
11704
11705             if ((xmlStrcasestr(BAD_CAST ctxt->input->buf->encoder->name,
11706                                BAD_CAST "UTF-16")) ||
11707                 (xmlStrcasestr(BAD_CAST ctxt->input->buf->encoder->name,
11708                                BAD_CAST "UTF16")))
11709                 len = 90;
11710             else if ((xmlStrcasestr(BAD_CAST ctxt->input->buf->encoder->name,
11711                                     BAD_CAST "UCS-4")) ||
11712                      (xmlStrcasestr(BAD_CAST ctxt->input->buf->encoder->name,
11713                                     BAD_CAST "UCS4")))
11714                 len = 180;
11715
11716             if (ctxt->input->buf->rawconsumed < len)
11717                 len -= ctxt->input->buf->rawconsumed;
11718
11719             /*
11720              * Change size for reading the initial declaration only
11721              * if size is greater than len. Otherwise, memmove in xmlBufferAdd
11722              * will blindly copy extra bytes from memory.
11723              */
11724             if ((unsigned int) size > len) {
11725                 remain = size - len;
11726                 size = len;
11727             } else {
11728                 remain = 0;
11729             }
11730         }
11731         res =xmlParserInputBufferPush(ctxt->input->buf, size, chunk);
11732         if (res < 0) {
11733             ctxt->errNo = XML_PARSER_EOF;
11734             ctxt->disableSAX = 1;
11735             return (XML_PARSER_EOF);
11736         }
11737         ctxt->input->base = ctxt->input->buf->buffer->content + base;
11738         ctxt->input->cur = ctxt->input->base + cur;
11739         ctxt->input->end =
11740             &ctxt->input->buf->buffer->content[ctxt->input->buf->buffer->use];
11741 #ifdef DEBUG_PUSH
11742         xmlGenericError(xmlGenericErrorContext, "PP: pushed %d\n", size);
11743 #endif
11744
11745     } else if (ctxt->instate != XML_PARSER_EOF) {
11746         if ((ctxt->input != NULL) && ctxt->input->buf != NULL) {
11747             xmlParserInputBufferPtr in = ctxt->input->buf;
11748             if ((in->encoder != NULL) && (in->buffer != NULL) &&
11749                     (in->raw != NULL)) {
11750                 int nbchars;
11751
11752                 nbchars = xmlCharEncInFunc(in->encoder, in->buffer, in->raw);
11753                 if (nbchars < 0) {
11754                     /* TODO 2.6.0 */
11755                     xmlGenericError(xmlGenericErrorContext,
11756                                     "xmlParseChunk: encoder error\n");
11757                     return(XML_ERR_INVALID_ENCODING);
11758                 }
11759             }
11760         }
11761     }
11762     if (remain != 0)
11763         xmlParseTryOrFinish(ctxt, 0);
11764     else
11765         xmlParseTryOrFinish(ctxt, terminate);
11766     if ((ctxt->errNo != XML_ERR_OK) && (ctxt->disableSAX == 1))
11767         return(ctxt->errNo);
11768
11769     if (remain != 0) {
11770         chunk += size;
11771         size = remain;
11772         remain = 0;
11773         goto xmldecl_done;
11774     }
11775     if ((end_in_lf == 1) && (ctxt->input != NULL) &&
11776         (ctxt->input->buf != NULL)) {
11777         xmlParserInputBufferPush(ctxt->input->buf, 1, "\r");
11778     }
11779     if (terminate) {
11780         /*
11781          * Check for termination
11782          */
11783         int avail = 0;
11784
11785         if (ctxt->input != NULL) {
11786             if (ctxt->input->buf == NULL)
11787                 avail = ctxt->input->length -
11788                         (ctxt->input->cur - ctxt->input->base);
11789             else
11790                 avail = ctxt->input->buf->buffer->use -
11791                         (ctxt->input->cur - ctxt->input->base);
11792         }
11793
11794         if ((ctxt->instate != XML_PARSER_EOF) &&
11795             (ctxt->instate != XML_PARSER_EPILOG)) {
11796             xmlFatalErr(ctxt, XML_ERR_DOCUMENT_END, NULL);
11797         }
11798         if ((ctxt->instate == XML_PARSER_EPILOG) && (avail > 0)) {
11799             xmlFatalErr(ctxt, XML_ERR_DOCUMENT_END, NULL);
11800         }
11801         if (ctxt->instate != XML_PARSER_EOF) {
11802             if ((ctxt->sax) && (ctxt->sax->endDocument != NULL))
11803                 ctxt->sax->endDocument(ctxt->userData);
11804         }
11805         ctxt->instate = XML_PARSER_EOF;
11806     }
11807     return((xmlParserErrors) ctxt->errNo);
11808 }
11809
11810 /************************************************************************
11811  *                                                                      *
11812  *              I/O front end functions to the parser                   *
11813  *                                                                      *
11814  ************************************************************************/
11815
11816 /**
11817  * xmlCreatePushParserCtxt:
11818  * @sax:  a SAX handler
11819  * @user_data:  The user data returned on SAX callbacks
11820  * @chunk:  a pointer to an array of chars
11821  * @size:  number of chars in the array
11822  * @filename:  an optional file name or URI
11823  *
11824  * Create a parser context for using the XML parser in push mode.
11825  * If @buffer and @size are non-NULL, the data is used to detect
11826  * the encoding.  The remaining characters will be parsed so they
11827  * don't need to be fed in again through xmlParseChunk.
11828  * To allow content encoding detection, @size should be >= 4
11829  * The value of @filename is used for fetching external entities
11830  * and error/warning reports.
11831  *
11832  * Returns the new parser context or NULL
11833  */
11834
11835 xmlParserCtxtPtr
11836 xmlCreatePushParserCtxt(xmlSAXHandlerPtr sax, void *user_data,
11837                         const char *chunk, int size, const char *filename) {
11838     xmlParserCtxtPtr ctxt;
11839     xmlParserInputPtr inputStream;
11840     xmlParserInputBufferPtr buf;
11841     xmlCharEncoding enc = XML_CHAR_ENCODING_NONE;
11842
11843     /*
11844      * plug some encoding conversion routines
11845      */
11846     if ((chunk != NULL) && (size >= 4))
11847         enc = xmlDetectCharEncoding((const xmlChar *) chunk, size);
11848
11849     buf = xmlAllocParserInputBuffer(enc);
11850     if (buf == NULL) return(NULL);
11851
11852     ctxt = xmlNewParserCtxt();
11853     if (ctxt == NULL) {
11854         xmlErrMemory(NULL, "creating parser: out of memory\n");
11855         xmlFreeParserInputBuffer(buf);
11856         return(NULL);
11857     }
11858     ctxt->dictNames = 1;
11859     ctxt->pushTab = (void **) xmlMalloc(ctxt->nameMax * 3 * sizeof(xmlChar *));
11860     if (ctxt->pushTab == NULL) {
11861         xmlErrMemory(ctxt, NULL);
11862         xmlFreeParserInputBuffer(buf);
11863         xmlFreeParserCtxt(ctxt);
11864         return(NULL);
11865     }
11866     if (sax != NULL) {
11867 #ifdef LIBXML_SAX1_ENABLED
11868         if (ctxt->sax != (xmlSAXHandlerPtr) &xmlDefaultSAXHandler)
11869 #endif /* LIBXML_SAX1_ENABLED */
11870             xmlFree(ctxt->sax);
11871         ctxt->sax = (xmlSAXHandlerPtr) xmlMalloc(sizeof(xmlSAXHandler));
11872         if (ctxt->sax == NULL) {
11873             xmlErrMemory(ctxt, NULL);
11874             xmlFreeParserInputBuffer(buf);
11875             xmlFreeParserCtxt(ctxt);
11876             return(NULL);
11877         }
11878         memset(ctxt->sax, 0, sizeof(xmlSAXHandler));
11879         if (sax->initialized == XML_SAX2_MAGIC)
11880             memcpy(ctxt->sax, sax, sizeof(xmlSAXHandler));
11881         else
11882             memcpy(ctxt->sax, sax, sizeof(xmlSAXHandlerV1));
11883         if (user_data != NULL)
11884             ctxt->userData = user_data;
11885     }
11886     if (filename == NULL) {
11887         ctxt->directory = NULL;
11888     } else {
11889         ctxt->directory = xmlParserGetDirectory(filename);
11890     }
11891
11892     inputStream = xmlNewInputStream(ctxt);
11893     if (inputStream == NULL) {
11894         xmlFreeParserCtxt(ctxt);
11895         xmlFreeParserInputBuffer(buf);
11896         return(NULL);
11897     }
11898
11899     if (filename == NULL)
11900         inputStream->filename = NULL;
11901     else {
11902         inputStream->filename = (char *)
11903             xmlCanonicPath((const xmlChar *) filename);
11904         if (inputStream->filename == NULL) {
11905             xmlFreeParserCtxt(ctxt);
11906             xmlFreeParserInputBuffer(buf);
11907             return(NULL);
11908         }
11909     }
11910     inputStream->buf = buf;
11911     inputStream->base = inputStream->buf->buffer->content;
11912     inputStream->cur = inputStream->buf->buffer->content;
11913     inputStream->end =
11914         &inputStream->buf->buffer->content[inputStream->buf->buffer->use];
11915
11916     inputPush(ctxt, inputStream);
11917
11918     /*
11919      * If the caller didn't provide an initial 'chunk' for determining
11920      * the encoding, we set the context to XML_CHAR_ENCODING_NONE so
11921      * that it can be automatically determined later
11922      */
11923     if ((size == 0) || (chunk == NULL)) {
11924         ctxt->charset = XML_CHAR_ENCODING_NONE;
11925     } else if ((ctxt->input != NULL) && (ctxt->input->buf != NULL)) {
11926         int base = ctxt->input->base - ctxt->input->buf->buffer->content;
11927         int cur = ctxt->input->cur - ctxt->input->base;
11928
11929         xmlParserInputBufferPush(ctxt->input->buf, size, chunk);
11930
11931         ctxt->input->base = ctxt->input->buf->buffer->content + base;
11932         ctxt->input->cur = ctxt->input->base + cur;
11933         ctxt->input->end =
11934             &ctxt->input->buf->buffer->content[ctxt->input->buf->buffer->use];
11935 #ifdef DEBUG_PUSH
11936         xmlGenericError(xmlGenericErrorContext, "PP: pushed %d\n", size);
11937 #endif
11938     }
11939
11940     if (enc != XML_CHAR_ENCODING_NONE) {
11941         xmlSwitchEncoding(ctxt, enc);
11942     }
11943
11944     return(ctxt);
11945 }
11946 #endif /* LIBXML_PUSH_ENABLED */
11947
11948 /**
11949  * xmlStopParser:
11950  * @ctxt:  an XML parser context
11951  *
11952  * Blocks further parser processing
11953  */
11954 void
11955 xmlStopParser(xmlParserCtxtPtr ctxt) {
11956     if (ctxt == NULL)
11957         return;
11958     ctxt->instate = XML_PARSER_EOF;
11959     ctxt->disableSAX = 1;
11960     if (ctxt->input != NULL) {
11961         ctxt->input->cur = BAD_CAST"";
11962         ctxt->input->base = ctxt->input->cur;
11963     }
11964 }
11965
11966 /**
11967  * xmlCreateIOParserCtxt:
11968  * @sax:  a SAX handler
11969  * @user_data:  The user data returned on SAX callbacks
11970  * @ioread:  an I/O read function
11971  * @ioclose:  an I/O close function
11972  * @ioctx:  an I/O handler
11973  * @enc:  the charset encoding if known
11974  *
11975  * Create a parser context for using the XML parser with an existing
11976  * I/O stream
11977  *
11978  * Returns the new parser context or NULL
11979  */
11980 xmlParserCtxtPtr
11981 xmlCreateIOParserCtxt(xmlSAXHandlerPtr sax, void *user_data,
11982         xmlInputReadCallback   ioread, xmlInputCloseCallback  ioclose,
11983         void *ioctx, xmlCharEncoding enc) {
11984     xmlParserCtxtPtr ctxt;
11985     xmlParserInputPtr inputStream;
11986     xmlParserInputBufferPtr buf;
11987
11988     if (ioread == NULL) return(NULL);
11989
11990     buf = xmlParserInputBufferCreateIO(ioread, ioclose, ioctx, enc);
11991     if (buf == NULL) {
11992         if (ioclose != NULL)
11993             ioclose(ioctx);
11994         return (NULL);
11995     }
11996
11997     ctxt = xmlNewParserCtxt();
11998     if (ctxt == NULL) {
11999         xmlFreeParserInputBuffer(buf);
12000         return(NULL);
12001     }
12002     if (sax != NULL) {
12003 #ifdef LIBXML_SAX1_ENABLED
12004         if (ctxt->sax != (xmlSAXHandlerPtr) &xmlDefaultSAXHandler)
12005 #endif /* LIBXML_SAX1_ENABLED */
12006             xmlFree(ctxt->sax);
12007         ctxt->sax = (xmlSAXHandlerPtr) xmlMalloc(sizeof(xmlSAXHandler));
12008         if (ctxt->sax == NULL) {
12009             xmlErrMemory(ctxt, NULL);
12010             xmlFreeParserCtxt(ctxt);
12011             return(NULL);
12012         }
12013         memset(ctxt->sax, 0, sizeof(xmlSAXHandler));
12014         if (sax->initialized == XML_SAX2_MAGIC)
12015             memcpy(ctxt->sax, sax, sizeof(xmlSAXHandler));
12016         else
12017             memcpy(ctxt->sax, sax, sizeof(xmlSAXHandlerV1));
12018         if (user_data != NULL)
12019             ctxt->userData = user_data;
12020     }
12021
12022     inputStream = xmlNewIOInputStream(ctxt, buf, enc);
12023     if (inputStream == NULL) {
12024         xmlFreeParserCtxt(ctxt);
12025         return(NULL);
12026     }
12027     inputPush(ctxt, inputStream);
12028
12029     return(ctxt);
12030 }
12031
12032 #ifdef LIBXML_VALID_ENABLED
12033 /************************************************************************
12034  *                                                                      *
12035  *              Front ends when parsing a DTD                           *
12036  *                                                                      *
12037  ************************************************************************/
12038
12039 /**
12040  * xmlIOParseDTD:
12041  * @sax:  the SAX handler block or NULL
12042  * @input:  an Input Buffer
12043  * @enc:  the charset encoding if known
12044  *
12045  * Load and parse a DTD
12046  *
12047  * Returns the resulting xmlDtdPtr or NULL in case of error.
12048  * @input will be freed by the function in any case.
12049  */
12050
12051 xmlDtdPtr
12052 xmlIOParseDTD(xmlSAXHandlerPtr sax, xmlParserInputBufferPtr input,
12053               xmlCharEncoding enc) {
12054     xmlDtdPtr ret = NULL;
12055     xmlParserCtxtPtr ctxt;
12056     xmlParserInputPtr pinput = NULL;
12057     xmlChar start[4];
12058
12059     if (input == NULL)
12060         return(NULL);
12061
12062     ctxt = xmlNewParserCtxt();
12063     if (ctxt == NULL) {
12064         xmlFreeParserInputBuffer(input);
12065         return(NULL);
12066     }
12067
12068     /*
12069      * Set-up the SAX context
12070      */
12071     if (sax != NULL) {
12072         if (ctxt->sax != NULL)
12073             xmlFree(ctxt->sax);
12074         ctxt->sax = sax;
12075         ctxt->userData = ctxt;
12076     }
12077     xmlDetectSAX2(ctxt);
12078
12079     /*
12080      * generate a parser input from the I/O handler
12081      */
12082
12083     pinput = xmlNewIOInputStream(ctxt, input, XML_CHAR_ENCODING_NONE);
12084     if (pinput == NULL) {
12085         if (sax != NULL) ctxt->sax = NULL;
12086         xmlFreeParserInputBuffer(input);
12087         xmlFreeParserCtxt(ctxt);
12088         return(NULL);
12089     }
12090
12091     /*
12092      * plug some encoding conversion routines here.
12093      */
12094     if (xmlPushInput(ctxt, pinput) < 0) {
12095         if (sax != NULL) ctxt->sax = NULL;
12096         xmlFreeParserCtxt(ctxt);
12097         return(NULL);
12098     }
12099     if (enc != XML_CHAR_ENCODING_NONE) {
12100         xmlSwitchEncoding(ctxt, enc);
12101     }
12102
12103     pinput->filename = NULL;
12104     pinput->line = 1;
12105     pinput->col = 1;
12106     pinput->base = ctxt->input->cur;
12107     pinput->cur = ctxt->input->cur;
12108     pinput->free = NULL;
12109
12110     /*
12111      * let's parse that entity knowing it's an external subset.
12112      */
12113     ctxt->inSubset = 2;
12114     ctxt->myDoc = xmlNewDoc(BAD_CAST "1.0");
12115     if (ctxt->myDoc == NULL) {
12116         xmlErrMemory(ctxt, "New Doc failed");
12117         return(NULL);
12118     }
12119     ctxt->myDoc->properties = XML_DOC_INTERNAL;
12120     ctxt->myDoc->extSubset = xmlNewDtd(ctxt->myDoc, BAD_CAST "none",
12121                                        BAD_CAST "none", BAD_CAST "none");
12122
12123     if ((enc == XML_CHAR_ENCODING_NONE) &&
12124         ((ctxt->input->end - ctxt->input->cur) >= 4)) {
12125         /*
12126          * Get the 4 first bytes and decode the charset
12127          * if enc != XML_CHAR_ENCODING_NONE
12128          * plug some encoding conversion routines.
12129          */
12130         start[0] = RAW;
12131         start[1] = NXT(1);
12132         start[2] = NXT(2);
12133         start[3] = NXT(3);
12134         enc = xmlDetectCharEncoding(start, 4);
12135         if (enc != XML_CHAR_ENCODING_NONE) {
12136             xmlSwitchEncoding(ctxt, enc);
12137         }
12138     }
12139
12140     xmlParseExternalSubset(ctxt, BAD_CAST "none", BAD_CAST "none");
12141
12142     if (ctxt->myDoc != NULL) {
12143         if (ctxt->wellFormed) {
12144             ret = ctxt->myDoc->extSubset;
12145             ctxt->myDoc->extSubset = NULL;
12146             if (ret != NULL) {
12147                 xmlNodePtr tmp;
12148
12149                 ret->doc = NULL;
12150                 tmp = ret->children;
12151                 while (tmp != NULL) {
12152                     tmp->doc = NULL;
12153                     tmp = tmp->next;
12154                 }
12155             }
12156         } else {
12157             ret = NULL;
12158         }
12159         xmlFreeDoc(ctxt->myDoc);
12160         ctxt->myDoc = NULL;
12161     }
12162     if (sax != NULL) ctxt->sax = NULL;
12163     xmlFreeParserCtxt(ctxt);
12164
12165     return(ret);
12166 }
12167
12168 /**
12169  * xmlSAXParseDTD:
12170  * @sax:  the SAX handler block
12171  * @ExternalID:  a NAME* containing the External ID of the DTD
12172  * @SystemID:  a NAME* containing the URL to the DTD
12173  *
12174  * Load and parse an external subset.
12175  *
12176  * Returns the resulting xmlDtdPtr or NULL in case of error.
12177  */
12178
12179 xmlDtdPtr
12180 xmlSAXParseDTD(xmlSAXHandlerPtr sax, const xmlChar *ExternalID,
12181                           const xmlChar *SystemID) {
12182     xmlDtdPtr ret = NULL;
12183     xmlParserCtxtPtr ctxt;
12184     xmlParserInputPtr input = NULL;
12185     xmlCharEncoding enc;
12186     xmlChar* systemIdCanonic;
12187
12188     if ((ExternalID == NULL) && (SystemID == NULL)) return(NULL);
12189
12190     ctxt = xmlNewParserCtxt();
12191     if (ctxt == NULL) {
12192         return(NULL);
12193     }
12194
12195     /*
12196      * Set-up the SAX context
12197      */
12198     if (sax != NULL) {
12199         if (ctxt->sax != NULL)
12200             xmlFree(ctxt->sax);
12201         ctxt->sax = sax;
12202         ctxt->userData = ctxt;
12203     }
12204
12205     /*
12206      * Canonicalise the system ID
12207      */
12208     systemIdCanonic = xmlCanonicPath(SystemID);
12209     if ((SystemID != NULL) && (systemIdCanonic == NULL)) {
12210         xmlFreeParserCtxt(ctxt);
12211         return(NULL);
12212     }
12213
12214     /*
12215      * Ask the Entity resolver to load the damn thing
12216      */
12217
12218     if ((ctxt->sax != NULL) && (ctxt->sax->resolveEntity != NULL))
12219         input = ctxt->sax->resolveEntity(ctxt->userData, ExternalID,
12220                                          systemIdCanonic);
12221     if (input == NULL) {
12222         if (sax != NULL) ctxt->sax = NULL;
12223         xmlFreeParserCtxt(ctxt);
12224         if (systemIdCanonic != NULL)
12225             xmlFree(systemIdCanonic);
12226         return(NULL);
12227     }
12228
12229     /*
12230      * plug some encoding conversion routines here.
12231      */
12232     if (xmlPushInput(ctxt, input) < 0) {
12233         if (sax != NULL) ctxt->sax = NULL;
12234         xmlFreeParserCtxt(ctxt);
12235         if (systemIdCanonic != NULL)
12236             xmlFree(systemIdCanonic);
12237         return(NULL);
12238     }
12239     if ((ctxt->input->end - ctxt->input->cur) >= 4) {
12240         enc = xmlDetectCharEncoding(ctxt->input->cur, 4);
12241         xmlSwitchEncoding(ctxt, enc);
12242     }
12243
12244     if (input->filename == NULL)
12245         input->filename = (char *) systemIdCanonic;
12246     else
12247         xmlFree(systemIdCanonic);
12248     input->line = 1;
12249     input->col = 1;
12250     input->base = ctxt->input->cur;
12251     input->cur = ctxt->input->cur;
12252     input->free = NULL;
12253
12254     /*
12255      * let's parse that entity knowing it's an external subset.
12256      */
12257     ctxt->inSubset = 2;
12258     ctxt->myDoc = xmlNewDoc(BAD_CAST "1.0");
12259     if (ctxt->myDoc == NULL) {
12260         xmlErrMemory(ctxt, "New Doc failed");
12261         if (sax != NULL) ctxt->sax = NULL;
12262         xmlFreeParserCtxt(ctxt);
12263         return(NULL);
12264     }
12265     ctxt->myDoc->properties = XML_DOC_INTERNAL;
12266     ctxt->myDoc->extSubset = xmlNewDtd(ctxt->myDoc, BAD_CAST "none",
12267                                        ExternalID, SystemID);
12268     xmlParseExternalSubset(ctxt, ExternalID, SystemID);
12269
12270     if (ctxt->myDoc != NULL) {
12271         if (ctxt->wellFormed) {
12272             ret = ctxt->myDoc->extSubset;
12273             ctxt->myDoc->extSubset = NULL;
12274             if (ret != NULL) {
12275                 xmlNodePtr tmp;
12276
12277                 ret->doc = NULL;
12278                 tmp = ret->children;
12279                 while (tmp != NULL) {
12280                     tmp->doc = NULL;
12281                     tmp = tmp->next;
12282                 }
12283             }
12284         } else {
12285             ret = NULL;
12286         }
12287         xmlFreeDoc(ctxt->myDoc);
12288         ctxt->myDoc = NULL;
12289     }
12290     if (sax != NULL) ctxt->sax = NULL;
12291     xmlFreeParserCtxt(ctxt);
12292
12293     return(ret);
12294 }
12295
12296
12297 /**
12298  * xmlParseDTD:
12299  * @ExternalID:  a NAME* containing the External ID of the DTD
12300  * @SystemID:  a NAME* containing the URL to the DTD
12301  *
12302  * Load and parse an external subset.
12303  *
12304  * Returns the resulting xmlDtdPtr or NULL in case of error.
12305  */
12306
12307 xmlDtdPtr
12308 xmlParseDTD(const xmlChar *ExternalID, const xmlChar *SystemID) {
12309     return(xmlSAXParseDTD(NULL, ExternalID, SystemID));
12310 }
12311 #endif /* LIBXML_VALID_ENABLED */
12312
12313 /************************************************************************
12314  *                                                                      *
12315  *              Front ends when parsing an Entity                       *
12316  *                                                                      *
12317  ************************************************************************/
12318
12319 /**
12320  * xmlParseCtxtExternalEntity:
12321  * @ctx:  the existing parsing context
12322  * @URL:  the URL for the entity to load
12323  * @ID:  the System ID for the entity to load
12324  * @lst:  the return value for the set of parsed nodes
12325  *
12326  * Parse an external general entity within an existing parsing context
12327  * An external general parsed entity is well-formed if it matches the
12328  * production labeled extParsedEnt.
12329  *
12330  * [78] extParsedEnt ::= TextDecl? content
12331  *
12332  * Returns 0 if the entity is well formed, -1 in case of args problem and
12333  *    the parser error code otherwise
12334  */
12335
12336 int
12337 xmlParseCtxtExternalEntity(xmlParserCtxtPtr ctx, const xmlChar *URL,
12338                        const xmlChar *ID, xmlNodePtr *lst) {
12339     xmlParserCtxtPtr ctxt;
12340     xmlDocPtr newDoc;
12341     xmlNodePtr newRoot;
12342     xmlSAXHandlerPtr oldsax = NULL;
12343     int ret = 0;
12344     xmlChar start[4];
12345     xmlCharEncoding enc;
12346
12347     if (ctx == NULL) return(-1);
12348
12349     if (((ctx->depth > 40) && ((ctx->options & XML_PARSE_HUGE) == 0)) ||
12350         (ctx->depth > 1024)) {
12351         return(XML_ERR_ENTITY_LOOP);
12352     }
12353
12354     if (lst != NULL)
12355         *lst = NULL;
12356     if ((URL == NULL) && (ID == NULL))
12357         return(-1);
12358     if (ctx->myDoc == NULL) /* @@ relax but check for dereferences */
12359         return(-1);
12360
12361     ctxt = xmlCreateEntityParserCtxtInternal(URL, ID, NULL, ctx);
12362     if (ctxt == NULL) {
12363         return(-1);
12364     }
12365
12366     oldsax = ctxt->sax;
12367     ctxt->sax = ctx->sax;
12368     xmlDetectSAX2(ctxt);
12369     newDoc = xmlNewDoc(BAD_CAST "1.0");
12370     if (newDoc == NULL) {
12371         xmlFreeParserCtxt(ctxt);
12372         return(-1);
12373     }
12374     newDoc->properties = XML_DOC_INTERNAL;
12375     if (ctx->myDoc->dict) {
12376         newDoc->dict = ctx->myDoc->dict;
12377         xmlDictReference(newDoc->dict);
12378     }
12379     if (ctx->myDoc != NULL) {
12380         newDoc->intSubset = ctx->myDoc->intSubset;
12381         newDoc->extSubset = ctx->myDoc->extSubset;
12382     }
12383     if (ctx->myDoc->URL != NULL) {
12384         newDoc->URL = xmlStrdup(ctx->myDoc->URL);
12385     }
12386     newRoot = xmlNewDocNode(newDoc, NULL, BAD_CAST "pseudoroot", NULL);
12387     if (newRoot == NULL) {
12388         ctxt->sax = oldsax;
12389         xmlFreeParserCtxt(ctxt);
12390         newDoc->intSubset = NULL;
12391         newDoc->extSubset = NULL;
12392         xmlFreeDoc(newDoc);
12393         return(-1);
12394     }
12395     xmlAddChild((xmlNodePtr) newDoc, newRoot);
12396     nodePush(ctxt, newDoc->children);
12397     if (ctx->myDoc == NULL) {
12398         ctxt->myDoc = newDoc;
12399     } else {
12400         ctxt->myDoc = ctx->myDoc;
12401         newDoc->children->doc = ctx->myDoc;
12402     }
12403
12404     /*
12405      * Get the 4 first bytes and decode the charset
12406      * if enc != XML_CHAR_ENCODING_NONE
12407      * plug some encoding conversion routines.
12408      */
12409     GROW
12410     if ((ctxt->input->end - ctxt->input->cur) >= 4) {
12411         start[0] = RAW;
12412         start[1] = NXT(1);
12413         start[2] = NXT(2);
12414         start[3] = NXT(3);
12415         enc = xmlDetectCharEncoding(start, 4);
12416         if (enc != XML_CHAR_ENCODING_NONE) {
12417             xmlSwitchEncoding(ctxt, enc);
12418         }
12419     }
12420
12421     /*
12422      * Parse a possible text declaration first
12423      */
12424     if ((CMP5(CUR_PTR, '<', '?', 'x', 'm', 'l')) && (IS_BLANK_CH(NXT(5)))) {
12425         xmlParseTextDecl(ctxt);
12426         /*
12427          * An XML-1.0 document can't reference an entity not XML-1.0
12428          */
12429         if ((xmlStrEqual(ctx->version, BAD_CAST "1.0")) &&
12430             (!xmlStrEqual(ctxt->input->version, BAD_CAST "1.0"))) {
12431             xmlFatalErrMsg(ctxt, XML_ERR_VERSION_MISMATCH,
12432                            "Version mismatch between document and entity\n");
12433         }
12434     }
12435
12436     /*
12437      * If the user provided its own SAX callbacks then reuse the
12438      * useData callback field, otherwise the expected setup in a
12439      * DOM builder is to have userData == ctxt
12440      */
12441     if (ctx->userData == ctx)
12442         ctxt->userData = ctxt;
12443     else
12444         ctxt->userData = ctx->userData;
12445
12446     /*
12447      * Doing validity checking on chunk doesn't make sense
12448      */
12449     ctxt->instate = XML_PARSER_CONTENT;
12450     ctxt->validate = ctx->validate;
12451     ctxt->valid = ctx->valid;
12452     ctxt->loadsubset = ctx->loadsubset;
12453     ctxt->depth = ctx->depth + 1;
12454     ctxt->replaceEntities = ctx->replaceEntities;
12455     if (ctxt->validate) {
12456         ctxt->vctxt.error = ctx->vctxt.error;
12457         ctxt->vctxt.warning = ctx->vctxt.warning;
12458     } else {
12459         ctxt->vctxt.error = NULL;
12460         ctxt->vctxt.warning = NULL;
12461     }
12462     ctxt->vctxt.nodeTab = NULL;
12463     ctxt->vctxt.nodeNr = 0;
12464     ctxt->vctxt.nodeMax = 0;
12465     ctxt->vctxt.node = NULL;
12466     if (ctxt->dict != NULL) xmlDictFree(ctxt->dict);
12467     ctxt->dict = ctx->dict;
12468     ctxt->str_xml = xmlDictLookup(ctxt->dict, BAD_CAST "xml", 3);
12469     ctxt->str_xmlns = xmlDictLookup(ctxt->dict, BAD_CAST "xmlns", 5);
12470     ctxt->str_xml_ns = xmlDictLookup(ctxt->dict, XML_XML_NAMESPACE, 36);
12471     ctxt->dictNames = ctx->dictNames;
12472     ctxt->attsDefault = ctx->attsDefault;
12473     ctxt->attsSpecial = ctx->attsSpecial;
12474     ctxt->linenumbers = ctx->linenumbers;
12475
12476     xmlParseContent(ctxt);
12477
12478     ctx->validate = ctxt->validate;
12479     ctx->valid = ctxt->valid;
12480     if ((RAW == '<') && (NXT(1) == '/')) {
12481         xmlFatalErr(ctxt, XML_ERR_NOT_WELL_BALANCED, NULL);
12482     } else if (RAW != 0) {
12483         xmlFatalErr(ctxt, XML_ERR_EXTRA_CONTENT, NULL);
12484     }
12485     if (ctxt->node != newDoc->children) {
12486         xmlFatalErr(ctxt, XML_ERR_NOT_WELL_BALANCED, NULL);
12487     }
12488
12489     if (!ctxt->wellFormed) {
12490         if (ctxt->errNo == 0)
12491             ret = 1;
12492         else
12493             ret = ctxt->errNo;
12494     } else {
12495         if (lst != NULL) {
12496             xmlNodePtr cur;
12497
12498             /*
12499              * Return the newly created nodeset after unlinking it from
12500              * they pseudo parent.
12501              */
12502             cur = newDoc->children->children;
12503             *lst = cur;
12504             while (cur != NULL) {
12505                 cur->parent = NULL;
12506                 cur = cur->next;
12507             }
12508             newDoc->children->children = NULL;
12509         }
12510         ret = 0;
12511     }
12512     ctxt->sax = oldsax;
12513     ctxt->dict = NULL;
12514     ctxt->attsDefault = NULL;
12515     ctxt->attsSpecial = NULL;
12516     xmlFreeParserCtxt(ctxt);
12517     newDoc->intSubset = NULL;
12518     newDoc->extSubset = NULL;
12519     xmlFreeDoc(newDoc);
12520
12521     return(ret);
12522 }
12523
12524 /**
12525  * xmlParseExternalEntityPrivate:
12526  * @doc:  the document the chunk pertains to
12527  * @oldctxt:  the previous parser context if available
12528  * @sax:  the SAX handler bloc (possibly NULL)
12529  * @user_data:  The user data returned on SAX callbacks (possibly NULL)
12530  * @depth:  Used for loop detection, use 0
12531  * @URL:  the URL for the entity to load
12532  * @ID:  the System ID for the entity to load
12533  * @list:  the return value for the set of parsed nodes
12534  *
12535  * Private version of xmlParseExternalEntity()
12536  *
12537  * Returns 0 if the entity is well formed, -1 in case of args problem and
12538  *    the parser error code otherwise
12539  */
12540
12541 static xmlParserErrors
12542 xmlParseExternalEntityPrivate(xmlDocPtr doc, xmlParserCtxtPtr oldctxt,
12543                       xmlSAXHandlerPtr sax,
12544                       void *user_data, int depth, const xmlChar *URL,
12545                       const xmlChar *ID, xmlNodePtr *list) {
12546     xmlParserCtxtPtr ctxt;
12547     xmlDocPtr newDoc;
12548     xmlNodePtr newRoot;
12549     xmlSAXHandlerPtr oldsax = NULL;
12550     xmlParserErrors ret = XML_ERR_OK;
12551     xmlChar start[4];
12552     xmlCharEncoding enc;
12553
12554     if (((depth > 40) &&
12555         ((oldctxt == NULL) || (oldctxt->options & XML_PARSE_HUGE) == 0)) ||
12556         (depth > 1024)) {
12557         return(XML_ERR_ENTITY_LOOP);
12558     }
12559
12560     if (list != NULL)
12561         *list = NULL;
12562     if ((URL == NULL) && (ID == NULL))
12563         return(XML_ERR_INTERNAL_ERROR);
12564     if (doc == NULL)
12565         return(XML_ERR_INTERNAL_ERROR);
12566
12567
12568     ctxt = xmlCreateEntityParserCtxtInternal(URL, ID, NULL, oldctxt);
12569     if (ctxt == NULL) return(XML_WAR_UNDECLARED_ENTITY);
12570     ctxt->userData = ctxt;
12571     if (oldctxt != NULL) {
12572         ctxt->_private = oldctxt->_private;
12573         ctxt->loadsubset = oldctxt->loadsubset;
12574         ctxt->validate = oldctxt->validate;
12575         ctxt->external = oldctxt->external;
12576         ctxt->record_info = oldctxt->record_info;
12577         ctxt->node_seq.maximum = oldctxt->node_seq.maximum;
12578         ctxt->node_seq.length = oldctxt->node_seq.length;
12579         ctxt->node_seq.buffer = oldctxt->node_seq.buffer;
12580     } else {
12581         /*
12582          * Doing validity checking on chunk without context
12583          * doesn't make sense
12584          */
12585         ctxt->_private = NULL;
12586         ctxt->validate = 0;
12587         ctxt->external = 2;
12588         ctxt->loadsubset = 0;
12589     }
12590     if (sax != NULL) {
12591         oldsax = ctxt->sax;
12592         ctxt->sax = sax;
12593         if (user_data != NULL)
12594             ctxt->userData = user_data;
12595     }
12596     xmlDetectSAX2(ctxt);
12597     newDoc = xmlNewDoc(BAD_CAST "1.0");
12598     if (newDoc == NULL) {
12599         ctxt->node_seq.maximum = 0;
12600         ctxt->node_seq.length = 0;
12601         ctxt->node_seq.buffer = NULL;
12602         xmlFreeParserCtxt(ctxt);
12603         return(XML_ERR_INTERNAL_ERROR);
12604     }
12605     newDoc->properties = XML_DOC_INTERNAL;
12606     newDoc->intSubset = doc->intSubset;
12607     newDoc->extSubset = doc->extSubset;
12608     newDoc->dict = doc->dict;
12609     xmlDictReference(newDoc->dict);
12610
12611     if (doc->URL != NULL) {
12612         newDoc->URL = xmlStrdup(doc->URL);
12613     }
12614     newRoot = xmlNewDocNode(newDoc, NULL, BAD_CAST "pseudoroot", NULL);
12615     if (newRoot == NULL) {
12616         if (sax != NULL)
12617             ctxt->sax = oldsax;
12618         ctxt->node_seq.maximum = 0;
12619         ctxt->node_seq.length = 0;
12620         ctxt->node_seq.buffer = NULL;
12621         xmlFreeParserCtxt(ctxt);
12622         newDoc->intSubset = NULL;
12623         newDoc->extSubset = NULL;
12624         xmlFreeDoc(newDoc);
12625         return(XML_ERR_INTERNAL_ERROR);
12626     }
12627     xmlAddChild((xmlNodePtr) newDoc, newRoot);
12628     nodePush(ctxt, newDoc->children);
12629     ctxt->myDoc = doc;
12630     newRoot->doc = doc;
12631
12632     /*
12633      * Get the 4 first bytes and decode the charset
12634      * if enc != XML_CHAR_ENCODING_NONE
12635      * plug some encoding conversion routines.
12636      */
12637     GROW;
12638     if ((ctxt->input->end - ctxt->input->cur) >= 4) {
12639         start[0] = RAW;
12640         start[1] = NXT(1);
12641         start[2] = NXT(2);
12642         start[3] = NXT(3);
12643         enc = xmlDetectCharEncoding(start, 4);
12644         if (enc != XML_CHAR_ENCODING_NONE) {
12645             xmlSwitchEncoding(ctxt, enc);
12646         }
12647     }
12648
12649     /*
12650      * Parse a possible text declaration first
12651      */
12652     if ((CMP5(CUR_PTR, '<', '?', 'x', 'm', 'l')) && (IS_BLANK_CH(NXT(5)))) {
12653         xmlParseTextDecl(ctxt);
12654     }
12655
12656     ctxt->instate = XML_PARSER_CONTENT;
12657     ctxt->depth = depth;
12658
12659     xmlParseContent(ctxt);
12660
12661     if ((RAW == '<') && (NXT(1) == '/')) {
12662         xmlFatalErr(ctxt, XML_ERR_NOT_WELL_BALANCED, NULL);
12663     } else if (RAW != 0) {
12664         xmlFatalErr(ctxt, XML_ERR_EXTRA_CONTENT, NULL);
12665     }
12666     if (ctxt->node != newDoc->children) {
12667         xmlFatalErr(ctxt, XML_ERR_NOT_WELL_BALANCED, NULL);
12668     }
12669
12670     if (!ctxt->wellFormed) {
12671         if (ctxt->errNo == 0)
12672             ret = XML_ERR_INTERNAL_ERROR;
12673         else
12674             ret = (xmlParserErrors)ctxt->errNo;
12675     } else {
12676         if (list != NULL) {
12677             xmlNodePtr cur;
12678
12679             /*
12680              * Return the newly created nodeset after unlinking it from
12681              * they pseudo parent.
12682              */
12683             cur = newDoc->children->children;
12684             *list = cur;
12685             while (cur != NULL) {
12686                 cur->parent = NULL;
12687                 cur = cur->next;
12688             }
12689             newDoc->children->children = NULL;
12690         }
12691         ret = XML_ERR_OK;
12692     }
12693
12694     /*
12695      * Record in the parent context the number of entities replacement
12696      * done when parsing that reference.
12697      */
12698     if (oldctxt != NULL)
12699         oldctxt->nbentities += ctxt->nbentities;
12700
12701     /*
12702      * Also record the size of the entity parsed
12703      */
12704     if (ctxt->input != NULL) {
12705         oldctxt->sizeentities += ctxt->input->consumed;
12706         oldctxt->sizeentities += (ctxt->input->cur - ctxt->input->base);
12707     }
12708     /*
12709      * And record the last error if any
12710      */
12711     if (ctxt->lastError.code != XML_ERR_OK)
12712         xmlCopyError(&ctxt->lastError, &oldctxt->lastError);
12713
12714     if (sax != NULL)
12715         ctxt->sax = oldsax;
12716     oldctxt->node_seq.maximum = ctxt->node_seq.maximum;
12717     oldctxt->node_seq.length = ctxt->node_seq.length;
12718     oldctxt->node_seq.buffer = ctxt->node_seq.buffer;
12719     ctxt->node_seq.maximum = 0;
12720     ctxt->node_seq.length = 0;
12721     ctxt->node_seq.buffer = NULL;
12722     xmlFreeParserCtxt(ctxt);
12723     newDoc->intSubset = NULL;
12724     newDoc->extSubset = NULL;
12725     xmlFreeDoc(newDoc);
12726
12727     return(ret);
12728 }
12729
12730 #ifdef LIBXML_SAX1_ENABLED
12731 /**
12732  * xmlParseExternalEntity:
12733  * @doc:  the document the chunk pertains to
12734  * @sax:  the SAX handler bloc (possibly NULL)
12735  * @user_data:  The user data returned on SAX callbacks (possibly NULL)
12736  * @depth:  Used for loop detection, use 0
12737  * @URL:  the URL for the entity to load
12738  * @ID:  the System ID for the entity to load
12739  * @lst:  the return value for the set of parsed nodes
12740  *
12741  * Parse an external general entity
12742  * An external general parsed entity is well-formed if it matches the
12743  * production labeled extParsedEnt.
12744  *
12745  * [78] extParsedEnt ::= TextDecl? content
12746  *
12747  * Returns 0 if the entity is well formed, -1 in case of args problem and
12748  *    the parser error code otherwise
12749  */
12750
12751 int
12752 xmlParseExternalEntity(xmlDocPtr doc, xmlSAXHandlerPtr sax, void *user_data,
12753           int depth, const xmlChar *URL, const xmlChar *ID, xmlNodePtr *lst) {
12754     return(xmlParseExternalEntityPrivate(doc, NULL, sax, user_data, depth, URL,
12755                                        ID, lst));
12756 }
12757
12758 /**
12759  * xmlParseBalancedChunkMemory:
12760  * @doc:  the document the chunk pertains to
12761  * @sax:  the SAX handler bloc (possibly NULL)
12762  * @user_data:  The user data returned on SAX callbacks (possibly NULL)
12763  * @depth:  Used for loop detection, use 0
12764  * @string:  the input string in UTF8 or ISO-Latin (zero terminated)
12765  * @lst:  the return value for the set of parsed nodes
12766  *
12767  * Parse a well-balanced chunk of an XML document
12768  * called by the parser
12769  * The allowed sequence for the Well Balanced Chunk is the one defined by
12770  * the content production in the XML grammar:
12771  *
12772  * [43] content ::= (element | CharData | Reference | CDSect | PI | Comment)*
12773  *
12774  * Returns 0 if the chunk is well balanced, -1 in case of args problem and
12775  *    the parser error code otherwise
12776  */
12777
12778 int
12779 xmlParseBalancedChunkMemory(xmlDocPtr doc, xmlSAXHandlerPtr sax,
12780      void *user_data, int depth, const xmlChar *string, xmlNodePtr *lst) {
12781     return xmlParseBalancedChunkMemoryRecover( doc, sax, user_data,
12782                                                 depth, string, lst, 0 );
12783 }
12784 #endif /* LIBXML_SAX1_ENABLED */
12785
12786 /**
12787  * xmlParseBalancedChunkMemoryInternal:
12788  * @oldctxt:  the existing parsing context
12789  * @string:  the input string in UTF8 or ISO-Latin (zero terminated)
12790  * @user_data:  the user data field for the parser context
12791  * @lst:  the return value for the set of parsed nodes
12792  *
12793  *
12794  * Parse a well-balanced chunk of an XML document
12795  * called by the parser
12796  * The allowed sequence for the Well Balanced Chunk is the one defined by
12797  * the content production in the XML grammar:
12798  *
12799  * [43] content ::= (element | CharData | Reference | CDSect | PI | Comment)*
12800  *
12801  * Returns XML_ERR_OK if the chunk is well balanced, and the parser
12802  * error code otherwise
12803  *
12804  * In case recover is set to 1, the nodelist will not be empty even if
12805  * the parsed chunk is not well balanced.
12806  */
12807 static xmlParserErrors
12808 xmlParseBalancedChunkMemoryInternal(xmlParserCtxtPtr oldctxt,
12809         const xmlChar *string, void *user_data, xmlNodePtr *lst) {
12810     xmlParserCtxtPtr ctxt;
12811     xmlDocPtr newDoc = NULL;
12812     xmlNodePtr newRoot;
12813     xmlSAXHandlerPtr oldsax = NULL;
12814     xmlNodePtr content = NULL;
12815     xmlNodePtr last = NULL;
12816     int size;
12817     xmlParserErrors ret = XML_ERR_OK;
12818 #ifdef SAX2
12819     int i;
12820 #endif
12821
12822     if (((oldctxt->depth > 40) && ((oldctxt->options & XML_PARSE_HUGE) == 0)) ||
12823         (oldctxt->depth >  1024)) {
12824         return(XML_ERR_ENTITY_LOOP);
12825     }
12826
12827
12828     if (lst != NULL)
12829         *lst = NULL;
12830     if (string == NULL)
12831         return(XML_ERR_INTERNAL_ERROR);
12832
12833     size = xmlStrlen(string);
12834
12835     ctxt = xmlCreateMemoryParserCtxt((char *) string, size);
12836     if (ctxt == NULL) return(XML_WAR_UNDECLARED_ENTITY);
12837     if (user_data != NULL)
12838         ctxt->userData = user_data;
12839     else
12840         ctxt->userData = ctxt;
12841     if (ctxt->dict != NULL) xmlDictFree(ctxt->dict);
12842     ctxt->dict = oldctxt->dict;
12843     ctxt->str_xml = xmlDictLookup(ctxt->dict, BAD_CAST "xml", 3);
12844     ctxt->str_xmlns = xmlDictLookup(ctxt->dict, BAD_CAST "xmlns", 5);
12845     ctxt->str_xml_ns = xmlDictLookup(ctxt->dict, XML_XML_NAMESPACE, 36);
12846
12847 #ifdef SAX2
12848     /* propagate namespaces down the entity */
12849     for (i = 0;i < oldctxt->nsNr;i += 2) {
12850         nsPush(ctxt, oldctxt->nsTab[i], oldctxt->nsTab[i+1]);
12851     }
12852 #endif
12853
12854     oldsax = ctxt->sax;
12855     ctxt->sax = oldctxt->sax;
12856     xmlDetectSAX2(ctxt);
12857     ctxt->replaceEntities = oldctxt->replaceEntities;
12858     ctxt->options = oldctxt->options;
12859
12860     ctxt->_private = oldctxt->_private;
12861     if (oldctxt->myDoc == NULL) {
12862         newDoc = xmlNewDoc(BAD_CAST "1.0");
12863         if (newDoc == NULL) {
12864             ctxt->sax = oldsax;
12865             ctxt->dict = NULL;
12866             xmlFreeParserCtxt(ctxt);
12867             return(XML_ERR_INTERNAL_ERROR);
12868         }
12869         newDoc->properties = XML_DOC_INTERNAL;
12870         newDoc->dict = ctxt->dict;
12871         xmlDictReference(newDoc->dict);
12872         ctxt->myDoc = newDoc;
12873     } else {
12874         ctxt->myDoc = oldctxt->myDoc;
12875         content = ctxt->myDoc->children;
12876         last = ctxt->myDoc->last;
12877     }
12878     newRoot = xmlNewDocNode(ctxt->myDoc, NULL, BAD_CAST "pseudoroot", NULL);
12879     if (newRoot == NULL) {
12880         ctxt->sax = oldsax;
12881         ctxt->dict = NULL;
12882         xmlFreeParserCtxt(ctxt);
12883         if (newDoc != NULL) {
12884             xmlFreeDoc(newDoc);
12885         }
12886         return(XML_ERR_INTERNAL_ERROR);
12887     }
12888     ctxt->myDoc->children = NULL;
12889     ctxt->myDoc->last = NULL;
12890     xmlAddChild((xmlNodePtr) ctxt->myDoc, newRoot);
12891     nodePush(ctxt, ctxt->myDoc->children);
12892     ctxt->instate = XML_PARSER_CONTENT;
12893     ctxt->depth = oldctxt->depth + 1;
12894
12895     ctxt->validate = 0;
12896     ctxt->loadsubset = oldctxt->loadsubset;
12897     if ((oldctxt->validate) || (oldctxt->replaceEntities != 0)) {
12898         /*
12899          * ID/IDREF registration will be done in xmlValidateElement below
12900          */
12901         ctxt->loadsubset |= XML_SKIP_IDS;
12902     }
12903     ctxt->dictNames = oldctxt->dictNames;
12904     ctxt->attsDefault = oldctxt->attsDefault;
12905     ctxt->attsSpecial = oldctxt->attsSpecial;
12906
12907     xmlParseContent(ctxt);
12908     if ((RAW == '<') && (NXT(1) == '/')) {
12909         xmlFatalErr(ctxt, XML_ERR_NOT_WELL_BALANCED, NULL);
12910     } else if (RAW != 0) {
12911         xmlFatalErr(ctxt, XML_ERR_EXTRA_CONTENT, NULL);
12912     }
12913     if (ctxt->node != ctxt->myDoc->children) {
12914         xmlFatalErr(ctxt, XML_ERR_NOT_WELL_BALANCED, NULL);
12915     }
12916
12917     if (!ctxt->wellFormed) {
12918         if (ctxt->errNo == 0)
12919             ret = XML_ERR_INTERNAL_ERROR;
12920         else
12921             ret = (xmlParserErrors)ctxt->errNo;
12922     } else {
12923       ret = XML_ERR_OK;
12924     }
12925
12926     if ((lst != NULL) && (ret == XML_ERR_OK)) {
12927         xmlNodePtr cur;
12928
12929         /*
12930          * Return the newly created nodeset after unlinking it from
12931          * they pseudo parent.
12932          */
12933         cur = ctxt->myDoc->children->children;
12934         *lst = cur;
12935         while (cur != NULL) {
12936 #ifdef LIBXML_VALID_ENABLED
12937             if ((oldctxt->validate) && (oldctxt->wellFormed) &&
12938                 (oldctxt->myDoc) && (oldctxt->myDoc->intSubset) &&
12939                 (cur->type == XML_ELEMENT_NODE)) {
12940                 oldctxt->valid &= xmlValidateElement(&oldctxt->vctxt,
12941                         oldctxt->myDoc, cur);
12942             }
12943 #endif /* LIBXML_VALID_ENABLED */
12944             cur->parent = NULL;
12945             cur = cur->next;
12946         }
12947         ctxt->myDoc->children->children = NULL;
12948     }
12949     if (ctxt->myDoc != NULL) {
12950         xmlFreeNode(ctxt->myDoc->children);
12951         ctxt->myDoc->children = content;
12952         ctxt->myDoc->last = last;
12953     }
12954
12955     /*
12956      * Record in the parent context the number of entities replacement
12957      * done when parsing that reference.
12958      */
12959     if (oldctxt != NULL)
12960         oldctxt->nbentities += ctxt->nbentities;
12961
12962     /*
12963      * Also record the last error if any
12964      */
12965     if (ctxt->lastError.code != XML_ERR_OK)
12966         xmlCopyError(&ctxt->lastError, &oldctxt->lastError);
12967
12968     ctxt->sax = oldsax;
12969     ctxt->dict = NULL;
12970     ctxt->attsDefault = NULL;
12971     ctxt->attsSpecial = NULL;
12972     xmlFreeParserCtxt(ctxt);
12973     if (newDoc != NULL) {
12974         xmlFreeDoc(newDoc);
12975     }
12976
12977     return(ret);
12978 }
12979
12980 /**
12981  * xmlParseInNodeContext:
12982  * @node:  the context node
12983  * @data:  the input string
12984  * @datalen:  the input string length in bytes
12985  * @options:  a combination of xmlParserOption
12986  * @lst:  the return value for the set of parsed nodes
12987  *
12988  * Parse a well-balanced chunk of an XML document
12989  * within the context (DTD, namespaces, etc ...) of the given node.
12990  *
12991  * The allowed sequence for the data is a Well Balanced Chunk defined by
12992  * the content production in the XML grammar:
12993  *
12994  * [43] content ::= (element | CharData | Reference | CDSect | PI | Comment)*
12995  *
12996  * Returns XML_ERR_OK if the chunk is well balanced, and the parser
12997  * error code otherwise
12998  */
12999 xmlParserErrors
13000 xmlParseInNodeContext(xmlNodePtr node, const char *data, int datalen,
13001                       int options, xmlNodePtr *lst) {
13002 #ifdef SAX2
13003     xmlParserCtxtPtr ctxt;
13004     xmlDocPtr doc = NULL;
13005     xmlNodePtr fake, cur;
13006     int nsnr = 0;
13007
13008     xmlParserErrors ret = XML_ERR_OK;
13009
13010     /*
13011      * check all input parameters, grab the document
13012      */
13013     if ((lst == NULL) || (node == NULL) || (data == NULL) || (datalen < 0))
13014         return(XML_ERR_INTERNAL_ERROR);
13015     switch (node->type) {
13016         case XML_ELEMENT_NODE:
13017         case XML_ATTRIBUTE_NODE:
13018         case XML_TEXT_NODE:
13019         case XML_CDATA_SECTION_NODE:
13020         case XML_ENTITY_REF_NODE:
13021         case XML_PI_NODE:
13022         case XML_COMMENT_NODE:
13023         case XML_DOCUMENT_NODE:
13024         case XML_HTML_DOCUMENT_NODE:
13025             break;
13026         default:
13027             return(XML_ERR_INTERNAL_ERROR);
13028
13029     }
13030     while ((node != NULL) && (node->type != XML_ELEMENT_NODE) &&
13031            (node->type != XML_DOCUMENT_NODE) &&
13032            (node->type != XML_HTML_DOCUMENT_NODE))
13033         node = node->parent;
13034     if (node == NULL)
13035         return(XML_ERR_INTERNAL_ERROR);
13036     if (node->type == XML_ELEMENT_NODE)
13037         doc = node->doc;
13038     else
13039         doc = (xmlDocPtr) node;
13040     if (doc == NULL)
13041         return(XML_ERR_INTERNAL_ERROR);
13042
13043     /*
13044      * allocate a context and set-up everything not related to the
13045      * node position in the tree
13046      */
13047     if (doc->type == XML_DOCUMENT_NODE)
13048         ctxt = xmlCreateMemoryParserCtxt((char *) data, datalen);
13049 #ifdef LIBXML_HTML_ENABLED
13050     else if (doc->type == XML_HTML_DOCUMENT_NODE) {
13051         ctxt = htmlCreateMemoryParserCtxt((char *) data, datalen);
13052         /*
13053          * When parsing in context, it makes no sense to add implied
13054          * elements like html/body/etc...
13055          */
13056         options |= HTML_PARSE_NOIMPLIED;
13057     }
13058 #endif
13059     else
13060         return(XML_ERR_INTERNAL_ERROR);
13061
13062     if (ctxt == NULL)
13063         return(XML_ERR_NO_MEMORY);
13064
13065     /*
13066      * Use input doc's dict if present, else assure XML_PARSE_NODICT is set.
13067      * We need a dictionary for xmlDetectSAX2, so if there's no doc dict
13068      * we must wait until the last moment to free the original one.
13069      */
13070     if (doc->dict != NULL) {
13071         if (ctxt->dict != NULL)
13072             xmlDictFree(ctxt->dict);
13073         ctxt->dict = doc->dict;
13074     } else
13075         options |= XML_PARSE_NODICT;
13076
13077     if (doc->encoding != NULL) {
13078         xmlCharEncodingHandlerPtr hdlr;
13079
13080         if (ctxt->encoding != NULL)
13081             xmlFree((xmlChar *) ctxt->encoding);
13082         ctxt->encoding = xmlStrdup((const xmlChar *) doc->encoding);
13083
13084         hdlr = xmlFindCharEncodingHandler(doc->encoding);
13085         if (hdlr != NULL) {
13086             xmlSwitchToEncoding(ctxt, hdlr);
13087         } else {
13088             return(XML_ERR_UNSUPPORTED_ENCODING);
13089         }
13090     }
13091
13092     xmlCtxtUseOptionsInternal(ctxt, options, NULL);
13093     xmlDetectSAX2(ctxt);
13094     ctxt->myDoc = doc;
13095
13096     fake = xmlNewComment(NULL);
13097     if (fake == NULL) {
13098         xmlFreeParserCtxt(ctxt);
13099         return(XML_ERR_NO_MEMORY);
13100     }
13101     xmlAddChild(node, fake);
13102
13103     if (node->type == XML_ELEMENT_NODE) {
13104         nodePush(ctxt, node);
13105         /*
13106          * initialize the SAX2 namespaces stack
13107          */
13108         cur = node;
13109         while ((cur != NULL) && (cur->type == XML_ELEMENT_NODE)) {
13110             xmlNsPtr ns = cur->nsDef;
13111             const xmlChar *iprefix, *ihref;
13112
13113             while (ns != NULL) {
13114                 if (ctxt->dict) {
13115                     iprefix = xmlDictLookup(ctxt->dict, ns->prefix, -1);
13116                     ihref = xmlDictLookup(ctxt->dict, ns->href, -1);
13117                 } else {
13118                     iprefix = ns->prefix;
13119                     ihref = ns->href;
13120                 }
13121
13122                 if (xmlGetNamespace(ctxt, iprefix) == NULL) {
13123                     nsPush(ctxt, iprefix, ihref);
13124                     nsnr++;
13125                 }
13126                 ns = ns->next;
13127             }
13128             cur = cur->parent;
13129         }
13130         ctxt->instate = XML_PARSER_CONTENT;
13131     }
13132
13133     if ((ctxt->validate) || (ctxt->replaceEntities != 0)) {
13134         /*
13135          * ID/IDREF registration will be done in xmlValidateElement below
13136          */
13137         ctxt->loadsubset |= XML_SKIP_IDS;
13138     }
13139
13140 #ifdef LIBXML_HTML_ENABLED
13141     if (doc->type == XML_HTML_DOCUMENT_NODE)
13142         __htmlParseContent(ctxt);
13143     else
13144 #endif
13145         xmlParseContent(ctxt);
13146
13147     nsPop(ctxt, nsnr);
13148     if ((RAW == '<') && (NXT(1) == '/')) {
13149         xmlFatalErr(ctxt, XML_ERR_NOT_WELL_BALANCED, NULL);
13150     } else if (RAW != 0) {
13151         xmlFatalErr(ctxt, XML_ERR_EXTRA_CONTENT, NULL);
13152     }
13153     if ((ctxt->node != NULL) && (ctxt->node != node)) {
13154         xmlFatalErr(ctxt, XML_ERR_NOT_WELL_BALANCED, NULL);
13155         ctxt->wellFormed = 0;
13156     }
13157
13158     if (!ctxt->wellFormed) {
13159         if (ctxt->errNo == 0)
13160             ret = XML_ERR_INTERNAL_ERROR;
13161         else
13162             ret = (xmlParserErrors)ctxt->errNo;
13163     } else {
13164         ret = XML_ERR_OK;
13165     }
13166
13167     /*
13168      * Return the newly created nodeset after unlinking it from
13169      * the pseudo sibling.
13170      */
13171
13172     cur = fake->next;
13173     fake->next = NULL;
13174     node->last = fake;
13175
13176     if (cur != NULL) {
13177         cur->prev = NULL;
13178     }
13179
13180     *lst = cur;
13181
13182     while (cur != NULL) {
13183         cur->parent = NULL;
13184         cur = cur->next;
13185     }
13186
13187     xmlUnlinkNode(fake);
13188     xmlFreeNode(fake);
13189
13190
13191     if (ret != XML_ERR_OK) {
13192         xmlFreeNodeList(*lst);
13193         *lst = NULL;
13194     }
13195
13196     if (doc->dict != NULL)
13197         ctxt->dict = NULL;
13198     xmlFreeParserCtxt(ctxt);
13199
13200     return(ret);
13201 #else /* !SAX2 */
13202     return(XML_ERR_INTERNAL_ERROR);
13203 #endif
13204 }
13205
13206 #ifdef LIBXML_SAX1_ENABLED
13207 /**
13208  * xmlParseBalancedChunkMemoryRecover:
13209  * @doc:  the document the chunk pertains to
13210  * @sax:  the SAX handler bloc (possibly NULL)
13211  * @user_data:  The user data returned on SAX callbacks (possibly NULL)
13212  * @depth:  Used for loop detection, use 0
13213  * @string:  the input string in UTF8 or ISO-Latin (zero terminated)
13214  * @lst:  the return value for the set of parsed nodes
13215  * @recover: return nodes even if the data is broken (use 0)
13216  *
13217  *
13218  * Parse a well-balanced chunk of an XML document
13219  * called by the parser
13220  * The allowed sequence for the Well Balanced Chunk is the one defined by
13221  * the content production in the XML grammar:
13222  *
13223  * [43] content ::= (element | CharData | Reference | CDSect | PI | Comment)*
13224  *
13225  * Returns 0 if the chunk is well balanced, -1 in case of args problem and
13226  *    the parser error code otherwise
13227  *
13228  * In case recover is set to 1, the nodelist will not be empty even if
13229  * the parsed chunk is not well balanced, assuming the parsing succeeded to
13230  * some extent.
13231  */
13232 int
13233 xmlParseBalancedChunkMemoryRecover(xmlDocPtr doc, xmlSAXHandlerPtr sax,
13234      void *user_data, int depth, const xmlChar *string, xmlNodePtr *lst,
13235      int recover) {
13236     xmlParserCtxtPtr ctxt;
13237     xmlDocPtr newDoc;
13238     xmlSAXHandlerPtr oldsax = NULL;
13239     xmlNodePtr content, newRoot;
13240     int size;
13241     int ret = 0;
13242
13243     if (depth > 40) {
13244         return(XML_ERR_ENTITY_LOOP);
13245     }
13246
13247
13248     if (lst != NULL)
13249         *lst = NULL;
13250     if (string == NULL)
13251         return(-1);
13252
13253     size = xmlStrlen(string);
13254
13255     ctxt = xmlCreateMemoryParserCtxt((char *) string, size);
13256     if (ctxt == NULL) return(-1);
13257     ctxt->userData = ctxt;
13258     if (sax != NULL) {
13259         oldsax = ctxt->sax;
13260         ctxt->sax = sax;
13261         if (user_data != NULL)
13262             ctxt->userData = user_data;
13263     }
13264     newDoc = xmlNewDoc(BAD_CAST "1.0");
13265     if (newDoc == NULL) {
13266         xmlFreeParserCtxt(ctxt);
13267         return(-1);
13268     }
13269     newDoc->properties = XML_DOC_INTERNAL;
13270     if ((doc != NULL) && (doc->dict != NULL)) {
13271         xmlDictFree(ctxt->dict);
13272         ctxt->dict = doc->dict;
13273         xmlDictReference(ctxt->dict);
13274         ctxt->str_xml = xmlDictLookup(ctxt->dict, BAD_CAST "xml", 3);
13275         ctxt->str_xmlns = xmlDictLookup(ctxt->dict, BAD_CAST "xmlns", 5);
13276         ctxt->str_xml_ns = xmlDictLookup(ctxt->dict, XML_XML_NAMESPACE, 36);
13277         ctxt->dictNames = 1;
13278     } else {
13279         xmlCtxtUseOptionsInternal(ctxt, XML_PARSE_NODICT, NULL);
13280     }
13281     if (doc != NULL) {
13282         newDoc->intSubset = doc->intSubset;
13283         newDoc->extSubset = doc->extSubset;
13284     }
13285     newRoot = xmlNewDocNode(newDoc, NULL, BAD_CAST "pseudoroot", NULL);
13286     if (newRoot == NULL) {
13287         if (sax != NULL)
13288             ctxt->sax = oldsax;
13289         xmlFreeParserCtxt(ctxt);
13290         newDoc->intSubset = NULL;
13291         newDoc->extSubset = NULL;
13292         xmlFreeDoc(newDoc);
13293         return(-1);
13294     }
13295     xmlAddChild((xmlNodePtr) newDoc, newRoot);
13296     nodePush(ctxt, newRoot);
13297     if (doc == NULL) {
13298         ctxt->myDoc = newDoc;
13299     } else {
13300         ctxt->myDoc = newDoc;
13301         newDoc->children->doc = doc;
13302         /* Ensure that doc has XML spec namespace */
13303         xmlSearchNsByHref(doc, (xmlNodePtr)doc, XML_XML_NAMESPACE);
13304         newDoc->oldNs = doc->oldNs;
13305     }
13306     ctxt->instate = XML_PARSER_CONTENT;
13307     ctxt->depth = depth;
13308
13309     /*
13310      * Doing validity checking on chunk doesn't make sense
13311      */
13312     ctxt->validate = 0;
13313     ctxt->loadsubset = 0;
13314     xmlDetectSAX2(ctxt);
13315
13316     if ( doc != NULL ){
13317         content = doc->children;
13318         doc->children = NULL;
13319         xmlParseContent(ctxt);
13320         doc->children = content;
13321     }
13322     else {
13323         xmlParseContent(ctxt);
13324     }
13325     if ((RAW == '<') && (NXT(1) == '/')) {
13326         xmlFatalErr(ctxt, XML_ERR_NOT_WELL_BALANCED, NULL);
13327     } else if (RAW != 0) {
13328         xmlFatalErr(ctxt, XML_ERR_EXTRA_CONTENT, NULL);
13329     }
13330     if (ctxt->node != newDoc->children) {
13331         xmlFatalErr(ctxt, XML_ERR_NOT_WELL_BALANCED, NULL);
13332     }
13333
13334     if (!ctxt->wellFormed) {
13335         if (ctxt->errNo == 0)
13336             ret = 1;
13337         else
13338             ret = ctxt->errNo;
13339     } else {
13340       ret = 0;
13341     }
13342
13343     if ((lst != NULL) && ((ret == 0) || (recover == 1))) {
13344         xmlNodePtr cur;
13345
13346         /*
13347          * Return the newly created nodeset after unlinking it from
13348          * they pseudo parent.
13349          */
13350         cur = newDoc->children->children;
13351         *lst = cur;
13352         while (cur != NULL) {
13353             xmlSetTreeDoc(cur, doc);
13354             cur->parent = NULL;
13355             cur = cur->next;
13356         }
13357         newDoc->children->children = NULL;
13358     }
13359
13360     if (sax != NULL)
13361         ctxt->sax = oldsax;
13362     xmlFreeParserCtxt(ctxt);
13363     newDoc->intSubset = NULL;
13364     newDoc->extSubset = NULL;
13365     newDoc->oldNs = NULL;
13366     xmlFreeDoc(newDoc);
13367
13368     return(ret);
13369 }
13370
13371 /**
13372  * xmlSAXParseEntity:
13373  * @sax:  the SAX handler block
13374  * @filename:  the filename
13375  *
13376  * parse an XML external entity out of context and build a tree.
13377  * It use the given SAX function block to handle the parsing callback.
13378  * If sax is NULL, fallback to the default DOM tree building routines.
13379  *
13380  * [78] extParsedEnt ::= TextDecl? content
13381  *
13382  * This correspond to a "Well Balanced" chunk
13383  *
13384  * Returns the resulting document tree
13385  */
13386
13387 xmlDocPtr
13388 xmlSAXParseEntity(xmlSAXHandlerPtr sax, const char *filename) {
13389     xmlDocPtr ret;
13390     xmlParserCtxtPtr ctxt;
13391
13392     ctxt = xmlCreateFileParserCtxt(filename);
13393     if (ctxt == NULL) {
13394         return(NULL);
13395     }
13396     if (sax != NULL) {
13397         if (ctxt->sax != NULL)
13398             xmlFree(ctxt->sax);
13399         ctxt->sax = sax;
13400         ctxt->userData = NULL;
13401     }
13402
13403     xmlParseExtParsedEnt(ctxt);
13404
13405     if (ctxt->wellFormed)
13406         ret = ctxt->myDoc;
13407     else {
13408         ret = NULL;
13409         xmlFreeDoc(ctxt->myDoc);
13410         ctxt->myDoc = NULL;
13411     }
13412     if (sax != NULL)
13413         ctxt->sax = NULL;
13414     xmlFreeParserCtxt(ctxt);
13415
13416     return(ret);
13417 }
13418
13419 /**
13420  * xmlParseEntity:
13421  * @filename:  the filename
13422  *
13423  * parse an XML external entity out of context and build a tree.
13424  *
13425  * [78] extParsedEnt ::= TextDecl? content
13426  *
13427  * This correspond to a "Well Balanced" chunk
13428  *
13429  * Returns the resulting document tree
13430  */
13431
13432 xmlDocPtr
13433 xmlParseEntity(const char *filename) {
13434     return(xmlSAXParseEntity(NULL, filename));
13435 }
13436 #endif /* LIBXML_SAX1_ENABLED */
13437
13438 /**
13439  * xmlCreateEntityParserCtxtInternal:
13440  * @URL:  the entity URL
13441  * @ID:  the entity PUBLIC ID
13442  * @base:  a possible base for the target URI
13443  * @pctx:  parser context used to set options on new context
13444  *
13445  * Create a parser context for an external entity
13446  * Automatic support for ZLIB/Compress compressed document is provided
13447  * by default if found at compile-time.
13448  *
13449  * Returns the new parser context or NULL
13450  */
13451 static xmlParserCtxtPtr
13452 xmlCreateEntityParserCtxtInternal(const xmlChar *URL, const xmlChar *ID,
13453                           const xmlChar *base, xmlParserCtxtPtr pctx) {
13454     xmlParserCtxtPtr ctxt;
13455     xmlParserInputPtr inputStream;
13456     char *directory = NULL;
13457     xmlChar *uri;
13458
13459     ctxt = xmlNewParserCtxt();
13460     if (ctxt == NULL) {
13461         return(NULL);
13462     }
13463
13464     if (pctx != NULL) {
13465         ctxt->options = pctx->options;
13466         ctxt->_private = pctx->_private;
13467     }
13468
13469     uri = xmlBuildURI(URL, base);
13470
13471     if (uri == NULL) {
13472         inputStream = xmlLoadExternalEntity((char *)URL, (char *)ID, ctxt);
13473         if (inputStream == NULL) {
13474             xmlFreeParserCtxt(ctxt);
13475             return(NULL);
13476         }
13477
13478         inputPush(ctxt, inputStream);
13479
13480         if ((ctxt->directory == NULL) && (directory == NULL))
13481             directory = xmlParserGetDirectory((char *)URL);
13482         if ((ctxt->directory == NULL) && (directory != NULL))
13483             ctxt->directory = directory;
13484     } else {
13485         inputStream = xmlLoadExternalEntity((char *)uri, (char *)ID, ctxt);
13486         if (inputStream == NULL) {
13487             xmlFree(uri);
13488             xmlFreeParserCtxt(ctxt);
13489             return(NULL);
13490         }
13491
13492         inputPush(ctxt, inputStream);
13493
13494         if ((ctxt->directory == NULL) && (directory == NULL))
13495             directory = xmlParserGetDirectory((char *)uri);
13496         if ((ctxt->directory == NULL) && (directory != NULL))
13497             ctxt->directory = directory;
13498         xmlFree(uri);
13499     }
13500     return(ctxt);
13501 }
13502
13503 /**
13504  * xmlCreateEntityParserCtxt:
13505  * @URL:  the entity URL
13506  * @ID:  the entity PUBLIC ID
13507  * @base:  a possible base for the target URI
13508  *
13509  * Create a parser context for an external entity
13510  * Automatic support for ZLIB/Compress compressed document is provided
13511  * by default if found at compile-time.
13512  *
13513  * Returns the new parser context or NULL
13514  */
13515 xmlParserCtxtPtr
13516 xmlCreateEntityParserCtxt(const xmlChar *URL, const xmlChar *ID,
13517                           const xmlChar *base) {
13518     return xmlCreateEntityParserCtxtInternal(URL, ID, base, NULL);
13519
13520 }
13521
13522 /************************************************************************
13523  *                                                                      *
13524  *              Front ends when parsing from a file                     *
13525  *                                                                      *
13526  ************************************************************************/
13527
13528 /**
13529  * xmlCreateURLParserCtxt:
13530  * @filename:  the filename or URL
13531  * @options:  a combination of xmlParserOption
13532  *
13533  * Create a parser context for a file or URL content.
13534  * Automatic support for ZLIB/Compress compressed document is provided
13535  * by default if found at compile-time and for file accesses
13536  *
13537  * Returns the new parser context or NULL
13538  */
13539 xmlParserCtxtPtr
13540 xmlCreateURLParserCtxt(const char *filename, int options)
13541 {
13542     xmlParserCtxtPtr ctxt;
13543     xmlParserInputPtr inputStream;
13544     char *directory = NULL;
13545
13546     ctxt = xmlNewParserCtxt();
13547     if (ctxt == NULL) {
13548         xmlErrMemory(NULL, "cannot allocate parser context");
13549         return(NULL);
13550     }
13551
13552     if (options)
13553         xmlCtxtUseOptionsInternal(ctxt, options, NULL);
13554     ctxt->linenumbers = 1;
13555
13556     inputStream = xmlLoadExternalEntity(filename, NULL, ctxt);
13557     if (inputStream == NULL) {
13558         xmlFreeParserCtxt(ctxt);
13559         return(NULL);
13560     }
13561
13562     inputPush(ctxt, inputStream);
13563     if ((ctxt->directory == NULL) && (directory == NULL))
13564         directory = xmlParserGetDirectory(filename);
13565     if ((ctxt->directory == NULL) && (directory != NULL))
13566         ctxt->directory = directory;
13567
13568     return(ctxt);
13569 }
13570
13571 /**
13572  * xmlCreateFileParserCtxt:
13573  * @filename:  the filename
13574  *
13575  * Create a parser context for a file content.
13576  * Automatic support for ZLIB/Compress compressed document is provided
13577  * by default if found at compile-time.
13578  *
13579  * Returns the new parser context or NULL
13580  */
13581 xmlParserCtxtPtr
13582 xmlCreateFileParserCtxt(const char *filename)
13583 {
13584     return(xmlCreateURLParserCtxt(filename, 0));
13585 }
13586
13587 #ifdef LIBXML_SAX1_ENABLED
13588 /**
13589  * xmlSAXParseFileWithData:
13590  * @sax:  the SAX handler block
13591  * @filename:  the filename
13592  * @recovery:  work in recovery mode, i.e. tries to read no Well Formed
13593  *             documents
13594  * @data:  the userdata
13595  *
13596  * parse an XML file and build a tree. Automatic support for ZLIB/Compress
13597  * compressed document is provided by default if found at compile-time.
13598  * It use the given SAX function block to handle the parsing callback.
13599  * If sax is NULL, fallback to the default DOM tree building routines.
13600  *
13601  * User data (void *) is stored within the parser context in the
13602  * context's _private member, so it is available nearly everywhere in libxml
13603  *
13604  * Returns the resulting document tree
13605  */
13606
13607 xmlDocPtr
13608 xmlSAXParseFileWithData(xmlSAXHandlerPtr sax, const char *filename,
13609                         int recovery, void *data) {
13610     xmlDocPtr ret;
13611     xmlParserCtxtPtr ctxt;
13612
13613     xmlInitParser();
13614
13615     ctxt = xmlCreateFileParserCtxt(filename);
13616     if (ctxt == NULL) {
13617         return(NULL);
13618     }
13619     if (sax != NULL) {
13620         if (ctxt->sax != NULL)
13621             xmlFree(ctxt->sax);
13622         ctxt->sax = sax;
13623     }
13624     xmlDetectSAX2(ctxt);
13625     if (data!=NULL) {
13626         ctxt->_private = data;
13627     }
13628
13629     if (ctxt->directory == NULL)
13630         ctxt->directory = xmlParserGetDirectory(filename);
13631
13632     ctxt->recovery = recovery;
13633
13634     xmlParseDocument(ctxt);
13635
13636     if ((ctxt->wellFormed) || recovery) {
13637         ret = ctxt->myDoc;
13638         if (ret != NULL) {
13639             if (ctxt->input->buf->compressed > 0)
13640                 ret->compression = 9;
13641             else
13642                 ret->compression = ctxt->input->buf->compressed;
13643         }
13644     }
13645     else {
13646        ret = NULL;
13647        xmlFreeDoc(ctxt->myDoc);
13648        ctxt->myDoc = NULL;
13649     }
13650     if (sax != NULL)
13651         ctxt->sax = NULL;
13652     xmlFreeParserCtxt(ctxt);
13653
13654     return(ret);
13655 }
13656
13657 /**
13658  * xmlSAXParseFile:
13659  * @sax:  the SAX handler block
13660  * @filename:  the filename
13661  * @recovery:  work in recovery mode, i.e. tries to read no Well Formed
13662  *             documents
13663  *
13664  * parse an XML file and build a tree. Automatic support for ZLIB/Compress
13665  * compressed document is provided by default if found at compile-time.
13666  * It use the given SAX function block to handle the parsing callback.
13667  * If sax is NULL, fallback to the default DOM tree building routines.
13668  *
13669  * Returns the resulting document tree
13670  */
13671
13672 xmlDocPtr
13673 xmlSAXParseFile(xmlSAXHandlerPtr sax, const char *filename,
13674                           int recovery) {
13675     return(xmlSAXParseFileWithData(sax,filename,recovery,NULL));
13676 }
13677
13678 /**
13679  * xmlRecoverDoc:
13680  * @cur:  a pointer to an array of xmlChar
13681  *
13682  * parse an XML in-memory document and build a tree.
13683  * In the case the document is not Well Formed, a attempt to build a
13684  * tree is tried anyway
13685  *
13686  * Returns the resulting document tree or NULL in case of failure
13687  */
13688
13689 xmlDocPtr
13690 xmlRecoverDoc(const xmlChar *cur) {
13691     return(xmlSAXParseDoc(NULL, cur, 1));
13692 }
13693
13694 /**
13695  * xmlParseFile:
13696  * @filename:  the filename
13697  *
13698  * parse an XML file and build a tree. Automatic support for ZLIB/Compress
13699  * compressed document is provided by default if found at compile-time.
13700  *
13701  * Returns the resulting document tree if the file was wellformed,
13702  * NULL otherwise.
13703  */
13704
13705 xmlDocPtr
13706 xmlParseFile(const char *filename) {
13707     return(xmlSAXParseFile(NULL, filename, 0));
13708 }
13709
13710 /**
13711  * xmlRecoverFile:
13712  * @filename:  the filename
13713  *
13714  * parse an XML file and build a tree. Automatic support for ZLIB/Compress
13715  * compressed document is provided by default if found at compile-time.
13716  * In the case the document is not Well Formed, it attempts to build
13717  * a tree anyway
13718  *
13719  * Returns the resulting document tree or NULL in case of failure
13720  */
13721
13722 xmlDocPtr
13723 xmlRecoverFile(const char *filename) {
13724     return(xmlSAXParseFile(NULL, filename, 1));
13725 }
13726
13727
13728 /**
13729  * xmlSetupParserForBuffer:
13730  * @ctxt:  an XML parser context
13731  * @buffer:  a xmlChar * buffer
13732  * @filename:  a file name
13733  *
13734  * Setup the parser context to parse a new buffer; Clears any prior
13735  * contents from the parser context. The buffer parameter must not be
13736  * NULL, but the filename parameter can be
13737  */
13738 void
13739 xmlSetupParserForBuffer(xmlParserCtxtPtr ctxt, const xmlChar* buffer,
13740                              const char* filename)
13741 {
13742     xmlParserInputPtr input;
13743
13744     if ((ctxt == NULL) || (buffer == NULL))
13745         return;
13746
13747     input = xmlNewInputStream(ctxt);
13748     if (input == NULL) {
13749         xmlErrMemory(NULL, "parsing new buffer: out of memory\n");
13750         xmlClearParserCtxt(ctxt);
13751         return;
13752     }
13753
13754     xmlClearParserCtxt(ctxt);
13755     if (filename != NULL)
13756         input->filename = (char *) xmlCanonicPath((const xmlChar *)filename);
13757     input->base = buffer;
13758     input->cur = buffer;
13759     input->end = &buffer[xmlStrlen(buffer)];
13760     inputPush(ctxt, input);
13761 }
13762
13763 /**
13764  * xmlSAXUserParseFile:
13765  * @sax:  a SAX handler
13766  * @user_data:  The user data returned on SAX callbacks
13767  * @filename:  a file name
13768  *
13769  * parse an XML file and call the given SAX handler routines.
13770  * Automatic support for ZLIB/Compress compressed document is provided
13771  *
13772  * Returns 0 in case of success or a error number otherwise
13773  */
13774 int
13775 xmlSAXUserParseFile(xmlSAXHandlerPtr sax, void *user_data,
13776                     const char *filename) {
13777     int ret = 0;
13778     xmlParserCtxtPtr ctxt;
13779
13780     ctxt = xmlCreateFileParserCtxt(filename);
13781     if (ctxt == NULL) return -1;
13782     if (ctxt->sax != (xmlSAXHandlerPtr) &xmlDefaultSAXHandler)
13783         xmlFree(ctxt->sax);
13784     ctxt->sax = sax;
13785     xmlDetectSAX2(ctxt);
13786
13787     if (user_data != NULL)
13788         ctxt->userData = user_data;
13789
13790     xmlParseDocument(ctxt);
13791
13792     if (ctxt->wellFormed)
13793         ret = 0;
13794     else {
13795         if (ctxt->errNo != 0)
13796             ret = ctxt->errNo;
13797         else
13798             ret = -1;
13799     }
13800     if (sax != NULL)
13801         ctxt->sax = NULL;
13802     if (ctxt->myDoc != NULL) {
13803         xmlFreeDoc(ctxt->myDoc);
13804         ctxt->myDoc = NULL;
13805     }
13806     xmlFreeParserCtxt(ctxt);
13807
13808     return ret;
13809 }
13810 #endif /* LIBXML_SAX1_ENABLED */
13811
13812 /************************************************************************
13813  *                                                                      *
13814  *              Front ends when parsing from memory                     *
13815  *                                                                      *
13816  ************************************************************************/
13817
13818 /**
13819  * xmlCreateMemoryParserCtxt:
13820  * @buffer:  a pointer to a char array
13821  * @size:  the size of the array
13822  *
13823  * Create a parser context for an XML in-memory document.
13824  *
13825  * Returns the new parser context or NULL
13826  */
13827 xmlParserCtxtPtr
13828 xmlCreateMemoryParserCtxt(const char *buffer, int size) {
13829     xmlParserCtxtPtr ctxt;
13830     xmlParserInputPtr input;
13831     xmlParserInputBufferPtr buf;
13832
13833     if (buffer == NULL)
13834         return(NULL);
13835     if (size <= 0)
13836         return(NULL);
13837
13838     ctxt = xmlNewParserCtxt();
13839     if (ctxt == NULL)
13840         return(NULL);
13841
13842     /* TODO: xmlParserInputBufferCreateStatic, requires some serious changes */
13843     buf = xmlParserInputBufferCreateMem(buffer, size, XML_CHAR_ENCODING_NONE);
13844     if (buf == NULL) {
13845         xmlFreeParserCtxt(ctxt);
13846         return(NULL);
13847     }
13848
13849     input = xmlNewInputStream(ctxt);
13850     if (input == NULL) {
13851         xmlFreeParserInputBuffer(buf);
13852         xmlFreeParserCtxt(ctxt);
13853         return(NULL);
13854     }
13855
13856     input->filename = NULL;
13857     input->buf = buf;
13858     input->base = input->buf->buffer->content;
13859     input->cur = input->buf->buffer->content;
13860     input->end = &input->buf->buffer->content[input->buf->buffer->use];
13861
13862     inputPush(ctxt, input);
13863     return(ctxt);
13864 }
13865
13866 #ifdef LIBXML_SAX1_ENABLED
13867 /**
13868  * xmlSAXParseMemoryWithData:
13869  * @sax:  the SAX handler block
13870  * @buffer:  an pointer to a char array
13871  * @size:  the size of the array
13872  * @recovery:  work in recovery mode, i.e. tries to read no Well Formed
13873  *             documents
13874  * @data:  the userdata
13875  *
13876  * parse an XML in-memory block and use the given SAX function block
13877  * to handle the parsing callback. If sax is NULL, fallback to the default
13878  * DOM tree building routines.
13879  *
13880  * User data (void *) is stored within the parser context in the
13881  * context's _private member, so it is available nearly everywhere in libxml
13882  *
13883  * Returns the resulting document tree
13884  */
13885
13886 xmlDocPtr
13887 xmlSAXParseMemoryWithData(xmlSAXHandlerPtr sax, const char *buffer,
13888                   int size, int recovery, void *data) {
13889     xmlDocPtr ret;
13890     xmlParserCtxtPtr ctxt;
13891
13892     xmlInitParser();
13893
13894     ctxt = xmlCreateMemoryParserCtxt(buffer, size);
13895     if (ctxt == NULL) return(NULL);
13896     if (sax != NULL) {
13897         if (ctxt->sax != NULL)
13898             xmlFree(ctxt->sax);
13899         ctxt->sax = sax;
13900     }
13901     xmlDetectSAX2(ctxt);
13902     if (data!=NULL) {
13903         ctxt->_private=data;
13904     }
13905
13906     ctxt->recovery = recovery;
13907
13908     xmlParseDocument(ctxt);
13909
13910     if ((ctxt->wellFormed) || recovery) ret = ctxt->myDoc;
13911     else {
13912        ret = NULL;
13913        xmlFreeDoc(ctxt->myDoc);
13914        ctxt->myDoc = NULL;
13915     }
13916     if (sax != NULL)
13917         ctxt->sax = NULL;
13918     xmlFreeParserCtxt(ctxt);
13919
13920     return(ret);
13921 }
13922
13923 /**
13924  * xmlSAXParseMemory:
13925  * @sax:  the SAX handler block
13926  * @buffer:  an pointer to a char array
13927  * @size:  the size of the array
13928  * @recovery:  work in recovery mode, i.e. tries to read not Well Formed
13929  *             documents
13930  *
13931  * parse an XML in-memory block and use the given SAX function block
13932  * to handle the parsing callback. If sax is NULL, fallback to the default
13933  * DOM tree building routines.
13934  *
13935  * Returns the resulting document tree
13936  */
13937 xmlDocPtr
13938 xmlSAXParseMemory(xmlSAXHandlerPtr sax, const char *buffer,
13939                   int size, int recovery) {
13940     return xmlSAXParseMemoryWithData(sax, buffer, size, recovery, NULL);
13941 }
13942
13943 /**
13944  * xmlParseMemory:
13945  * @buffer:  an pointer to a char array
13946  * @size:  the size of the array
13947  *
13948  * parse an XML in-memory block and build a tree.
13949  *
13950  * Returns the resulting document tree
13951  */
13952
13953 xmlDocPtr xmlParseMemory(const char *buffer, int size) {
13954    return(xmlSAXParseMemory(NULL, buffer, size, 0));
13955 }
13956
13957 /**
13958  * xmlRecoverMemory:
13959  * @buffer:  an pointer to a char array
13960  * @size:  the size of the array
13961  *
13962  * parse an XML in-memory block and build a tree.
13963  * In the case the document is not Well Formed, an attempt to
13964  * build a tree is tried anyway
13965  *
13966  * Returns the resulting document tree or NULL in case of error
13967  */
13968
13969 xmlDocPtr xmlRecoverMemory(const char *buffer, int size) {
13970    return(xmlSAXParseMemory(NULL, buffer, size, 1));
13971 }
13972
13973 /**
13974  * xmlSAXUserParseMemory:
13975  * @sax:  a SAX handler
13976  * @user_data:  The user data returned on SAX callbacks
13977  * @buffer:  an in-memory XML document input
13978  * @size:  the length of the XML document in bytes
13979  *
13980  * A better SAX parsing routine.
13981  * parse an XML in-memory buffer and call the given SAX handler routines.
13982  *
13983  * Returns 0 in case of success or a error number otherwise
13984  */
13985 int xmlSAXUserParseMemory(xmlSAXHandlerPtr sax, void *user_data,
13986                           const char *buffer, int size) {
13987     int ret = 0;
13988     xmlParserCtxtPtr ctxt;
13989
13990     xmlInitParser();
13991
13992     ctxt = xmlCreateMemoryParserCtxt(buffer, size);
13993     if (ctxt == NULL) return -1;
13994     if (ctxt->sax != (xmlSAXHandlerPtr) &xmlDefaultSAXHandler)
13995         xmlFree(ctxt->sax);
13996     ctxt->sax = sax;
13997     xmlDetectSAX2(ctxt);
13998
13999     if (user_data != NULL)
14000         ctxt->userData = user_data;
14001
14002     xmlParseDocument(ctxt);
14003
14004     if (ctxt->wellFormed)
14005         ret = 0;
14006     else {
14007         if (ctxt->errNo != 0)
14008             ret = ctxt->errNo;
14009         else
14010             ret = -1;
14011     }
14012     if (sax != NULL)
14013         ctxt->sax = NULL;
14014     if (ctxt->myDoc != NULL) {
14015         xmlFreeDoc(ctxt->myDoc);
14016         ctxt->myDoc = NULL;
14017     }
14018     xmlFreeParserCtxt(ctxt);
14019
14020     return ret;
14021 }
14022 #endif /* LIBXML_SAX1_ENABLED */
14023
14024 /**
14025  * xmlCreateDocParserCtxt:
14026  * @cur:  a pointer to an array of xmlChar
14027  *
14028  * Creates a parser context for an XML in-memory document.
14029  *
14030  * Returns the new parser context or NULL
14031  */
14032 xmlParserCtxtPtr
14033 xmlCreateDocParserCtxt(const xmlChar *cur) {
14034     int len;
14035
14036     if (cur == NULL)
14037         return(NULL);
14038     len = xmlStrlen(cur);
14039     return(xmlCreateMemoryParserCtxt((const char *)cur, len));
14040 }
14041
14042 #ifdef LIBXML_SAX1_ENABLED
14043 /**
14044  * xmlSAXParseDoc:
14045  * @sax:  the SAX handler block
14046  * @cur:  a pointer to an array of xmlChar
14047  * @recovery:  work in recovery mode, i.e. tries to read no Well Formed
14048  *             documents
14049  *
14050  * parse an XML in-memory document and build a tree.
14051  * It use the given SAX function block to handle the parsing callback.
14052  * If sax is NULL, fallback to the default DOM tree building routines.
14053  *
14054  * Returns the resulting document tree
14055  */
14056
14057 xmlDocPtr
14058 xmlSAXParseDoc(xmlSAXHandlerPtr sax, const xmlChar *cur, int recovery) {
14059     xmlDocPtr ret;
14060     xmlParserCtxtPtr ctxt;
14061     xmlSAXHandlerPtr oldsax = NULL;
14062
14063     if (cur == NULL) return(NULL);
14064
14065
14066     ctxt = xmlCreateDocParserCtxt(cur);
14067     if (ctxt == NULL) return(NULL);
14068     if (sax != NULL) {
14069         oldsax = ctxt->sax;
14070         ctxt->sax = sax;
14071         ctxt->userData = NULL;
14072     }
14073     xmlDetectSAX2(ctxt);
14074
14075     xmlParseDocument(ctxt);
14076     if ((ctxt->wellFormed) || recovery) ret = ctxt->myDoc;
14077     else {
14078        ret = NULL;
14079        xmlFreeDoc(ctxt->myDoc);
14080        ctxt->myDoc = NULL;
14081     }
14082     if (sax != NULL)
14083         ctxt->sax = oldsax;
14084     xmlFreeParserCtxt(ctxt);
14085
14086     return(ret);
14087 }
14088
14089 /**
14090  * xmlParseDoc:
14091  * @cur:  a pointer to an array of xmlChar
14092  *
14093  * parse an XML in-memory document and build a tree.
14094  *
14095  * Returns the resulting document tree
14096  */
14097
14098 xmlDocPtr
14099 xmlParseDoc(const xmlChar *cur) {
14100     return(xmlSAXParseDoc(NULL, cur, 0));
14101 }
14102 #endif /* LIBXML_SAX1_ENABLED */
14103
14104 #ifdef LIBXML_LEGACY_ENABLED
14105 /************************************************************************
14106  *                                                                      *
14107  *      Specific function to keep track of entities references          *
14108  *      and used by the XSLT debugger                                   *
14109  *                                                                      *
14110  ************************************************************************/
14111
14112 static xmlEntityReferenceFunc xmlEntityRefFunc = NULL;
14113
14114 /**
14115  * xmlAddEntityReference:
14116  * @ent : A valid entity
14117  * @firstNode : A valid first node for children of entity
14118  * @lastNode : A valid last node of children entity
14119  *
14120  * Notify of a reference to an entity of type XML_EXTERNAL_GENERAL_PARSED_ENTITY
14121  */
14122 static void
14123 xmlAddEntityReference(xmlEntityPtr ent, xmlNodePtr firstNode,
14124                       xmlNodePtr lastNode)
14125 {
14126     if (xmlEntityRefFunc != NULL) {
14127         (*xmlEntityRefFunc) (ent, firstNode, lastNode);
14128     }
14129 }
14130
14131
14132 /**
14133  * xmlSetEntityReferenceFunc:
14134  * @func: A valid function
14135  *
14136  * Set the function to call call back when a xml reference has been made
14137  */
14138 void
14139 xmlSetEntityReferenceFunc(xmlEntityReferenceFunc func)
14140 {
14141     xmlEntityRefFunc = func;
14142 }
14143 #endif /* LIBXML_LEGACY_ENABLED */
14144
14145 /************************************************************************
14146  *                                                                      *
14147  *                              Miscellaneous                           *
14148  *                                                                      *
14149  ************************************************************************/
14150
14151 #ifdef LIBXML_XPATH_ENABLED
14152 #include <libxml/xpath.h>
14153 #endif
14154
14155 extern void XMLCDECL xmlGenericErrorDefaultFunc(void *ctx, const char *msg, ...);
14156 static int xmlParserInitialized = 0;
14157
14158 /**
14159  * xmlInitParser:
14160  *
14161  * Initialization function for the XML parser.
14162  * This is not reentrant. Call once before processing in case of
14163  * use in multithreaded programs.
14164  */
14165
14166 void
14167 xmlInitParser(void) {
14168     if (xmlParserInitialized != 0)
14169         return;
14170
14171 #ifdef LIBXML_THREAD_ENABLED
14172     __xmlGlobalInitMutexLock();
14173     if (xmlParserInitialized == 0) {
14174 #endif
14175         xmlInitThreads();
14176         xmlInitGlobals();
14177         if ((xmlGenericError == xmlGenericErrorDefaultFunc) ||
14178             (xmlGenericError == NULL))
14179             initGenericErrorDefaultFunc(NULL);
14180         xmlInitMemory();
14181         xmlInitializeDict();
14182         xmlInitCharEncodingHandlers();
14183         xmlDefaultSAXHandlerInit();
14184         xmlRegisterDefaultInputCallbacks();
14185 #ifdef LIBXML_OUTPUT_ENABLED
14186         xmlRegisterDefaultOutputCallbacks();
14187 #endif /* LIBXML_OUTPUT_ENABLED */
14188 #ifdef LIBXML_HTML_ENABLED
14189         htmlInitAutoClose();
14190         htmlDefaultSAXHandlerInit();
14191 #endif
14192 #ifdef LIBXML_XPATH_ENABLED
14193         xmlXPathInit();
14194 #endif
14195         xmlParserInitialized = 1;
14196 #ifdef LIBXML_THREAD_ENABLED
14197     }
14198     __xmlGlobalInitMutexUnlock();
14199 #endif
14200 }
14201
14202 /**
14203  * xmlCleanupParser:
14204  *
14205  * This function name is somewhat misleading. It does not clean up
14206  * parser state, it cleans up memory allocated by the library itself.
14207  * It is a cleanup function for the XML library. It tries to reclaim all
14208  * related global memory allocated for the library processing.
14209  * It doesn't deallocate any document related memory. One should
14210  * call xmlCleanupParser() only when the process has finished using
14211  * the library and all XML/HTML documents built with it.
14212  * See also xmlInitParser() which has the opposite function of preparing
14213  * the library for operations.
14214  *
14215  * WARNING: if your application is multithreaded or has plugin support
14216  *          calling this may crash the application if another thread or
14217  *          a plugin is still using libxml2. It's sometimes very hard to
14218  *          guess if libxml2 is in use in the application, some libraries
14219  *          or plugins may use it without notice. In case of doubt abstain
14220  *          from calling this function or do it just before calling exit()
14221  *          to avoid leak reports from valgrind !
14222  */
14223
14224 void
14225 xmlCleanupParser(void) {
14226     if (!xmlParserInitialized)
14227         return;
14228
14229     xmlCleanupCharEncodingHandlers();
14230 #ifdef LIBXML_CATALOG_ENABLED
14231     xmlCatalogCleanup();
14232 #endif
14233     xmlDictCleanup();
14234     xmlCleanupInputCallbacks();
14235 #ifdef LIBXML_OUTPUT_ENABLED
14236     xmlCleanupOutputCallbacks();
14237 #endif
14238 #ifdef LIBXML_SCHEMAS_ENABLED
14239     xmlSchemaCleanupTypes();
14240     xmlRelaxNGCleanupTypes();
14241 #endif
14242     xmlCleanupGlobals();
14243     xmlResetLastError();
14244     xmlCleanupThreads(); /* must be last if called not from the main thread */
14245     xmlCleanupMemory();
14246     xmlParserInitialized = 0;
14247 }
14248
14249 /************************************************************************
14250  *                                                                      *
14251  *      New set (2.6.0) of simpler and more flexible APIs               *
14252  *                                                                      *
14253  ************************************************************************/
14254
14255 /**
14256  * DICT_FREE:
14257  * @str:  a string
14258  *
14259  * Free a string if it is not owned by the "dict" dictionnary in the
14260  * current scope
14261  */
14262 #define DICT_FREE(str)                                          \
14263         if ((str) && ((!dict) ||                                \
14264             (xmlDictOwns(dict, (const xmlChar *)(str)) == 0)))  \
14265             xmlFree((char *)(str));
14266
14267 /**
14268  * xmlCtxtReset:
14269  * @ctxt: an XML parser context
14270  *
14271  * Reset a parser context
14272  */
14273 void
14274 xmlCtxtReset(xmlParserCtxtPtr ctxt)
14275 {
14276     xmlParserInputPtr input;
14277     xmlDictPtr dict;
14278
14279     if (ctxt == NULL)
14280         return;
14281
14282     dict = ctxt->dict;
14283
14284     while ((input = inputPop(ctxt)) != NULL) { /* Non consuming */
14285         xmlFreeInputStream(input);
14286     }
14287     ctxt->inputNr = 0;
14288     ctxt->input = NULL;
14289
14290     ctxt->spaceNr = 0;
14291     if (ctxt->spaceTab != NULL) {
14292         ctxt->spaceTab[0] = -1;
14293         ctxt->space = &ctxt->spaceTab[0];
14294     } else {
14295         ctxt->space = NULL;
14296     }
14297
14298
14299     ctxt->nodeNr = 0;
14300     ctxt->node = NULL;
14301
14302     ctxt->nameNr = 0;
14303     ctxt->name = NULL;
14304
14305     DICT_FREE(ctxt->version);
14306     ctxt->version = NULL;
14307     DICT_FREE(ctxt->encoding);
14308     ctxt->encoding = NULL;
14309     DICT_FREE(ctxt->directory);
14310     ctxt->directory = NULL;
14311     DICT_FREE(ctxt->extSubURI);
14312     ctxt->extSubURI = NULL;
14313     DICT_FREE(ctxt->extSubSystem);
14314     ctxt->extSubSystem = NULL;
14315     if (ctxt->myDoc != NULL)
14316         xmlFreeDoc(ctxt->myDoc);
14317     ctxt->myDoc = NULL;
14318
14319     ctxt->standalone = -1;
14320     ctxt->hasExternalSubset = 0;
14321     ctxt->hasPErefs = 0;
14322     ctxt->html = 0;
14323     ctxt->external = 0;
14324     ctxt->instate = XML_PARSER_START;
14325     ctxt->token = 0;
14326
14327     ctxt->wellFormed = 1;
14328     ctxt->nsWellFormed = 1;
14329     ctxt->disableSAX = 0;
14330     ctxt->valid = 1;
14331 #if 0
14332     ctxt->vctxt.userData = ctxt;
14333     ctxt->vctxt.error = xmlParserValidityError;
14334     ctxt->vctxt.warning = xmlParserValidityWarning;
14335 #endif
14336     ctxt->record_info = 0;
14337     ctxt->nbChars = 0;
14338     ctxt->checkIndex = 0;
14339     ctxt->inSubset = 0;
14340     ctxt->errNo = XML_ERR_OK;
14341     ctxt->depth = 0;
14342     ctxt->charset = XML_CHAR_ENCODING_UTF8;
14343     ctxt->catalogs = NULL;
14344     ctxt->nbentities = 0;
14345     ctxt->sizeentities = 0;
14346     xmlInitNodeInfoSeq(&ctxt->node_seq);
14347
14348     if (ctxt->attsDefault != NULL) {
14349         xmlHashFree(ctxt->attsDefault, (xmlHashDeallocator) xmlFree);
14350         ctxt->attsDefault = NULL;
14351     }
14352     if (ctxt->attsSpecial != NULL) {
14353         xmlHashFree(ctxt->attsSpecial, NULL);
14354         ctxt->attsSpecial = NULL;
14355     }
14356
14357 #ifdef LIBXML_CATALOG_ENABLED
14358     if (ctxt->catalogs != NULL)
14359         xmlCatalogFreeLocal(ctxt->catalogs);
14360 #endif
14361     if (ctxt->lastError.code != XML_ERR_OK)
14362         xmlResetError(&ctxt->lastError);
14363 }
14364
14365 /**
14366  * xmlCtxtResetPush:
14367  * @ctxt: an XML parser context
14368  * @chunk:  a pointer to an array of chars
14369  * @size:  number of chars in the array
14370  * @filename:  an optional file name or URI
14371  * @encoding:  the document encoding, or NULL
14372  *
14373  * Reset a push parser context
14374  *
14375  * Returns 0 in case of success and 1 in case of error
14376  */
14377 int
14378 xmlCtxtResetPush(xmlParserCtxtPtr ctxt, const char *chunk,
14379                  int size, const char *filename, const char *encoding)
14380 {
14381     xmlParserInputPtr inputStream;
14382     xmlParserInputBufferPtr buf;
14383     xmlCharEncoding enc = XML_CHAR_ENCODING_NONE;
14384
14385     if (ctxt == NULL)
14386         return(1);
14387
14388     if ((encoding == NULL) && (chunk != NULL) && (size >= 4))
14389         enc = xmlDetectCharEncoding((const xmlChar *) chunk, size);
14390
14391     buf = xmlAllocParserInputBuffer(enc);
14392     if (buf == NULL)
14393         return(1);
14394
14395     if (ctxt == NULL) {
14396         xmlFreeParserInputBuffer(buf);
14397         return(1);
14398     }
14399
14400     xmlCtxtReset(ctxt);
14401
14402     if (ctxt->pushTab == NULL) {
14403         ctxt->pushTab = (void **) xmlMalloc(ctxt->nameMax * 3 *
14404                                             sizeof(xmlChar *));
14405         if (ctxt->pushTab == NULL) {
14406             xmlErrMemory(ctxt, NULL);
14407             xmlFreeParserInputBuffer(buf);
14408             return(1);
14409         }
14410     }
14411
14412     if (filename == NULL) {
14413         ctxt->directory = NULL;
14414     } else {
14415         ctxt->directory = xmlParserGetDirectory(filename);
14416     }
14417
14418     inputStream = xmlNewInputStream(ctxt);
14419     if (inputStream == NULL) {
14420         xmlFreeParserInputBuffer(buf);
14421         return(1);
14422     }
14423
14424     if (filename == NULL)
14425         inputStream->filename = NULL;
14426     else
14427         inputStream->filename = (char *)
14428             xmlCanonicPath((const xmlChar *) filename);
14429     inputStream->buf = buf;
14430     inputStream->base = inputStream->buf->buffer->content;
14431     inputStream->cur = inputStream->buf->buffer->content;
14432     inputStream->end =
14433         &inputStream->buf->buffer->content[inputStream->buf->buffer->use];
14434
14435     inputPush(ctxt, inputStream);
14436
14437     if ((size > 0) && (chunk != NULL) && (ctxt->input != NULL) &&
14438         (ctxt->input->buf != NULL)) {
14439         int base = ctxt->input->base - ctxt->input->buf->buffer->content;
14440         int cur = ctxt->input->cur - ctxt->input->base;
14441
14442         xmlParserInputBufferPush(ctxt->input->buf, size, chunk);
14443
14444         ctxt->input->base = ctxt->input->buf->buffer->content + base;
14445         ctxt->input->cur = ctxt->input->base + cur;
14446         ctxt->input->end =
14447             &ctxt->input->buf->buffer->content[ctxt->input->buf->buffer->
14448                                                use];
14449 #ifdef DEBUG_PUSH
14450         xmlGenericError(xmlGenericErrorContext, "PP: pushed %d\n", size);
14451 #endif
14452     }
14453
14454     if (encoding != NULL) {
14455         xmlCharEncodingHandlerPtr hdlr;
14456
14457         if (ctxt->encoding != NULL)
14458             xmlFree((xmlChar *) ctxt->encoding);
14459         ctxt->encoding = xmlStrdup((const xmlChar *) encoding);
14460
14461         hdlr = xmlFindCharEncodingHandler(encoding);
14462         if (hdlr != NULL) {
14463             xmlSwitchToEncoding(ctxt, hdlr);
14464         } else {
14465             xmlFatalErrMsgStr(ctxt, XML_ERR_UNSUPPORTED_ENCODING,
14466                               "Unsupported encoding %s\n", BAD_CAST encoding);
14467         }
14468     } else if (enc != XML_CHAR_ENCODING_NONE) {
14469         xmlSwitchEncoding(ctxt, enc);
14470     }
14471
14472     return(0);
14473 }
14474
14475
14476 /**
14477  * xmlCtxtUseOptionsInternal:
14478  * @ctxt: an XML parser context
14479  * @options:  a combination of xmlParserOption
14480  * @encoding:  the user provided encoding to use
14481  *
14482  * Applies the options to the parser context
14483  *
14484  * Returns 0 in case of success, the set of unknown or unimplemented options
14485  *         in case of error.
14486  */
14487 static int
14488 xmlCtxtUseOptionsInternal(xmlParserCtxtPtr ctxt, int options, const char *encoding)
14489 {
14490     if (ctxt == NULL)
14491         return(-1);
14492     if (encoding != NULL) {
14493         if (ctxt->encoding != NULL)
14494             xmlFree((xmlChar *) ctxt->encoding);
14495         ctxt->encoding = xmlStrdup((const xmlChar *) encoding);
14496     }
14497     if (options & XML_PARSE_RECOVER) {
14498         ctxt->recovery = 1;
14499         options -= XML_PARSE_RECOVER;
14500         ctxt->options |= XML_PARSE_RECOVER;
14501     } else
14502         ctxt->recovery = 0;
14503     if (options & XML_PARSE_DTDLOAD) {
14504         ctxt->loadsubset = XML_DETECT_IDS;
14505         options -= XML_PARSE_DTDLOAD;
14506         ctxt->options |= XML_PARSE_DTDLOAD;
14507     } else
14508         ctxt->loadsubset = 0;
14509     if (options & XML_PARSE_DTDATTR) {
14510         ctxt->loadsubset |= XML_COMPLETE_ATTRS;
14511         options -= XML_PARSE_DTDATTR;
14512         ctxt->options |= XML_PARSE_DTDATTR;
14513     }
14514     if (options & XML_PARSE_NOENT) {
14515         ctxt->replaceEntities = 1;
14516         /* ctxt->loadsubset |= XML_DETECT_IDS; */
14517         options -= XML_PARSE_NOENT;
14518         ctxt->options |= XML_PARSE_NOENT;
14519     } else
14520         ctxt->replaceEntities = 0;
14521     if (options & XML_PARSE_PEDANTIC) {
14522         ctxt->pedantic = 1;
14523         options -= XML_PARSE_PEDANTIC;
14524         ctxt->options |= XML_PARSE_PEDANTIC;
14525     } else
14526         ctxt->pedantic = 0;
14527     if (options & XML_PARSE_NOBLANKS) {
14528         ctxt->keepBlanks = 0;
14529         ctxt->sax->ignorableWhitespace = xmlSAX2IgnorableWhitespace;
14530         options -= XML_PARSE_NOBLANKS;
14531         ctxt->options |= XML_PARSE_NOBLANKS;
14532     } else
14533         ctxt->keepBlanks = 1;
14534     if (options & XML_PARSE_DTDVALID) {
14535         ctxt->validate = 1;
14536         if (options & XML_PARSE_NOWARNING)
14537             ctxt->vctxt.warning = NULL;
14538         if (options & XML_PARSE_NOERROR)
14539             ctxt->vctxt.error = NULL;
14540         options -= XML_PARSE_DTDVALID;
14541         ctxt->options |= XML_PARSE_DTDVALID;
14542     } else
14543         ctxt->validate = 0;
14544     if (options & XML_PARSE_NOWARNING) {
14545         ctxt->sax->warning = NULL;
14546         options -= XML_PARSE_NOWARNING;
14547     }
14548     if (options & XML_PARSE_NOERROR) {
14549         ctxt->sax->error = NULL;
14550         ctxt->sax->fatalError = NULL;
14551         options -= XML_PARSE_NOERROR;
14552     }
14553 #ifdef LIBXML_SAX1_ENABLED
14554     if (options & XML_PARSE_SAX1) {
14555         ctxt->sax->startElement = xmlSAX2StartElement;
14556         ctxt->sax->endElement = xmlSAX2EndElement;
14557         ctxt->sax->startElementNs = NULL;
14558         ctxt->sax->endElementNs = NULL;
14559         ctxt->sax->initialized = 1;
14560         options -= XML_PARSE_SAX1;
14561         ctxt->options |= XML_PARSE_SAX1;
14562     }
14563 #endif /* LIBXML_SAX1_ENABLED */
14564     if (options & XML_PARSE_NODICT) {
14565         ctxt->dictNames = 0;
14566         options -= XML_PARSE_NODICT;
14567         ctxt->options |= XML_PARSE_NODICT;
14568     } else {
14569         ctxt->dictNames = 1;
14570     }
14571     if (options & XML_PARSE_NOCDATA) {
14572         ctxt->sax->cdataBlock = NULL;
14573         options -= XML_PARSE_NOCDATA;
14574         ctxt->options |= XML_PARSE_NOCDATA;
14575     }
14576     if (options & XML_PARSE_NSCLEAN) {
14577         ctxt->options |= XML_PARSE_NSCLEAN;
14578         options -= XML_PARSE_NSCLEAN;
14579     }
14580     if (options & XML_PARSE_NONET) {
14581         ctxt->options |= XML_PARSE_NONET;
14582         options -= XML_PARSE_NONET;
14583     }
14584     if (options & XML_PARSE_COMPACT) {
14585         ctxt->options |= XML_PARSE_COMPACT;
14586         options -= XML_PARSE_COMPACT;
14587     }
14588     if (options & XML_PARSE_OLD10) {
14589         ctxt->options |= XML_PARSE_OLD10;
14590         options -= XML_PARSE_OLD10;
14591     }
14592     if (options & XML_PARSE_NOBASEFIX) {
14593         ctxt->options |= XML_PARSE_NOBASEFIX;
14594         options -= XML_PARSE_NOBASEFIX;
14595     }
14596     if (options & XML_PARSE_HUGE) {
14597         ctxt->options |= XML_PARSE_HUGE;
14598         options -= XML_PARSE_HUGE;
14599     }
14600     if (options & XML_PARSE_OLDSAX) {
14601         ctxt->options |= XML_PARSE_OLDSAX;
14602         options -= XML_PARSE_OLDSAX;
14603     }
14604     if (options & XML_PARSE_IGNORE_ENC) {
14605         ctxt->options |= XML_PARSE_IGNORE_ENC;
14606         options -= XML_PARSE_IGNORE_ENC;
14607     }
14608     ctxt->linenumbers = 1;
14609     return (options);
14610 }
14611
14612 /**
14613  * xmlCtxtUseOptions:
14614  * @ctxt: an XML parser context
14615  * @options:  a combination of xmlParserOption
14616  *
14617  * Applies the options to the parser context
14618  *
14619  * Returns 0 in case of success, the set of unknown or unimplemented options
14620  *         in case of error.
14621  */
14622 int
14623 xmlCtxtUseOptions(xmlParserCtxtPtr ctxt, int options)
14624 {
14625    return(xmlCtxtUseOptionsInternal(ctxt, options, NULL));
14626 }
14627
14628 /**
14629  * xmlDoRead:
14630  * @ctxt:  an XML parser context
14631  * @URL:  the base URL to use for the document
14632  * @encoding:  the document encoding, or NULL
14633  * @options:  a combination of xmlParserOption
14634  * @reuse:  keep the context for reuse
14635  *
14636  * Common front-end for the xmlRead functions
14637  *
14638  * Returns the resulting document tree or NULL
14639  */
14640 static xmlDocPtr
14641 xmlDoRead(xmlParserCtxtPtr ctxt, const char *URL, const char *encoding,
14642           int options, int reuse)
14643 {
14644     xmlDocPtr ret;
14645
14646     xmlCtxtUseOptionsInternal(ctxt, options, encoding);
14647     if (encoding != NULL) {
14648         xmlCharEncodingHandlerPtr hdlr;
14649
14650         hdlr = xmlFindCharEncodingHandler(encoding);
14651         if (hdlr != NULL)
14652             xmlSwitchToEncoding(ctxt, hdlr);
14653     }
14654     if ((URL != NULL) && (ctxt->input != NULL) &&
14655         (ctxt->input->filename == NULL))
14656         ctxt->input->filename = (char *) xmlStrdup((const xmlChar *) URL);
14657     xmlParseDocument(ctxt);
14658     if ((ctxt->wellFormed) || ctxt->recovery)
14659         ret = ctxt->myDoc;
14660     else {
14661         ret = NULL;
14662         if (ctxt->myDoc != NULL) {
14663             xmlFreeDoc(ctxt->myDoc);
14664         }
14665     }
14666     ctxt->myDoc = NULL;
14667     if (!reuse) {
14668         xmlFreeParserCtxt(ctxt);
14669     }
14670
14671     return (ret);
14672 }
14673
14674 /**
14675  * xmlReadDoc:
14676  * @cur:  a pointer to a zero terminated string
14677  * @URL:  the base URL to use for the document
14678  * @encoding:  the document encoding, or NULL
14679  * @options:  a combination of xmlParserOption
14680  *
14681  * parse an XML in-memory document and build a tree.
14682  *
14683  * Returns the resulting document tree
14684  */
14685 xmlDocPtr
14686 xmlReadDoc(const xmlChar * cur, const char *URL, const char *encoding, int options)
14687 {
14688     xmlParserCtxtPtr ctxt;
14689
14690     if (cur == NULL)
14691         return (NULL);
14692
14693     ctxt = xmlCreateDocParserCtxt(cur);
14694     if (ctxt == NULL)
14695         return (NULL);
14696     return (xmlDoRead(ctxt, URL, encoding, options, 0));
14697 }
14698
14699 /**
14700  * xmlReadFile:
14701  * @filename:  a file or URL
14702  * @encoding:  the document encoding, or NULL
14703  * @options:  a combination of xmlParserOption
14704  *
14705  * parse an XML file from the filesystem or the network.
14706  *
14707  * Returns the resulting document tree
14708  */
14709 xmlDocPtr
14710 xmlReadFile(const char *filename, const char *encoding, int options)
14711 {
14712     xmlParserCtxtPtr ctxt;
14713
14714     ctxt = xmlCreateURLParserCtxt(filename, options);
14715     if (ctxt == NULL)
14716         return (NULL);
14717     return (xmlDoRead(ctxt, NULL, encoding, options, 0));
14718 }
14719
14720 /**
14721  * xmlReadMemory:
14722  * @buffer:  a pointer to a char array
14723  * @size:  the size of the array
14724  * @URL:  the base URL to use for the document
14725  * @encoding:  the document encoding, or NULL
14726  * @options:  a combination of xmlParserOption
14727  *
14728  * parse an XML in-memory document and build a tree.
14729  *
14730  * Returns the resulting document tree
14731  */
14732 xmlDocPtr
14733 xmlReadMemory(const char *buffer, int size, const char *URL, const char *encoding, int options)
14734 {
14735     xmlParserCtxtPtr ctxt;
14736
14737     ctxt = xmlCreateMemoryParserCtxt(buffer, size);
14738     if (ctxt == NULL)
14739         return (NULL);
14740     return (xmlDoRead(ctxt, URL, encoding, options, 0));
14741 }
14742
14743 /**
14744  * xmlReadFd:
14745  * @fd:  an open file descriptor
14746  * @URL:  the base URL to use for the document
14747  * @encoding:  the document encoding, or NULL
14748  * @options:  a combination of xmlParserOption
14749  *
14750  * parse an XML from a file descriptor and build a tree.
14751  * NOTE that the file descriptor will not be closed when the
14752  *      reader is closed or reset.
14753  *
14754  * Returns the resulting document tree
14755  */
14756 xmlDocPtr
14757 xmlReadFd(int fd, const char *URL, const char *encoding, int options)
14758 {
14759     xmlParserCtxtPtr ctxt;
14760     xmlParserInputBufferPtr input;
14761     xmlParserInputPtr stream;
14762
14763     if (fd < 0)
14764         return (NULL);
14765
14766     input = xmlParserInputBufferCreateFd(fd, XML_CHAR_ENCODING_NONE);
14767     if (input == NULL)
14768         return (NULL);
14769     input->closecallback = NULL;
14770     ctxt = xmlNewParserCtxt();
14771     if (ctxt == NULL) {
14772         xmlFreeParserInputBuffer(input);
14773         return (NULL);
14774     }
14775     stream = xmlNewIOInputStream(ctxt, input, XML_CHAR_ENCODING_NONE);
14776     if (stream == NULL) {
14777         xmlFreeParserInputBuffer(input);
14778         xmlFreeParserCtxt(ctxt);
14779         return (NULL);
14780     }
14781     inputPush(ctxt, stream);
14782     return (xmlDoRead(ctxt, URL, encoding, options, 0));
14783 }
14784
14785 /**
14786  * xmlReadIO:
14787  * @ioread:  an I/O read function
14788  * @ioclose:  an I/O close function
14789  * @ioctx:  an I/O handler
14790  * @URL:  the base URL to use for the document
14791  * @encoding:  the document encoding, or NULL
14792  * @options:  a combination of xmlParserOption
14793  *
14794  * parse an XML document from I/O functions and source and build a tree.
14795  *
14796  * Returns the resulting document tree
14797  */
14798 xmlDocPtr
14799 xmlReadIO(xmlInputReadCallback ioread, xmlInputCloseCallback ioclose,
14800           void *ioctx, const char *URL, const char *encoding, int options)
14801 {
14802     xmlParserCtxtPtr ctxt;
14803     xmlParserInputBufferPtr input;
14804     xmlParserInputPtr stream;
14805
14806     if (ioread == NULL)
14807         return (NULL);
14808
14809     input = xmlParserInputBufferCreateIO(ioread, ioclose, ioctx,
14810                                          XML_CHAR_ENCODING_NONE);
14811     if (input == NULL) {
14812         if (ioclose != NULL)
14813             ioclose(ioctx);
14814         return (NULL);
14815     }
14816     ctxt = xmlNewParserCtxt();
14817     if (ctxt == NULL) {
14818         xmlFreeParserInputBuffer(input);
14819         return (NULL);
14820     }
14821     stream = xmlNewIOInputStream(ctxt, input, XML_CHAR_ENCODING_NONE);
14822     if (stream == NULL) {
14823         xmlFreeParserInputBuffer(input);
14824         xmlFreeParserCtxt(ctxt);
14825         return (NULL);
14826     }
14827     inputPush(ctxt, stream);
14828     return (xmlDoRead(ctxt, URL, encoding, options, 0));
14829 }
14830
14831 /**
14832  * xmlCtxtReadDoc:
14833  * @ctxt:  an XML parser context
14834  * @cur:  a pointer to a zero terminated string
14835  * @URL:  the base URL to use for the document
14836  * @encoding:  the document encoding, or NULL
14837  * @options:  a combination of xmlParserOption
14838  *
14839  * parse an XML in-memory document and build a tree.
14840  * This reuses the existing @ctxt parser context
14841  *
14842  * Returns the resulting document tree
14843  */
14844 xmlDocPtr
14845 xmlCtxtReadDoc(xmlParserCtxtPtr ctxt, const xmlChar * cur,
14846                const char *URL, const char *encoding, int options)
14847 {
14848     xmlParserInputPtr stream;
14849
14850     if (cur == NULL)
14851         return (NULL);
14852     if (ctxt == NULL)
14853         return (NULL);
14854
14855     xmlCtxtReset(ctxt);
14856
14857     stream = xmlNewStringInputStream(ctxt, cur);
14858     if (stream == NULL) {
14859         return (NULL);
14860     }
14861     inputPush(ctxt, stream);
14862     return (xmlDoRead(ctxt, URL, encoding, options, 1));
14863 }
14864
14865 /**
14866  * xmlCtxtReadFile:
14867  * @ctxt:  an XML parser context
14868  * @filename:  a file or URL
14869  * @encoding:  the document encoding, or NULL
14870  * @options:  a combination of xmlParserOption
14871  *
14872  * parse an XML file from the filesystem or the network.
14873  * This reuses the existing @ctxt parser context
14874  *
14875  * Returns the resulting document tree
14876  */
14877 xmlDocPtr
14878 xmlCtxtReadFile(xmlParserCtxtPtr ctxt, const char *filename,
14879                 const char *encoding, int options)
14880 {
14881     xmlParserInputPtr stream;
14882
14883     if (filename == NULL)
14884         return (NULL);
14885     if (ctxt == NULL)
14886         return (NULL);
14887
14888     xmlCtxtReset(ctxt);
14889
14890     stream = xmlLoadExternalEntity(filename, NULL, ctxt);
14891     if (stream == NULL) {
14892         return (NULL);
14893     }
14894     inputPush(ctxt, stream);
14895     return (xmlDoRead(ctxt, NULL, encoding, options, 1));
14896 }
14897
14898 /**
14899  * xmlCtxtReadMemory:
14900  * @ctxt:  an XML parser context
14901  * @buffer:  a pointer to a char array
14902  * @size:  the size of the array
14903  * @URL:  the base URL to use for the document
14904  * @encoding:  the document encoding, or NULL
14905  * @options:  a combination of xmlParserOption
14906  *
14907  * parse an XML in-memory document and build a tree.
14908  * This reuses the existing @ctxt parser context
14909  *
14910  * Returns the resulting document tree
14911  */
14912 xmlDocPtr
14913 xmlCtxtReadMemory(xmlParserCtxtPtr ctxt, const char *buffer, int size,
14914                   const char *URL, const char *encoding, int options)
14915 {
14916     xmlParserInputBufferPtr input;
14917     xmlParserInputPtr stream;
14918
14919     if (ctxt == NULL)
14920         return (NULL);
14921     if (buffer == NULL)
14922         return (NULL);
14923
14924     xmlCtxtReset(ctxt);
14925
14926     input = xmlParserInputBufferCreateMem(buffer, size, XML_CHAR_ENCODING_NONE);
14927     if (input == NULL) {
14928         return(NULL);
14929     }
14930
14931     stream = xmlNewIOInputStream(ctxt, input, XML_CHAR_ENCODING_NONE);
14932     if (stream == NULL) {
14933         xmlFreeParserInputBuffer(input);
14934         return(NULL);
14935     }
14936
14937     inputPush(ctxt, stream);
14938     return (xmlDoRead(ctxt, URL, encoding, options, 1));
14939 }
14940
14941 /**
14942  * xmlCtxtReadFd:
14943  * @ctxt:  an XML parser context
14944  * @fd:  an open file descriptor
14945  * @URL:  the base URL to use for the document
14946  * @encoding:  the document encoding, or NULL
14947  * @options:  a combination of xmlParserOption
14948  *
14949  * parse an XML from a file descriptor and build a tree.
14950  * This reuses the existing @ctxt parser context
14951  * NOTE that the file descriptor will not be closed when the
14952  *      reader is closed or reset.
14953  *
14954  * Returns the resulting document tree
14955  */
14956 xmlDocPtr
14957 xmlCtxtReadFd(xmlParserCtxtPtr ctxt, int fd,
14958               const char *URL, const char *encoding, int options)
14959 {
14960     xmlParserInputBufferPtr input;
14961     xmlParserInputPtr stream;
14962
14963     if (fd < 0)
14964         return (NULL);
14965     if (ctxt == NULL)
14966         return (NULL);
14967
14968     xmlCtxtReset(ctxt);
14969
14970
14971     input = xmlParserInputBufferCreateFd(fd, XML_CHAR_ENCODING_NONE);
14972     if (input == NULL)
14973         return (NULL);
14974     input->closecallback = NULL;
14975     stream = xmlNewIOInputStream(ctxt, input, XML_CHAR_ENCODING_NONE);
14976     if (stream == NULL) {
14977         xmlFreeParserInputBuffer(input);
14978         return (NULL);
14979     }
14980     inputPush(ctxt, stream);
14981     return (xmlDoRead(ctxt, URL, encoding, options, 1));
14982 }
14983
14984 /**
14985  * xmlCtxtReadIO:
14986  * @ctxt:  an XML parser context
14987  * @ioread:  an I/O read function
14988  * @ioclose:  an I/O close function
14989  * @ioctx:  an I/O handler
14990  * @URL:  the base URL to use for the document
14991  * @encoding:  the document encoding, or NULL
14992  * @options:  a combination of xmlParserOption
14993  *
14994  * parse an XML document from I/O functions and source and build a tree.
14995  * This reuses the existing @ctxt parser context
14996  *
14997  * Returns the resulting document tree
14998  */
14999 xmlDocPtr
15000 xmlCtxtReadIO(xmlParserCtxtPtr ctxt, xmlInputReadCallback ioread,
15001               xmlInputCloseCallback ioclose, void *ioctx,
15002               const char *URL,
15003               const char *encoding, int options)
15004 {
15005     xmlParserInputBufferPtr input;
15006     xmlParserInputPtr stream;
15007
15008     if (ioread == NULL)
15009         return (NULL);
15010     if (ctxt == NULL)
15011         return (NULL);
15012
15013     xmlCtxtReset(ctxt);
15014
15015     input = xmlParserInputBufferCreateIO(ioread, ioclose, ioctx,
15016                                          XML_CHAR_ENCODING_NONE);
15017     if (input == NULL) {
15018         if (ioclose != NULL)
15019             ioclose(ioctx);
15020         return (NULL);
15021     }
15022     stream = xmlNewIOInputStream(ctxt, input, XML_CHAR_ENCODING_NONE);
15023     if (stream == NULL) {
15024         xmlFreeParserInputBuffer(input);
15025         return (NULL);
15026     }
15027     inputPush(ctxt, stream);
15028     return (xmlDoRead(ctxt, URL, encoding, options, 1));
15029 }
15030
15031 #define bottom_parser
15032 #include "elfgcchack.h"