Annotation of embedaddon/libxml2/parser.c, revision 1.1
1.1 ! misho 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:
! 83: static void
! 84: xmlFatalErr(xmlParserCtxtPtr ctxt, xmlParserErrors error, const char *info);
! 85:
! 86: static xmlParserCtxtPtr
! 87: xmlCreateEntityParserCtxtInternal(const xmlChar *URL, const xmlChar *ID,
! 88: const xmlChar *base, xmlParserCtxtPtr pctx);
! 89:
! 90: /************************************************************************
! 91: * *
! 92: * Arbitrary limits set in the parser. See XML_PARSE_HUGE *
! 93: * *
! 94: ************************************************************************/
! 95:
! 96: #define XML_PARSER_BIG_ENTITY 1000
! 97: #define XML_PARSER_LOT_ENTITY 5000
! 98:
! 99: /*
! 100: * XML_PARSER_NON_LINEAR is the threshold where the ratio of parsed entity
! 101: * replacement over the size in byte of the input indicates that you have
! 102: * and eponential behaviour. A value of 10 correspond to at least 3 entity
! 103: * replacement per byte of input.
! 104: */
! 105: #define XML_PARSER_NON_LINEAR 10
! 106:
! 107: /*
! 108: * xmlParserEntityCheck
! 109: *
! 110: * Function to check non-linear entity expansion behaviour
! 111: * This is here to detect and stop exponential linear entity expansion
! 112: * This is not a limitation of the parser but a safety
! 113: * boundary feature. It can be disabled with the XML_PARSE_HUGE
! 114: * parser option.
! 115: */
! 116: static int
! 117: xmlParserEntityCheck(xmlParserCtxtPtr ctxt, unsigned long size,
! 118: xmlEntityPtr ent)
! 119: {
! 120: unsigned long consumed = 0;
! 121:
! 122: if ((ctxt == NULL) || (ctxt->options & XML_PARSE_HUGE))
! 123: return (0);
! 124: if (ctxt->lastError.code == XML_ERR_ENTITY_LOOP)
! 125: return (1);
! 126: if (size != 0) {
! 127: /*
! 128: * Do the check based on the replacement size of the entity
! 129: */
! 130: if (size < XML_PARSER_BIG_ENTITY)
! 131: return(0);
! 132:
! 133: /*
! 134: * A limit on the amount of text data reasonably used
! 135: */
! 136: if (ctxt->input != NULL) {
! 137: consumed = ctxt->input->consumed +
! 138: (ctxt->input->cur - ctxt->input->base);
! 139: }
! 140: consumed += ctxt->sizeentities;
! 141:
! 142: if ((size < XML_PARSER_NON_LINEAR * consumed) &&
! 143: (ctxt->nbentities * 3 < XML_PARSER_NON_LINEAR * consumed))
! 144: return (0);
! 145: } else if (ent != NULL) {
! 146: /*
! 147: * use the number of parsed entities in the replacement
! 148: */
! 149: size = ent->checked;
! 150:
! 151: /*
! 152: * The amount of data parsed counting entities size only once
! 153: */
! 154: if (ctxt->input != NULL) {
! 155: consumed = ctxt->input->consumed +
! 156: (ctxt->input->cur - ctxt->input->base);
! 157: }
! 158: consumed += ctxt->sizeentities;
! 159:
! 160: /*
! 161: * Check the density of entities for the amount of data
! 162: * knowing an entity reference will take at least 3 bytes
! 163: */
! 164: if (size * 3 < consumed * XML_PARSER_NON_LINEAR)
! 165: return (0);
! 166: } else {
! 167: /*
! 168: * strange we got no data for checking just return
! 169: */
! 170: return (0);
! 171: }
! 172:
! 173: xmlFatalErr(ctxt, XML_ERR_ENTITY_LOOP, NULL);
! 174: return (1);
! 175: }
! 176:
! 177: /**
! 178: * xmlParserMaxDepth:
! 179: *
! 180: * arbitrary depth limit for the XML documents that we allow to
! 181: * process. This is not a limitation of the parser but a safety
! 182: * boundary feature. It can be disabled with the XML_PARSE_HUGE
! 183: * parser option.
! 184: */
! 185: unsigned int xmlParserMaxDepth = 256;
! 186:
! 187:
! 188:
! 189: #define SAX2 1
! 190: #define XML_PARSER_BIG_BUFFER_SIZE 300
! 191: #define XML_PARSER_BUFFER_SIZE 100
! 192: #define SAX_COMPAT_MODE BAD_CAST "SAX compatibility mode document"
! 193:
! 194: /*
! 195: * List of XML prefixed PI allowed by W3C specs
! 196: */
! 197:
! 198: static const char *xmlW3CPIs[] = {
! 199: "xml-stylesheet",
! 200: NULL
! 201: };
! 202:
! 203:
! 204: /* DEPR void xmlParserHandleReference(xmlParserCtxtPtr ctxt); */
! 205: static xmlEntityPtr xmlParseStringPEReference(xmlParserCtxtPtr ctxt,
! 206: const xmlChar **str);
! 207:
! 208: static xmlParserErrors
! 209: xmlParseExternalEntityPrivate(xmlDocPtr doc, xmlParserCtxtPtr oldctxt,
! 210: xmlSAXHandlerPtr sax,
! 211: void *user_data, int depth, const xmlChar *URL,
! 212: const xmlChar *ID, xmlNodePtr *list);
! 213:
! 214: static int
! 215: xmlCtxtUseOptionsInternal(xmlParserCtxtPtr ctxt, int options,
! 216: const char *encoding);
! 217: #ifdef LIBXML_LEGACY_ENABLED
! 218: static void
! 219: xmlAddEntityReference(xmlEntityPtr ent, xmlNodePtr firstNode,
! 220: xmlNodePtr lastNode);
! 221: #endif /* LIBXML_LEGACY_ENABLED */
! 222:
! 223: static xmlParserErrors
! 224: xmlParseBalancedChunkMemoryInternal(xmlParserCtxtPtr oldctxt,
! 225: const xmlChar *string, void *user_data, xmlNodePtr *lst);
! 226:
! 227: static int
! 228: xmlLoadEntityContent(xmlParserCtxtPtr ctxt, xmlEntityPtr entity);
! 229:
! 230: /************************************************************************
! 231: * *
! 232: * Some factorized error routines *
! 233: * *
! 234: ************************************************************************/
! 235:
! 236: /**
! 237: * xmlErrAttributeDup:
! 238: * @ctxt: an XML parser context
! 239: * @prefix: the attribute prefix
! 240: * @localname: the attribute localname
! 241: *
! 242: * Handle a redefinition of attribute error
! 243: */
! 244: static void
! 245: xmlErrAttributeDup(xmlParserCtxtPtr ctxt, const xmlChar * prefix,
! 246: const xmlChar * localname)
! 247: {
! 248: if ((ctxt != NULL) && (ctxt->disableSAX != 0) &&
! 249: (ctxt->instate == XML_PARSER_EOF))
! 250: return;
! 251: if (ctxt != NULL)
! 252: ctxt->errNo = XML_ERR_ATTRIBUTE_REDEFINED;
! 253:
! 254: if (prefix == NULL)
! 255: __xmlRaiseError(NULL, NULL, NULL, ctxt, NULL, XML_FROM_PARSER,
! 256: XML_ERR_ATTRIBUTE_REDEFINED, XML_ERR_FATAL, NULL, 0,
! 257: (const char *) localname, NULL, NULL, 0, 0,
! 258: "Attribute %s redefined\n", localname);
! 259: else
! 260: __xmlRaiseError(NULL, NULL, NULL, ctxt, NULL, XML_FROM_PARSER,
! 261: XML_ERR_ATTRIBUTE_REDEFINED, XML_ERR_FATAL, NULL, 0,
! 262: (const char *) prefix, (const char *) localname,
! 263: NULL, 0, 0, "Attribute %s:%s redefined\n", prefix,
! 264: localname);
! 265: if (ctxt != NULL) {
! 266: ctxt->wellFormed = 0;
! 267: if (ctxt->recovery == 0)
! 268: ctxt->disableSAX = 1;
! 269: }
! 270: }
! 271:
! 272: /**
! 273: * xmlFatalErr:
! 274: * @ctxt: an XML parser context
! 275: * @error: the error number
! 276: * @extra: extra information string
! 277: *
! 278: * Handle a fatal parser error, i.e. violating Well-Formedness constraints
! 279: */
! 280: static void
! 281: xmlFatalErr(xmlParserCtxtPtr ctxt, xmlParserErrors error, const char *info)
! 282: {
! 283: const char *errmsg;
! 284:
! 285: if ((ctxt != NULL) && (ctxt->disableSAX != 0) &&
! 286: (ctxt->instate == XML_PARSER_EOF))
! 287: return;
! 288: switch (error) {
! 289: case XML_ERR_INVALID_HEX_CHARREF:
! 290: errmsg = "CharRef: invalid hexadecimal value\n";
! 291: break;
! 292: case XML_ERR_INVALID_DEC_CHARREF:
! 293: errmsg = "CharRef: invalid decimal value\n";
! 294: break;
! 295: case XML_ERR_INVALID_CHARREF:
! 296: errmsg = "CharRef: invalid value\n";
! 297: break;
! 298: case XML_ERR_INTERNAL_ERROR:
! 299: errmsg = "internal error";
! 300: break;
! 301: case XML_ERR_PEREF_AT_EOF:
! 302: errmsg = "PEReference at end of document\n";
! 303: break;
! 304: case XML_ERR_PEREF_IN_PROLOG:
! 305: errmsg = "PEReference in prolog\n";
! 306: break;
! 307: case XML_ERR_PEREF_IN_EPILOG:
! 308: errmsg = "PEReference in epilog\n";
! 309: break;
! 310: case XML_ERR_PEREF_NO_NAME:
! 311: errmsg = "PEReference: no name\n";
! 312: break;
! 313: case XML_ERR_PEREF_SEMICOL_MISSING:
! 314: errmsg = "PEReference: expecting ';'\n";
! 315: break;
! 316: case XML_ERR_ENTITY_LOOP:
! 317: errmsg = "Detected an entity reference loop\n";
! 318: break;
! 319: case XML_ERR_ENTITY_NOT_STARTED:
! 320: errmsg = "EntityValue: \" or ' expected\n";
! 321: break;
! 322: case XML_ERR_ENTITY_PE_INTERNAL:
! 323: errmsg = "PEReferences forbidden in internal subset\n";
! 324: break;
! 325: case XML_ERR_ENTITY_NOT_FINISHED:
! 326: errmsg = "EntityValue: \" or ' expected\n";
! 327: break;
! 328: case XML_ERR_ATTRIBUTE_NOT_STARTED:
! 329: errmsg = "AttValue: \" or ' expected\n";
! 330: break;
! 331: case XML_ERR_LT_IN_ATTRIBUTE:
! 332: errmsg = "Unescaped '<' not allowed in attributes values\n";
! 333: break;
! 334: case XML_ERR_LITERAL_NOT_STARTED:
! 335: errmsg = "SystemLiteral \" or ' expected\n";
! 336: break;
! 337: case XML_ERR_LITERAL_NOT_FINISHED:
! 338: errmsg = "Unfinished System or Public ID \" or ' expected\n";
! 339: break;
! 340: case XML_ERR_MISPLACED_CDATA_END:
! 341: errmsg = "Sequence ']]>' not allowed in content\n";
! 342: break;
! 343: case XML_ERR_URI_REQUIRED:
! 344: errmsg = "SYSTEM or PUBLIC, the URI is missing\n";
! 345: break;
! 346: case XML_ERR_PUBID_REQUIRED:
! 347: errmsg = "PUBLIC, the Public Identifier is missing\n";
! 348: break;
! 349: case XML_ERR_HYPHEN_IN_COMMENT:
! 350: errmsg = "Comment must not contain '--' (double-hyphen)\n";
! 351: break;
! 352: case XML_ERR_PI_NOT_STARTED:
! 353: errmsg = "xmlParsePI : no target name\n";
! 354: break;
! 355: case XML_ERR_RESERVED_XML_NAME:
! 356: errmsg = "Invalid PI name\n";
! 357: break;
! 358: case XML_ERR_NOTATION_NOT_STARTED:
! 359: errmsg = "NOTATION: Name expected here\n";
! 360: break;
! 361: case XML_ERR_NOTATION_NOT_FINISHED:
! 362: errmsg = "'>' required to close NOTATION declaration\n";
! 363: break;
! 364: case XML_ERR_VALUE_REQUIRED:
! 365: errmsg = "Entity value required\n";
! 366: break;
! 367: case XML_ERR_URI_FRAGMENT:
! 368: errmsg = "Fragment not allowed";
! 369: break;
! 370: case XML_ERR_ATTLIST_NOT_STARTED:
! 371: errmsg = "'(' required to start ATTLIST enumeration\n";
! 372: break;
! 373: case XML_ERR_NMTOKEN_REQUIRED:
! 374: errmsg = "NmToken expected in ATTLIST enumeration\n";
! 375: break;
! 376: case XML_ERR_ATTLIST_NOT_FINISHED:
! 377: errmsg = "')' required to finish ATTLIST enumeration\n";
! 378: break;
! 379: case XML_ERR_MIXED_NOT_STARTED:
! 380: errmsg = "MixedContentDecl : '|' or ')*' expected\n";
! 381: break;
! 382: case XML_ERR_PCDATA_REQUIRED:
! 383: errmsg = "MixedContentDecl : '#PCDATA' expected\n";
! 384: break;
! 385: case XML_ERR_ELEMCONTENT_NOT_STARTED:
! 386: errmsg = "ContentDecl : Name or '(' expected\n";
! 387: break;
! 388: case XML_ERR_ELEMCONTENT_NOT_FINISHED:
! 389: errmsg = "ContentDecl : ',' '|' or ')' expected\n";
! 390: break;
! 391: case XML_ERR_PEREF_IN_INT_SUBSET:
! 392: errmsg =
! 393: "PEReference: forbidden within markup decl in internal subset\n";
! 394: break;
! 395: case XML_ERR_GT_REQUIRED:
! 396: errmsg = "expected '>'\n";
! 397: break;
! 398: case XML_ERR_CONDSEC_INVALID:
! 399: errmsg = "XML conditional section '[' expected\n";
! 400: break;
! 401: case XML_ERR_EXT_SUBSET_NOT_FINISHED:
! 402: errmsg = "Content error in the external subset\n";
! 403: break;
! 404: case XML_ERR_CONDSEC_INVALID_KEYWORD:
! 405: errmsg =
! 406: "conditional section INCLUDE or IGNORE keyword expected\n";
! 407: break;
! 408: case XML_ERR_CONDSEC_NOT_FINISHED:
! 409: errmsg = "XML conditional section not closed\n";
! 410: break;
! 411: case XML_ERR_XMLDECL_NOT_STARTED:
! 412: errmsg = "Text declaration '<?xml' required\n";
! 413: break;
! 414: case XML_ERR_XMLDECL_NOT_FINISHED:
! 415: errmsg = "parsing XML declaration: '?>' expected\n";
! 416: break;
! 417: case XML_ERR_EXT_ENTITY_STANDALONE:
! 418: errmsg = "external parsed entities cannot be standalone\n";
! 419: break;
! 420: case XML_ERR_ENTITYREF_SEMICOL_MISSING:
! 421: errmsg = "EntityRef: expecting ';'\n";
! 422: break;
! 423: case XML_ERR_DOCTYPE_NOT_FINISHED:
! 424: errmsg = "DOCTYPE improperly terminated\n";
! 425: break;
! 426: case XML_ERR_LTSLASH_REQUIRED:
! 427: errmsg = "EndTag: '</' not found\n";
! 428: break;
! 429: case XML_ERR_EQUAL_REQUIRED:
! 430: errmsg = "expected '='\n";
! 431: break;
! 432: case XML_ERR_STRING_NOT_CLOSED:
! 433: errmsg = "String not closed expecting \" or '\n";
! 434: break;
! 435: case XML_ERR_STRING_NOT_STARTED:
! 436: errmsg = "String not started expecting ' or \"\n";
! 437: break;
! 438: case XML_ERR_ENCODING_NAME:
! 439: errmsg = "Invalid XML encoding name\n";
! 440: break;
! 441: case XML_ERR_STANDALONE_VALUE:
! 442: errmsg = "standalone accepts only 'yes' or 'no'\n";
! 443: break;
! 444: case XML_ERR_DOCUMENT_EMPTY:
! 445: errmsg = "Document is empty\n";
! 446: break;
! 447: case XML_ERR_DOCUMENT_END:
! 448: errmsg = "Extra content at the end of the document\n";
! 449: break;
! 450: case XML_ERR_NOT_WELL_BALANCED:
! 451: errmsg = "chunk is not well balanced\n";
! 452: break;
! 453: case XML_ERR_EXTRA_CONTENT:
! 454: errmsg = "extra content at the end of well balanced chunk\n";
! 455: break;
! 456: case XML_ERR_VERSION_MISSING:
! 457: errmsg = "Malformed declaration expecting version\n";
! 458: break;
! 459: #if 0
! 460: case:
! 461: errmsg = "\n";
! 462: break;
! 463: #endif
! 464: default:
! 465: errmsg = "Unregistered error message\n";
! 466: }
! 467: if (ctxt != NULL)
! 468: ctxt->errNo = error;
! 469: __xmlRaiseError(NULL, NULL, NULL, ctxt, NULL, XML_FROM_PARSER, error,
! 470: XML_ERR_FATAL, NULL, 0, info, NULL, NULL, 0, 0, errmsg,
! 471: info);
! 472: if (ctxt != NULL) {
! 473: ctxt->wellFormed = 0;
! 474: if (ctxt->recovery == 0)
! 475: ctxt->disableSAX = 1;
! 476: }
! 477: }
! 478:
! 479: /**
! 480: * xmlFatalErrMsg:
! 481: * @ctxt: an XML parser context
! 482: * @error: the error number
! 483: * @msg: the error message
! 484: *
! 485: * Handle a fatal parser error, i.e. violating Well-Formedness constraints
! 486: */
! 487: static void
! 488: xmlFatalErrMsg(xmlParserCtxtPtr ctxt, xmlParserErrors error,
! 489: const char *msg)
! 490: {
! 491: if ((ctxt != NULL) && (ctxt->disableSAX != 0) &&
! 492: (ctxt->instate == XML_PARSER_EOF))
! 493: return;
! 494: if (ctxt != NULL)
! 495: ctxt->errNo = error;
! 496: __xmlRaiseError(NULL, NULL, NULL, ctxt, NULL, XML_FROM_PARSER, error,
! 497: XML_ERR_FATAL, NULL, 0, NULL, NULL, NULL, 0, 0, "%s", msg);
! 498: if (ctxt != NULL) {
! 499: ctxt->wellFormed = 0;
! 500: if (ctxt->recovery == 0)
! 501: ctxt->disableSAX = 1;
! 502: }
! 503: }
! 504:
! 505: /**
! 506: * xmlWarningMsg:
! 507: * @ctxt: an XML parser context
! 508: * @error: the error number
! 509: * @msg: the error message
! 510: * @str1: extra data
! 511: * @str2: extra data
! 512: *
! 513: * Handle a warning.
! 514: */
! 515: static void
! 516: xmlWarningMsg(xmlParserCtxtPtr ctxt, xmlParserErrors error,
! 517: const char *msg, const xmlChar *str1, const xmlChar *str2)
! 518: {
! 519: xmlStructuredErrorFunc schannel = NULL;
! 520:
! 521: if ((ctxt != NULL) && (ctxt->disableSAX != 0) &&
! 522: (ctxt->instate == XML_PARSER_EOF))
! 523: return;
! 524: if ((ctxt != NULL) && (ctxt->sax != NULL) &&
! 525: (ctxt->sax->initialized == XML_SAX2_MAGIC))
! 526: schannel = ctxt->sax->serror;
! 527: if (ctxt != NULL) {
! 528: __xmlRaiseError(schannel,
! 529: (ctxt->sax) ? ctxt->sax->warning : NULL,
! 530: ctxt->userData,
! 531: ctxt, NULL, XML_FROM_PARSER, error,
! 532: XML_ERR_WARNING, NULL, 0,
! 533: (const char *) str1, (const char *) str2, NULL, 0, 0,
! 534: msg, (const char *) str1, (const char *) str2);
! 535: } else {
! 536: __xmlRaiseError(schannel, NULL, NULL,
! 537: ctxt, NULL, XML_FROM_PARSER, error,
! 538: XML_ERR_WARNING, NULL, 0,
! 539: (const char *) str1, (const char *) str2, NULL, 0, 0,
! 540: msg, (const char *) str1, (const char *) str2);
! 541: }
! 542: }
! 543:
! 544: /**
! 545: * xmlValidityError:
! 546: * @ctxt: an XML parser context
! 547: * @error: the error number
! 548: * @msg: the error message
! 549: * @str1: extra data
! 550: *
! 551: * Handle a validity error.
! 552: */
! 553: static void
! 554: xmlValidityError(xmlParserCtxtPtr ctxt, xmlParserErrors error,
! 555: const char *msg, const xmlChar *str1, const xmlChar *str2)
! 556: {
! 557: xmlStructuredErrorFunc schannel = NULL;
! 558:
! 559: if ((ctxt != NULL) && (ctxt->disableSAX != 0) &&
! 560: (ctxt->instate == XML_PARSER_EOF))
! 561: return;
! 562: if (ctxt != NULL) {
! 563: ctxt->errNo = error;
! 564: if ((ctxt->sax != NULL) && (ctxt->sax->initialized == XML_SAX2_MAGIC))
! 565: schannel = ctxt->sax->serror;
! 566: }
! 567: if (ctxt != NULL) {
! 568: __xmlRaiseError(schannel,
! 569: ctxt->vctxt.error, ctxt->vctxt.userData,
! 570: ctxt, NULL, XML_FROM_DTD, error,
! 571: XML_ERR_ERROR, NULL, 0, (const char *) str1,
! 572: (const char *) str2, NULL, 0, 0,
! 573: msg, (const char *) str1, (const char *) str2);
! 574: ctxt->valid = 0;
! 575: } else {
! 576: __xmlRaiseError(schannel, NULL, NULL,
! 577: ctxt, NULL, XML_FROM_DTD, error,
! 578: XML_ERR_ERROR, NULL, 0, (const char *) str1,
! 579: (const char *) str2, NULL, 0, 0,
! 580: msg, (const char *) str1, (const char *) str2);
! 581: }
! 582: }
! 583:
! 584: /**
! 585: * xmlFatalErrMsgInt:
! 586: * @ctxt: an XML parser context
! 587: * @error: the error number
! 588: * @msg: the error message
! 589: * @val: an integer value
! 590: *
! 591: * Handle a fatal parser error, i.e. violating Well-Formedness constraints
! 592: */
! 593: static void
! 594: xmlFatalErrMsgInt(xmlParserCtxtPtr ctxt, xmlParserErrors error,
! 595: const char *msg, int val)
! 596: {
! 597: if ((ctxt != NULL) && (ctxt->disableSAX != 0) &&
! 598: (ctxt->instate == XML_PARSER_EOF))
! 599: return;
! 600: if (ctxt != NULL)
! 601: ctxt->errNo = error;
! 602: __xmlRaiseError(NULL, NULL, NULL,
! 603: ctxt, NULL, XML_FROM_PARSER, error, XML_ERR_FATAL,
! 604: NULL, 0, NULL, NULL, NULL, val, 0, msg, val);
! 605: if (ctxt != NULL) {
! 606: ctxt->wellFormed = 0;
! 607: if (ctxt->recovery == 0)
! 608: ctxt->disableSAX = 1;
! 609: }
! 610: }
! 611:
! 612: /**
! 613: * xmlFatalErrMsgStrIntStr:
! 614: * @ctxt: an XML parser context
! 615: * @error: the error number
! 616: * @msg: the error message
! 617: * @str1: an string info
! 618: * @val: an integer value
! 619: * @str2: an string info
! 620: *
! 621: * Handle a fatal parser error, i.e. violating Well-Formedness constraints
! 622: */
! 623: static void
! 624: xmlFatalErrMsgStrIntStr(xmlParserCtxtPtr ctxt, xmlParserErrors error,
! 625: const char *msg, const xmlChar *str1, int val,
! 626: const xmlChar *str2)
! 627: {
! 628: if ((ctxt != NULL) && (ctxt->disableSAX != 0) &&
! 629: (ctxt->instate == XML_PARSER_EOF))
! 630: return;
! 631: if (ctxt != NULL)
! 632: ctxt->errNo = error;
! 633: __xmlRaiseError(NULL, NULL, NULL,
! 634: ctxt, NULL, XML_FROM_PARSER, error, XML_ERR_FATAL,
! 635: NULL, 0, (const char *) str1, (const char *) str2,
! 636: NULL, val, 0, msg, str1, val, str2);
! 637: if (ctxt != NULL) {
! 638: ctxt->wellFormed = 0;
! 639: if (ctxt->recovery == 0)
! 640: ctxt->disableSAX = 1;
! 641: }
! 642: }
! 643:
! 644: /**
! 645: * xmlFatalErrMsgStr:
! 646: * @ctxt: an XML parser context
! 647: * @error: the error number
! 648: * @msg: the error message
! 649: * @val: a string value
! 650: *
! 651: * Handle a fatal parser error, i.e. violating Well-Formedness constraints
! 652: */
! 653: static void
! 654: xmlFatalErrMsgStr(xmlParserCtxtPtr ctxt, xmlParserErrors error,
! 655: const char *msg, const xmlChar * val)
! 656: {
! 657: if ((ctxt != NULL) && (ctxt->disableSAX != 0) &&
! 658: (ctxt->instate == XML_PARSER_EOF))
! 659: return;
! 660: if (ctxt != NULL)
! 661: ctxt->errNo = error;
! 662: __xmlRaiseError(NULL, NULL, NULL, ctxt, NULL,
! 663: XML_FROM_PARSER, error, XML_ERR_FATAL,
! 664: NULL, 0, (const char *) val, NULL, NULL, 0, 0, msg,
! 665: val);
! 666: if (ctxt != NULL) {
! 667: ctxt->wellFormed = 0;
! 668: if (ctxt->recovery == 0)
! 669: ctxt->disableSAX = 1;
! 670: }
! 671: }
! 672:
! 673: /**
! 674: * xmlErrMsgStr:
! 675: * @ctxt: an XML parser context
! 676: * @error: the error number
! 677: * @msg: the error message
! 678: * @val: a string value
! 679: *
! 680: * Handle a non fatal parser error
! 681: */
! 682: static void
! 683: xmlErrMsgStr(xmlParserCtxtPtr ctxt, xmlParserErrors error,
! 684: const char *msg, const xmlChar * val)
! 685: {
! 686: if ((ctxt != NULL) && (ctxt->disableSAX != 0) &&
! 687: (ctxt->instate == XML_PARSER_EOF))
! 688: return;
! 689: if (ctxt != NULL)
! 690: ctxt->errNo = error;
! 691: __xmlRaiseError(NULL, NULL, NULL, ctxt, NULL,
! 692: XML_FROM_PARSER, error, XML_ERR_ERROR,
! 693: NULL, 0, (const char *) val, NULL, NULL, 0, 0, msg,
! 694: val);
! 695: }
! 696:
! 697: /**
! 698: * xmlNsErr:
! 699: * @ctxt: an XML parser context
! 700: * @error: the error number
! 701: * @msg: the message
! 702: * @info1: extra information string
! 703: * @info2: extra information string
! 704: *
! 705: * Handle a fatal parser error, i.e. violating Well-Formedness constraints
! 706: */
! 707: static void
! 708: xmlNsErr(xmlParserCtxtPtr ctxt, xmlParserErrors error,
! 709: const char *msg,
! 710: const xmlChar * info1, const xmlChar * info2,
! 711: const xmlChar * info3)
! 712: {
! 713: if ((ctxt != NULL) && (ctxt->disableSAX != 0) &&
! 714: (ctxt->instate == XML_PARSER_EOF))
! 715: return;
! 716: if (ctxt != NULL)
! 717: ctxt->errNo = error;
! 718: __xmlRaiseError(NULL, NULL, NULL, ctxt, NULL, XML_FROM_NAMESPACE, error,
! 719: XML_ERR_ERROR, NULL, 0, (const char *) info1,
! 720: (const char *) info2, (const char *) info3, 0, 0, msg,
! 721: info1, info2, info3);
! 722: if (ctxt != NULL)
! 723: ctxt->nsWellFormed = 0;
! 724: }
! 725:
! 726: /**
! 727: * xmlNsWarn
! 728: * @ctxt: an XML parser context
! 729: * @error: the error number
! 730: * @msg: the message
! 731: * @info1: extra information string
! 732: * @info2: extra information string
! 733: *
! 734: * Handle a fatal parser error, i.e. violating Well-Formedness constraints
! 735: */
! 736: static void
! 737: xmlNsWarn(xmlParserCtxtPtr ctxt, xmlParserErrors error,
! 738: const char *msg,
! 739: const xmlChar * info1, const xmlChar * info2,
! 740: const xmlChar * info3)
! 741: {
! 742: if ((ctxt != NULL) && (ctxt->disableSAX != 0) &&
! 743: (ctxt->instate == XML_PARSER_EOF))
! 744: return;
! 745: __xmlRaiseError(NULL, NULL, NULL, ctxt, NULL, XML_FROM_NAMESPACE, error,
! 746: XML_ERR_WARNING, NULL, 0, (const char *) info1,
! 747: (const char *) info2, (const char *) info3, 0, 0, msg,
! 748: info1, info2, info3);
! 749: }
! 750:
! 751: /************************************************************************
! 752: * *
! 753: * Library wide options *
! 754: * *
! 755: ************************************************************************/
! 756:
! 757: /**
! 758: * xmlHasFeature:
! 759: * @feature: the feature to be examined
! 760: *
! 761: * Examines if the library has been compiled with a given feature.
! 762: *
! 763: * Returns a non-zero value if the feature exist, otherwise zero.
! 764: * Returns zero (0) if the feature does not exist or an unknown
! 765: * unknown feature is requested, non-zero otherwise.
! 766: */
! 767: int
! 768: xmlHasFeature(xmlFeature feature)
! 769: {
! 770: switch (feature) {
! 771: case XML_WITH_THREAD:
! 772: #ifdef LIBXML_THREAD_ENABLED
! 773: return(1);
! 774: #else
! 775: return(0);
! 776: #endif
! 777: case XML_WITH_TREE:
! 778: #ifdef LIBXML_TREE_ENABLED
! 779: return(1);
! 780: #else
! 781: return(0);
! 782: #endif
! 783: case XML_WITH_OUTPUT:
! 784: #ifdef LIBXML_OUTPUT_ENABLED
! 785: return(1);
! 786: #else
! 787: return(0);
! 788: #endif
! 789: case XML_WITH_PUSH:
! 790: #ifdef LIBXML_PUSH_ENABLED
! 791: return(1);
! 792: #else
! 793: return(0);
! 794: #endif
! 795: case XML_WITH_READER:
! 796: #ifdef LIBXML_READER_ENABLED
! 797: return(1);
! 798: #else
! 799: return(0);
! 800: #endif
! 801: case XML_WITH_PATTERN:
! 802: #ifdef LIBXML_PATTERN_ENABLED
! 803: return(1);
! 804: #else
! 805: return(0);
! 806: #endif
! 807: case XML_WITH_WRITER:
! 808: #ifdef LIBXML_WRITER_ENABLED
! 809: return(1);
! 810: #else
! 811: return(0);
! 812: #endif
! 813: case XML_WITH_SAX1:
! 814: #ifdef LIBXML_SAX1_ENABLED
! 815: return(1);
! 816: #else
! 817: return(0);
! 818: #endif
! 819: case XML_WITH_FTP:
! 820: #ifdef LIBXML_FTP_ENABLED
! 821: return(1);
! 822: #else
! 823: return(0);
! 824: #endif
! 825: case XML_WITH_HTTP:
! 826: #ifdef LIBXML_HTTP_ENABLED
! 827: return(1);
! 828: #else
! 829: return(0);
! 830: #endif
! 831: case XML_WITH_VALID:
! 832: #ifdef LIBXML_VALID_ENABLED
! 833: return(1);
! 834: #else
! 835: return(0);
! 836: #endif
! 837: case XML_WITH_HTML:
! 838: #ifdef LIBXML_HTML_ENABLED
! 839: return(1);
! 840: #else
! 841: return(0);
! 842: #endif
! 843: case XML_WITH_LEGACY:
! 844: #ifdef LIBXML_LEGACY_ENABLED
! 845: return(1);
! 846: #else
! 847: return(0);
! 848: #endif
! 849: case XML_WITH_C14N:
! 850: #ifdef LIBXML_C14N_ENABLED
! 851: return(1);
! 852: #else
! 853: return(0);
! 854: #endif
! 855: case XML_WITH_CATALOG:
! 856: #ifdef LIBXML_CATALOG_ENABLED
! 857: return(1);
! 858: #else
! 859: return(0);
! 860: #endif
! 861: case XML_WITH_XPATH:
! 862: #ifdef LIBXML_XPATH_ENABLED
! 863: return(1);
! 864: #else
! 865: return(0);
! 866: #endif
! 867: case XML_WITH_XPTR:
! 868: #ifdef LIBXML_XPTR_ENABLED
! 869: return(1);
! 870: #else
! 871: return(0);
! 872: #endif
! 873: case XML_WITH_XINCLUDE:
! 874: #ifdef LIBXML_XINCLUDE_ENABLED
! 875: return(1);
! 876: #else
! 877: return(0);
! 878: #endif
! 879: case XML_WITH_ICONV:
! 880: #ifdef LIBXML_ICONV_ENABLED
! 881: return(1);
! 882: #else
! 883: return(0);
! 884: #endif
! 885: case XML_WITH_ISO8859X:
! 886: #ifdef LIBXML_ISO8859X_ENABLED
! 887: return(1);
! 888: #else
! 889: return(0);
! 890: #endif
! 891: case XML_WITH_UNICODE:
! 892: #ifdef LIBXML_UNICODE_ENABLED
! 893: return(1);
! 894: #else
! 895: return(0);
! 896: #endif
! 897: case XML_WITH_REGEXP:
! 898: #ifdef LIBXML_REGEXP_ENABLED
! 899: return(1);
! 900: #else
! 901: return(0);
! 902: #endif
! 903: case XML_WITH_AUTOMATA:
! 904: #ifdef LIBXML_AUTOMATA_ENABLED
! 905: return(1);
! 906: #else
! 907: return(0);
! 908: #endif
! 909: case XML_WITH_EXPR:
! 910: #ifdef LIBXML_EXPR_ENABLED
! 911: return(1);
! 912: #else
! 913: return(0);
! 914: #endif
! 915: case XML_WITH_SCHEMAS:
! 916: #ifdef LIBXML_SCHEMAS_ENABLED
! 917: return(1);
! 918: #else
! 919: return(0);
! 920: #endif
! 921: case XML_WITH_SCHEMATRON:
! 922: #ifdef LIBXML_SCHEMATRON_ENABLED
! 923: return(1);
! 924: #else
! 925: return(0);
! 926: #endif
! 927: case XML_WITH_MODULES:
! 928: #ifdef LIBXML_MODULES_ENABLED
! 929: return(1);
! 930: #else
! 931: return(0);
! 932: #endif
! 933: case XML_WITH_DEBUG:
! 934: #ifdef LIBXML_DEBUG_ENABLED
! 935: return(1);
! 936: #else
! 937: return(0);
! 938: #endif
! 939: case XML_WITH_DEBUG_MEM:
! 940: #ifdef DEBUG_MEMORY_LOCATION
! 941: return(1);
! 942: #else
! 943: return(0);
! 944: #endif
! 945: case XML_WITH_DEBUG_RUN:
! 946: #ifdef LIBXML_DEBUG_RUNTIME
! 947: return(1);
! 948: #else
! 949: return(0);
! 950: #endif
! 951: case XML_WITH_ZLIB:
! 952: #ifdef LIBXML_ZLIB_ENABLED
! 953: return(1);
! 954: #else
! 955: return(0);
! 956: #endif
! 957: case XML_WITH_ICU:
! 958: #ifdef LIBXML_ICU_ENABLED
! 959: return(1);
! 960: #else
! 961: return(0);
! 962: #endif
! 963: default:
! 964: break;
! 965: }
! 966: return(0);
! 967: }
! 968:
! 969: /************************************************************************
! 970: * *
! 971: * SAX2 defaulted attributes handling *
! 972: * *
! 973: ************************************************************************/
! 974:
! 975: /**
! 976: * xmlDetectSAX2:
! 977: * @ctxt: an XML parser context
! 978: *
! 979: * Do the SAX2 detection and specific intialization
! 980: */
! 981: static void
! 982: xmlDetectSAX2(xmlParserCtxtPtr ctxt) {
! 983: if (ctxt == NULL) return;
! 984: #ifdef LIBXML_SAX1_ENABLED
! 985: if ((ctxt->sax) && (ctxt->sax->initialized == XML_SAX2_MAGIC) &&
! 986: ((ctxt->sax->startElementNs != NULL) ||
! 987: (ctxt->sax->endElementNs != NULL))) ctxt->sax2 = 1;
! 988: #else
! 989: ctxt->sax2 = 1;
! 990: #endif /* LIBXML_SAX1_ENABLED */
! 991:
! 992: ctxt->str_xml = xmlDictLookup(ctxt->dict, BAD_CAST "xml", 3);
! 993: ctxt->str_xmlns = xmlDictLookup(ctxt->dict, BAD_CAST "xmlns", 5);
! 994: ctxt->str_xml_ns = xmlDictLookup(ctxt->dict, XML_XML_NAMESPACE, 36);
! 995: if ((ctxt->str_xml==NULL) || (ctxt->str_xmlns==NULL) ||
! 996: (ctxt->str_xml_ns == NULL)) {
! 997: xmlErrMemory(ctxt, NULL);
! 998: }
! 999: }
! 1000:
! 1001: typedef struct _xmlDefAttrs xmlDefAttrs;
! 1002: typedef xmlDefAttrs *xmlDefAttrsPtr;
! 1003: struct _xmlDefAttrs {
! 1004: int nbAttrs; /* number of defaulted attributes on that element */
! 1005: int maxAttrs; /* the size of the array */
! 1006: const xmlChar *values[5]; /* array of localname/prefix/values/external */
! 1007: };
! 1008:
! 1009: /**
! 1010: * xmlAttrNormalizeSpace:
! 1011: * @src: the source string
! 1012: * @dst: the target string
! 1013: *
! 1014: * Normalize the space in non CDATA attribute values:
! 1015: * If the attribute type is not CDATA, then the XML processor MUST further
! 1016: * process the normalized attribute value by discarding any leading and
! 1017: * trailing space (#x20) characters, and by replacing sequences of space
! 1018: * (#x20) characters by a single space (#x20) character.
! 1019: * Note that the size of dst need to be at least src, and if one doesn't need
! 1020: * to preserve dst (and it doesn't come from a dictionary or read-only) then
! 1021: * passing src as dst is just fine.
! 1022: *
! 1023: * Returns a pointer to the normalized value (dst) or NULL if no conversion
! 1024: * is needed.
! 1025: */
! 1026: static xmlChar *
! 1027: xmlAttrNormalizeSpace(const xmlChar *src, xmlChar *dst)
! 1028: {
! 1029: if ((src == NULL) || (dst == NULL))
! 1030: return(NULL);
! 1031:
! 1032: while (*src == 0x20) src++;
! 1033: while (*src != 0) {
! 1034: if (*src == 0x20) {
! 1035: while (*src == 0x20) src++;
! 1036: if (*src != 0)
! 1037: *dst++ = 0x20;
! 1038: } else {
! 1039: *dst++ = *src++;
! 1040: }
! 1041: }
! 1042: *dst = 0;
! 1043: if (dst == src)
! 1044: return(NULL);
! 1045: return(dst);
! 1046: }
! 1047:
! 1048: /**
! 1049: * xmlAttrNormalizeSpace2:
! 1050: * @src: the source string
! 1051: *
! 1052: * Normalize the space in non CDATA attribute values, a slightly more complex
! 1053: * front end to avoid allocation problems when running on attribute values
! 1054: * coming from the input.
! 1055: *
! 1056: * Returns a pointer to the normalized value (dst) or NULL if no conversion
! 1057: * is needed.
! 1058: */
! 1059: static const xmlChar *
! 1060: xmlAttrNormalizeSpace2(xmlParserCtxtPtr ctxt, xmlChar *src, int *len)
! 1061: {
! 1062: int i;
! 1063: int remove_head = 0;
! 1064: int need_realloc = 0;
! 1065: const xmlChar *cur;
! 1066:
! 1067: if ((ctxt == NULL) || (src == NULL) || (len == NULL))
! 1068: return(NULL);
! 1069: i = *len;
! 1070: if (i <= 0)
! 1071: return(NULL);
! 1072:
! 1073: cur = src;
! 1074: while (*cur == 0x20) {
! 1075: cur++;
! 1076: remove_head++;
! 1077: }
! 1078: while (*cur != 0) {
! 1079: if (*cur == 0x20) {
! 1080: cur++;
! 1081: if ((*cur == 0x20) || (*cur == 0)) {
! 1082: need_realloc = 1;
! 1083: break;
! 1084: }
! 1085: } else
! 1086: cur++;
! 1087: }
! 1088: if (need_realloc) {
! 1089: xmlChar *ret;
! 1090:
! 1091: ret = xmlStrndup(src + remove_head, i - remove_head + 1);
! 1092: if (ret == NULL) {
! 1093: xmlErrMemory(ctxt, NULL);
! 1094: return(NULL);
! 1095: }
! 1096: xmlAttrNormalizeSpace(ret, ret);
! 1097: *len = (int) strlen((const char *)ret);
! 1098: return(ret);
! 1099: } else if (remove_head) {
! 1100: *len -= remove_head;
! 1101: memmove(src, src + remove_head, 1 + *len);
! 1102: return(src);
! 1103: }
! 1104: return(NULL);
! 1105: }
! 1106:
! 1107: /**
! 1108: * xmlAddDefAttrs:
! 1109: * @ctxt: an XML parser context
! 1110: * @fullname: the element fullname
! 1111: * @fullattr: the attribute fullname
! 1112: * @value: the attribute value
! 1113: *
! 1114: * Add a defaulted attribute for an element
! 1115: */
! 1116: static void
! 1117: xmlAddDefAttrs(xmlParserCtxtPtr ctxt,
! 1118: const xmlChar *fullname,
! 1119: const xmlChar *fullattr,
! 1120: const xmlChar *value) {
! 1121: xmlDefAttrsPtr defaults;
! 1122: int len;
! 1123: const xmlChar *name;
! 1124: const xmlChar *prefix;
! 1125:
! 1126: /*
! 1127: * Allows to detect attribute redefinitions
! 1128: */
! 1129: if (ctxt->attsSpecial != NULL) {
! 1130: if (xmlHashLookup2(ctxt->attsSpecial, fullname, fullattr) != NULL)
! 1131: return;
! 1132: }
! 1133:
! 1134: if (ctxt->attsDefault == NULL) {
! 1135: ctxt->attsDefault = xmlHashCreateDict(10, ctxt->dict);
! 1136: if (ctxt->attsDefault == NULL)
! 1137: goto mem_error;
! 1138: }
! 1139:
! 1140: /*
! 1141: * split the element name into prefix:localname , the string found
! 1142: * are within the DTD and then not associated to namespace names.
! 1143: */
! 1144: name = xmlSplitQName3(fullname, &len);
! 1145: if (name == NULL) {
! 1146: name = xmlDictLookup(ctxt->dict, fullname, -1);
! 1147: prefix = NULL;
! 1148: } else {
! 1149: name = xmlDictLookup(ctxt->dict, name, -1);
! 1150: prefix = xmlDictLookup(ctxt->dict, fullname, len);
! 1151: }
! 1152:
! 1153: /*
! 1154: * make sure there is some storage
! 1155: */
! 1156: defaults = xmlHashLookup2(ctxt->attsDefault, name, prefix);
! 1157: if (defaults == NULL) {
! 1158: defaults = (xmlDefAttrsPtr) xmlMalloc(sizeof(xmlDefAttrs) +
! 1159: (4 * 5) * sizeof(const xmlChar *));
! 1160: if (defaults == NULL)
! 1161: goto mem_error;
! 1162: defaults->nbAttrs = 0;
! 1163: defaults->maxAttrs = 4;
! 1164: if (xmlHashUpdateEntry2(ctxt->attsDefault, name, prefix,
! 1165: defaults, NULL) < 0) {
! 1166: xmlFree(defaults);
! 1167: goto mem_error;
! 1168: }
! 1169: } else if (defaults->nbAttrs >= defaults->maxAttrs) {
! 1170: xmlDefAttrsPtr temp;
! 1171:
! 1172: temp = (xmlDefAttrsPtr) xmlRealloc(defaults, sizeof(xmlDefAttrs) +
! 1173: (2 * defaults->maxAttrs * 5) * sizeof(const xmlChar *));
! 1174: if (temp == NULL)
! 1175: goto mem_error;
! 1176: defaults = temp;
! 1177: defaults->maxAttrs *= 2;
! 1178: if (xmlHashUpdateEntry2(ctxt->attsDefault, name, prefix,
! 1179: defaults, NULL) < 0) {
! 1180: xmlFree(defaults);
! 1181: goto mem_error;
! 1182: }
! 1183: }
! 1184:
! 1185: /*
! 1186: * Split the element name into prefix:localname , the string found
! 1187: * are within the DTD and hen not associated to namespace names.
! 1188: */
! 1189: name = xmlSplitQName3(fullattr, &len);
! 1190: if (name == NULL) {
! 1191: name = xmlDictLookup(ctxt->dict, fullattr, -1);
! 1192: prefix = NULL;
! 1193: } else {
! 1194: name = xmlDictLookup(ctxt->dict, name, -1);
! 1195: prefix = xmlDictLookup(ctxt->dict, fullattr, len);
! 1196: }
! 1197:
! 1198: defaults->values[5 * defaults->nbAttrs] = name;
! 1199: defaults->values[5 * defaults->nbAttrs + 1] = prefix;
! 1200: /* intern the string and precompute the end */
! 1201: len = xmlStrlen(value);
! 1202: value = xmlDictLookup(ctxt->dict, value, len);
! 1203: defaults->values[5 * defaults->nbAttrs + 2] = value;
! 1204: defaults->values[5 * defaults->nbAttrs + 3] = value + len;
! 1205: if (ctxt->external)
! 1206: defaults->values[5 * defaults->nbAttrs + 4] = BAD_CAST "external";
! 1207: else
! 1208: defaults->values[5 * defaults->nbAttrs + 4] = NULL;
! 1209: defaults->nbAttrs++;
! 1210:
! 1211: return;
! 1212:
! 1213: mem_error:
! 1214: xmlErrMemory(ctxt, NULL);
! 1215: return;
! 1216: }
! 1217:
! 1218: /**
! 1219: * xmlAddSpecialAttr:
! 1220: * @ctxt: an XML parser context
! 1221: * @fullname: the element fullname
! 1222: * @fullattr: the attribute fullname
! 1223: * @type: the attribute type
! 1224: *
! 1225: * Register this attribute type
! 1226: */
! 1227: static void
! 1228: xmlAddSpecialAttr(xmlParserCtxtPtr ctxt,
! 1229: const xmlChar *fullname,
! 1230: const xmlChar *fullattr,
! 1231: int type)
! 1232: {
! 1233: if (ctxt->attsSpecial == NULL) {
! 1234: ctxt->attsSpecial = xmlHashCreateDict(10, ctxt->dict);
! 1235: if (ctxt->attsSpecial == NULL)
! 1236: goto mem_error;
! 1237: }
! 1238:
! 1239: if (xmlHashLookup2(ctxt->attsSpecial, fullname, fullattr) != NULL)
! 1240: return;
! 1241:
! 1242: xmlHashAddEntry2(ctxt->attsSpecial, fullname, fullattr,
! 1243: (void *) (long) type);
! 1244: return;
! 1245:
! 1246: mem_error:
! 1247: xmlErrMemory(ctxt, NULL);
! 1248: return;
! 1249: }
! 1250:
! 1251: /**
! 1252: * xmlCleanSpecialAttrCallback:
! 1253: *
! 1254: * Removes CDATA attributes from the special attribute table
! 1255: */
! 1256: static void
! 1257: xmlCleanSpecialAttrCallback(void *payload, void *data,
! 1258: const xmlChar *fullname, const xmlChar *fullattr,
! 1259: const xmlChar *unused ATTRIBUTE_UNUSED) {
! 1260: xmlParserCtxtPtr ctxt = (xmlParserCtxtPtr) data;
! 1261:
! 1262: if (((long) payload) == XML_ATTRIBUTE_CDATA) {
! 1263: xmlHashRemoveEntry2(ctxt->attsSpecial, fullname, fullattr, NULL);
! 1264: }
! 1265: }
! 1266:
! 1267: /**
! 1268: * xmlCleanSpecialAttr:
! 1269: * @ctxt: an XML parser context
! 1270: *
! 1271: * Trim the list of attributes defined to remove all those of type
! 1272: * CDATA as they are not special. This call should be done when finishing
! 1273: * to parse the DTD and before starting to parse the document root.
! 1274: */
! 1275: static void
! 1276: xmlCleanSpecialAttr(xmlParserCtxtPtr ctxt)
! 1277: {
! 1278: if (ctxt->attsSpecial == NULL)
! 1279: return;
! 1280:
! 1281: xmlHashScanFull(ctxt->attsSpecial, xmlCleanSpecialAttrCallback, ctxt);
! 1282:
! 1283: if (xmlHashSize(ctxt->attsSpecial) == 0) {
! 1284: xmlHashFree(ctxt->attsSpecial, NULL);
! 1285: ctxt->attsSpecial = NULL;
! 1286: }
! 1287: return;
! 1288: }
! 1289:
! 1290: /**
! 1291: * xmlCheckLanguageID:
! 1292: * @lang: pointer to the string value
! 1293: *
! 1294: * Checks that the value conforms to the LanguageID production:
! 1295: *
! 1296: * NOTE: this is somewhat deprecated, those productions were removed from
! 1297: * the XML Second edition.
! 1298: *
! 1299: * [33] LanguageID ::= Langcode ('-' Subcode)*
! 1300: * [34] Langcode ::= ISO639Code | IanaCode | UserCode
! 1301: * [35] ISO639Code ::= ([a-z] | [A-Z]) ([a-z] | [A-Z])
! 1302: * [36] IanaCode ::= ('i' | 'I') '-' ([a-z] | [A-Z])+
! 1303: * [37] UserCode ::= ('x' | 'X') '-' ([a-z] | [A-Z])+
! 1304: * [38] Subcode ::= ([a-z] | [A-Z])+
! 1305: *
! 1306: * The current REC reference the sucessors of RFC 1766, currently 5646
! 1307: *
! 1308: * http://www.rfc-editor.org/rfc/rfc5646.txt
! 1309: * langtag = language
! 1310: * ["-" script]
! 1311: * ["-" region]
! 1312: * *("-" variant)
! 1313: * *("-" extension)
! 1314: * ["-" privateuse]
! 1315: * language = 2*3ALPHA ; shortest ISO 639 code
! 1316: * ["-" extlang] ; sometimes followed by
! 1317: * ; extended language subtags
! 1318: * / 4ALPHA ; or reserved for future use
! 1319: * / 5*8ALPHA ; or registered language subtag
! 1320: *
! 1321: * extlang = 3ALPHA ; selected ISO 639 codes
! 1322: * *2("-" 3ALPHA) ; permanently reserved
! 1323: *
! 1324: * script = 4ALPHA ; ISO 15924 code
! 1325: *
! 1326: * region = 2ALPHA ; ISO 3166-1 code
! 1327: * / 3DIGIT ; UN M.49 code
! 1328: *
! 1329: * variant = 5*8alphanum ; registered variants
! 1330: * / (DIGIT 3alphanum)
! 1331: *
! 1332: * extension = singleton 1*("-" (2*8alphanum))
! 1333: *
! 1334: * ; Single alphanumerics
! 1335: * ; "x" reserved for private use
! 1336: * singleton = DIGIT ; 0 - 9
! 1337: * / %x41-57 ; A - W
! 1338: * / %x59-5A ; Y - Z
! 1339: * / %x61-77 ; a - w
! 1340: * / %x79-7A ; y - z
! 1341: *
! 1342: * it sounds right to still allow Irregular i-xxx IANA and user codes too
! 1343: * The parser below doesn't try to cope with extension or privateuse
! 1344: * that could be added but that's not interoperable anyway
! 1345: *
! 1346: * Returns 1 if correct 0 otherwise
! 1347: **/
! 1348: int
! 1349: xmlCheckLanguageID(const xmlChar * lang)
! 1350: {
! 1351: const xmlChar *cur = lang, *nxt;
! 1352:
! 1353: if (cur == NULL)
! 1354: return (0);
! 1355: if (((cur[0] == 'i') && (cur[1] == '-')) ||
! 1356: ((cur[0] == 'I') && (cur[1] == '-')) ||
! 1357: ((cur[0] == 'x') && (cur[1] == '-')) ||
! 1358: ((cur[0] == 'X') && (cur[1] == '-'))) {
! 1359: /*
! 1360: * Still allow IANA code and user code which were coming
! 1361: * from the previous version of the XML-1.0 specification
! 1362: * it's deprecated but we should not fail
! 1363: */
! 1364: cur += 2;
! 1365: while (((cur[0] >= 'A') && (cur[0] <= 'Z')) ||
! 1366: ((cur[0] >= 'a') && (cur[0] <= 'z')))
! 1367: cur++;
! 1368: return(cur[0] == 0);
! 1369: }
! 1370: nxt = cur;
! 1371: while (((nxt[0] >= 'A') && (nxt[0] <= 'Z')) ||
! 1372: ((nxt[0] >= 'a') && (nxt[0] <= 'z')))
! 1373: nxt++;
! 1374: if (nxt - cur >= 4) {
! 1375: /*
! 1376: * Reserved
! 1377: */
! 1378: if ((nxt - cur > 8) || (nxt[0] != 0))
! 1379: return(0);
! 1380: return(1);
! 1381: }
! 1382: if (nxt - cur < 2)
! 1383: return(0);
! 1384: /* we got an ISO 639 code */
! 1385: if (nxt[0] == 0)
! 1386: return(1);
! 1387: if (nxt[0] != '-')
! 1388: return(0);
! 1389:
! 1390: nxt++;
! 1391: cur = nxt;
! 1392: /* now we can have extlang or script or region or variant */
! 1393: if ((nxt[0] >= '0') && (nxt[0] <= '9'))
! 1394: goto region_m49;
! 1395:
! 1396: while (((nxt[0] >= 'A') && (nxt[0] <= 'Z')) ||
! 1397: ((nxt[0] >= 'a') && (nxt[0] <= 'z')))
! 1398: nxt++;
! 1399: if (nxt - cur == 4)
! 1400: goto script;
! 1401: if (nxt - cur == 2)
! 1402: goto region;
! 1403: if ((nxt - cur >= 5) && (nxt - cur <= 8))
! 1404: goto variant;
! 1405: if (nxt - cur != 3)
! 1406: return(0);
! 1407: /* we parsed an extlang */
! 1408: if (nxt[0] == 0)
! 1409: return(1);
! 1410: if (nxt[0] != '-')
! 1411: return(0);
! 1412:
! 1413: nxt++;
! 1414: cur = nxt;
! 1415: /* now we can have script or region or variant */
! 1416: if ((nxt[0] >= '0') && (nxt[0] <= '9'))
! 1417: goto region_m49;
! 1418:
! 1419: while (((nxt[0] >= 'A') && (nxt[0] <= 'Z')) ||
! 1420: ((nxt[0] >= 'a') && (nxt[0] <= 'z')))
! 1421: nxt++;
! 1422: if (nxt - cur == 2)
! 1423: goto region;
! 1424: if ((nxt - cur >= 5) && (nxt - cur <= 8))
! 1425: goto variant;
! 1426: if (nxt - cur != 4)
! 1427: return(0);
! 1428: /* we parsed a script */
! 1429: script:
! 1430: if (nxt[0] == 0)
! 1431: return(1);
! 1432: if (nxt[0] != '-')
! 1433: return(0);
! 1434:
! 1435: nxt++;
! 1436: cur = nxt;
! 1437: /* now we can have region or variant */
! 1438: if ((nxt[0] >= '0') && (nxt[0] <= '9'))
! 1439: goto region_m49;
! 1440:
! 1441: while (((nxt[0] >= 'A') && (nxt[0] <= 'Z')) ||
! 1442: ((nxt[0] >= 'a') && (nxt[0] <= 'z')))
! 1443: nxt++;
! 1444:
! 1445: if ((nxt - cur >= 5) && (nxt - cur <= 8))
! 1446: goto variant;
! 1447: if (nxt - cur != 2)
! 1448: return(0);
! 1449: /* we parsed a region */
! 1450: region:
! 1451: if (nxt[0] == 0)
! 1452: return(1);
! 1453: if (nxt[0] != '-')
! 1454: return(0);
! 1455:
! 1456: nxt++;
! 1457: cur = nxt;
! 1458: /* now we can just have a variant */
! 1459: while (((nxt[0] >= 'A') && (nxt[0] <= 'Z')) ||
! 1460: ((nxt[0] >= 'a') && (nxt[0] <= 'z')))
! 1461: nxt++;
! 1462:
! 1463: if ((nxt - cur < 5) || (nxt - cur > 8))
! 1464: return(0);
! 1465:
! 1466: /* we parsed a variant */
! 1467: variant:
! 1468: if (nxt[0] == 0)
! 1469: return(1);
! 1470: if (nxt[0] != '-')
! 1471: return(0);
! 1472: /* extensions and private use subtags not checked */
! 1473: return (1);
! 1474:
! 1475: region_m49:
! 1476: if (((nxt[1] >= '0') && (nxt[1] <= '9')) &&
! 1477: ((nxt[2] >= '0') && (nxt[2] <= '9'))) {
! 1478: nxt += 3;
! 1479: goto region;
! 1480: }
! 1481: return(0);
! 1482: }
! 1483:
! 1484: /************************************************************************
! 1485: * *
! 1486: * Parser stacks related functions and macros *
! 1487: * *
! 1488: ************************************************************************/
! 1489:
! 1490: static xmlEntityPtr xmlParseStringEntityRef(xmlParserCtxtPtr ctxt,
! 1491: const xmlChar ** str);
! 1492:
! 1493: #ifdef SAX2
! 1494: /**
! 1495: * nsPush:
! 1496: * @ctxt: an XML parser context
! 1497: * @prefix: the namespace prefix or NULL
! 1498: * @URL: the namespace name
! 1499: *
! 1500: * Pushes a new parser namespace on top of the ns stack
! 1501: *
! 1502: * Returns -1 in case of error, -2 if the namespace should be discarded
! 1503: * and the index in the stack otherwise.
! 1504: */
! 1505: static int
! 1506: nsPush(xmlParserCtxtPtr ctxt, const xmlChar *prefix, const xmlChar *URL)
! 1507: {
! 1508: if (ctxt->options & XML_PARSE_NSCLEAN) {
! 1509: int i;
! 1510: for (i = 0;i < ctxt->nsNr;i += 2) {
! 1511: if (ctxt->nsTab[i] == prefix) {
! 1512: /* in scope */
! 1513: if (ctxt->nsTab[i + 1] == URL)
! 1514: return(-2);
! 1515: /* out of scope keep it */
! 1516: break;
! 1517: }
! 1518: }
! 1519: }
! 1520: if ((ctxt->nsMax == 0) || (ctxt->nsTab == NULL)) {
! 1521: ctxt->nsMax = 10;
! 1522: ctxt->nsNr = 0;
! 1523: ctxt->nsTab = (const xmlChar **)
! 1524: xmlMalloc(ctxt->nsMax * sizeof(xmlChar *));
! 1525: if (ctxt->nsTab == NULL) {
! 1526: xmlErrMemory(ctxt, NULL);
! 1527: ctxt->nsMax = 0;
! 1528: return (-1);
! 1529: }
! 1530: } else if (ctxt->nsNr >= ctxt->nsMax) {
! 1531: const xmlChar ** tmp;
! 1532: ctxt->nsMax *= 2;
! 1533: tmp = (const xmlChar **) xmlRealloc((char *) ctxt->nsTab,
! 1534: ctxt->nsMax * sizeof(ctxt->nsTab[0]));
! 1535: if (tmp == NULL) {
! 1536: xmlErrMemory(ctxt, NULL);
! 1537: ctxt->nsMax /= 2;
! 1538: return (-1);
! 1539: }
! 1540: ctxt->nsTab = tmp;
! 1541: }
! 1542: ctxt->nsTab[ctxt->nsNr++] = prefix;
! 1543: ctxt->nsTab[ctxt->nsNr++] = URL;
! 1544: return (ctxt->nsNr);
! 1545: }
! 1546: /**
! 1547: * nsPop:
! 1548: * @ctxt: an XML parser context
! 1549: * @nr: the number to pop
! 1550: *
! 1551: * Pops the top @nr parser prefix/namespace from the ns stack
! 1552: *
! 1553: * Returns the number of namespaces removed
! 1554: */
! 1555: static int
! 1556: nsPop(xmlParserCtxtPtr ctxt, int nr)
! 1557: {
! 1558: int i;
! 1559:
! 1560: if (ctxt->nsTab == NULL) return(0);
! 1561: if (ctxt->nsNr < nr) {
! 1562: xmlGenericError(xmlGenericErrorContext, "Pbm popping %d NS\n", nr);
! 1563: nr = ctxt->nsNr;
! 1564: }
! 1565: if (ctxt->nsNr <= 0)
! 1566: return (0);
! 1567:
! 1568: for (i = 0;i < nr;i++) {
! 1569: ctxt->nsNr--;
! 1570: ctxt->nsTab[ctxt->nsNr] = NULL;
! 1571: }
! 1572: return(nr);
! 1573: }
! 1574: #endif
! 1575:
! 1576: static int
! 1577: xmlCtxtGrowAttrs(xmlParserCtxtPtr ctxt, int nr) {
! 1578: const xmlChar **atts;
! 1579: int *attallocs;
! 1580: int maxatts;
! 1581:
! 1582: if (ctxt->atts == NULL) {
! 1583: maxatts = 55; /* allow for 10 attrs by default */
! 1584: atts = (const xmlChar **)
! 1585: xmlMalloc(maxatts * sizeof(xmlChar *));
! 1586: if (atts == NULL) goto mem_error;
! 1587: ctxt->atts = atts;
! 1588: attallocs = (int *) xmlMalloc((maxatts / 5) * sizeof(int));
! 1589: if (attallocs == NULL) goto mem_error;
! 1590: ctxt->attallocs = attallocs;
! 1591: ctxt->maxatts = maxatts;
! 1592: } else if (nr + 5 > ctxt->maxatts) {
! 1593: maxatts = (nr + 5) * 2;
! 1594: atts = (const xmlChar **) xmlRealloc((void *) ctxt->atts,
! 1595: maxatts * sizeof(const xmlChar *));
! 1596: if (atts == NULL) goto mem_error;
! 1597: ctxt->atts = atts;
! 1598: attallocs = (int *) xmlRealloc((void *) ctxt->attallocs,
! 1599: (maxatts / 5) * sizeof(int));
! 1600: if (attallocs == NULL) goto mem_error;
! 1601: ctxt->attallocs = attallocs;
! 1602: ctxt->maxatts = maxatts;
! 1603: }
! 1604: return(ctxt->maxatts);
! 1605: mem_error:
! 1606: xmlErrMemory(ctxt, NULL);
! 1607: return(-1);
! 1608: }
! 1609:
! 1610: /**
! 1611: * inputPush:
! 1612: * @ctxt: an XML parser context
! 1613: * @value: the parser input
! 1614: *
! 1615: * Pushes a new parser input on top of the input stack
! 1616: *
! 1617: * Returns -1 in case of error, the index in the stack otherwise
! 1618: */
! 1619: int
! 1620: inputPush(xmlParserCtxtPtr ctxt, xmlParserInputPtr value)
! 1621: {
! 1622: if ((ctxt == NULL) || (value == NULL))
! 1623: return(-1);
! 1624: if (ctxt->inputNr >= ctxt->inputMax) {
! 1625: ctxt->inputMax *= 2;
! 1626: ctxt->inputTab =
! 1627: (xmlParserInputPtr *) xmlRealloc(ctxt->inputTab,
! 1628: ctxt->inputMax *
! 1629: sizeof(ctxt->inputTab[0]));
! 1630: if (ctxt->inputTab == NULL) {
! 1631: xmlErrMemory(ctxt, NULL);
! 1632: xmlFreeInputStream(value);
! 1633: ctxt->inputMax /= 2;
! 1634: value = NULL;
! 1635: return (-1);
! 1636: }
! 1637: }
! 1638: ctxt->inputTab[ctxt->inputNr] = value;
! 1639: ctxt->input = value;
! 1640: return (ctxt->inputNr++);
! 1641: }
! 1642: /**
! 1643: * inputPop:
! 1644: * @ctxt: an XML parser context
! 1645: *
! 1646: * Pops the top parser input from the input stack
! 1647: *
! 1648: * Returns the input just removed
! 1649: */
! 1650: xmlParserInputPtr
! 1651: inputPop(xmlParserCtxtPtr ctxt)
! 1652: {
! 1653: xmlParserInputPtr ret;
! 1654:
! 1655: if (ctxt == NULL)
! 1656: return(NULL);
! 1657: if (ctxt->inputNr <= 0)
! 1658: return (NULL);
! 1659: ctxt->inputNr--;
! 1660: if (ctxt->inputNr > 0)
! 1661: ctxt->input = ctxt->inputTab[ctxt->inputNr - 1];
! 1662: else
! 1663: ctxt->input = NULL;
! 1664: ret = ctxt->inputTab[ctxt->inputNr];
! 1665: ctxt->inputTab[ctxt->inputNr] = NULL;
! 1666: return (ret);
! 1667: }
! 1668: /**
! 1669: * nodePush:
! 1670: * @ctxt: an XML parser context
! 1671: * @value: the element node
! 1672: *
! 1673: * Pushes a new element node on top of the node stack
! 1674: *
! 1675: * Returns -1 in case of error, the index in the stack otherwise
! 1676: */
! 1677: int
! 1678: nodePush(xmlParserCtxtPtr ctxt, xmlNodePtr value)
! 1679: {
! 1680: if (ctxt == NULL) return(0);
! 1681: if (ctxt->nodeNr >= ctxt->nodeMax) {
! 1682: xmlNodePtr *tmp;
! 1683:
! 1684: tmp = (xmlNodePtr *) xmlRealloc(ctxt->nodeTab,
! 1685: ctxt->nodeMax * 2 *
! 1686: sizeof(ctxt->nodeTab[0]));
! 1687: if (tmp == NULL) {
! 1688: xmlErrMemory(ctxt, NULL);
! 1689: return (-1);
! 1690: }
! 1691: ctxt->nodeTab = tmp;
! 1692: ctxt->nodeMax *= 2;
! 1693: }
! 1694: if ((((unsigned int) ctxt->nodeNr) > xmlParserMaxDepth) &&
! 1695: ((ctxt->options & XML_PARSE_HUGE) == 0)) {
! 1696: xmlFatalErrMsgInt(ctxt, XML_ERR_INTERNAL_ERROR,
! 1697: "Excessive depth in document: %d use XML_PARSE_HUGE option\n",
! 1698: xmlParserMaxDepth);
! 1699: ctxt->instate = XML_PARSER_EOF;
! 1700: return(-1);
! 1701: }
! 1702: ctxt->nodeTab[ctxt->nodeNr] = value;
! 1703: ctxt->node = value;
! 1704: return (ctxt->nodeNr++);
! 1705: }
! 1706:
! 1707: /**
! 1708: * nodePop:
! 1709: * @ctxt: an XML parser context
! 1710: *
! 1711: * Pops the top element node from the node stack
! 1712: *
! 1713: * Returns the node just removed
! 1714: */
! 1715: xmlNodePtr
! 1716: nodePop(xmlParserCtxtPtr ctxt)
! 1717: {
! 1718: xmlNodePtr ret;
! 1719:
! 1720: if (ctxt == NULL) return(NULL);
! 1721: if (ctxt->nodeNr <= 0)
! 1722: return (NULL);
! 1723: ctxt->nodeNr--;
! 1724: if (ctxt->nodeNr > 0)
! 1725: ctxt->node = ctxt->nodeTab[ctxt->nodeNr - 1];
! 1726: else
! 1727: ctxt->node = NULL;
! 1728: ret = ctxt->nodeTab[ctxt->nodeNr];
! 1729: ctxt->nodeTab[ctxt->nodeNr] = NULL;
! 1730: return (ret);
! 1731: }
! 1732:
! 1733: #ifdef LIBXML_PUSH_ENABLED
! 1734: /**
! 1735: * nameNsPush:
! 1736: * @ctxt: an XML parser context
! 1737: * @value: the element name
! 1738: * @prefix: the element prefix
! 1739: * @URI: the element namespace name
! 1740: *
! 1741: * Pushes a new element name/prefix/URL on top of the name stack
! 1742: *
! 1743: * Returns -1 in case of error, the index in the stack otherwise
! 1744: */
! 1745: static int
! 1746: nameNsPush(xmlParserCtxtPtr ctxt, const xmlChar * value,
! 1747: const xmlChar *prefix, const xmlChar *URI, int nsNr)
! 1748: {
! 1749: if (ctxt->nameNr >= ctxt->nameMax) {
! 1750: const xmlChar * *tmp;
! 1751: void **tmp2;
! 1752: ctxt->nameMax *= 2;
! 1753: tmp = (const xmlChar * *) xmlRealloc((xmlChar * *)ctxt->nameTab,
! 1754: ctxt->nameMax *
! 1755: sizeof(ctxt->nameTab[0]));
! 1756: if (tmp == NULL) {
! 1757: ctxt->nameMax /= 2;
! 1758: goto mem_error;
! 1759: }
! 1760: ctxt->nameTab = tmp;
! 1761: tmp2 = (void **) xmlRealloc((void * *)ctxt->pushTab,
! 1762: ctxt->nameMax * 3 *
! 1763: sizeof(ctxt->pushTab[0]));
! 1764: if (tmp2 == NULL) {
! 1765: ctxt->nameMax /= 2;
! 1766: goto mem_error;
! 1767: }
! 1768: ctxt->pushTab = tmp2;
! 1769: }
! 1770: ctxt->nameTab[ctxt->nameNr] = value;
! 1771: ctxt->name = value;
! 1772: ctxt->pushTab[ctxt->nameNr * 3] = (void *) prefix;
! 1773: ctxt->pushTab[ctxt->nameNr * 3 + 1] = (void *) URI;
! 1774: ctxt->pushTab[ctxt->nameNr * 3 + 2] = (void *) (long) nsNr;
! 1775: return (ctxt->nameNr++);
! 1776: mem_error:
! 1777: xmlErrMemory(ctxt, NULL);
! 1778: return (-1);
! 1779: }
! 1780: /**
! 1781: * nameNsPop:
! 1782: * @ctxt: an XML parser context
! 1783: *
! 1784: * Pops the top element/prefix/URI name from the name stack
! 1785: *
! 1786: * Returns the name just removed
! 1787: */
! 1788: static const xmlChar *
! 1789: nameNsPop(xmlParserCtxtPtr ctxt)
! 1790: {
! 1791: const xmlChar *ret;
! 1792:
! 1793: if (ctxt->nameNr <= 0)
! 1794: return (NULL);
! 1795: ctxt->nameNr--;
! 1796: if (ctxt->nameNr > 0)
! 1797: ctxt->name = ctxt->nameTab[ctxt->nameNr - 1];
! 1798: else
! 1799: ctxt->name = NULL;
! 1800: ret = ctxt->nameTab[ctxt->nameNr];
! 1801: ctxt->nameTab[ctxt->nameNr] = NULL;
! 1802: return (ret);
! 1803: }
! 1804: #endif /* LIBXML_PUSH_ENABLED */
! 1805:
! 1806: /**
! 1807: * namePush:
! 1808: * @ctxt: an XML parser context
! 1809: * @value: the element name
! 1810: *
! 1811: * Pushes a new element name on top of the name stack
! 1812: *
! 1813: * Returns -1 in case of error, the index in the stack otherwise
! 1814: */
! 1815: int
! 1816: namePush(xmlParserCtxtPtr ctxt, const xmlChar * value)
! 1817: {
! 1818: if (ctxt == NULL) return (-1);
! 1819:
! 1820: if (ctxt->nameNr >= ctxt->nameMax) {
! 1821: const xmlChar * *tmp;
! 1822: ctxt->nameMax *= 2;
! 1823: tmp = (const xmlChar * *) xmlRealloc((xmlChar * *)ctxt->nameTab,
! 1824: ctxt->nameMax *
! 1825: sizeof(ctxt->nameTab[0]));
! 1826: if (tmp == NULL) {
! 1827: ctxt->nameMax /= 2;
! 1828: goto mem_error;
! 1829: }
! 1830: ctxt->nameTab = tmp;
! 1831: }
! 1832: ctxt->nameTab[ctxt->nameNr] = value;
! 1833: ctxt->name = value;
! 1834: return (ctxt->nameNr++);
! 1835: mem_error:
! 1836: xmlErrMemory(ctxt, NULL);
! 1837: return (-1);
! 1838: }
! 1839: /**
! 1840: * namePop:
! 1841: * @ctxt: an XML parser context
! 1842: *
! 1843: * Pops the top element name from the name stack
! 1844: *
! 1845: * Returns the name just removed
! 1846: */
! 1847: const xmlChar *
! 1848: namePop(xmlParserCtxtPtr ctxt)
! 1849: {
! 1850: const xmlChar *ret;
! 1851:
! 1852: if ((ctxt == NULL) || (ctxt->nameNr <= 0))
! 1853: return (NULL);
! 1854: ctxt->nameNr--;
! 1855: if (ctxt->nameNr > 0)
! 1856: ctxt->name = ctxt->nameTab[ctxt->nameNr - 1];
! 1857: else
! 1858: ctxt->name = NULL;
! 1859: ret = ctxt->nameTab[ctxt->nameNr];
! 1860: ctxt->nameTab[ctxt->nameNr] = NULL;
! 1861: return (ret);
! 1862: }
! 1863:
! 1864: static int spacePush(xmlParserCtxtPtr ctxt, int val) {
! 1865: if (ctxt->spaceNr >= ctxt->spaceMax) {
! 1866: int *tmp;
! 1867:
! 1868: ctxt->spaceMax *= 2;
! 1869: tmp = (int *) xmlRealloc(ctxt->spaceTab,
! 1870: ctxt->spaceMax * sizeof(ctxt->spaceTab[0]));
! 1871: if (tmp == NULL) {
! 1872: xmlErrMemory(ctxt, NULL);
! 1873: ctxt->spaceMax /=2;
! 1874: return(-1);
! 1875: }
! 1876: ctxt->spaceTab = tmp;
! 1877: }
! 1878: ctxt->spaceTab[ctxt->spaceNr] = val;
! 1879: ctxt->space = &ctxt->spaceTab[ctxt->spaceNr];
! 1880: return(ctxt->spaceNr++);
! 1881: }
! 1882:
! 1883: static int spacePop(xmlParserCtxtPtr ctxt) {
! 1884: int ret;
! 1885: if (ctxt->spaceNr <= 0) return(0);
! 1886: ctxt->spaceNr--;
! 1887: if (ctxt->spaceNr > 0)
! 1888: ctxt->space = &ctxt->spaceTab[ctxt->spaceNr - 1];
! 1889: else
! 1890: ctxt->space = &ctxt->spaceTab[0];
! 1891: ret = ctxt->spaceTab[ctxt->spaceNr];
! 1892: ctxt->spaceTab[ctxt->spaceNr] = -1;
! 1893: return(ret);
! 1894: }
! 1895:
! 1896: /*
! 1897: * Macros for accessing the content. Those should be used only by the parser,
! 1898: * and not exported.
! 1899: *
! 1900: * Dirty macros, i.e. one often need to make assumption on the context to
! 1901: * use them
! 1902: *
! 1903: * CUR_PTR return the current pointer to the xmlChar to be parsed.
! 1904: * To be used with extreme caution since operations consuming
! 1905: * characters may move the input buffer to a different location !
! 1906: * CUR returns the current xmlChar value, i.e. a 8 bit value if compiled
! 1907: * This should be used internally by the parser
! 1908: * only to compare to ASCII values otherwise it would break when
! 1909: * running with UTF-8 encoding.
! 1910: * RAW same as CUR but in the input buffer, bypass any token
! 1911: * extraction that may have been done
! 1912: * NXT(n) returns the n'th next xmlChar. Same as CUR is should be used only
! 1913: * to compare on ASCII based substring.
! 1914: * SKIP(n) Skip n xmlChar, and must also be used only to skip ASCII defined
! 1915: * strings without newlines within the parser.
! 1916: * NEXT1(l) Skip 1 xmlChar, and must also be used only to skip 1 non-newline ASCII
! 1917: * defined char within the parser.
! 1918: * Clean macros, not dependent of an ASCII context, expect UTF-8 encoding
! 1919: *
! 1920: * NEXT Skip to the next character, this does the proper decoding
! 1921: * in UTF-8 mode. It also pop-up unfinished entities on the fly.
! 1922: * NEXTL(l) Skip the current unicode character of l xmlChars long.
! 1923: * CUR_CHAR(l) returns the current unicode character (int), set l
! 1924: * to the number of xmlChars used for the encoding [0-5].
! 1925: * CUR_SCHAR same but operate on a string instead of the context
! 1926: * COPY_BUF copy the current unicode char to the target buffer, increment
! 1927: * the index
! 1928: * GROW, SHRINK handling of input buffers
! 1929: */
! 1930:
! 1931: #define RAW (*ctxt->input->cur)
! 1932: #define CUR (*ctxt->input->cur)
! 1933: #define NXT(val) ctxt->input->cur[(val)]
! 1934: #define CUR_PTR ctxt->input->cur
! 1935:
! 1936: #define CMP4( s, c1, c2, c3, c4 ) \
! 1937: ( ((unsigned char *) s)[ 0 ] == c1 && ((unsigned char *) s)[ 1 ] == c2 && \
! 1938: ((unsigned char *) s)[ 2 ] == c3 && ((unsigned char *) s)[ 3 ] == c4 )
! 1939: #define CMP5( s, c1, c2, c3, c4, c5 ) \
! 1940: ( CMP4( s, c1, c2, c3, c4 ) && ((unsigned char *) s)[ 4 ] == c5 )
! 1941: #define CMP6( s, c1, c2, c3, c4, c5, c6 ) \
! 1942: ( CMP5( s, c1, c2, c3, c4, c5 ) && ((unsigned char *) s)[ 5 ] == c6 )
! 1943: #define CMP7( s, c1, c2, c3, c4, c5, c6, c7 ) \
! 1944: ( CMP6( s, c1, c2, c3, c4, c5, c6 ) && ((unsigned char *) s)[ 6 ] == c7 )
! 1945: #define CMP8( s, c1, c2, c3, c4, c5, c6, c7, c8 ) \
! 1946: ( CMP7( s, c1, c2, c3, c4, c5, c6, c7 ) && ((unsigned char *) s)[ 7 ] == c8 )
! 1947: #define CMP9( s, c1, c2, c3, c4, c5, c6, c7, c8, c9 ) \
! 1948: ( CMP8( s, c1, c2, c3, c4, c5, c6, c7, c8 ) && \
! 1949: ((unsigned char *) s)[ 8 ] == c9 )
! 1950: #define CMP10( s, c1, c2, c3, c4, c5, c6, c7, c8, c9, c10 ) \
! 1951: ( CMP9( s, c1, c2, c3, c4, c5, c6, c7, c8, c9 ) && \
! 1952: ((unsigned char *) s)[ 9 ] == c10 )
! 1953:
! 1954: #define SKIP(val) do { \
! 1955: ctxt->nbChars += (val),ctxt->input->cur += (val),ctxt->input->col+=(val); \
! 1956: if (*ctxt->input->cur == '%') xmlParserHandlePEReference(ctxt); \
! 1957: if ((*ctxt->input->cur == 0) && \
! 1958: (xmlParserInputGrow(ctxt->input, INPUT_CHUNK) <= 0)) \
! 1959: xmlPopInput(ctxt); \
! 1960: } while (0)
! 1961:
! 1962: #define SKIPL(val) do { \
! 1963: int skipl; \
! 1964: for(skipl=0; skipl<val; skipl++) { \
! 1965: if (*(ctxt->input->cur) == '\n') { \
! 1966: ctxt->input->line++; ctxt->input->col = 1; \
! 1967: } else ctxt->input->col++; \
! 1968: ctxt->nbChars++; \
! 1969: ctxt->input->cur++; \
! 1970: } \
! 1971: if (*ctxt->input->cur == '%') xmlParserHandlePEReference(ctxt); \
! 1972: if ((*ctxt->input->cur == 0) && \
! 1973: (xmlParserInputGrow(ctxt->input, INPUT_CHUNK) <= 0)) \
! 1974: xmlPopInput(ctxt); \
! 1975: } while (0)
! 1976:
! 1977: #define SHRINK if ((ctxt->progressive == 0) && \
! 1978: (ctxt->input->cur - ctxt->input->base > 2 * INPUT_CHUNK) && \
! 1979: (ctxt->input->end - ctxt->input->cur < 2 * INPUT_CHUNK)) \
! 1980: xmlSHRINK (ctxt);
! 1981:
! 1982: static void xmlSHRINK (xmlParserCtxtPtr ctxt) {
! 1983: xmlParserInputShrink(ctxt->input);
! 1984: if ((*ctxt->input->cur == 0) &&
! 1985: (xmlParserInputGrow(ctxt->input, INPUT_CHUNK) <= 0))
! 1986: xmlPopInput(ctxt);
! 1987: }
! 1988:
! 1989: #define GROW if ((ctxt->progressive == 0) && \
! 1990: (ctxt->input->end - ctxt->input->cur < INPUT_CHUNK)) \
! 1991: xmlGROW (ctxt);
! 1992:
! 1993: static void xmlGROW (xmlParserCtxtPtr ctxt) {
! 1994: xmlParserInputGrow(ctxt->input, INPUT_CHUNK);
! 1995: if ((ctxt->input->cur != NULL) && (*ctxt->input->cur == 0) &&
! 1996: (xmlParserInputGrow(ctxt->input, INPUT_CHUNK) <= 0))
! 1997: xmlPopInput(ctxt);
! 1998: }
! 1999:
! 2000: #define SKIP_BLANKS xmlSkipBlankChars(ctxt)
! 2001:
! 2002: #define NEXT xmlNextChar(ctxt)
! 2003:
! 2004: #define NEXT1 { \
! 2005: ctxt->input->col++; \
! 2006: ctxt->input->cur++; \
! 2007: ctxt->nbChars++; \
! 2008: if (*ctxt->input->cur == 0) \
! 2009: xmlParserInputGrow(ctxt->input, INPUT_CHUNK); \
! 2010: }
! 2011:
! 2012: #define NEXTL(l) do { \
! 2013: if (*(ctxt->input->cur) == '\n') { \
! 2014: ctxt->input->line++; ctxt->input->col = 1; \
! 2015: } else ctxt->input->col++; \
! 2016: ctxt->input->cur += l; \
! 2017: if (*ctxt->input->cur == '%') xmlParserHandlePEReference(ctxt); \
! 2018: } while (0)
! 2019:
! 2020: #define CUR_CHAR(l) xmlCurrentChar(ctxt, &l)
! 2021: #define CUR_SCHAR(s, l) xmlStringCurrentChar(ctxt, s, &l)
! 2022:
! 2023: #define COPY_BUF(l,b,i,v) \
! 2024: if (l == 1) b[i++] = (xmlChar) v; \
! 2025: else i += xmlCopyCharMultiByte(&b[i],v)
! 2026:
! 2027: /**
! 2028: * xmlSkipBlankChars:
! 2029: * @ctxt: the XML parser context
! 2030: *
! 2031: * skip all blanks character found at that point in the input streams.
! 2032: * It pops up finished entities in the process if allowable at that point.
! 2033: *
! 2034: * Returns the number of space chars skipped
! 2035: */
! 2036:
! 2037: int
! 2038: xmlSkipBlankChars(xmlParserCtxtPtr ctxt) {
! 2039: int res = 0;
! 2040:
! 2041: /*
! 2042: * It's Okay to use CUR/NEXT here since all the blanks are on
! 2043: * the ASCII range.
! 2044: */
! 2045: if ((ctxt->inputNr == 1) && (ctxt->instate != XML_PARSER_DTD)) {
! 2046: const xmlChar *cur;
! 2047: /*
! 2048: * if we are in the document content, go really fast
! 2049: */
! 2050: cur = ctxt->input->cur;
! 2051: while (IS_BLANK_CH(*cur)) {
! 2052: if (*cur == '\n') {
! 2053: ctxt->input->line++; ctxt->input->col = 1;
! 2054: }
! 2055: cur++;
! 2056: res++;
! 2057: if (*cur == 0) {
! 2058: ctxt->input->cur = cur;
! 2059: xmlParserInputGrow(ctxt->input, INPUT_CHUNK);
! 2060: cur = ctxt->input->cur;
! 2061: }
! 2062: }
! 2063: ctxt->input->cur = cur;
! 2064: } else {
! 2065: int cur;
! 2066: do {
! 2067: cur = CUR;
! 2068: while (IS_BLANK_CH(cur)) { /* CHECKED tstblanks.xml */
! 2069: NEXT;
! 2070: cur = CUR;
! 2071: res++;
! 2072: }
! 2073: while ((cur == 0) && (ctxt->inputNr > 1) &&
! 2074: (ctxt->instate != XML_PARSER_COMMENT)) {
! 2075: xmlPopInput(ctxt);
! 2076: cur = CUR;
! 2077: }
! 2078: /*
! 2079: * Need to handle support of entities branching here
! 2080: */
! 2081: if (*ctxt->input->cur == '%') xmlParserHandlePEReference(ctxt);
! 2082: } while (IS_BLANK(cur)); /* CHECKED tstblanks.xml */
! 2083: }
! 2084: return(res);
! 2085: }
! 2086:
! 2087: /************************************************************************
! 2088: * *
! 2089: * Commodity functions to handle entities *
! 2090: * *
! 2091: ************************************************************************/
! 2092:
! 2093: /**
! 2094: * xmlPopInput:
! 2095: * @ctxt: an XML parser context
! 2096: *
! 2097: * xmlPopInput: the current input pointed by ctxt->input came to an end
! 2098: * pop it and return the next char.
! 2099: *
! 2100: * Returns the current xmlChar in the parser context
! 2101: */
! 2102: xmlChar
! 2103: xmlPopInput(xmlParserCtxtPtr ctxt) {
! 2104: if ((ctxt == NULL) || (ctxt->inputNr <= 1)) return(0);
! 2105: if (xmlParserDebugEntities)
! 2106: xmlGenericError(xmlGenericErrorContext,
! 2107: "Popping input %d\n", ctxt->inputNr);
! 2108: xmlFreeInputStream(inputPop(ctxt));
! 2109: if ((*ctxt->input->cur == 0) &&
! 2110: (xmlParserInputGrow(ctxt->input, INPUT_CHUNK) <= 0))
! 2111: return(xmlPopInput(ctxt));
! 2112: return(CUR);
! 2113: }
! 2114:
! 2115: /**
! 2116: * xmlPushInput:
! 2117: * @ctxt: an XML parser context
! 2118: * @input: an XML parser input fragment (entity, XML fragment ...).
! 2119: *
! 2120: * xmlPushInput: switch to a new input stream which is stacked on top
! 2121: * of the previous one(s).
! 2122: * Returns -1 in case of error or the index in the input stack
! 2123: */
! 2124: int
! 2125: xmlPushInput(xmlParserCtxtPtr ctxt, xmlParserInputPtr input) {
! 2126: int ret;
! 2127: if (input == NULL) return(-1);
! 2128:
! 2129: if (xmlParserDebugEntities) {
! 2130: if ((ctxt->input != NULL) && (ctxt->input->filename))
! 2131: xmlGenericError(xmlGenericErrorContext,
! 2132: "%s(%d): ", ctxt->input->filename,
! 2133: ctxt->input->line);
! 2134: xmlGenericError(xmlGenericErrorContext,
! 2135: "Pushing input %d : %.30s\n", ctxt->inputNr+1, input->cur);
! 2136: }
! 2137: ret = inputPush(ctxt, input);
! 2138: GROW;
! 2139: return(ret);
! 2140: }
! 2141:
! 2142: /**
! 2143: * xmlParseCharRef:
! 2144: * @ctxt: an XML parser context
! 2145: *
! 2146: * parse Reference declarations
! 2147: *
! 2148: * [66] CharRef ::= '&#' [0-9]+ ';' |
! 2149: * '&#x' [0-9a-fA-F]+ ';'
! 2150: *
! 2151: * [ WFC: Legal Character ]
! 2152: * Characters referred to using character references must match the
! 2153: * production for Char.
! 2154: *
! 2155: * Returns the value parsed (as an int), 0 in case of error
! 2156: */
! 2157: int
! 2158: xmlParseCharRef(xmlParserCtxtPtr ctxt) {
! 2159: unsigned int val = 0;
! 2160: int count = 0;
! 2161: unsigned int outofrange = 0;
! 2162:
! 2163: /*
! 2164: * Using RAW/CUR/NEXT is okay since we are working on ASCII range here
! 2165: */
! 2166: if ((RAW == '&') && (NXT(1) == '#') &&
! 2167: (NXT(2) == 'x')) {
! 2168: SKIP(3);
! 2169: GROW;
! 2170: while (RAW != ';') { /* loop blocked by count */
! 2171: if (count++ > 20) {
! 2172: count = 0;
! 2173: GROW;
! 2174: }
! 2175: if ((RAW >= '0') && (RAW <= '9'))
! 2176: val = val * 16 + (CUR - '0');
! 2177: else if ((RAW >= 'a') && (RAW <= 'f') && (count < 20))
! 2178: val = val * 16 + (CUR - 'a') + 10;
! 2179: else if ((RAW >= 'A') && (RAW <= 'F') && (count < 20))
! 2180: val = val * 16 + (CUR - 'A') + 10;
! 2181: else {
! 2182: xmlFatalErr(ctxt, XML_ERR_INVALID_HEX_CHARREF, NULL);
! 2183: val = 0;
! 2184: break;
! 2185: }
! 2186: if (val > 0x10FFFF)
! 2187: outofrange = val;
! 2188:
! 2189: NEXT;
! 2190: count++;
! 2191: }
! 2192: if (RAW == ';') {
! 2193: /* on purpose to avoid reentrancy problems with NEXT and SKIP */
! 2194: ctxt->input->col++;
! 2195: ctxt->nbChars ++;
! 2196: ctxt->input->cur++;
! 2197: }
! 2198: } else if ((RAW == '&') && (NXT(1) == '#')) {
! 2199: SKIP(2);
! 2200: GROW;
! 2201: while (RAW != ';') { /* loop blocked by count */
! 2202: if (count++ > 20) {
! 2203: count = 0;
! 2204: GROW;
! 2205: }
! 2206: if ((RAW >= '0') && (RAW <= '9'))
! 2207: val = val * 10 + (CUR - '0');
! 2208: else {
! 2209: xmlFatalErr(ctxt, XML_ERR_INVALID_DEC_CHARREF, NULL);
! 2210: val = 0;
! 2211: break;
! 2212: }
! 2213: if (val > 0x10FFFF)
! 2214: outofrange = val;
! 2215:
! 2216: NEXT;
! 2217: count++;
! 2218: }
! 2219: if (RAW == ';') {
! 2220: /* on purpose to avoid reentrancy problems with NEXT and SKIP */
! 2221: ctxt->input->col++;
! 2222: ctxt->nbChars ++;
! 2223: ctxt->input->cur++;
! 2224: }
! 2225: } else {
! 2226: xmlFatalErr(ctxt, XML_ERR_INVALID_CHARREF, NULL);
! 2227: }
! 2228:
! 2229: /*
! 2230: * [ WFC: Legal Character ]
! 2231: * Characters referred to using character references must match the
! 2232: * production for Char.
! 2233: */
! 2234: if ((IS_CHAR(val) && (outofrange == 0))) {
! 2235: return(val);
! 2236: } else {
! 2237: xmlFatalErrMsgInt(ctxt, XML_ERR_INVALID_CHAR,
! 2238: "xmlParseCharRef: invalid xmlChar value %d\n",
! 2239: val);
! 2240: }
! 2241: return(0);
! 2242: }
! 2243:
! 2244: /**
! 2245: * xmlParseStringCharRef:
! 2246: * @ctxt: an XML parser context
! 2247: * @str: a pointer to an index in the string
! 2248: *
! 2249: * parse Reference declarations, variant parsing from a string rather
! 2250: * than an an input flow.
! 2251: *
! 2252: * [66] CharRef ::= '&#' [0-9]+ ';' |
! 2253: * '&#x' [0-9a-fA-F]+ ';'
! 2254: *
! 2255: * [ WFC: Legal Character ]
! 2256: * Characters referred to using character references must match the
! 2257: * production for Char.
! 2258: *
! 2259: * Returns the value parsed (as an int), 0 in case of error, str will be
! 2260: * updated to the current value of the index
! 2261: */
! 2262: static int
! 2263: xmlParseStringCharRef(xmlParserCtxtPtr ctxt, const xmlChar **str) {
! 2264: const xmlChar *ptr;
! 2265: xmlChar cur;
! 2266: unsigned int val = 0;
! 2267: unsigned int outofrange = 0;
! 2268:
! 2269: if ((str == NULL) || (*str == NULL)) return(0);
! 2270: ptr = *str;
! 2271: cur = *ptr;
! 2272: if ((cur == '&') && (ptr[1] == '#') && (ptr[2] == 'x')) {
! 2273: ptr += 3;
! 2274: cur = *ptr;
! 2275: while (cur != ';') { /* Non input consuming loop */
! 2276: if ((cur >= '0') && (cur <= '9'))
! 2277: val = val * 16 + (cur - '0');
! 2278: else if ((cur >= 'a') && (cur <= 'f'))
! 2279: val = val * 16 + (cur - 'a') + 10;
! 2280: else if ((cur >= 'A') && (cur <= 'F'))
! 2281: val = val * 16 + (cur - 'A') + 10;
! 2282: else {
! 2283: xmlFatalErr(ctxt, XML_ERR_INVALID_HEX_CHARREF, NULL);
! 2284: val = 0;
! 2285: break;
! 2286: }
! 2287: if (val > 0x10FFFF)
! 2288: outofrange = val;
! 2289:
! 2290: ptr++;
! 2291: cur = *ptr;
! 2292: }
! 2293: if (cur == ';')
! 2294: ptr++;
! 2295: } else if ((cur == '&') && (ptr[1] == '#')){
! 2296: ptr += 2;
! 2297: cur = *ptr;
! 2298: while (cur != ';') { /* Non input consuming loops */
! 2299: if ((cur >= '0') && (cur <= '9'))
! 2300: val = val * 10 + (cur - '0');
! 2301: else {
! 2302: xmlFatalErr(ctxt, XML_ERR_INVALID_DEC_CHARREF, NULL);
! 2303: val = 0;
! 2304: break;
! 2305: }
! 2306: if (val > 0x10FFFF)
! 2307: outofrange = val;
! 2308:
! 2309: ptr++;
! 2310: cur = *ptr;
! 2311: }
! 2312: if (cur == ';')
! 2313: ptr++;
! 2314: } else {
! 2315: xmlFatalErr(ctxt, XML_ERR_INVALID_CHARREF, NULL);
! 2316: return(0);
! 2317: }
! 2318: *str = ptr;
! 2319:
! 2320: /*
! 2321: * [ WFC: Legal Character ]
! 2322: * Characters referred to using character references must match the
! 2323: * production for Char.
! 2324: */
! 2325: if ((IS_CHAR(val) && (outofrange == 0))) {
! 2326: return(val);
! 2327: } else {
! 2328: xmlFatalErrMsgInt(ctxt, XML_ERR_INVALID_CHAR,
! 2329: "xmlParseStringCharRef: invalid xmlChar value %d\n",
! 2330: val);
! 2331: }
! 2332: return(0);
! 2333: }
! 2334:
! 2335: /**
! 2336: * xmlNewBlanksWrapperInputStream:
! 2337: * @ctxt: an XML parser context
! 2338: * @entity: an Entity pointer
! 2339: *
! 2340: * Create a new input stream for wrapping
! 2341: * blanks around a PEReference
! 2342: *
! 2343: * Returns the new input stream or NULL
! 2344: */
! 2345:
! 2346: static void deallocblankswrapper (xmlChar *str) {xmlFree(str);}
! 2347:
! 2348: static xmlParserInputPtr
! 2349: xmlNewBlanksWrapperInputStream(xmlParserCtxtPtr ctxt, xmlEntityPtr entity) {
! 2350: xmlParserInputPtr input;
! 2351: xmlChar *buffer;
! 2352: size_t length;
! 2353: if (entity == NULL) {
! 2354: xmlFatalErr(ctxt, XML_ERR_INTERNAL_ERROR,
! 2355: "xmlNewBlanksWrapperInputStream entity\n");
! 2356: return(NULL);
! 2357: }
! 2358: if (xmlParserDebugEntities)
! 2359: xmlGenericError(xmlGenericErrorContext,
! 2360: "new blanks wrapper for entity: %s\n", entity->name);
! 2361: input = xmlNewInputStream(ctxt);
! 2362: if (input == NULL) {
! 2363: return(NULL);
! 2364: }
! 2365: length = xmlStrlen(entity->name) + 5;
! 2366: buffer = xmlMallocAtomic(length);
! 2367: if (buffer == NULL) {
! 2368: xmlErrMemory(ctxt, NULL);
! 2369: xmlFree(input);
! 2370: return(NULL);
! 2371: }
! 2372: buffer [0] = ' ';
! 2373: buffer [1] = '%';
! 2374: buffer [length-3] = ';';
! 2375: buffer [length-2] = ' ';
! 2376: buffer [length-1] = 0;
! 2377: memcpy(buffer + 2, entity->name, length - 5);
! 2378: input->free = deallocblankswrapper;
! 2379: input->base = buffer;
! 2380: input->cur = buffer;
! 2381: input->length = length;
! 2382: input->end = &buffer[length];
! 2383: return(input);
! 2384: }
! 2385:
! 2386: /**
! 2387: * xmlParserHandlePEReference:
! 2388: * @ctxt: the parser context
! 2389: *
! 2390: * [69] PEReference ::= '%' Name ';'
! 2391: *
! 2392: * [ WFC: No Recursion ]
! 2393: * A parsed entity must not contain a recursive
! 2394: * reference to itself, either directly or indirectly.
! 2395: *
! 2396: * [ WFC: Entity Declared ]
! 2397: * In a document without any DTD, a document with only an internal DTD
! 2398: * subset which contains no parameter entity references, or a document
! 2399: * with "standalone='yes'", ... ... The declaration of a parameter
! 2400: * entity must precede any reference to it...
! 2401: *
! 2402: * [ VC: Entity Declared ]
! 2403: * In a document with an external subset or external parameter entities
! 2404: * with "standalone='no'", ... ... The declaration of a parameter entity
! 2405: * must precede any reference to it...
! 2406: *
! 2407: * [ WFC: In DTD ]
! 2408: * Parameter-entity references may only appear in the DTD.
! 2409: * NOTE: misleading but this is handled.
! 2410: *
! 2411: * A PEReference may have been detected in the current input stream
! 2412: * the handling is done accordingly to
! 2413: * http://www.w3.org/TR/REC-xml#entproc
! 2414: * i.e.
! 2415: * - Included in literal in entity values
! 2416: * - Included as Parameter Entity reference within DTDs
! 2417: */
! 2418: void
! 2419: xmlParserHandlePEReference(xmlParserCtxtPtr ctxt) {
! 2420: const xmlChar *name;
! 2421: xmlEntityPtr entity = NULL;
! 2422: xmlParserInputPtr input;
! 2423:
! 2424: if (RAW != '%') return;
! 2425: switch(ctxt->instate) {
! 2426: case XML_PARSER_CDATA_SECTION:
! 2427: return;
! 2428: case XML_PARSER_COMMENT:
! 2429: return;
! 2430: case XML_PARSER_START_TAG:
! 2431: return;
! 2432: case XML_PARSER_END_TAG:
! 2433: return;
! 2434: case XML_PARSER_EOF:
! 2435: xmlFatalErr(ctxt, XML_ERR_PEREF_AT_EOF, NULL);
! 2436: return;
! 2437: case XML_PARSER_PROLOG:
! 2438: case XML_PARSER_START:
! 2439: case XML_PARSER_MISC:
! 2440: xmlFatalErr(ctxt, XML_ERR_PEREF_IN_PROLOG, NULL);
! 2441: return;
! 2442: case XML_PARSER_ENTITY_DECL:
! 2443: case XML_PARSER_CONTENT:
! 2444: case XML_PARSER_ATTRIBUTE_VALUE:
! 2445: case XML_PARSER_PI:
! 2446: case XML_PARSER_SYSTEM_LITERAL:
! 2447: case XML_PARSER_PUBLIC_LITERAL:
! 2448: /* we just ignore it there */
! 2449: return;
! 2450: case XML_PARSER_EPILOG:
! 2451: xmlFatalErr(ctxt, XML_ERR_PEREF_IN_EPILOG, NULL);
! 2452: return;
! 2453: case XML_PARSER_ENTITY_VALUE:
! 2454: /*
! 2455: * NOTE: in the case of entity values, we don't do the
! 2456: * substitution here since we need the literal
! 2457: * entity value to be able to save the internal
! 2458: * subset of the document.
! 2459: * This will be handled by xmlStringDecodeEntities
! 2460: */
! 2461: return;
! 2462: case XML_PARSER_DTD:
! 2463: /*
! 2464: * [WFC: Well-Formedness Constraint: PEs in Internal Subset]
! 2465: * In the internal DTD subset, parameter-entity references
! 2466: * can occur only where markup declarations can occur, not
! 2467: * within markup declarations.
! 2468: * In that case this is handled in xmlParseMarkupDecl
! 2469: */
! 2470: if ((ctxt->external == 0) && (ctxt->inputNr == 1))
! 2471: return;
! 2472: if (IS_BLANK_CH(NXT(1)) || NXT(1) == 0)
! 2473: return;
! 2474: break;
! 2475: case XML_PARSER_IGNORE:
! 2476: return;
! 2477: }
! 2478:
! 2479: NEXT;
! 2480: name = xmlParseName(ctxt);
! 2481: if (xmlParserDebugEntities)
! 2482: xmlGenericError(xmlGenericErrorContext,
! 2483: "PEReference: %s\n", name);
! 2484: if (name == NULL) {
! 2485: xmlFatalErr(ctxt, XML_ERR_PEREF_NO_NAME, NULL);
! 2486: } else {
! 2487: if (RAW == ';') {
! 2488: NEXT;
! 2489: if ((ctxt->sax != NULL) && (ctxt->sax->getParameterEntity != NULL))
! 2490: entity = ctxt->sax->getParameterEntity(ctxt->userData, name);
! 2491: if (entity == NULL) {
! 2492:
! 2493: /*
! 2494: * [ WFC: Entity Declared ]
! 2495: * In a document without any DTD, a document with only an
! 2496: * internal DTD subset which contains no parameter entity
! 2497: * references, or a document with "standalone='yes'", ...
! 2498: * ... The declaration of a parameter entity must precede
! 2499: * any reference to it...
! 2500: */
! 2501: if ((ctxt->standalone == 1) ||
! 2502: ((ctxt->hasExternalSubset == 0) &&
! 2503: (ctxt->hasPErefs == 0))) {
! 2504: xmlFatalErrMsgStr(ctxt, XML_ERR_UNDECLARED_ENTITY,
! 2505: "PEReference: %%%s; not found\n", name);
! 2506: } else {
! 2507: /*
! 2508: * [ VC: Entity Declared ]
! 2509: * In a document with an external subset or external
! 2510: * parameter entities with "standalone='no'", ...
! 2511: * ... The declaration of a parameter entity must precede
! 2512: * any reference to it...
! 2513: */
! 2514: if ((ctxt->validate) && (ctxt->vctxt.error != NULL)) {
! 2515: xmlValidityError(ctxt, XML_WAR_UNDECLARED_ENTITY,
! 2516: "PEReference: %%%s; not found\n",
! 2517: name, NULL);
! 2518: } else
! 2519: xmlWarningMsg(ctxt, XML_WAR_UNDECLARED_ENTITY,
! 2520: "PEReference: %%%s; not found\n",
! 2521: name, NULL);
! 2522: ctxt->valid = 0;
! 2523: }
! 2524: } else if (ctxt->input->free != deallocblankswrapper) {
! 2525: input = xmlNewBlanksWrapperInputStream(ctxt, entity);
! 2526: if (xmlPushInput(ctxt, input) < 0)
! 2527: return;
! 2528: } else {
! 2529: if ((entity->etype == XML_INTERNAL_PARAMETER_ENTITY) ||
! 2530: (entity->etype == XML_EXTERNAL_PARAMETER_ENTITY)) {
! 2531: xmlChar start[4];
! 2532: xmlCharEncoding enc;
! 2533:
! 2534: /*
! 2535: * handle the extra spaces added before and after
! 2536: * c.f. http://www.w3.org/TR/REC-xml#as-PE
! 2537: * this is done independently.
! 2538: */
! 2539: input = xmlNewEntityInputStream(ctxt, entity);
! 2540: if (xmlPushInput(ctxt, input) < 0)
! 2541: return;
! 2542:
! 2543: /*
! 2544: * Get the 4 first bytes and decode the charset
! 2545: * if enc != XML_CHAR_ENCODING_NONE
! 2546: * plug some encoding conversion routines.
! 2547: * Note that, since we may have some non-UTF8
! 2548: * encoding (like UTF16, bug 135229), the 'length'
! 2549: * is not known, but we can calculate based upon
! 2550: * the amount of data in the buffer.
! 2551: */
! 2552: GROW
! 2553: if ((ctxt->input->end - ctxt->input->cur)>=4) {
! 2554: start[0] = RAW;
! 2555: start[1] = NXT(1);
! 2556: start[2] = NXT(2);
! 2557: start[3] = NXT(3);
! 2558: enc = xmlDetectCharEncoding(start, 4);
! 2559: if (enc != XML_CHAR_ENCODING_NONE) {
! 2560: xmlSwitchEncoding(ctxt, enc);
! 2561: }
! 2562: }
! 2563:
! 2564: if ((entity->etype == XML_EXTERNAL_PARAMETER_ENTITY) &&
! 2565: (CMP5(CUR_PTR, '<', '?', 'x', 'm', 'l' )) &&
! 2566: (IS_BLANK_CH(NXT(5)))) {
! 2567: xmlParseTextDecl(ctxt);
! 2568: }
! 2569: } else {
! 2570: xmlFatalErrMsgStr(ctxt, XML_ERR_ENTITY_IS_PARAMETER,
! 2571: "PEReference: %s is not a parameter entity\n",
! 2572: name);
! 2573: }
! 2574: }
! 2575: } else {
! 2576: xmlFatalErr(ctxt, XML_ERR_PEREF_SEMICOL_MISSING, NULL);
! 2577: }
! 2578: }
! 2579: }
! 2580:
! 2581: /*
! 2582: * Macro used to grow the current buffer.
! 2583: */
! 2584: #define growBuffer(buffer, n) { \
! 2585: xmlChar *tmp; \
! 2586: buffer##_size *= 2; \
! 2587: buffer##_size += n; \
! 2588: tmp = (xmlChar *) \
! 2589: xmlRealloc(buffer, buffer##_size * sizeof(xmlChar)); \
! 2590: if (tmp == NULL) goto mem_error; \
! 2591: buffer = tmp; \
! 2592: }
! 2593:
! 2594: /**
! 2595: * xmlStringLenDecodeEntities:
! 2596: * @ctxt: the parser context
! 2597: * @str: the input string
! 2598: * @len: the string length
! 2599: * @what: combination of XML_SUBSTITUTE_REF and XML_SUBSTITUTE_PEREF
! 2600: * @end: an end marker xmlChar, 0 if none
! 2601: * @end2: an end marker xmlChar, 0 if none
! 2602: * @end3: an end marker xmlChar, 0 if none
! 2603: *
! 2604: * Takes a entity string content and process to do the adequate substitutions.
! 2605: *
! 2606: * [67] Reference ::= EntityRef | CharRef
! 2607: *
! 2608: * [69] PEReference ::= '%' Name ';'
! 2609: *
! 2610: * Returns A newly allocated string with the substitution done. The caller
! 2611: * must deallocate it !
! 2612: */
! 2613: xmlChar *
! 2614: xmlStringLenDecodeEntities(xmlParserCtxtPtr ctxt, const xmlChar *str, int len,
! 2615: int what, xmlChar end, xmlChar end2, xmlChar end3) {
! 2616: xmlChar *buffer = NULL;
! 2617: int buffer_size = 0;
! 2618:
! 2619: xmlChar *current = NULL;
! 2620: xmlChar *rep = NULL;
! 2621: const xmlChar *last;
! 2622: xmlEntityPtr ent;
! 2623: int c,l;
! 2624: int nbchars = 0;
! 2625:
! 2626: if ((ctxt == NULL) || (str == NULL) || (len < 0))
! 2627: return(NULL);
! 2628: last = str + len;
! 2629:
! 2630: if (((ctxt->depth > 40) &&
! 2631: ((ctxt->options & XML_PARSE_HUGE) == 0)) ||
! 2632: (ctxt->depth > 1024)) {
! 2633: xmlFatalErr(ctxt, XML_ERR_ENTITY_LOOP, NULL);
! 2634: return(NULL);
! 2635: }
! 2636:
! 2637: /*
! 2638: * allocate a translation buffer.
! 2639: */
! 2640: buffer_size = XML_PARSER_BIG_BUFFER_SIZE;
! 2641: buffer = (xmlChar *) xmlMallocAtomic(buffer_size * sizeof(xmlChar));
! 2642: if (buffer == NULL) goto mem_error;
! 2643:
! 2644: /*
! 2645: * OK loop until we reach one of the ending char or a size limit.
! 2646: * we are operating on already parsed values.
! 2647: */
! 2648: if (str < last)
! 2649: c = CUR_SCHAR(str, l);
! 2650: else
! 2651: c = 0;
! 2652: while ((c != 0) && (c != end) && /* non input consuming loop */
! 2653: (c != end2) && (c != end3)) {
! 2654:
! 2655: if (c == 0) break;
! 2656: if ((c == '&') && (str[1] == '#')) {
! 2657: int val = xmlParseStringCharRef(ctxt, &str);
! 2658: if (val != 0) {
! 2659: COPY_BUF(0,buffer,nbchars,val);
! 2660: }
! 2661: if (nbchars > buffer_size - XML_PARSER_BUFFER_SIZE) {
! 2662: growBuffer(buffer, XML_PARSER_BUFFER_SIZE);
! 2663: }
! 2664: } else if ((c == '&') && (what & XML_SUBSTITUTE_REF)) {
! 2665: if (xmlParserDebugEntities)
! 2666: xmlGenericError(xmlGenericErrorContext,
! 2667: "String decoding Entity Reference: %.30s\n",
! 2668: str);
! 2669: ent = xmlParseStringEntityRef(ctxt, &str);
! 2670: if ((ctxt->lastError.code == XML_ERR_ENTITY_LOOP) ||
! 2671: (ctxt->lastError.code == XML_ERR_INTERNAL_ERROR))
! 2672: goto int_error;
! 2673: if (ent != NULL)
! 2674: ctxt->nbentities += ent->checked;
! 2675: if ((ent != NULL) &&
! 2676: (ent->etype == XML_INTERNAL_PREDEFINED_ENTITY)) {
! 2677: if (ent->content != NULL) {
! 2678: COPY_BUF(0,buffer,nbchars,ent->content[0]);
! 2679: if (nbchars > buffer_size - XML_PARSER_BUFFER_SIZE) {
! 2680: growBuffer(buffer, XML_PARSER_BUFFER_SIZE);
! 2681: }
! 2682: } else {
! 2683: xmlFatalErrMsg(ctxt, XML_ERR_INTERNAL_ERROR,
! 2684: "predefined entity has no content\n");
! 2685: }
! 2686: } else if ((ent != NULL) && (ent->content != NULL)) {
! 2687: ctxt->depth++;
! 2688: rep = xmlStringDecodeEntities(ctxt, ent->content, what,
! 2689: 0, 0, 0);
! 2690: ctxt->depth--;
! 2691:
! 2692: if (rep != NULL) {
! 2693: current = rep;
! 2694: while (*current != 0) { /* non input consuming loop */
! 2695: buffer[nbchars++] = *current++;
! 2696: if (nbchars >
! 2697: buffer_size - XML_PARSER_BUFFER_SIZE) {
! 2698: if (xmlParserEntityCheck(ctxt, nbchars, ent))
! 2699: goto int_error;
! 2700: growBuffer(buffer, XML_PARSER_BUFFER_SIZE);
! 2701: }
! 2702: }
! 2703: xmlFree(rep);
! 2704: rep = NULL;
! 2705: }
! 2706: } else if (ent != NULL) {
! 2707: int i = xmlStrlen(ent->name);
! 2708: const xmlChar *cur = ent->name;
! 2709:
! 2710: buffer[nbchars++] = '&';
! 2711: if (nbchars > buffer_size - i - XML_PARSER_BUFFER_SIZE) {
! 2712: growBuffer(buffer, XML_PARSER_BUFFER_SIZE);
! 2713: }
! 2714: for (;i > 0;i--)
! 2715: buffer[nbchars++] = *cur++;
! 2716: buffer[nbchars++] = ';';
! 2717: }
! 2718: } else if (c == '%' && (what & XML_SUBSTITUTE_PEREF)) {
! 2719: if (xmlParserDebugEntities)
! 2720: xmlGenericError(xmlGenericErrorContext,
! 2721: "String decoding PE Reference: %.30s\n", str);
! 2722: ent = xmlParseStringPEReference(ctxt, &str);
! 2723: if (ctxt->lastError.code == XML_ERR_ENTITY_LOOP)
! 2724: goto int_error;
! 2725: if (ent != NULL)
! 2726: ctxt->nbentities += ent->checked;
! 2727: if (ent != NULL) {
! 2728: if (ent->content == NULL) {
! 2729: xmlLoadEntityContent(ctxt, ent);
! 2730: }
! 2731: ctxt->depth++;
! 2732: rep = xmlStringDecodeEntities(ctxt, ent->content, what,
! 2733: 0, 0, 0);
! 2734: ctxt->depth--;
! 2735: if (rep != NULL) {
! 2736: current = rep;
! 2737: while (*current != 0) { /* non input consuming loop */
! 2738: buffer[nbchars++] = *current++;
! 2739: if (nbchars >
! 2740: buffer_size - XML_PARSER_BUFFER_SIZE) {
! 2741: if (xmlParserEntityCheck(ctxt, nbchars, ent))
! 2742: goto int_error;
! 2743: growBuffer(buffer, XML_PARSER_BUFFER_SIZE);
! 2744: }
! 2745: }
! 2746: xmlFree(rep);
! 2747: rep = NULL;
! 2748: }
! 2749: }
! 2750: } else {
! 2751: COPY_BUF(l,buffer,nbchars,c);
! 2752: str += l;
! 2753: if (nbchars > buffer_size - XML_PARSER_BUFFER_SIZE) {
! 2754: growBuffer(buffer, XML_PARSER_BUFFER_SIZE);
! 2755: }
! 2756: }
! 2757: if (str < last)
! 2758: c = CUR_SCHAR(str, l);
! 2759: else
! 2760: c = 0;
! 2761: }
! 2762: buffer[nbchars] = 0;
! 2763: return(buffer);
! 2764:
! 2765: mem_error:
! 2766: xmlErrMemory(ctxt, NULL);
! 2767: int_error:
! 2768: if (rep != NULL)
! 2769: xmlFree(rep);
! 2770: if (buffer != NULL)
! 2771: xmlFree(buffer);
! 2772: return(NULL);
! 2773: }
! 2774:
! 2775: /**
! 2776: * xmlStringDecodeEntities:
! 2777: * @ctxt: the parser context
! 2778: * @str: the input string
! 2779: * @what: combination of XML_SUBSTITUTE_REF and XML_SUBSTITUTE_PEREF
! 2780: * @end: an end marker xmlChar, 0 if none
! 2781: * @end2: an end marker xmlChar, 0 if none
! 2782: * @end3: an end marker xmlChar, 0 if none
! 2783: *
! 2784: * Takes a entity string content and process to do the adequate substitutions.
! 2785: *
! 2786: * [67] Reference ::= EntityRef | CharRef
! 2787: *
! 2788: * [69] PEReference ::= '%' Name ';'
! 2789: *
! 2790: * Returns A newly allocated string with the substitution done. The caller
! 2791: * must deallocate it !
! 2792: */
! 2793: xmlChar *
! 2794: xmlStringDecodeEntities(xmlParserCtxtPtr ctxt, const xmlChar *str, int what,
! 2795: xmlChar end, xmlChar end2, xmlChar end3) {
! 2796: if ((ctxt == NULL) || (str == NULL)) return(NULL);
! 2797: return(xmlStringLenDecodeEntities(ctxt, str, xmlStrlen(str), what,
! 2798: end, end2, end3));
! 2799: }
! 2800:
! 2801: /************************************************************************
! 2802: * *
! 2803: * Commodity functions, cleanup needed ? *
! 2804: * *
! 2805: ************************************************************************/
! 2806:
! 2807: /**
! 2808: * areBlanks:
! 2809: * @ctxt: an XML parser context
! 2810: * @str: a xmlChar *
! 2811: * @len: the size of @str
! 2812: * @blank_chars: we know the chars are blanks
! 2813: *
! 2814: * Is this a sequence of blank chars that one can ignore ?
! 2815: *
! 2816: * Returns 1 if ignorable 0 otherwise.
! 2817: */
! 2818:
! 2819: static int areBlanks(xmlParserCtxtPtr ctxt, const xmlChar *str, int len,
! 2820: int blank_chars) {
! 2821: int i, ret;
! 2822: xmlNodePtr lastChild;
! 2823:
! 2824: /*
! 2825: * Don't spend time trying to differentiate them, the same callback is
! 2826: * used !
! 2827: */
! 2828: if (ctxt->sax->ignorableWhitespace == ctxt->sax->characters)
! 2829: return(0);
! 2830:
! 2831: /*
! 2832: * Check for xml:space value.
! 2833: */
! 2834: if ((ctxt->space == NULL) || (*(ctxt->space) == 1) ||
! 2835: (*(ctxt->space) == -2))
! 2836: return(0);
! 2837:
! 2838: /*
! 2839: * Check that the string is made of blanks
! 2840: */
! 2841: if (blank_chars == 0) {
! 2842: for (i = 0;i < len;i++)
! 2843: if (!(IS_BLANK_CH(str[i]))) return(0);
! 2844: }
! 2845:
! 2846: /*
! 2847: * Look if the element is mixed content in the DTD if available
! 2848: */
! 2849: if (ctxt->node == NULL) return(0);
! 2850: if (ctxt->myDoc != NULL) {
! 2851: ret = xmlIsMixedElement(ctxt->myDoc, ctxt->node->name);
! 2852: if (ret == 0) return(1);
! 2853: if (ret == 1) return(0);
! 2854: }
! 2855:
! 2856: /*
! 2857: * Otherwise, heuristic :-\
! 2858: */
! 2859: if ((RAW != '<') && (RAW != 0xD)) return(0);
! 2860: if ((ctxt->node->children == NULL) &&
! 2861: (RAW == '<') && (NXT(1) == '/')) return(0);
! 2862:
! 2863: lastChild = xmlGetLastChild(ctxt->node);
! 2864: if (lastChild == NULL) {
! 2865: if ((ctxt->node->type != XML_ELEMENT_NODE) &&
! 2866: (ctxt->node->content != NULL)) return(0);
! 2867: } else if (xmlNodeIsText(lastChild))
! 2868: return(0);
! 2869: else if ((ctxt->node->children != NULL) &&
! 2870: (xmlNodeIsText(ctxt->node->children)))
! 2871: return(0);
! 2872: return(1);
! 2873: }
! 2874:
! 2875: /************************************************************************
! 2876: * *
! 2877: * Extra stuff for namespace support *
! 2878: * Relates to http://www.w3.org/TR/WD-xml-names *
! 2879: * *
! 2880: ************************************************************************/
! 2881:
! 2882: /**
! 2883: * xmlSplitQName:
! 2884: * @ctxt: an XML parser context
! 2885: * @name: an XML parser context
! 2886: * @prefix: a xmlChar **
! 2887: *
! 2888: * parse an UTF8 encoded XML qualified name string
! 2889: *
! 2890: * [NS 5] QName ::= (Prefix ':')? LocalPart
! 2891: *
! 2892: * [NS 6] Prefix ::= NCName
! 2893: *
! 2894: * [NS 7] LocalPart ::= NCName
! 2895: *
! 2896: * Returns the local part, and prefix is updated
! 2897: * to get the Prefix if any.
! 2898: */
! 2899:
! 2900: xmlChar *
! 2901: xmlSplitQName(xmlParserCtxtPtr ctxt, const xmlChar *name, xmlChar **prefix) {
! 2902: xmlChar buf[XML_MAX_NAMELEN + 5];
! 2903: xmlChar *buffer = NULL;
! 2904: int len = 0;
! 2905: int max = XML_MAX_NAMELEN;
! 2906: xmlChar *ret = NULL;
! 2907: const xmlChar *cur = name;
! 2908: int c;
! 2909:
! 2910: if (prefix == NULL) return(NULL);
! 2911: *prefix = NULL;
! 2912:
! 2913: if (cur == NULL) return(NULL);
! 2914:
! 2915: #ifndef XML_XML_NAMESPACE
! 2916: /* xml: prefix is not really a namespace */
! 2917: if ((cur[0] == 'x') && (cur[1] == 'm') &&
! 2918: (cur[2] == 'l') && (cur[3] == ':'))
! 2919: return(xmlStrdup(name));
! 2920: #endif
! 2921:
! 2922: /* nasty but well=formed */
! 2923: if (cur[0] == ':')
! 2924: return(xmlStrdup(name));
! 2925:
! 2926: c = *cur++;
! 2927: while ((c != 0) && (c != ':') && (len < max)) { /* tested bigname.xml */
! 2928: buf[len++] = c;
! 2929: c = *cur++;
! 2930: }
! 2931: if (len >= max) {
! 2932: /*
! 2933: * Okay someone managed to make a huge name, so he's ready to pay
! 2934: * for the processing speed.
! 2935: */
! 2936: max = len * 2;
! 2937:
! 2938: buffer = (xmlChar *) xmlMallocAtomic(max * sizeof(xmlChar));
! 2939: if (buffer == NULL) {
! 2940: xmlErrMemory(ctxt, NULL);
! 2941: return(NULL);
! 2942: }
! 2943: memcpy(buffer, buf, len);
! 2944: while ((c != 0) && (c != ':')) { /* tested bigname.xml */
! 2945: if (len + 10 > max) {
! 2946: xmlChar *tmp;
! 2947:
! 2948: max *= 2;
! 2949: tmp = (xmlChar *) xmlRealloc(buffer,
! 2950: max * sizeof(xmlChar));
! 2951: if (tmp == NULL) {
! 2952: xmlFree(buffer);
! 2953: xmlErrMemory(ctxt, NULL);
! 2954: return(NULL);
! 2955: }
! 2956: buffer = tmp;
! 2957: }
! 2958: buffer[len++] = c;
! 2959: c = *cur++;
! 2960: }
! 2961: buffer[len] = 0;
! 2962: }
! 2963:
! 2964: if ((c == ':') && (*cur == 0)) {
! 2965: if (buffer != NULL)
! 2966: xmlFree(buffer);
! 2967: *prefix = NULL;
! 2968: return(xmlStrdup(name));
! 2969: }
! 2970:
! 2971: if (buffer == NULL)
! 2972: ret = xmlStrndup(buf, len);
! 2973: else {
! 2974: ret = buffer;
! 2975: buffer = NULL;
! 2976: max = XML_MAX_NAMELEN;
! 2977: }
! 2978:
! 2979:
! 2980: if (c == ':') {
! 2981: c = *cur;
! 2982: *prefix = ret;
! 2983: if (c == 0) {
! 2984: return(xmlStrndup(BAD_CAST "", 0));
! 2985: }
! 2986: len = 0;
! 2987:
! 2988: /*
! 2989: * Check that the first character is proper to start
! 2990: * a new name
! 2991: */
! 2992: if (!(((c >= 0x61) && (c <= 0x7A)) ||
! 2993: ((c >= 0x41) && (c <= 0x5A)) ||
! 2994: (c == '_') || (c == ':'))) {
! 2995: int l;
! 2996: int first = CUR_SCHAR(cur, l);
! 2997:
! 2998: if (!IS_LETTER(first) && (first != '_')) {
! 2999: xmlFatalErrMsgStr(ctxt, XML_NS_ERR_QNAME,
! 3000: "Name %s is not XML Namespace compliant\n",
! 3001: name);
! 3002: }
! 3003: }
! 3004: cur++;
! 3005:
! 3006: while ((c != 0) && (len < max)) { /* tested bigname2.xml */
! 3007: buf[len++] = c;
! 3008: c = *cur++;
! 3009: }
! 3010: if (len >= max) {
! 3011: /*
! 3012: * Okay someone managed to make a huge name, so he's ready to pay
! 3013: * for the processing speed.
! 3014: */
! 3015: max = len * 2;
! 3016:
! 3017: buffer = (xmlChar *) xmlMallocAtomic(max * sizeof(xmlChar));
! 3018: if (buffer == NULL) {
! 3019: xmlErrMemory(ctxt, NULL);
! 3020: return(NULL);
! 3021: }
! 3022: memcpy(buffer, buf, len);
! 3023: while (c != 0) { /* tested bigname2.xml */
! 3024: if (len + 10 > max) {
! 3025: xmlChar *tmp;
! 3026:
! 3027: max *= 2;
! 3028: tmp = (xmlChar *) xmlRealloc(buffer,
! 3029: max * sizeof(xmlChar));
! 3030: if (tmp == NULL) {
! 3031: xmlErrMemory(ctxt, NULL);
! 3032: xmlFree(buffer);
! 3033: return(NULL);
! 3034: }
! 3035: buffer = tmp;
! 3036: }
! 3037: buffer[len++] = c;
! 3038: c = *cur++;
! 3039: }
! 3040: buffer[len] = 0;
! 3041: }
! 3042:
! 3043: if (buffer == NULL)
! 3044: ret = xmlStrndup(buf, len);
! 3045: else {
! 3046: ret = buffer;
! 3047: }
! 3048: }
! 3049:
! 3050: return(ret);
! 3051: }
! 3052:
! 3053: /************************************************************************
! 3054: * *
! 3055: * The parser itself *
! 3056: * Relates to http://www.w3.org/TR/REC-xml *
! 3057: * *
! 3058: ************************************************************************/
! 3059:
! 3060: /************************************************************************
! 3061: * *
! 3062: * Routines to parse Name, NCName and NmToken *
! 3063: * *
! 3064: ************************************************************************/
! 3065: #ifdef DEBUG
! 3066: static unsigned long nbParseName = 0;
! 3067: static unsigned long nbParseNmToken = 0;
! 3068: static unsigned long nbParseNCName = 0;
! 3069: static unsigned long nbParseNCNameComplex = 0;
! 3070: static unsigned long nbParseNameComplex = 0;
! 3071: static unsigned long nbParseStringName = 0;
! 3072: #endif
! 3073:
! 3074: /*
! 3075: * The two following functions are related to the change of accepted
! 3076: * characters for Name and NmToken in the Revision 5 of XML-1.0
! 3077: * They correspond to the modified production [4] and the new production [4a]
! 3078: * changes in that revision. Also note that the macros used for the
! 3079: * productions Letter, Digit, CombiningChar and Extender are not needed
! 3080: * anymore.
! 3081: * We still keep compatibility to pre-revision5 parsing semantic if the
! 3082: * new XML_PARSE_OLD10 option is given to the parser.
! 3083: */
! 3084: static int
! 3085: xmlIsNameStartChar(xmlParserCtxtPtr ctxt, int c) {
! 3086: if ((ctxt->options & XML_PARSE_OLD10) == 0) {
! 3087: /*
! 3088: * Use the new checks of production [4] [4a] amd [5] of the
! 3089: * Update 5 of XML-1.0
! 3090: */
! 3091: if ((c != ' ') && (c != '>') && (c != '/') && /* accelerators */
! 3092: (((c >= 'a') && (c <= 'z')) ||
! 3093: ((c >= 'A') && (c <= 'Z')) ||
! 3094: (c == '_') || (c == ':') ||
! 3095: ((c >= 0xC0) && (c <= 0xD6)) ||
! 3096: ((c >= 0xD8) && (c <= 0xF6)) ||
! 3097: ((c >= 0xF8) && (c <= 0x2FF)) ||
! 3098: ((c >= 0x370) && (c <= 0x37D)) ||
! 3099: ((c >= 0x37F) && (c <= 0x1FFF)) ||
! 3100: ((c >= 0x200C) && (c <= 0x200D)) ||
! 3101: ((c >= 0x2070) && (c <= 0x218F)) ||
! 3102: ((c >= 0x2C00) && (c <= 0x2FEF)) ||
! 3103: ((c >= 0x3001) && (c <= 0xD7FF)) ||
! 3104: ((c >= 0xF900) && (c <= 0xFDCF)) ||
! 3105: ((c >= 0xFDF0) && (c <= 0xFFFD)) ||
! 3106: ((c >= 0x10000) && (c <= 0xEFFFF))))
! 3107: return(1);
! 3108: } else {
! 3109: if (IS_LETTER(c) || (c == '_') || (c == ':'))
! 3110: return(1);
! 3111: }
! 3112: return(0);
! 3113: }
! 3114:
! 3115: static int
! 3116: xmlIsNameChar(xmlParserCtxtPtr ctxt, int c) {
! 3117: if ((ctxt->options & XML_PARSE_OLD10) == 0) {
! 3118: /*
! 3119: * Use the new checks of production [4] [4a] amd [5] of the
! 3120: * Update 5 of XML-1.0
! 3121: */
! 3122: if ((c != ' ') && (c != '>') && (c != '/') && /* accelerators */
! 3123: (((c >= 'a') && (c <= 'z')) ||
! 3124: ((c >= 'A') && (c <= 'Z')) ||
! 3125: ((c >= '0') && (c <= '9')) || /* !start */
! 3126: (c == '_') || (c == ':') ||
! 3127: (c == '-') || (c == '.') || (c == 0xB7) || /* !start */
! 3128: ((c >= 0xC0) && (c <= 0xD6)) ||
! 3129: ((c >= 0xD8) && (c <= 0xF6)) ||
! 3130: ((c >= 0xF8) && (c <= 0x2FF)) ||
! 3131: ((c >= 0x300) && (c <= 0x36F)) || /* !start */
! 3132: ((c >= 0x370) && (c <= 0x37D)) ||
! 3133: ((c >= 0x37F) && (c <= 0x1FFF)) ||
! 3134: ((c >= 0x200C) && (c <= 0x200D)) ||
! 3135: ((c >= 0x203F) && (c <= 0x2040)) || /* !start */
! 3136: ((c >= 0x2070) && (c <= 0x218F)) ||
! 3137: ((c >= 0x2C00) && (c <= 0x2FEF)) ||
! 3138: ((c >= 0x3001) && (c <= 0xD7FF)) ||
! 3139: ((c >= 0xF900) && (c <= 0xFDCF)) ||
! 3140: ((c >= 0xFDF0) && (c <= 0xFFFD)) ||
! 3141: ((c >= 0x10000) && (c <= 0xEFFFF))))
! 3142: return(1);
! 3143: } else {
! 3144: if ((IS_LETTER(c)) || (IS_DIGIT(c)) ||
! 3145: (c == '.') || (c == '-') ||
! 3146: (c == '_') || (c == ':') ||
! 3147: (IS_COMBINING(c)) ||
! 3148: (IS_EXTENDER(c)))
! 3149: return(1);
! 3150: }
! 3151: return(0);
! 3152: }
! 3153:
! 3154: static xmlChar * xmlParseAttValueInternal(xmlParserCtxtPtr ctxt,
! 3155: int *len, int *alloc, int normalize);
! 3156:
! 3157: static const xmlChar *
! 3158: xmlParseNameComplex(xmlParserCtxtPtr ctxt) {
! 3159: int len = 0, l;
! 3160: int c;
! 3161: int count = 0;
! 3162:
! 3163: #ifdef DEBUG
! 3164: nbParseNameComplex++;
! 3165: #endif
! 3166:
! 3167: /*
! 3168: * Handler for more complex cases
! 3169: */
! 3170: GROW;
! 3171: c = CUR_CHAR(l);
! 3172: if ((ctxt->options & XML_PARSE_OLD10) == 0) {
! 3173: /*
! 3174: * Use the new checks of production [4] [4a] amd [5] of the
! 3175: * Update 5 of XML-1.0
! 3176: */
! 3177: if ((c == ' ') || (c == '>') || (c == '/') || /* accelerators */
! 3178: (!(((c >= 'a') && (c <= 'z')) ||
! 3179: ((c >= 'A') && (c <= 'Z')) ||
! 3180: (c == '_') || (c == ':') ||
! 3181: ((c >= 0xC0) && (c <= 0xD6)) ||
! 3182: ((c >= 0xD8) && (c <= 0xF6)) ||
! 3183: ((c >= 0xF8) && (c <= 0x2FF)) ||
! 3184: ((c >= 0x370) && (c <= 0x37D)) ||
! 3185: ((c >= 0x37F) && (c <= 0x1FFF)) ||
! 3186: ((c >= 0x200C) && (c <= 0x200D)) ||
! 3187: ((c >= 0x2070) && (c <= 0x218F)) ||
! 3188: ((c >= 0x2C00) && (c <= 0x2FEF)) ||
! 3189: ((c >= 0x3001) && (c <= 0xD7FF)) ||
! 3190: ((c >= 0xF900) && (c <= 0xFDCF)) ||
! 3191: ((c >= 0xFDF0) && (c <= 0xFFFD)) ||
! 3192: ((c >= 0x10000) && (c <= 0xEFFFF))))) {
! 3193: return(NULL);
! 3194: }
! 3195: len += l;
! 3196: NEXTL(l);
! 3197: c = CUR_CHAR(l);
! 3198: while ((c != ' ') && (c != '>') && (c != '/') && /* accelerators */
! 3199: (((c >= 'a') && (c <= 'z')) ||
! 3200: ((c >= 'A') && (c <= 'Z')) ||
! 3201: ((c >= '0') && (c <= '9')) || /* !start */
! 3202: (c == '_') || (c == ':') ||
! 3203: (c == '-') || (c == '.') || (c == 0xB7) || /* !start */
! 3204: ((c >= 0xC0) && (c <= 0xD6)) ||
! 3205: ((c >= 0xD8) && (c <= 0xF6)) ||
! 3206: ((c >= 0xF8) && (c <= 0x2FF)) ||
! 3207: ((c >= 0x300) && (c <= 0x36F)) || /* !start */
! 3208: ((c >= 0x370) && (c <= 0x37D)) ||
! 3209: ((c >= 0x37F) && (c <= 0x1FFF)) ||
! 3210: ((c >= 0x200C) && (c <= 0x200D)) ||
! 3211: ((c >= 0x203F) && (c <= 0x2040)) || /* !start */
! 3212: ((c >= 0x2070) && (c <= 0x218F)) ||
! 3213: ((c >= 0x2C00) && (c <= 0x2FEF)) ||
! 3214: ((c >= 0x3001) && (c <= 0xD7FF)) ||
! 3215: ((c >= 0xF900) && (c <= 0xFDCF)) ||
! 3216: ((c >= 0xFDF0) && (c <= 0xFFFD)) ||
! 3217: ((c >= 0x10000) && (c <= 0xEFFFF))
! 3218: )) {
! 3219: if (count++ > 100) {
! 3220: count = 0;
! 3221: GROW;
! 3222: }
! 3223: len += l;
! 3224: NEXTL(l);
! 3225: c = CUR_CHAR(l);
! 3226: }
! 3227: } else {
! 3228: if ((c == ' ') || (c == '>') || (c == '/') || /* accelerators */
! 3229: (!IS_LETTER(c) && (c != '_') &&
! 3230: (c != ':'))) {
! 3231: return(NULL);
! 3232: }
! 3233: len += l;
! 3234: NEXTL(l);
! 3235: c = CUR_CHAR(l);
! 3236:
! 3237: while ((c != ' ') && (c != '>') && (c != '/') && /* test bigname.xml */
! 3238: ((IS_LETTER(c)) || (IS_DIGIT(c)) ||
! 3239: (c == '.') || (c == '-') ||
! 3240: (c == '_') || (c == ':') ||
! 3241: (IS_COMBINING(c)) ||
! 3242: (IS_EXTENDER(c)))) {
! 3243: if (count++ > 100) {
! 3244: count = 0;
! 3245: GROW;
! 3246: }
! 3247: len += l;
! 3248: NEXTL(l);
! 3249: c = CUR_CHAR(l);
! 3250: }
! 3251: }
! 3252: if ((*ctxt->input->cur == '\n') && (ctxt->input->cur[-1] == '\r'))
! 3253: return(xmlDictLookup(ctxt->dict, ctxt->input->cur - (len + 1), len));
! 3254: return(xmlDictLookup(ctxt->dict, ctxt->input->cur - len, len));
! 3255: }
! 3256:
! 3257: /**
! 3258: * xmlParseName:
! 3259: * @ctxt: an XML parser context
! 3260: *
! 3261: * parse an XML name.
! 3262: *
! 3263: * [4] NameChar ::= Letter | Digit | '.' | '-' | '_' | ':' |
! 3264: * CombiningChar | Extender
! 3265: *
! 3266: * [5] Name ::= (Letter | '_' | ':') (NameChar)*
! 3267: *
! 3268: * [6] Names ::= Name (#x20 Name)*
! 3269: *
! 3270: * Returns the Name parsed or NULL
! 3271: */
! 3272:
! 3273: const xmlChar *
! 3274: xmlParseName(xmlParserCtxtPtr ctxt) {
! 3275: const xmlChar *in;
! 3276: const xmlChar *ret;
! 3277: int count = 0;
! 3278:
! 3279: GROW;
! 3280:
! 3281: #ifdef DEBUG
! 3282: nbParseName++;
! 3283: #endif
! 3284:
! 3285: /*
! 3286: * Accelerator for simple ASCII names
! 3287: */
! 3288: in = ctxt->input->cur;
! 3289: if (((*in >= 0x61) && (*in <= 0x7A)) ||
! 3290: ((*in >= 0x41) && (*in <= 0x5A)) ||
! 3291: (*in == '_') || (*in == ':')) {
! 3292: in++;
! 3293: while (((*in >= 0x61) && (*in <= 0x7A)) ||
! 3294: ((*in >= 0x41) && (*in <= 0x5A)) ||
! 3295: ((*in >= 0x30) && (*in <= 0x39)) ||
! 3296: (*in == '_') || (*in == '-') ||
! 3297: (*in == ':') || (*in == '.'))
! 3298: in++;
! 3299: if ((*in > 0) && (*in < 0x80)) {
! 3300: count = in - ctxt->input->cur;
! 3301: ret = xmlDictLookup(ctxt->dict, ctxt->input->cur, count);
! 3302: ctxt->input->cur = in;
! 3303: ctxt->nbChars += count;
! 3304: ctxt->input->col += count;
! 3305: if (ret == NULL)
! 3306: xmlErrMemory(ctxt, NULL);
! 3307: return(ret);
! 3308: }
! 3309: }
! 3310: /* accelerator for special cases */
! 3311: return(xmlParseNameComplex(ctxt));
! 3312: }
! 3313:
! 3314: static const xmlChar *
! 3315: xmlParseNCNameComplex(xmlParserCtxtPtr ctxt) {
! 3316: int len = 0, l;
! 3317: int c;
! 3318: int count = 0;
! 3319:
! 3320: #ifdef DEBUG
! 3321: nbParseNCNameComplex++;
! 3322: #endif
! 3323:
! 3324: /*
! 3325: * Handler for more complex cases
! 3326: */
! 3327: GROW;
! 3328: c = CUR_CHAR(l);
! 3329: if ((c == ' ') || (c == '>') || (c == '/') || /* accelerators */
! 3330: (!xmlIsNameStartChar(ctxt, c) || (c == ':'))) {
! 3331: return(NULL);
! 3332: }
! 3333:
! 3334: while ((c != ' ') && (c != '>') && (c != '/') && /* test bigname.xml */
! 3335: (xmlIsNameChar(ctxt, c) && (c != ':'))) {
! 3336: if (count++ > 100) {
! 3337: count = 0;
! 3338: GROW;
! 3339: }
! 3340: len += l;
! 3341: NEXTL(l);
! 3342: c = CUR_CHAR(l);
! 3343: }
! 3344: return(xmlDictLookup(ctxt->dict, ctxt->input->cur - len, len));
! 3345: }
! 3346:
! 3347: /**
! 3348: * xmlParseNCName:
! 3349: * @ctxt: an XML parser context
! 3350: * @len: lenght of the string parsed
! 3351: *
! 3352: * parse an XML name.
! 3353: *
! 3354: * [4NS] NCNameChar ::= Letter | Digit | '.' | '-' | '_' |
! 3355: * CombiningChar | Extender
! 3356: *
! 3357: * [5NS] NCName ::= (Letter | '_') (NCNameChar)*
! 3358: *
! 3359: * Returns the Name parsed or NULL
! 3360: */
! 3361:
! 3362: static const xmlChar *
! 3363: xmlParseNCName(xmlParserCtxtPtr ctxt) {
! 3364: const xmlChar *in;
! 3365: const xmlChar *ret;
! 3366: int count = 0;
! 3367:
! 3368: #ifdef DEBUG
! 3369: nbParseNCName++;
! 3370: #endif
! 3371:
! 3372: /*
! 3373: * Accelerator for simple ASCII names
! 3374: */
! 3375: in = ctxt->input->cur;
! 3376: if (((*in >= 0x61) && (*in <= 0x7A)) ||
! 3377: ((*in >= 0x41) && (*in <= 0x5A)) ||
! 3378: (*in == '_')) {
! 3379: in++;
! 3380: while (((*in >= 0x61) && (*in <= 0x7A)) ||
! 3381: ((*in >= 0x41) && (*in <= 0x5A)) ||
! 3382: ((*in >= 0x30) && (*in <= 0x39)) ||
! 3383: (*in == '_') || (*in == '-') ||
! 3384: (*in == '.'))
! 3385: in++;
! 3386: if ((*in > 0) && (*in < 0x80)) {
! 3387: count = in - ctxt->input->cur;
! 3388: ret = xmlDictLookup(ctxt->dict, ctxt->input->cur, count);
! 3389: ctxt->input->cur = in;
! 3390: ctxt->nbChars += count;
! 3391: ctxt->input->col += count;
! 3392: if (ret == NULL) {
! 3393: xmlErrMemory(ctxt, NULL);
! 3394: }
! 3395: return(ret);
! 3396: }
! 3397: }
! 3398: return(xmlParseNCNameComplex(ctxt));
! 3399: }
! 3400:
! 3401: /**
! 3402: * xmlParseNameAndCompare:
! 3403: * @ctxt: an XML parser context
! 3404: *
! 3405: * parse an XML name and compares for match
! 3406: * (specialized for endtag parsing)
! 3407: *
! 3408: * Returns NULL for an illegal name, (xmlChar*) 1 for success
! 3409: * and the name for mismatch
! 3410: */
! 3411:
! 3412: static const xmlChar *
! 3413: xmlParseNameAndCompare(xmlParserCtxtPtr ctxt, xmlChar const *other) {
! 3414: register const xmlChar *cmp = other;
! 3415: register const xmlChar *in;
! 3416: const xmlChar *ret;
! 3417:
! 3418: GROW;
! 3419:
! 3420: in = ctxt->input->cur;
! 3421: while (*in != 0 && *in == *cmp) {
! 3422: ++in;
! 3423: ++cmp;
! 3424: ctxt->input->col++;
! 3425: }
! 3426: if (*cmp == 0 && (*in == '>' || IS_BLANK_CH (*in))) {
! 3427: /* success */
! 3428: ctxt->input->cur = in;
! 3429: return (const xmlChar*) 1;
! 3430: }
! 3431: /* failure (or end of input buffer), check with full function */
! 3432: ret = xmlParseName (ctxt);
! 3433: /* strings coming from the dictionnary direct compare possible */
! 3434: if (ret == other) {
! 3435: return (const xmlChar*) 1;
! 3436: }
! 3437: return ret;
! 3438: }
! 3439:
! 3440: /**
! 3441: * xmlParseStringName:
! 3442: * @ctxt: an XML parser context
! 3443: * @str: a pointer to the string pointer (IN/OUT)
! 3444: *
! 3445: * parse an XML name.
! 3446: *
! 3447: * [4] NameChar ::= Letter | Digit | '.' | '-' | '_' | ':' |
! 3448: * CombiningChar | Extender
! 3449: *
! 3450: * [5] Name ::= (Letter | '_' | ':') (NameChar)*
! 3451: *
! 3452: * [6] Names ::= Name (#x20 Name)*
! 3453: *
! 3454: * Returns the Name parsed or NULL. The @str pointer
! 3455: * is updated to the current location in the string.
! 3456: */
! 3457:
! 3458: static xmlChar *
! 3459: xmlParseStringName(xmlParserCtxtPtr ctxt, const xmlChar** str) {
! 3460: xmlChar buf[XML_MAX_NAMELEN + 5];
! 3461: const xmlChar *cur = *str;
! 3462: int len = 0, l;
! 3463: int c;
! 3464:
! 3465: #ifdef DEBUG
! 3466: nbParseStringName++;
! 3467: #endif
! 3468:
! 3469: c = CUR_SCHAR(cur, l);
! 3470: if (!xmlIsNameStartChar(ctxt, c)) {
! 3471: return(NULL);
! 3472: }
! 3473:
! 3474: COPY_BUF(l,buf,len,c);
! 3475: cur += l;
! 3476: c = CUR_SCHAR(cur, l);
! 3477: while (xmlIsNameChar(ctxt, c)) {
! 3478: COPY_BUF(l,buf,len,c);
! 3479: cur += l;
! 3480: c = CUR_SCHAR(cur, l);
! 3481: if (len >= XML_MAX_NAMELEN) { /* test bigentname.xml */
! 3482: /*
! 3483: * Okay someone managed to make a huge name, so he's ready to pay
! 3484: * for the processing speed.
! 3485: */
! 3486: xmlChar *buffer;
! 3487: int max = len * 2;
! 3488:
! 3489: buffer = (xmlChar *) xmlMallocAtomic(max * sizeof(xmlChar));
! 3490: if (buffer == NULL) {
! 3491: xmlErrMemory(ctxt, NULL);
! 3492: return(NULL);
! 3493: }
! 3494: memcpy(buffer, buf, len);
! 3495: while (xmlIsNameChar(ctxt, c)) {
! 3496: if (len + 10 > max) {
! 3497: xmlChar *tmp;
! 3498: max *= 2;
! 3499: tmp = (xmlChar *) xmlRealloc(buffer,
! 3500: max * sizeof(xmlChar));
! 3501: if (tmp == NULL) {
! 3502: xmlErrMemory(ctxt, NULL);
! 3503: xmlFree(buffer);
! 3504: return(NULL);
! 3505: }
! 3506: buffer = tmp;
! 3507: }
! 3508: COPY_BUF(l,buffer,len,c);
! 3509: cur += l;
! 3510: c = CUR_SCHAR(cur, l);
! 3511: }
! 3512: buffer[len] = 0;
! 3513: *str = cur;
! 3514: return(buffer);
! 3515: }
! 3516: }
! 3517: *str = cur;
! 3518: return(xmlStrndup(buf, len));
! 3519: }
! 3520:
! 3521: /**
! 3522: * xmlParseNmtoken:
! 3523: * @ctxt: an XML parser context
! 3524: *
! 3525: * parse an XML Nmtoken.
! 3526: *
! 3527: * [7] Nmtoken ::= (NameChar)+
! 3528: *
! 3529: * [8] Nmtokens ::= Nmtoken (#x20 Nmtoken)*
! 3530: *
! 3531: * Returns the Nmtoken parsed or NULL
! 3532: */
! 3533:
! 3534: xmlChar *
! 3535: xmlParseNmtoken(xmlParserCtxtPtr ctxt) {
! 3536: xmlChar buf[XML_MAX_NAMELEN + 5];
! 3537: int len = 0, l;
! 3538: int c;
! 3539: int count = 0;
! 3540:
! 3541: #ifdef DEBUG
! 3542: nbParseNmToken++;
! 3543: #endif
! 3544:
! 3545: GROW;
! 3546: c = CUR_CHAR(l);
! 3547:
! 3548: while (xmlIsNameChar(ctxt, c)) {
! 3549: if (count++ > 100) {
! 3550: count = 0;
! 3551: GROW;
! 3552: }
! 3553: COPY_BUF(l,buf,len,c);
! 3554: NEXTL(l);
! 3555: c = CUR_CHAR(l);
! 3556: if (len >= XML_MAX_NAMELEN) {
! 3557: /*
! 3558: * Okay someone managed to make a huge token, so he's ready to pay
! 3559: * for the processing speed.
! 3560: */
! 3561: xmlChar *buffer;
! 3562: int max = len * 2;
! 3563:
! 3564: buffer = (xmlChar *) xmlMallocAtomic(max * sizeof(xmlChar));
! 3565: if (buffer == NULL) {
! 3566: xmlErrMemory(ctxt, NULL);
! 3567: return(NULL);
! 3568: }
! 3569: memcpy(buffer, buf, len);
! 3570: while (xmlIsNameChar(ctxt, c)) {
! 3571: if (count++ > 100) {
! 3572: count = 0;
! 3573: GROW;
! 3574: }
! 3575: if (len + 10 > max) {
! 3576: xmlChar *tmp;
! 3577:
! 3578: max *= 2;
! 3579: tmp = (xmlChar *) xmlRealloc(buffer,
! 3580: max * sizeof(xmlChar));
! 3581: if (tmp == NULL) {
! 3582: xmlErrMemory(ctxt, NULL);
! 3583: xmlFree(buffer);
! 3584: return(NULL);
! 3585: }
! 3586: buffer = tmp;
! 3587: }
! 3588: COPY_BUF(l,buffer,len,c);
! 3589: NEXTL(l);
! 3590: c = CUR_CHAR(l);
! 3591: }
! 3592: buffer[len] = 0;
! 3593: return(buffer);
! 3594: }
! 3595: }
! 3596: if (len == 0)
! 3597: return(NULL);
! 3598: return(xmlStrndup(buf, len));
! 3599: }
! 3600:
! 3601: /**
! 3602: * xmlParseEntityValue:
! 3603: * @ctxt: an XML parser context
! 3604: * @orig: if non-NULL store a copy of the original entity value
! 3605: *
! 3606: * parse a value for ENTITY declarations
! 3607: *
! 3608: * [9] EntityValue ::= '"' ([^%&"] | PEReference | Reference)* '"' |
! 3609: * "'" ([^%&'] | PEReference | Reference)* "'"
! 3610: *
! 3611: * Returns the EntityValue parsed with reference substituted or NULL
! 3612: */
! 3613:
! 3614: xmlChar *
! 3615: xmlParseEntityValue(xmlParserCtxtPtr ctxt, xmlChar **orig) {
! 3616: xmlChar *buf = NULL;
! 3617: int len = 0;
! 3618: int size = XML_PARSER_BUFFER_SIZE;
! 3619: int c, l;
! 3620: xmlChar stop;
! 3621: xmlChar *ret = NULL;
! 3622: const xmlChar *cur = NULL;
! 3623: xmlParserInputPtr input;
! 3624:
! 3625: if (RAW == '"') stop = '"';
! 3626: else if (RAW == '\'') stop = '\'';
! 3627: else {
! 3628: xmlFatalErr(ctxt, XML_ERR_ENTITY_NOT_STARTED, NULL);
! 3629: return(NULL);
! 3630: }
! 3631: buf = (xmlChar *) xmlMallocAtomic(size * sizeof(xmlChar));
! 3632: if (buf == NULL) {
! 3633: xmlErrMemory(ctxt, NULL);
! 3634: return(NULL);
! 3635: }
! 3636:
! 3637: /*
! 3638: * The content of the entity definition is copied in a buffer.
! 3639: */
! 3640:
! 3641: ctxt->instate = XML_PARSER_ENTITY_VALUE;
! 3642: input = ctxt->input;
! 3643: GROW;
! 3644: NEXT;
! 3645: c = CUR_CHAR(l);
! 3646: /*
! 3647: * NOTE: 4.4.5 Included in Literal
! 3648: * When a parameter entity reference appears in a literal entity
! 3649: * value, ... a single or double quote character in the replacement
! 3650: * text is always treated as a normal data character and will not
! 3651: * terminate the literal.
! 3652: * In practice it means we stop the loop only when back at parsing
! 3653: * the initial entity and the quote is found
! 3654: */
! 3655: while ((IS_CHAR(c)) && ((c != stop) || /* checked */
! 3656: (ctxt->input != input))) {
! 3657: if (len + 5 >= size) {
! 3658: xmlChar *tmp;
! 3659:
! 3660: size *= 2;
! 3661: tmp = (xmlChar *) xmlRealloc(buf, size * sizeof(xmlChar));
! 3662: if (tmp == NULL) {
! 3663: xmlErrMemory(ctxt, NULL);
! 3664: xmlFree(buf);
! 3665: return(NULL);
! 3666: }
! 3667: buf = tmp;
! 3668: }
! 3669: COPY_BUF(l,buf,len,c);
! 3670: NEXTL(l);
! 3671: /*
! 3672: * Pop-up of finished entities.
! 3673: */
! 3674: while ((RAW == 0) && (ctxt->inputNr > 1)) /* non input consuming */
! 3675: xmlPopInput(ctxt);
! 3676:
! 3677: GROW;
! 3678: c = CUR_CHAR(l);
! 3679: if (c == 0) {
! 3680: GROW;
! 3681: c = CUR_CHAR(l);
! 3682: }
! 3683: }
! 3684: buf[len] = 0;
! 3685:
! 3686: /*
! 3687: * Raise problem w.r.t. '&' and '%' being used in non-entities
! 3688: * reference constructs. Note Charref will be handled in
! 3689: * xmlStringDecodeEntities()
! 3690: */
! 3691: cur = buf;
! 3692: while (*cur != 0) { /* non input consuming */
! 3693: if ((*cur == '%') || ((*cur == '&') && (cur[1] != '#'))) {
! 3694: xmlChar *name;
! 3695: xmlChar tmp = *cur;
! 3696:
! 3697: cur++;
! 3698: name = xmlParseStringName(ctxt, &cur);
! 3699: if ((name == NULL) || (*cur != ';')) {
! 3700: xmlFatalErrMsgInt(ctxt, XML_ERR_ENTITY_CHAR_ERROR,
! 3701: "EntityValue: '%c' forbidden except for entities references\n",
! 3702: tmp);
! 3703: }
! 3704: if ((tmp == '%') && (ctxt->inSubset == 1) &&
! 3705: (ctxt->inputNr == 1)) {
! 3706: xmlFatalErr(ctxt, XML_ERR_ENTITY_PE_INTERNAL, NULL);
! 3707: }
! 3708: if (name != NULL)
! 3709: xmlFree(name);
! 3710: if (*cur == 0)
! 3711: break;
! 3712: }
! 3713: cur++;
! 3714: }
! 3715:
! 3716: /*
! 3717: * Then PEReference entities are substituted.
! 3718: */
! 3719: if (c != stop) {
! 3720: xmlFatalErr(ctxt, XML_ERR_ENTITY_NOT_FINISHED, NULL);
! 3721: xmlFree(buf);
! 3722: } else {
! 3723: NEXT;
! 3724: /*
! 3725: * NOTE: 4.4.7 Bypassed
! 3726: * When a general entity reference appears in the EntityValue in
! 3727: * an entity declaration, it is bypassed and left as is.
! 3728: * so XML_SUBSTITUTE_REF is not set here.
! 3729: */
! 3730: ret = xmlStringDecodeEntities(ctxt, buf, XML_SUBSTITUTE_PEREF,
! 3731: 0, 0, 0);
! 3732: if (orig != NULL)
! 3733: *orig = buf;
! 3734: else
! 3735: xmlFree(buf);
! 3736: }
! 3737:
! 3738: return(ret);
! 3739: }
! 3740:
! 3741: /**
! 3742: * xmlParseAttValueComplex:
! 3743: * @ctxt: an XML parser context
! 3744: * @len: the resulting attribute len
! 3745: * @normalize: wether to apply the inner normalization
! 3746: *
! 3747: * parse a value for an attribute, this is the fallback function
! 3748: * of xmlParseAttValue() when the attribute parsing requires handling
! 3749: * of non-ASCII characters, or normalization compaction.
! 3750: *
! 3751: * Returns the AttValue parsed or NULL. The value has to be freed by the caller.
! 3752: */
! 3753: static xmlChar *
! 3754: xmlParseAttValueComplex(xmlParserCtxtPtr ctxt, int *attlen, int normalize) {
! 3755: xmlChar limit = 0;
! 3756: xmlChar *buf = NULL;
! 3757: xmlChar *rep = NULL;
! 3758: int len = 0;
! 3759: int buf_size = 0;
! 3760: int c, l, in_space = 0;
! 3761: xmlChar *current = NULL;
! 3762: xmlEntityPtr ent;
! 3763:
! 3764: if (NXT(0) == '"') {
! 3765: ctxt->instate = XML_PARSER_ATTRIBUTE_VALUE;
! 3766: limit = '"';
! 3767: NEXT;
! 3768: } else if (NXT(0) == '\'') {
! 3769: limit = '\'';
! 3770: ctxt->instate = XML_PARSER_ATTRIBUTE_VALUE;
! 3771: NEXT;
! 3772: } else {
! 3773: xmlFatalErr(ctxt, XML_ERR_ATTRIBUTE_NOT_STARTED, NULL);
! 3774: return(NULL);
! 3775: }
! 3776:
! 3777: /*
! 3778: * allocate a translation buffer.
! 3779: */
! 3780: buf_size = XML_PARSER_BUFFER_SIZE;
! 3781: buf = (xmlChar *) xmlMallocAtomic(buf_size * sizeof(xmlChar));
! 3782: if (buf == NULL) goto mem_error;
! 3783:
! 3784: /*
! 3785: * OK loop until we reach one of the ending char or a size limit.
! 3786: */
! 3787: c = CUR_CHAR(l);
! 3788: while ((NXT(0) != limit) && /* checked */
! 3789: (IS_CHAR(c)) && (c != '<')) {
! 3790: if (c == 0) break;
! 3791: if (c == '&') {
! 3792: in_space = 0;
! 3793: if (NXT(1) == '#') {
! 3794: int val = xmlParseCharRef(ctxt);
! 3795:
! 3796: if (val == '&') {
! 3797: if (ctxt->replaceEntities) {
! 3798: if (len > buf_size - 10) {
! 3799: growBuffer(buf, 10);
! 3800: }
! 3801: buf[len++] = '&';
! 3802: } else {
! 3803: /*
! 3804: * The reparsing will be done in xmlStringGetNodeList()
! 3805: * called by the attribute() function in SAX.c
! 3806: */
! 3807: if (len > buf_size - 10) {
! 3808: growBuffer(buf, 10);
! 3809: }
! 3810: buf[len++] = '&';
! 3811: buf[len++] = '#';
! 3812: buf[len++] = '3';
! 3813: buf[len++] = '8';
! 3814: buf[len++] = ';';
! 3815: }
! 3816: } else if (val != 0) {
! 3817: if (len > buf_size - 10) {
! 3818: growBuffer(buf, 10);
! 3819: }
! 3820: len += xmlCopyChar(0, &buf[len], val);
! 3821: }
! 3822: } else {
! 3823: ent = xmlParseEntityRef(ctxt);
! 3824: ctxt->nbentities++;
! 3825: if (ent != NULL)
! 3826: ctxt->nbentities += ent->owner;
! 3827: if ((ent != NULL) &&
! 3828: (ent->etype == XML_INTERNAL_PREDEFINED_ENTITY)) {
! 3829: if (len > buf_size - 10) {
! 3830: growBuffer(buf, 10);
! 3831: }
! 3832: if ((ctxt->replaceEntities == 0) &&
! 3833: (ent->content[0] == '&')) {
! 3834: buf[len++] = '&';
! 3835: buf[len++] = '#';
! 3836: buf[len++] = '3';
! 3837: buf[len++] = '8';
! 3838: buf[len++] = ';';
! 3839: } else {
! 3840: buf[len++] = ent->content[0];
! 3841: }
! 3842: } else if ((ent != NULL) &&
! 3843: (ctxt->replaceEntities != 0)) {
! 3844: if (ent->etype != XML_INTERNAL_PREDEFINED_ENTITY) {
! 3845: rep = xmlStringDecodeEntities(ctxt, ent->content,
! 3846: XML_SUBSTITUTE_REF,
! 3847: 0, 0, 0);
! 3848: if (rep != NULL) {
! 3849: current = rep;
! 3850: while (*current != 0) { /* non input consuming */
! 3851: if ((*current == 0xD) || (*current == 0xA) ||
! 3852: (*current == 0x9)) {
! 3853: buf[len++] = 0x20;
! 3854: current++;
! 3855: } else
! 3856: buf[len++] = *current++;
! 3857: if (len > buf_size - 10) {
! 3858: growBuffer(buf, 10);
! 3859: }
! 3860: }
! 3861: xmlFree(rep);
! 3862: rep = NULL;
! 3863: }
! 3864: } else {
! 3865: if (len > buf_size - 10) {
! 3866: growBuffer(buf, 10);
! 3867: }
! 3868: if (ent->content != NULL)
! 3869: buf[len++] = ent->content[0];
! 3870: }
! 3871: } else if (ent != NULL) {
! 3872: int i = xmlStrlen(ent->name);
! 3873: const xmlChar *cur = ent->name;
! 3874:
! 3875: /*
! 3876: * This may look absurd but is needed to detect
! 3877: * entities problems
! 3878: */
! 3879: if ((ent->etype != XML_INTERNAL_PREDEFINED_ENTITY) &&
! 3880: (ent->content != NULL)) {
! 3881: rep = xmlStringDecodeEntities(ctxt, ent->content,
! 3882: XML_SUBSTITUTE_REF, 0, 0, 0);
! 3883: if (rep != NULL) {
! 3884: xmlFree(rep);
! 3885: rep = NULL;
! 3886: }
! 3887: }
! 3888:
! 3889: /*
! 3890: * Just output the reference
! 3891: */
! 3892: buf[len++] = '&';
! 3893: while (len > buf_size - i - 10) {
! 3894: growBuffer(buf, i + 10);
! 3895: }
! 3896: for (;i > 0;i--)
! 3897: buf[len++] = *cur++;
! 3898: buf[len++] = ';';
! 3899: }
! 3900: }
! 3901: } else {
! 3902: if ((c == 0x20) || (c == 0xD) || (c == 0xA) || (c == 0x9)) {
! 3903: if ((len != 0) || (!normalize)) {
! 3904: if ((!normalize) || (!in_space)) {
! 3905: COPY_BUF(l,buf,len,0x20);
! 3906: while (len > buf_size - 10) {
! 3907: growBuffer(buf, 10);
! 3908: }
! 3909: }
! 3910: in_space = 1;
! 3911: }
! 3912: } else {
! 3913: in_space = 0;
! 3914: COPY_BUF(l,buf,len,c);
! 3915: if (len > buf_size - 10) {
! 3916: growBuffer(buf, 10);
! 3917: }
! 3918: }
! 3919: NEXTL(l);
! 3920: }
! 3921: GROW;
! 3922: c = CUR_CHAR(l);
! 3923: }
! 3924: if ((in_space) && (normalize)) {
! 3925: while (buf[len - 1] == 0x20) len--;
! 3926: }
! 3927: buf[len] = 0;
! 3928: if (RAW == '<') {
! 3929: xmlFatalErr(ctxt, XML_ERR_LT_IN_ATTRIBUTE, NULL);
! 3930: } else if (RAW != limit) {
! 3931: if ((c != 0) && (!IS_CHAR(c))) {
! 3932: xmlFatalErrMsg(ctxt, XML_ERR_INVALID_CHAR,
! 3933: "invalid character in attribute value\n");
! 3934: } else {
! 3935: xmlFatalErrMsg(ctxt, XML_ERR_ATTRIBUTE_NOT_FINISHED,
! 3936: "AttValue: ' expected\n");
! 3937: }
! 3938: } else
! 3939: NEXT;
! 3940: if (attlen != NULL) *attlen = len;
! 3941: return(buf);
! 3942:
! 3943: mem_error:
! 3944: xmlErrMemory(ctxt, NULL);
! 3945: if (buf != NULL)
! 3946: xmlFree(buf);
! 3947: if (rep != NULL)
! 3948: xmlFree(rep);
! 3949: return(NULL);
! 3950: }
! 3951:
! 3952: /**
! 3953: * xmlParseAttValue:
! 3954: * @ctxt: an XML parser context
! 3955: *
! 3956: * parse a value for an attribute
! 3957: * Note: the parser won't do substitution of entities here, this
! 3958: * will be handled later in xmlStringGetNodeList
! 3959: *
! 3960: * [10] AttValue ::= '"' ([^<&"] | Reference)* '"' |
! 3961: * "'" ([^<&'] | Reference)* "'"
! 3962: *
! 3963: * 3.3.3 Attribute-Value Normalization:
! 3964: * Before the value of an attribute is passed to the application or
! 3965: * checked for validity, the XML processor must normalize it as follows:
! 3966: * - a character reference is processed by appending the referenced
! 3967: * character to the attribute value
! 3968: * - an entity reference is processed by recursively processing the
! 3969: * replacement text of the entity
! 3970: * - a whitespace character (#x20, #xD, #xA, #x9) is processed by
! 3971: * appending #x20 to the normalized value, except that only a single
! 3972: * #x20 is appended for a "#xD#xA" sequence that is part of an external
! 3973: * parsed entity or the literal entity value of an internal parsed entity
! 3974: * - other characters are processed by appending them to the normalized value
! 3975: * If the declared value is not CDATA, then the XML processor must further
! 3976: * process the normalized attribute value by discarding any leading and
! 3977: * trailing space (#x20) characters, and by replacing sequences of space
! 3978: * (#x20) characters by a single space (#x20) character.
! 3979: * All attributes for which no declaration has been read should be treated
! 3980: * by a non-validating parser as if declared CDATA.
! 3981: *
! 3982: * Returns the AttValue parsed or NULL. The value has to be freed by the caller.
! 3983: */
! 3984:
! 3985:
! 3986: xmlChar *
! 3987: xmlParseAttValue(xmlParserCtxtPtr ctxt) {
! 3988: if ((ctxt == NULL) || (ctxt->input == NULL)) return(NULL);
! 3989: return(xmlParseAttValueInternal(ctxt, NULL, NULL, 0));
! 3990: }
! 3991:
! 3992: /**
! 3993: * xmlParseSystemLiteral:
! 3994: * @ctxt: an XML parser context
! 3995: *
! 3996: * parse an XML Literal
! 3997: *
! 3998: * [11] SystemLiteral ::= ('"' [^"]* '"') | ("'" [^']* "'")
! 3999: *
! 4000: * Returns the SystemLiteral parsed or NULL
! 4001: */
! 4002:
! 4003: xmlChar *
! 4004: xmlParseSystemLiteral(xmlParserCtxtPtr ctxt) {
! 4005: xmlChar *buf = NULL;
! 4006: int len = 0;
! 4007: int size = XML_PARSER_BUFFER_SIZE;
! 4008: int cur, l;
! 4009: xmlChar stop;
! 4010: int state = ctxt->instate;
! 4011: int count = 0;
! 4012:
! 4013: SHRINK;
! 4014: if (RAW == '"') {
! 4015: NEXT;
! 4016: stop = '"';
! 4017: } else if (RAW == '\'') {
! 4018: NEXT;
! 4019: stop = '\'';
! 4020: } else {
! 4021: xmlFatalErr(ctxt, XML_ERR_LITERAL_NOT_STARTED, NULL);
! 4022: return(NULL);
! 4023: }
! 4024:
! 4025: buf = (xmlChar *) xmlMallocAtomic(size * sizeof(xmlChar));
! 4026: if (buf == NULL) {
! 4027: xmlErrMemory(ctxt, NULL);
! 4028: return(NULL);
! 4029: }
! 4030: ctxt->instate = XML_PARSER_SYSTEM_LITERAL;
! 4031: cur = CUR_CHAR(l);
! 4032: while ((IS_CHAR(cur)) && (cur != stop)) { /* checked */
! 4033: if (len + 5 >= size) {
! 4034: xmlChar *tmp;
! 4035:
! 4036: size *= 2;
! 4037: tmp = (xmlChar *) xmlRealloc(buf, size * sizeof(xmlChar));
! 4038: if (tmp == NULL) {
! 4039: xmlFree(buf);
! 4040: xmlErrMemory(ctxt, NULL);
! 4041: ctxt->instate = (xmlParserInputState) state;
! 4042: return(NULL);
! 4043: }
! 4044: buf = tmp;
! 4045: }
! 4046: count++;
! 4047: if (count > 50) {
! 4048: GROW;
! 4049: count = 0;
! 4050: }
! 4051: COPY_BUF(l,buf,len,cur);
! 4052: NEXTL(l);
! 4053: cur = CUR_CHAR(l);
! 4054: if (cur == 0) {
! 4055: GROW;
! 4056: SHRINK;
! 4057: cur = CUR_CHAR(l);
! 4058: }
! 4059: }
! 4060: buf[len] = 0;
! 4061: ctxt->instate = (xmlParserInputState) state;
! 4062: if (!IS_CHAR(cur)) {
! 4063: xmlFatalErr(ctxt, XML_ERR_LITERAL_NOT_FINISHED, NULL);
! 4064: } else {
! 4065: NEXT;
! 4066: }
! 4067: return(buf);
! 4068: }
! 4069:
! 4070: /**
! 4071: * xmlParsePubidLiteral:
! 4072: * @ctxt: an XML parser context
! 4073: *
! 4074: * parse an XML public literal
! 4075: *
! 4076: * [12] PubidLiteral ::= '"' PubidChar* '"' | "'" (PubidChar - "'")* "'"
! 4077: *
! 4078: * Returns the PubidLiteral parsed or NULL.
! 4079: */
! 4080:
! 4081: xmlChar *
! 4082: xmlParsePubidLiteral(xmlParserCtxtPtr ctxt) {
! 4083: xmlChar *buf = NULL;
! 4084: int len = 0;
! 4085: int size = XML_PARSER_BUFFER_SIZE;
! 4086: xmlChar cur;
! 4087: xmlChar stop;
! 4088: int count = 0;
! 4089: xmlParserInputState oldstate = ctxt->instate;
! 4090:
! 4091: SHRINK;
! 4092: if (RAW == '"') {
! 4093: NEXT;
! 4094: stop = '"';
! 4095: } else if (RAW == '\'') {
! 4096: NEXT;
! 4097: stop = '\'';
! 4098: } else {
! 4099: xmlFatalErr(ctxt, XML_ERR_LITERAL_NOT_STARTED, NULL);
! 4100: return(NULL);
! 4101: }
! 4102: buf = (xmlChar *) xmlMallocAtomic(size * sizeof(xmlChar));
! 4103: if (buf == NULL) {
! 4104: xmlErrMemory(ctxt, NULL);
! 4105: return(NULL);
! 4106: }
! 4107: ctxt->instate = XML_PARSER_PUBLIC_LITERAL;
! 4108: cur = CUR;
! 4109: while ((IS_PUBIDCHAR_CH(cur)) && (cur != stop)) { /* checked */
! 4110: if (len + 1 >= size) {
! 4111: xmlChar *tmp;
! 4112:
! 4113: size *= 2;
! 4114: tmp = (xmlChar *) xmlRealloc(buf, size * sizeof(xmlChar));
! 4115: if (tmp == NULL) {
! 4116: xmlErrMemory(ctxt, NULL);
! 4117: xmlFree(buf);
! 4118: return(NULL);
! 4119: }
! 4120: buf = tmp;
! 4121: }
! 4122: buf[len++] = cur;
! 4123: count++;
! 4124: if (count > 50) {
! 4125: GROW;
! 4126: count = 0;
! 4127: }
! 4128: NEXT;
! 4129: cur = CUR;
! 4130: if (cur == 0) {
! 4131: GROW;
! 4132: SHRINK;
! 4133: cur = CUR;
! 4134: }
! 4135: }
! 4136: buf[len] = 0;
! 4137: if (cur != stop) {
! 4138: xmlFatalErr(ctxt, XML_ERR_LITERAL_NOT_FINISHED, NULL);
! 4139: } else {
! 4140: NEXT;
! 4141: }
! 4142: ctxt->instate = oldstate;
! 4143: return(buf);
! 4144: }
! 4145:
! 4146: static void xmlParseCharDataComplex(xmlParserCtxtPtr ctxt, int cdata);
! 4147:
! 4148: /*
! 4149: * used for the test in the inner loop of the char data testing
! 4150: */
! 4151: static const unsigned char test_char_data[256] = {
! 4152: 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
! 4153: 0x00, 0x09, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, /* 0x9, CR/LF separated */
! 4154: 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
! 4155: 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
! 4156: 0x20, 0x21, 0x22, 0x23, 0x24, 0x25, 0x00, 0x27, /* & */
! 4157: 0x28, 0x29, 0x2A, 0x2B, 0x2C, 0x2D, 0x2E, 0x2F,
! 4158: 0x30, 0x31, 0x32, 0x33, 0x34, 0x35, 0x36, 0x37,
! 4159: 0x38, 0x39, 0x3A, 0x3B, 0x00, 0x3D, 0x3E, 0x3F, /* < */
! 4160: 0x40, 0x41, 0x42, 0x43, 0x44, 0x45, 0x46, 0x47,
! 4161: 0x48, 0x49, 0x4A, 0x4B, 0x4C, 0x4D, 0x4E, 0x4F,
! 4162: 0x50, 0x51, 0x52, 0x53, 0x54, 0x55, 0x56, 0x57,
! 4163: 0x58, 0x59, 0x5A, 0x5B, 0x5C, 0x00, 0x5E, 0x5F, /* ] */
! 4164: 0x60, 0x61, 0x62, 0x63, 0x64, 0x65, 0x66, 0x67,
! 4165: 0x68, 0x69, 0x6A, 0x6B, 0x6C, 0x6D, 0x6E, 0x6F,
! 4166: 0x70, 0x71, 0x72, 0x73, 0x74, 0x75, 0x76, 0x77,
! 4167: 0x78, 0x79, 0x7A, 0x7B, 0x7C, 0x7D, 0x7E, 0x7F,
! 4168: 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, /* non-ascii */
! 4169: 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
! 4170: 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
! 4171: 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
! 4172: 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
! 4173: 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
! 4174: 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
! 4175: 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
! 4176: 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
! 4177: 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
! 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: };
! 4185:
! 4186: /**
! 4187: * xmlParseCharData:
! 4188: * @ctxt: an XML parser context
! 4189: * @cdata: int indicating whether we are within a CDATA section
! 4190: *
! 4191: * parse a CharData section.
! 4192: * if we are within a CDATA section ']]>' marks an end of section.
! 4193: *
! 4194: * The right angle bracket (>) may be represented using the string ">",
! 4195: * and must, for compatibility, be escaped using ">" or a character
! 4196: * reference when it appears in the string "]]>" in content, when that
! 4197: * string is not marking the end of a CDATA section.
! 4198: *
! 4199: * [14] CharData ::= [^<&]* - ([^<&]* ']]>' [^<&]*)
! 4200: */
! 4201:
! 4202: void
! 4203: xmlParseCharData(xmlParserCtxtPtr ctxt, int cdata) {
! 4204: const xmlChar *in;
! 4205: int nbchar = 0;
! 4206: int line = ctxt->input->line;
! 4207: int col = ctxt->input->col;
! 4208: int ccol;
! 4209:
! 4210: SHRINK;
! 4211: GROW;
! 4212: /*
! 4213: * Accelerated common case where input don't need to be
! 4214: * modified before passing it to the handler.
! 4215: */
! 4216: if (!cdata) {
! 4217: in = ctxt->input->cur;
! 4218: do {
! 4219: get_more_space:
! 4220: while (*in == 0x20) { in++; ctxt->input->col++; }
! 4221: if (*in == 0xA) {
! 4222: do {
! 4223: ctxt->input->line++; ctxt->input->col = 1;
! 4224: in++;
! 4225: } while (*in == 0xA);
! 4226: goto get_more_space;
! 4227: }
! 4228: if (*in == '<') {
! 4229: nbchar = in - ctxt->input->cur;
! 4230: if (nbchar > 0) {
! 4231: const xmlChar *tmp = ctxt->input->cur;
! 4232: ctxt->input->cur = in;
! 4233:
! 4234: if ((ctxt->sax != NULL) &&
! 4235: (ctxt->sax->ignorableWhitespace !=
! 4236: ctxt->sax->characters)) {
! 4237: if (areBlanks(ctxt, tmp, nbchar, 1)) {
! 4238: if (ctxt->sax->ignorableWhitespace != NULL)
! 4239: ctxt->sax->ignorableWhitespace(ctxt->userData,
! 4240: tmp, nbchar);
! 4241: } else {
! 4242: if (ctxt->sax->characters != NULL)
! 4243: ctxt->sax->characters(ctxt->userData,
! 4244: tmp, nbchar);
! 4245: if (*ctxt->space == -1)
! 4246: *ctxt->space = -2;
! 4247: }
! 4248: } else if ((ctxt->sax != NULL) &&
! 4249: (ctxt->sax->characters != NULL)) {
! 4250: ctxt->sax->characters(ctxt->userData,
! 4251: tmp, nbchar);
! 4252: }
! 4253: }
! 4254: return;
! 4255: }
! 4256:
! 4257: get_more:
! 4258: ccol = ctxt->input->col;
! 4259: while (test_char_data[*in]) {
! 4260: in++;
! 4261: ccol++;
! 4262: }
! 4263: ctxt->input->col = ccol;
! 4264: if (*in == 0xA) {
! 4265: do {
! 4266: ctxt->input->line++; ctxt->input->col = 1;
! 4267: in++;
! 4268: } while (*in == 0xA);
! 4269: goto get_more;
! 4270: }
! 4271: if (*in == ']') {
! 4272: if ((in[1] == ']') && (in[2] == '>')) {
! 4273: xmlFatalErr(ctxt, XML_ERR_MISPLACED_CDATA_END, NULL);
! 4274: ctxt->input->cur = in;
! 4275: return;
! 4276: }
! 4277: in++;
! 4278: ctxt->input->col++;
! 4279: goto get_more;
! 4280: }
! 4281: nbchar = in - ctxt->input->cur;
! 4282: if (nbchar > 0) {
! 4283: if ((ctxt->sax != NULL) &&
! 4284: (ctxt->sax->ignorableWhitespace !=
! 4285: ctxt->sax->characters) &&
! 4286: (IS_BLANK_CH(*ctxt->input->cur))) {
! 4287: const xmlChar *tmp = ctxt->input->cur;
! 4288: ctxt->input->cur = in;
! 4289:
! 4290: if (areBlanks(ctxt, tmp, nbchar, 0)) {
! 4291: if (ctxt->sax->ignorableWhitespace != NULL)
! 4292: ctxt->sax->ignorableWhitespace(ctxt->userData,
! 4293: tmp, nbchar);
! 4294: } else {
! 4295: if (ctxt->sax->characters != NULL)
! 4296: ctxt->sax->characters(ctxt->userData,
! 4297: tmp, nbchar);
! 4298: if (*ctxt->space == -1)
! 4299: *ctxt->space = -2;
! 4300: }
! 4301: line = ctxt->input->line;
! 4302: col = ctxt->input->col;
! 4303: } else if (ctxt->sax != NULL) {
! 4304: if (ctxt->sax->characters != NULL)
! 4305: ctxt->sax->characters(ctxt->userData,
! 4306: ctxt->input->cur, nbchar);
! 4307: line = ctxt->input->line;
! 4308: col = ctxt->input->col;
! 4309: }
! 4310: /* something really bad happened in the SAX callback */
! 4311: if (ctxt->instate != XML_PARSER_CONTENT)
! 4312: return;
! 4313: }
! 4314: ctxt->input->cur = in;
! 4315: if (*in == 0xD) {
! 4316: in++;
! 4317: if (*in == 0xA) {
! 4318: ctxt->input->cur = in;
! 4319: in++;
! 4320: ctxt->input->line++; ctxt->input->col = 1;
! 4321: continue; /* while */
! 4322: }
! 4323: in--;
! 4324: }
! 4325: if (*in == '<') {
! 4326: return;
! 4327: }
! 4328: if (*in == '&') {
! 4329: return;
! 4330: }
! 4331: SHRINK;
! 4332: GROW;
! 4333: in = ctxt->input->cur;
! 4334: } while (((*in >= 0x20) && (*in <= 0x7F)) || (*in == 0x09));
! 4335: nbchar = 0;
! 4336: }
! 4337: ctxt->input->line = line;
! 4338: ctxt->input->col = col;
! 4339: xmlParseCharDataComplex(ctxt, cdata);
! 4340: }
! 4341:
! 4342: /**
! 4343: * xmlParseCharDataComplex:
! 4344: * @ctxt: an XML parser context
! 4345: * @cdata: int indicating whether we are within a CDATA section
! 4346: *
! 4347: * parse a CharData section.this is the fallback function
! 4348: * of xmlParseCharData() when the parsing requires handling
! 4349: * of non-ASCII characters.
! 4350: */
! 4351: static void
! 4352: xmlParseCharDataComplex(xmlParserCtxtPtr ctxt, int cdata) {
! 4353: xmlChar buf[XML_PARSER_BIG_BUFFER_SIZE + 5];
! 4354: int nbchar = 0;
! 4355: int cur, l;
! 4356: int count = 0;
! 4357:
! 4358: SHRINK;
! 4359: GROW;
! 4360: cur = CUR_CHAR(l);
! 4361: while ((cur != '<') && /* checked */
! 4362: (cur != '&') &&
! 4363: (IS_CHAR(cur))) /* test also done in xmlCurrentChar() */ {
! 4364: if ((cur == ']') && (NXT(1) == ']') &&
! 4365: (NXT(2) == '>')) {
! 4366: if (cdata) break;
! 4367: else {
! 4368: xmlFatalErr(ctxt, XML_ERR_MISPLACED_CDATA_END, NULL);
! 4369: }
! 4370: }
! 4371: COPY_BUF(l,buf,nbchar,cur);
! 4372: if (nbchar >= XML_PARSER_BIG_BUFFER_SIZE) {
! 4373: buf[nbchar] = 0;
! 4374:
! 4375: /*
! 4376: * OK the segment is to be consumed as chars.
! 4377: */
! 4378: if ((ctxt->sax != NULL) && (!ctxt->disableSAX)) {
! 4379: if (areBlanks(ctxt, buf, nbchar, 0)) {
! 4380: if (ctxt->sax->ignorableWhitespace != NULL)
! 4381: ctxt->sax->ignorableWhitespace(ctxt->userData,
! 4382: buf, nbchar);
! 4383: } else {
! 4384: if (ctxt->sax->characters != NULL)
! 4385: ctxt->sax->characters(ctxt->userData, buf, nbchar);
! 4386: if ((ctxt->sax->characters !=
! 4387: ctxt->sax->ignorableWhitespace) &&
! 4388: (*ctxt->space == -1))
! 4389: *ctxt->space = -2;
! 4390: }
! 4391: }
! 4392: nbchar = 0;
! 4393: /* something really bad happened in the SAX callback */
! 4394: if (ctxt->instate != XML_PARSER_CONTENT)
! 4395: return;
! 4396: }
! 4397: count++;
! 4398: if (count > 50) {
! 4399: GROW;
! 4400: count = 0;
! 4401: }
! 4402: NEXTL(l);
! 4403: cur = CUR_CHAR(l);
! 4404: }
! 4405: if (nbchar != 0) {
! 4406: buf[nbchar] = 0;
! 4407: /*
! 4408: * OK the segment is to be consumed as chars.
! 4409: */
! 4410: if ((ctxt->sax != NULL) && (!ctxt->disableSAX)) {
! 4411: if (areBlanks(ctxt, buf, nbchar, 0)) {
! 4412: if (ctxt->sax->ignorableWhitespace != NULL)
! 4413: ctxt->sax->ignorableWhitespace(ctxt->userData, buf, nbchar);
! 4414: } else {
! 4415: if (ctxt->sax->characters != NULL)
! 4416: ctxt->sax->characters(ctxt->userData, buf, nbchar);
! 4417: if ((ctxt->sax->characters != ctxt->sax->ignorableWhitespace) &&
! 4418: (*ctxt->space == -1))
! 4419: *ctxt->space = -2;
! 4420: }
! 4421: }
! 4422: }
! 4423: if ((cur != 0) && (!IS_CHAR(cur))) {
! 4424: /* Generate the error and skip the offending character */
! 4425: xmlFatalErrMsgInt(ctxt, XML_ERR_INVALID_CHAR,
! 4426: "PCDATA invalid Char value %d\n",
! 4427: cur);
! 4428: NEXTL(l);
! 4429: }
! 4430: }
! 4431:
! 4432: /**
! 4433: * xmlParseExternalID:
! 4434: * @ctxt: an XML parser context
! 4435: * @publicID: a xmlChar** receiving PubidLiteral
! 4436: * @strict: indicate whether we should restrict parsing to only
! 4437: * production [75], see NOTE below
! 4438: *
! 4439: * Parse an External ID or a Public ID
! 4440: *
! 4441: * NOTE: Productions [75] and [83] interact badly since [75] can generate
! 4442: * 'PUBLIC' S PubidLiteral S SystemLiteral
! 4443: *
! 4444: * [75] ExternalID ::= 'SYSTEM' S SystemLiteral
! 4445: * | 'PUBLIC' S PubidLiteral S SystemLiteral
! 4446: *
! 4447: * [83] PublicID ::= 'PUBLIC' S PubidLiteral
! 4448: *
! 4449: * Returns the function returns SystemLiteral and in the second
! 4450: * case publicID receives PubidLiteral, is strict is off
! 4451: * it is possible to return NULL and have publicID set.
! 4452: */
! 4453:
! 4454: xmlChar *
! 4455: xmlParseExternalID(xmlParserCtxtPtr ctxt, xmlChar **publicID, int strict) {
! 4456: xmlChar *URI = NULL;
! 4457:
! 4458: SHRINK;
! 4459:
! 4460: *publicID = NULL;
! 4461: if (CMP6(CUR_PTR, 'S', 'Y', 'S', 'T', 'E', 'M')) {
! 4462: SKIP(6);
! 4463: if (!IS_BLANK_CH(CUR)) {
! 4464: xmlFatalErrMsg(ctxt, XML_ERR_SPACE_REQUIRED,
! 4465: "Space required after 'SYSTEM'\n");
! 4466: }
! 4467: SKIP_BLANKS;
! 4468: URI = xmlParseSystemLiteral(ctxt);
! 4469: if (URI == NULL) {
! 4470: xmlFatalErr(ctxt, XML_ERR_URI_REQUIRED, NULL);
! 4471: }
! 4472: } else if (CMP6(CUR_PTR, 'P', 'U', 'B', 'L', 'I', 'C')) {
! 4473: SKIP(6);
! 4474: if (!IS_BLANK_CH(CUR)) {
! 4475: xmlFatalErrMsg(ctxt, XML_ERR_SPACE_REQUIRED,
! 4476: "Space required after 'PUBLIC'\n");
! 4477: }
! 4478: SKIP_BLANKS;
! 4479: *publicID = xmlParsePubidLiteral(ctxt);
! 4480: if (*publicID == NULL) {
! 4481: xmlFatalErr(ctxt, XML_ERR_PUBID_REQUIRED, NULL);
! 4482: }
! 4483: if (strict) {
! 4484: /*
! 4485: * We don't handle [83] so "S SystemLiteral" is required.
! 4486: */
! 4487: if (!IS_BLANK_CH(CUR)) {
! 4488: xmlFatalErrMsg(ctxt, XML_ERR_SPACE_REQUIRED,
! 4489: "Space required after the Public Identifier\n");
! 4490: }
! 4491: } else {
! 4492: /*
! 4493: * We handle [83] so we return immediately, if
! 4494: * "S SystemLiteral" is not detected. From a purely parsing
! 4495: * point of view that's a nice mess.
! 4496: */
! 4497: const xmlChar *ptr;
! 4498: GROW;
! 4499:
! 4500: ptr = CUR_PTR;
! 4501: if (!IS_BLANK_CH(*ptr)) return(NULL);
! 4502:
! 4503: while (IS_BLANK_CH(*ptr)) ptr++; /* TODO: dangerous, fix ! */
! 4504: if ((*ptr != '\'') && (*ptr != '"')) return(NULL);
! 4505: }
! 4506: SKIP_BLANKS;
! 4507: URI = xmlParseSystemLiteral(ctxt);
! 4508: if (URI == NULL) {
! 4509: xmlFatalErr(ctxt, XML_ERR_URI_REQUIRED, NULL);
! 4510: }
! 4511: }
! 4512: return(URI);
! 4513: }
! 4514:
! 4515: /**
! 4516: * xmlParseCommentComplex:
! 4517: * @ctxt: an XML parser context
! 4518: * @buf: the already parsed part of the buffer
! 4519: * @len: number of bytes filles in the buffer
! 4520: * @size: allocated size of the buffer
! 4521: *
! 4522: * Skip an XML (SGML) comment <!-- .... -->
! 4523: * The spec says that "For compatibility, the string "--" (double-hyphen)
! 4524: * must not occur within comments. "
! 4525: * This is the slow routine in case the accelerator for ascii didn't work
! 4526: *
! 4527: * [15] Comment ::= '<!--' ((Char - '-') | ('-' (Char - '-')))* '-->'
! 4528: */
! 4529: static void
! 4530: xmlParseCommentComplex(xmlParserCtxtPtr ctxt, xmlChar *buf, int len, int size) {
! 4531: int q, ql;
! 4532: int r, rl;
! 4533: int cur, l;
! 4534: int count = 0;
! 4535: int inputid;
! 4536:
! 4537: inputid = ctxt->input->id;
! 4538:
! 4539: if (buf == NULL) {
! 4540: len = 0;
! 4541: size = XML_PARSER_BUFFER_SIZE;
! 4542: buf = (xmlChar *) xmlMallocAtomic(size * sizeof(xmlChar));
! 4543: if (buf == NULL) {
! 4544: xmlErrMemory(ctxt, NULL);
! 4545: return;
! 4546: }
! 4547: }
! 4548: GROW; /* Assure there's enough input data */
! 4549: q = CUR_CHAR(ql);
! 4550: if (q == 0)
! 4551: goto not_terminated;
! 4552: if (!IS_CHAR(q)) {
! 4553: xmlFatalErrMsgInt(ctxt, XML_ERR_INVALID_CHAR,
! 4554: "xmlParseComment: invalid xmlChar value %d\n",
! 4555: q);
! 4556: xmlFree (buf);
! 4557: return;
! 4558: }
! 4559: NEXTL(ql);
! 4560: r = CUR_CHAR(rl);
! 4561: if (r == 0)
! 4562: goto not_terminated;
! 4563: if (!IS_CHAR(r)) {
! 4564: xmlFatalErrMsgInt(ctxt, XML_ERR_INVALID_CHAR,
! 4565: "xmlParseComment: invalid xmlChar value %d\n",
! 4566: q);
! 4567: xmlFree (buf);
! 4568: return;
! 4569: }
! 4570: NEXTL(rl);
! 4571: cur = CUR_CHAR(l);
! 4572: if (cur == 0)
! 4573: goto not_terminated;
! 4574: while (IS_CHAR(cur) && /* checked */
! 4575: ((cur != '>') ||
! 4576: (r != '-') || (q != '-'))) {
! 4577: if ((r == '-') && (q == '-')) {
! 4578: xmlFatalErr(ctxt, XML_ERR_HYPHEN_IN_COMMENT, NULL);
! 4579: }
! 4580: if (len + 5 >= size) {
! 4581: xmlChar *new_buf;
! 4582: size *= 2;
! 4583: new_buf = (xmlChar *) xmlRealloc(buf, size * sizeof(xmlChar));
! 4584: if (new_buf == NULL) {
! 4585: xmlFree (buf);
! 4586: xmlErrMemory(ctxt, NULL);
! 4587: return;
! 4588: }
! 4589: buf = new_buf;
! 4590: }
! 4591: COPY_BUF(ql,buf,len,q);
! 4592: q = r;
! 4593: ql = rl;
! 4594: r = cur;
! 4595: rl = l;
! 4596:
! 4597: count++;
! 4598: if (count > 50) {
! 4599: GROW;
! 4600: count = 0;
! 4601: }
! 4602: NEXTL(l);
! 4603: cur = CUR_CHAR(l);
! 4604: if (cur == 0) {
! 4605: SHRINK;
! 4606: GROW;
! 4607: cur = CUR_CHAR(l);
! 4608: }
! 4609: }
! 4610: buf[len] = 0;
! 4611: if (cur == 0) {
! 4612: xmlFatalErrMsgStr(ctxt, XML_ERR_COMMENT_NOT_FINISHED,
! 4613: "Comment not terminated \n<!--%.50s\n", buf);
! 4614: } else if (!IS_CHAR(cur)) {
! 4615: xmlFatalErrMsgInt(ctxt, XML_ERR_INVALID_CHAR,
! 4616: "xmlParseComment: invalid xmlChar value %d\n",
! 4617: cur);
! 4618: } else {
! 4619: if (inputid != ctxt->input->id) {
! 4620: xmlFatalErrMsg(ctxt, XML_ERR_ENTITY_BOUNDARY,
! 4621: "Comment doesn't start and stop in the same entity\n");
! 4622: }
! 4623: NEXT;
! 4624: if ((ctxt->sax != NULL) && (ctxt->sax->comment != NULL) &&
! 4625: (!ctxt->disableSAX))
! 4626: ctxt->sax->comment(ctxt->userData, buf);
! 4627: }
! 4628: xmlFree(buf);
! 4629: return;
! 4630: not_terminated:
! 4631: xmlFatalErrMsgStr(ctxt, XML_ERR_COMMENT_NOT_FINISHED,
! 4632: "Comment not terminated\n", NULL);
! 4633: xmlFree(buf);
! 4634: return;
! 4635: }
! 4636:
! 4637: /**
! 4638: * xmlParseComment:
! 4639: * @ctxt: an XML parser context
! 4640: *
! 4641: * Skip an XML (SGML) comment <!-- .... -->
! 4642: * The spec says that "For compatibility, the string "--" (double-hyphen)
! 4643: * must not occur within comments. "
! 4644: *
! 4645: * [15] Comment ::= '<!--' ((Char - '-') | ('-' (Char - '-')))* '-->'
! 4646: */
! 4647: void
! 4648: xmlParseComment(xmlParserCtxtPtr ctxt) {
! 4649: xmlChar *buf = NULL;
! 4650: int size = XML_PARSER_BUFFER_SIZE;
! 4651: int len = 0;
! 4652: xmlParserInputState state;
! 4653: const xmlChar *in;
! 4654: int nbchar = 0, ccol;
! 4655: int inputid;
! 4656:
! 4657: /*
! 4658: * Check that there is a comment right here.
! 4659: */
! 4660: if ((RAW != '<') || (NXT(1) != '!') ||
! 4661: (NXT(2) != '-') || (NXT(3) != '-')) return;
! 4662: state = ctxt->instate;
! 4663: ctxt->instate = XML_PARSER_COMMENT;
! 4664: inputid = ctxt->input->id;
! 4665: SKIP(4);
! 4666: SHRINK;
! 4667: GROW;
! 4668:
! 4669: /*
! 4670: * Accelerated common case where input don't need to be
! 4671: * modified before passing it to the handler.
! 4672: */
! 4673: in = ctxt->input->cur;
! 4674: do {
! 4675: if (*in == 0xA) {
! 4676: do {
! 4677: ctxt->input->line++; ctxt->input->col = 1;
! 4678: in++;
! 4679: } while (*in == 0xA);
! 4680: }
! 4681: get_more:
! 4682: ccol = ctxt->input->col;
! 4683: while (((*in > '-') && (*in <= 0x7F)) ||
! 4684: ((*in >= 0x20) && (*in < '-')) ||
! 4685: (*in == 0x09)) {
! 4686: in++;
! 4687: ccol++;
! 4688: }
! 4689: ctxt->input->col = ccol;
! 4690: if (*in == 0xA) {
! 4691: do {
! 4692: ctxt->input->line++; ctxt->input->col = 1;
! 4693: in++;
! 4694: } while (*in == 0xA);
! 4695: goto get_more;
! 4696: }
! 4697: nbchar = in - ctxt->input->cur;
! 4698: /*
! 4699: * save current set of data
! 4700: */
! 4701: if (nbchar > 0) {
! 4702: if ((ctxt->sax != NULL) &&
! 4703: (ctxt->sax->comment != NULL)) {
! 4704: if (buf == NULL) {
! 4705: if ((*in == '-') && (in[1] == '-'))
! 4706: size = nbchar + 1;
! 4707: else
! 4708: size = XML_PARSER_BUFFER_SIZE + nbchar;
! 4709: buf = (xmlChar *) xmlMallocAtomic(size * sizeof(xmlChar));
! 4710: if (buf == NULL) {
! 4711: xmlErrMemory(ctxt, NULL);
! 4712: ctxt->instate = state;
! 4713: return;
! 4714: }
! 4715: len = 0;
! 4716: } else if (len + nbchar + 1 >= size) {
! 4717: xmlChar *new_buf;
! 4718: size += len + nbchar + XML_PARSER_BUFFER_SIZE;
! 4719: new_buf = (xmlChar *) xmlRealloc(buf,
! 4720: size * sizeof(xmlChar));
! 4721: if (new_buf == NULL) {
! 4722: xmlFree (buf);
! 4723: xmlErrMemory(ctxt, NULL);
! 4724: ctxt->instate = state;
! 4725: return;
! 4726: }
! 4727: buf = new_buf;
! 4728: }
! 4729: memcpy(&buf[len], ctxt->input->cur, nbchar);
! 4730: len += nbchar;
! 4731: buf[len] = 0;
! 4732: }
! 4733: }
! 4734: ctxt->input->cur = in;
! 4735: if (*in == 0xA) {
! 4736: in++;
! 4737: ctxt->input->line++; ctxt->input->col = 1;
! 4738: }
! 4739: if (*in == 0xD) {
! 4740: in++;
! 4741: if (*in == 0xA) {
! 4742: ctxt->input->cur = in;
! 4743: in++;
! 4744: ctxt->input->line++; ctxt->input->col = 1;
! 4745: continue; /* while */
! 4746: }
! 4747: in--;
! 4748: }
! 4749: SHRINK;
! 4750: GROW;
! 4751: in = ctxt->input->cur;
! 4752: if (*in == '-') {
! 4753: if (in[1] == '-') {
! 4754: if (in[2] == '>') {
! 4755: if (ctxt->input->id != inputid) {
! 4756: xmlFatalErrMsg(ctxt, XML_ERR_ENTITY_BOUNDARY,
! 4757: "comment doesn't start and stop in the same entity\n");
! 4758: }
! 4759: SKIP(3);
! 4760: if ((ctxt->sax != NULL) && (ctxt->sax->comment != NULL) &&
! 4761: (!ctxt->disableSAX)) {
! 4762: if (buf != NULL)
! 4763: ctxt->sax->comment(ctxt->userData, buf);
! 4764: else
! 4765: ctxt->sax->comment(ctxt->userData, BAD_CAST "");
! 4766: }
! 4767: if (buf != NULL)
! 4768: xmlFree(buf);
! 4769: ctxt->instate = state;
! 4770: return;
! 4771: }
! 4772: if (buf != NULL)
! 4773: xmlFatalErrMsgStr(ctxt, XML_ERR_COMMENT_NOT_FINISHED,
! 4774: "Comment not terminated \n<!--%.50s\n",
! 4775: buf);
! 4776: else
! 4777: xmlFatalErrMsgStr(ctxt, XML_ERR_COMMENT_NOT_FINISHED,
! 4778: "Comment not terminated \n", NULL);
! 4779: in++;
! 4780: ctxt->input->col++;
! 4781: }
! 4782: in++;
! 4783: ctxt->input->col++;
! 4784: goto get_more;
! 4785: }
! 4786: } while (((*in >= 0x20) && (*in <= 0x7F)) || (*in == 0x09));
! 4787: xmlParseCommentComplex(ctxt, buf, len, size);
! 4788: ctxt->instate = state;
! 4789: return;
! 4790: }
! 4791:
! 4792:
! 4793: /**
! 4794: * xmlParsePITarget:
! 4795: * @ctxt: an XML parser context
! 4796: *
! 4797: * parse the name of a PI
! 4798: *
! 4799: * [17] PITarget ::= Name - (('X' | 'x') ('M' | 'm') ('L' | 'l'))
! 4800: *
! 4801: * Returns the PITarget name or NULL
! 4802: */
! 4803:
! 4804: const xmlChar *
! 4805: xmlParsePITarget(xmlParserCtxtPtr ctxt) {
! 4806: const xmlChar *name;
! 4807:
! 4808: name = xmlParseName(ctxt);
! 4809: if ((name != NULL) &&
! 4810: ((name[0] == 'x') || (name[0] == 'X')) &&
! 4811: ((name[1] == 'm') || (name[1] == 'M')) &&
! 4812: ((name[2] == 'l') || (name[2] == 'L'))) {
! 4813: int i;
! 4814: if ((name[0] == 'x') && (name[1] == 'm') &&
! 4815: (name[2] == 'l') && (name[3] == 0)) {
! 4816: xmlFatalErrMsg(ctxt, XML_ERR_RESERVED_XML_NAME,
! 4817: "XML declaration allowed only at the start of the document\n");
! 4818: return(name);
! 4819: } else if (name[3] == 0) {
! 4820: xmlFatalErr(ctxt, XML_ERR_RESERVED_XML_NAME, NULL);
! 4821: return(name);
! 4822: }
! 4823: for (i = 0;;i++) {
! 4824: if (xmlW3CPIs[i] == NULL) break;
! 4825: if (xmlStrEqual(name, (const xmlChar *)xmlW3CPIs[i]))
! 4826: return(name);
! 4827: }
! 4828: xmlWarningMsg(ctxt, XML_ERR_RESERVED_XML_NAME,
! 4829: "xmlParsePITarget: invalid name prefix 'xml'\n",
! 4830: NULL, NULL);
! 4831: }
! 4832: if ((name != NULL) && (xmlStrchr(name, ':') != NULL)) {
! 4833: xmlNsErr(ctxt, XML_NS_ERR_COLON,
! 4834: "colon are forbidden from PI names '%s'\n", name, NULL, NULL);
! 4835: }
! 4836: return(name);
! 4837: }
! 4838:
! 4839: #ifdef LIBXML_CATALOG_ENABLED
! 4840: /**
! 4841: * xmlParseCatalogPI:
! 4842: * @ctxt: an XML parser context
! 4843: * @catalog: the PI value string
! 4844: *
! 4845: * parse an XML Catalog Processing Instruction.
! 4846: *
! 4847: * <?oasis-xml-catalog catalog="http://example.com/catalog.xml"?>
! 4848: *
! 4849: * Occurs only if allowed by the user and if happening in the Misc
! 4850: * part of the document before any doctype informations
! 4851: * This will add the given catalog to the parsing context in order
! 4852: * to be used if there is a resolution need further down in the document
! 4853: */
! 4854:
! 4855: static void
! 4856: xmlParseCatalogPI(xmlParserCtxtPtr ctxt, const xmlChar *catalog) {
! 4857: xmlChar *URL = NULL;
! 4858: const xmlChar *tmp, *base;
! 4859: xmlChar marker;
! 4860:
! 4861: tmp = catalog;
! 4862: while (IS_BLANK_CH(*tmp)) tmp++;
! 4863: if (xmlStrncmp(tmp, BAD_CAST"catalog", 7))
! 4864: goto error;
! 4865: tmp += 7;
! 4866: while (IS_BLANK_CH(*tmp)) tmp++;
! 4867: if (*tmp != '=') {
! 4868: return;
! 4869: }
! 4870: tmp++;
! 4871: while (IS_BLANK_CH(*tmp)) tmp++;
! 4872: marker = *tmp;
! 4873: if ((marker != '\'') && (marker != '"'))
! 4874: goto error;
! 4875: tmp++;
! 4876: base = tmp;
! 4877: while ((*tmp != 0) && (*tmp != marker)) tmp++;
! 4878: if (*tmp == 0)
! 4879: goto error;
! 4880: URL = xmlStrndup(base, tmp - base);
! 4881: tmp++;
! 4882: while (IS_BLANK_CH(*tmp)) tmp++;
! 4883: if (*tmp != 0)
! 4884: goto error;
! 4885:
! 4886: if (URL != NULL) {
! 4887: ctxt->catalogs = xmlCatalogAddLocal(ctxt->catalogs, URL);
! 4888: xmlFree(URL);
! 4889: }
! 4890: return;
! 4891:
! 4892: error:
! 4893: xmlWarningMsg(ctxt, XML_WAR_CATALOG_PI,
! 4894: "Catalog PI syntax error: %s\n",
! 4895: catalog, NULL);
! 4896: if (URL != NULL)
! 4897: xmlFree(URL);
! 4898: }
! 4899: #endif
! 4900:
! 4901: /**
! 4902: * xmlParsePI:
! 4903: * @ctxt: an XML parser context
! 4904: *
! 4905: * parse an XML Processing Instruction.
! 4906: *
! 4907: * [16] PI ::= '<?' PITarget (S (Char* - (Char* '?>' Char*)))? '?>'
! 4908: *
! 4909: * The processing is transfered to SAX once parsed.
! 4910: */
! 4911:
! 4912: void
! 4913: xmlParsePI(xmlParserCtxtPtr ctxt) {
! 4914: xmlChar *buf = NULL;
! 4915: int len = 0;
! 4916: int size = XML_PARSER_BUFFER_SIZE;
! 4917: int cur, l;
! 4918: const xmlChar *target;
! 4919: xmlParserInputState state;
! 4920: int count = 0;
! 4921:
! 4922: if ((RAW == '<') && (NXT(1) == '?')) {
! 4923: xmlParserInputPtr input = ctxt->input;
! 4924: state = ctxt->instate;
! 4925: ctxt->instate = XML_PARSER_PI;
! 4926: /*
! 4927: * this is a Processing Instruction.
! 4928: */
! 4929: SKIP(2);
! 4930: SHRINK;
! 4931:
! 4932: /*
! 4933: * Parse the target name and check for special support like
! 4934: * namespace.
! 4935: */
! 4936: target = xmlParsePITarget(ctxt);
! 4937: if (target != NULL) {
! 4938: if ((RAW == '?') && (NXT(1) == '>')) {
! 4939: if (input != ctxt->input) {
! 4940: xmlFatalErrMsg(ctxt, XML_ERR_ENTITY_BOUNDARY,
! 4941: "PI declaration doesn't start and stop in the same entity\n");
! 4942: }
! 4943: SKIP(2);
! 4944:
! 4945: /*
! 4946: * SAX: PI detected.
! 4947: */
! 4948: if ((ctxt->sax) && (!ctxt->disableSAX) &&
! 4949: (ctxt->sax->processingInstruction != NULL))
! 4950: ctxt->sax->processingInstruction(ctxt->userData,
! 4951: target, NULL);
! 4952: ctxt->instate = state;
! 4953: return;
! 4954: }
! 4955: buf = (xmlChar *) xmlMallocAtomic(size * sizeof(xmlChar));
! 4956: if (buf == NULL) {
! 4957: xmlErrMemory(ctxt, NULL);
! 4958: ctxt->instate = state;
! 4959: return;
! 4960: }
! 4961: cur = CUR;
! 4962: if (!IS_BLANK(cur)) {
! 4963: xmlFatalErrMsgStr(ctxt, XML_ERR_SPACE_REQUIRED,
! 4964: "ParsePI: PI %s space expected\n", target);
! 4965: }
! 4966: SKIP_BLANKS;
! 4967: cur = CUR_CHAR(l);
! 4968: while (IS_CHAR(cur) && /* checked */
! 4969: ((cur != '?') || (NXT(1) != '>'))) {
! 4970: if (len + 5 >= size) {
! 4971: xmlChar *tmp;
! 4972:
! 4973: size *= 2;
! 4974: tmp = (xmlChar *) xmlRealloc(buf, size * sizeof(xmlChar));
! 4975: if (tmp == NULL) {
! 4976: xmlErrMemory(ctxt, NULL);
! 4977: xmlFree(buf);
! 4978: ctxt->instate = state;
! 4979: return;
! 4980: }
! 4981: buf = tmp;
! 4982: }
! 4983: count++;
! 4984: if (count > 50) {
! 4985: GROW;
! 4986: count = 0;
! 4987: }
! 4988: COPY_BUF(l,buf,len,cur);
! 4989: NEXTL(l);
! 4990: cur = CUR_CHAR(l);
! 4991: if (cur == 0) {
! 4992: SHRINK;
! 4993: GROW;
! 4994: cur = CUR_CHAR(l);
! 4995: }
! 4996: }
! 4997: buf[len] = 0;
! 4998: if (cur != '?') {
! 4999: xmlFatalErrMsgStr(ctxt, XML_ERR_PI_NOT_FINISHED,
! 5000: "ParsePI: PI %s never end ...\n", target);
! 5001: } else {
! 5002: if (input != ctxt->input) {
! 5003: xmlFatalErrMsg(ctxt, XML_ERR_SPACE_REQUIRED,
! 5004: "PI declaration doesn't start and stop in the same entity\n");
! 5005: }
! 5006: SKIP(2);
! 5007:
! 5008: #ifdef LIBXML_CATALOG_ENABLED
! 5009: if (((state == XML_PARSER_MISC) ||
! 5010: (state == XML_PARSER_START)) &&
! 5011: (xmlStrEqual(target, XML_CATALOG_PI))) {
! 5012: xmlCatalogAllow allow = xmlCatalogGetDefaults();
! 5013: if ((allow == XML_CATA_ALLOW_DOCUMENT) ||
! 5014: (allow == XML_CATA_ALLOW_ALL))
! 5015: xmlParseCatalogPI(ctxt, buf);
! 5016: }
! 5017: #endif
! 5018:
! 5019:
! 5020: /*
! 5021: * SAX: PI detected.
! 5022: */
! 5023: if ((ctxt->sax) && (!ctxt->disableSAX) &&
! 5024: (ctxt->sax->processingInstruction != NULL))
! 5025: ctxt->sax->processingInstruction(ctxt->userData,
! 5026: target, buf);
! 5027: }
! 5028: xmlFree(buf);
! 5029: } else {
! 5030: xmlFatalErr(ctxt, XML_ERR_PI_NOT_STARTED, NULL);
! 5031: }
! 5032: ctxt->instate = state;
! 5033: }
! 5034: }
! 5035:
! 5036: /**
! 5037: * xmlParseNotationDecl:
! 5038: * @ctxt: an XML parser context
! 5039: *
! 5040: * parse a notation declaration
! 5041: *
! 5042: * [82] NotationDecl ::= '<!NOTATION' S Name S (ExternalID | PublicID) S? '>'
! 5043: *
! 5044: * Hence there is actually 3 choices:
! 5045: * 'PUBLIC' S PubidLiteral
! 5046: * 'PUBLIC' S PubidLiteral S SystemLiteral
! 5047: * and 'SYSTEM' S SystemLiteral
! 5048: *
! 5049: * See the NOTE on xmlParseExternalID().
! 5050: */
! 5051:
! 5052: void
! 5053: xmlParseNotationDecl(xmlParserCtxtPtr ctxt) {
! 5054: const xmlChar *name;
! 5055: xmlChar *Pubid;
! 5056: xmlChar *Systemid;
! 5057:
! 5058: if (CMP10(CUR_PTR, '<', '!', 'N', 'O', 'T', 'A', 'T', 'I', 'O', 'N')) {
! 5059: xmlParserInputPtr input = ctxt->input;
! 5060: SHRINK;
! 5061: SKIP(10);
! 5062: if (!IS_BLANK_CH(CUR)) {
! 5063: xmlFatalErrMsg(ctxt, XML_ERR_SPACE_REQUIRED,
! 5064: "Space required after '<!NOTATION'\n");
! 5065: return;
! 5066: }
! 5067: SKIP_BLANKS;
! 5068:
! 5069: name = xmlParseName(ctxt);
! 5070: if (name == NULL) {
! 5071: xmlFatalErr(ctxt, XML_ERR_NOTATION_NOT_STARTED, NULL);
! 5072: return;
! 5073: }
! 5074: if (!IS_BLANK_CH(CUR)) {
! 5075: xmlFatalErrMsg(ctxt, XML_ERR_SPACE_REQUIRED,
! 5076: "Space required after the NOTATION name'\n");
! 5077: return;
! 5078: }
! 5079: if (xmlStrchr(name, ':') != NULL) {
! 5080: xmlNsErr(ctxt, XML_NS_ERR_COLON,
! 5081: "colon are forbidden from notation names '%s'\n",
! 5082: name, NULL, NULL);
! 5083: }
! 5084: SKIP_BLANKS;
! 5085:
! 5086: /*
! 5087: * Parse the IDs.
! 5088: */
! 5089: Systemid = xmlParseExternalID(ctxt, &Pubid, 0);
! 5090: SKIP_BLANKS;
! 5091:
! 5092: if (RAW == '>') {
! 5093: if (input != ctxt->input) {
! 5094: xmlFatalErrMsg(ctxt, XML_ERR_SPACE_REQUIRED,
! 5095: "Notation declaration doesn't start and stop in the same entity\n");
! 5096: }
! 5097: NEXT;
! 5098: if ((ctxt->sax != NULL) && (!ctxt->disableSAX) &&
! 5099: (ctxt->sax->notationDecl != NULL))
! 5100: ctxt->sax->notationDecl(ctxt->userData, name, Pubid, Systemid);
! 5101: } else {
! 5102: xmlFatalErr(ctxt, XML_ERR_NOTATION_NOT_FINISHED, NULL);
! 5103: }
! 5104: if (Systemid != NULL) xmlFree(Systemid);
! 5105: if (Pubid != NULL) xmlFree(Pubid);
! 5106: }
! 5107: }
! 5108:
! 5109: /**
! 5110: * xmlParseEntityDecl:
! 5111: * @ctxt: an XML parser context
! 5112: *
! 5113: * parse <!ENTITY declarations
! 5114: *
! 5115: * [70] EntityDecl ::= GEDecl | PEDecl
! 5116: *
! 5117: * [71] GEDecl ::= '<!ENTITY' S Name S EntityDef S? '>'
! 5118: *
! 5119: * [72] PEDecl ::= '<!ENTITY' S '%' S Name S PEDef S? '>'
! 5120: *
! 5121: * [73] EntityDef ::= EntityValue | (ExternalID NDataDecl?)
! 5122: *
! 5123: * [74] PEDef ::= EntityValue | ExternalID
! 5124: *
! 5125: * [76] NDataDecl ::= S 'NDATA' S Name
! 5126: *
! 5127: * [ VC: Notation Declared ]
! 5128: * The Name must match the declared name of a notation.
! 5129: */
! 5130:
! 5131: void
! 5132: xmlParseEntityDecl(xmlParserCtxtPtr ctxt) {
! 5133: const xmlChar *name = NULL;
! 5134: xmlChar *value = NULL;
! 5135: xmlChar *URI = NULL, *literal = NULL;
! 5136: const xmlChar *ndata = NULL;
! 5137: int isParameter = 0;
! 5138: xmlChar *orig = NULL;
! 5139: int skipped;
! 5140:
! 5141: /* GROW; done in the caller */
! 5142: if (CMP8(CUR_PTR, '<', '!', 'E', 'N', 'T', 'I', 'T', 'Y')) {
! 5143: xmlParserInputPtr input = ctxt->input;
! 5144: SHRINK;
! 5145: SKIP(8);
! 5146: skipped = SKIP_BLANKS;
! 5147: if (skipped == 0) {
! 5148: xmlFatalErrMsg(ctxt, XML_ERR_SPACE_REQUIRED,
! 5149: "Space required after '<!ENTITY'\n");
! 5150: }
! 5151:
! 5152: if (RAW == '%') {
! 5153: NEXT;
! 5154: skipped = SKIP_BLANKS;
! 5155: if (skipped == 0) {
! 5156: xmlFatalErrMsg(ctxt, XML_ERR_SPACE_REQUIRED,
! 5157: "Space required after '%'\n");
! 5158: }
! 5159: isParameter = 1;
! 5160: }
! 5161:
! 5162: name = xmlParseName(ctxt);
! 5163: if (name == NULL) {
! 5164: xmlFatalErrMsg(ctxt, XML_ERR_NAME_REQUIRED,
! 5165: "xmlParseEntityDecl: no name\n");
! 5166: return;
! 5167: }
! 5168: if (xmlStrchr(name, ':') != NULL) {
! 5169: xmlNsErr(ctxt, XML_NS_ERR_COLON,
! 5170: "colon are forbidden from entities names '%s'\n",
! 5171: name, NULL, NULL);
! 5172: }
! 5173: skipped = SKIP_BLANKS;
! 5174: if (skipped == 0) {
! 5175: xmlFatalErrMsg(ctxt, XML_ERR_SPACE_REQUIRED,
! 5176: "Space required after the entity name\n");
! 5177: }
! 5178:
! 5179: ctxt->instate = XML_PARSER_ENTITY_DECL;
! 5180: /*
! 5181: * handle the various case of definitions...
! 5182: */
! 5183: if (isParameter) {
! 5184: if ((RAW == '"') || (RAW == '\'')) {
! 5185: value = xmlParseEntityValue(ctxt, &orig);
! 5186: if (value) {
! 5187: if ((ctxt->sax != NULL) &&
! 5188: (!ctxt->disableSAX) && (ctxt->sax->entityDecl != NULL))
! 5189: ctxt->sax->entityDecl(ctxt->userData, name,
! 5190: XML_INTERNAL_PARAMETER_ENTITY,
! 5191: NULL, NULL, value);
! 5192: }
! 5193: } else {
! 5194: URI = xmlParseExternalID(ctxt, &literal, 1);
! 5195: if ((URI == NULL) && (literal == NULL)) {
! 5196: xmlFatalErr(ctxt, XML_ERR_VALUE_REQUIRED, NULL);
! 5197: }
! 5198: if (URI) {
! 5199: xmlURIPtr uri;
! 5200:
! 5201: uri = xmlParseURI((const char *) URI);
! 5202: if (uri == NULL) {
! 5203: xmlErrMsgStr(ctxt, XML_ERR_INVALID_URI,
! 5204: "Invalid URI: %s\n", URI);
! 5205: /*
! 5206: * This really ought to be a well formedness error
! 5207: * but the XML Core WG decided otherwise c.f. issue
! 5208: * E26 of the XML erratas.
! 5209: */
! 5210: } else {
! 5211: if (uri->fragment != NULL) {
! 5212: /*
! 5213: * Okay this is foolish to block those but not
! 5214: * invalid URIs.
! 5215: */
! 5216: xmlFatalErr(ctxt, XML_ERR_URI_FRAGMENT, NULL);
! 5217: } else {
! 5218: if ((ctxt->sax != NULL) &&
! 5219: (!ctxt->disableSAX) &&
! 5220: (ctxt->sax->entityDecl != NULL))
! 5221: ctxt->sax->entityDecl(ctxt->userData, name,
! 5222: XML_EXTERNAL_PARAMETER_ENTITY,
! 5223: literal, URI, NULL);
! 5224: }
! 5225: xmlFreeURI(uri);
! 5226: }
! 5227: }
! 5228: }
! 5229: } else {
! 5230: if ((RAW == '"') || (RAW == '\'')) {
! 5231: value = xmlParseEntityValue(ctxt, &orig);
! 5232: if ((ctxt->sax != NULL) &&
! 5233: (!ctxt->disableSAX) && (ctxt->sax->entityDecl != NULL))
! 5234: ctxt->sax->entityDecl(ctxt->userData, name,
! 5235: XML_INTERNAL_GENERAL_ENTITY,
! 5236: NULL, NULL, value);
! 5237: /*
! 5238: * For expat compatibility in SAX mode.
! 5239: */
! 5240: if ((ctxt->myDoc == NULL) ||
! 5241: (xmlStrEqual(ctxt->myDoc->version, SAX_COMPAT_MODE))) {
! 5242: if (ctxt->myDoc == NULL) {
! 5243: ctxt->myDoc = xmlNewDoc(SAX_COMPAT_MODE);
! 5244: if (ctxt->myDoc == NULL) {
! 5245: xmlErrMemory(ctxt, "New Doc failed");
! 5246: return;
! 5247: }
! 5248: ctxt->myDoc->properties = XML_DOC_INTERNAL;
! 5249: }
! 5250: if (ctxt->myDoc->intSubset == NULL)
! 5251: ctxt->myDoc->intSubset = xmlNewDtd(ctxt->myDoc,
! 5252: BAD_CAST "fake", NULL, NULL);
! 5253:
! 5254: xmlSAX2EntityDecl(ctxt, name, XML_INTERNAL_GENERAL_ENTITY,
! 5255: NULL, NULL, value);
! 5256: }
! 5257: } else {
! 5258: URI = xmlParseExternalID(ctxt, &literal, 1);
! 5259: if ((URI == NULL) && (literal == NULL)) {
! 5260: xmlFatalErr(ctxt, XML_ERR_VALUE_REQUIRED, NULL);
! 5261: }
! 5262: if (URI) {
! 5263: xmlURIPtr uri;
! 5264:
! 5265: uri = xmlParseURI((const char *)URI);
! 5266: if (uri == NULL) {
! 5267: xmlErrMsgStr(ctxt, XML_ERR_INVALID_URI,
! 5268: "Invalid URI: %s\n", URI);
! 5269: /*
! 5270: * This really ought to be a well formedness error
! 5271: * but the XML Core WG decided otherwise c.f. issue
! 5272: * E26 of the XML erratas.
! 5273: */
! 5274: } else {
! 5275: if (uri->fragment != NULL) {
! 5276: /*
! 5277: * Okay this is foolish to block those but not
! 5278: * invalid URIs.
! 5279: */
! 5280: xmlFatalErr(ctxt, XML_ERR_URI_FRAGMENT, NULL);
! 5281: }
! 5282: xmlFreeURI(uri);
! 5283: }
! 5284: }
! 5285: if ((RAW != '>') && (!IS_BLANK_CH(CUR))) {
! 5286: xmlFatalErrMsg(ctxt, XML_ERR_SPACE_REQUIRED,
! 5287: "Space required before 'NDATA'\n");
! 5288: }
! 5289: SKIP_BLANKS;
! 5290: if (CMP5(CUR_PTR, 'N', 'D', 'A', 'T', 'A')) {
! 5291: SKIP(5);
! 5292: if (!IS_BLANK_CH(CUR)) {
! 5293: xmlFatalErrMsg(ctxt, XML_ERR_SPACE_REQUIRED,
! 5294: "Space required after 'NDATA'\n");
! 5295: }
! 5296: SKIP_BLANKS;
! 5297: ndata = xmlParseName(ctxt);
! 5298: if ((ctxt->sax != NULL) && (!ctxt->disableSAX) &&
! 5299: (ctxt->sax->unparsedEntityDecl != NULL))
! 5300: ctxt->sax->unparsedEntityDecl(ctxt->userData, name,
! 5301: literal, URI, ndata);
! 5302: } else {
! 5303: if ((ctxt->sax != NULL) &&
! 5304: (!ctxt->disableSAX) && (ctxt->sax->entityDecl != NULL))
! 5305: ctxt->sax->entityDecl(ctxt->userData, name,
! 5306: XML_EXTERNAL_GENERAL_PARSED_ENTITY,
! 5307: literal, URI, NULL);
! 5308: /*
! 5309: * For expat compatibility in SAX mode.
! 5310: * assuming the entity repalcement was asked for
! 5311: */
! 5312: if ((ctxt->replaceEntities != 0) &&
! 5313: ((ctxt->myDoc == NULL) ||
! 5314: (xmlStrEqual(ctxt->myDoc->version, SAX_COMPAT_MODE)))) {
! 5315: if (ctxt->myDoc == NULL) {
! 5316: ctxt->myDoc = xmlNewDoc(SAX_COMPAT_MODE);
! 5317: if (ctxt->myDoc == NULL) {
! 5318: xmlErrMemory(ctxt, "New Doc failed");
! 5319: return;
! 5320: }
! 5321: ctxt->myDoc->properties = XML_DOC_INTERNAL;
! 5322: }
! 5323:
! 5324: if (ctxt->myDoc->intSubset == NULL)
! 5325: ctxt->myDoc->intSubset = xmlNewDtd(ctxt->myDoc,
! 5326: BAD_CAST "fake", NULL, NULL);
! 5327: xmlSAX2EntityDecl(ctxt, name,
! 5328: XML_EXTERNAL_GENERAL_PARSED_ENTITY,
! 5329: literal, URI, NULL);
! 5330: }
! 5331: }
! 5332: }
! 5333: }
! 5334: SKIP_BLANKS;
! 5335: if (RAW != '>') {
! 5336: xmlFatalErrMsgStr(ctxt, XML_ERR_ENTITY_NOT_FINISHED,
! 5337: "xmlParseEntityDecl: entity %s not terminated\n", name);
! 5338: } else {
! 5339: if (input != ctxt->input) {
! 5340: xmlFatalErrMsg(ctxt, XML_ERR_ENTITY_BOUNDARY,
! 5341: "Entity declaration doesn't start and stop in the same entity\n");
! 5342: }
! 5343: NEXT;
! 5344: }
! 5345: if (orig != NULL) {
! 5346: /*
! 5347: * Ugly mechanism to save the raw entity value.
! 5348: */
! 5349: xmlEntityPtr cur = NULL;
! 5350:
! 5351: if (isParameter) {
! 5352: if ((ctxt->sax != NULL) &&
! 5353: (ctxt->sax->getParameterEntity != NULL))
! 5354: cur = ctxt->sax->getParameterEntity(ctxt->userData, name);
! 5355: } else {
! 5356: if ((ctxt->sax != NULL) &&
! 5357: (ctxt->sax->getEntity != NULL))
! 5358: cur = ctxt->sax->getEntity(ctxt->userData, name);
! 5359: if ((cur == NULL) && (ctxt->userData==ctxt)) {
! 5360: cur = xmlSAX2GetEntity(ctxt, name);
! 5361: }
! 5362: }
! 5363: if (cur != NULL) {
! 5364: if (cur->orig != NULL)
! 5365: xmlFree(orig);
! 5366: else
! 5367: cur->orig = orig;
! 5368: } else
! 5369: xmlFree(orig);
! 5370: }
! 5371: if (value != NULL) xmlFree(value);
! 5372: if (URI != NULL) xmlFree(URI);
! 5373: if (literal != NULL) xmlFree(literal);
! 5374: }
! 5375: }
! 5376:
! 5377: /**
! 5378: * xmlParseDefaultDecl:
! 5379: * @ctxt: an XML parser context
! 5380: * @value: Receive a possible fixed default value for the attribute
! 5381: *
! 5382: * Parse an attribute default declaration
! 5383: *
! 5384: * [60] DefaultDecl ::= '#REQUIRED' | '#IMPLIED' | (('#FIXED' S)? AttValue)
! 5385: *
! 5386: * [ VC: Required Attribute ]
! 5387: * if the default declaration is the keyword #REQUIRED, then the
! 5388: * attribute must be specified for all elements of the type in the
! 5389: * attribute-list declaration.
! 5390: *
! 5391: * [ VC: Attribute Default Legal ]
! 5392: * The declared default value must meet the lexical constraints of
! 5393: * the declared attribute type c.f. xmlValidateAttributeDecl()
! 5394: *
! 5395: * [ VC: Fixed Attribute Default ]
! 5396: * if an attribute has a default value declared with the #FIXED
! 5397: * keyword, instances of that attribute must match the default value.
! 5398: *
! 5399: * [ WFC: No < in Attribute Values ]
! 5400: * handled in xmlParseAttValue()
! 5401: *
! 5402: * returns: XML_ATTRIBUTE_NONE, XML_ATTRIBUTE_REQUIRED, XML_ATTRIBUTE_IMPLIED
! 5403: * or XML_ATTRIBUTE_FIXED.
! 5404: */
! 5405:
! 5406: int
! 5407: xmlParseDefaultDecl(xmlParserCtxtPtr ctxt, xmlChar **value) {
! 5408: int val;
! 5409: xmlChar *ret;
! 5410:
! 5411: *value = NULL;
! 5412: if (CMP9(CUR_PTR, '#', 'R', 'E', 'Q', 'U', 'I', 'R', 'E', 'D')) {
! 5413: SKIP(9);
! 5414: return(XML_ATTRIBUTE_REQUIRED);
! 5415: }
! 5416: if (CMP8(CUR_PTR, '#', 'I', 'M', 'P', 'L', 'I', 'E', 'D')) {
! 5417: SKIP(8);
! 5418: return(XML_ATTRIBUTE_IMPLIED);
! 5419: }
! 5420: val = XML_ATTRIBUTE_NONE;
! 5421: if (CMP6(CUR_PTR, '#', 'F', 'I', 'X', 'E', 'D')) {
! 5422: SKIP(6);
! 5423: val = XML_ATTRIBUTE_FIXED;
! 5424: if (!IS_BLANK_CH(CUR)) {
! 5425: xmlFatalErrMsg(ctxt, XML_ERR_SPACE_REQUIRED,
! 5426: "Space required after '#FIXED'\n");
! 5427: }
! 5428: SKIP_BLANKS;
! 5429: }
! 5430: ret = xmlParseAttValue(ctxt);
! 5431: ctxt->instate = XML_PARSER_DTD;
! 5432: if (ret == NULL) {
! 5433: xmlFatalErrMsg(ctxt, (xmlParserErrors)ctxt->errNo,
! 5434: "Attribute default value declaration error\n");
! 5435: } else
! 5436: *value = ret;
! 5437: return(val);
! 5438: }
! 5439:
! 5440: /**
! 5441: * xmlParseNotationType:
! 5442: * @ctxt: an XML parser context
! 5443: *
! 5444: * parse an Notation attribute type.
! 5445: *
! 5446: * Note: the leading 'NOTATION' S part has already being parsed...
! 5447: *
! 5448: * [58] NotationType ::= 'NOTATION' S '(' S? Name (S? '|' S? Name)* S? ')'
! 5449: *
! 5450: * [ VC: Notation Attributes ]
! 5451: * Values of this type must match one of the notation names included
! 5452: * in the declaration; all notation names in the declaration must be declared.
! 5453: *
! 5454: * Returns: the notation attribute tree built while parsing
! 5455: */
! 5456:
! 5457: xmlEnumerationPtr
! 5458: xmlParseNotationType(xmlParserCtxtPtr ctxt) {
! 5459: const xmlChar *name;
! 5460: xmlEnumerationPtr ret = NULL, last = NULL, cur, tmp;
! 5461:
! 5462: if (RAW != '(') {
! 5463: xmlFatalErr(ctxt, XML_ERR_NOTATION_NOT_STARTED, NULL);
! 5464: return(NULL);
! 5465: }
! 5466: SHRINK;
! 5467: do {
! 5468: NEXT;
! 5469: SKIP_BLANKS;
! 5470: name = xmlParseName(ctxt);
! 5471: if (name == NULL) {
! 5472: xmlFatalErrMsg(ctxt, XML_ERR_NAME_REQUIRED,
! 5473: "Name expected in NOTATION declaration\n");
! 5474: xmlFreeEnumeration(ret);
! 5475: return(NULL);
! 5476: }
! 5477: tmp = ret;
! 5478: while (tmp != NULL) {
! 5479: if (xmlStrEqual(name, tmp->name)) {
! 5480: xmlValidityError(ctxt, XML_DTD_DUP_TOKEN,
! 5481: "standalone: attribute notation value token %s duplicated\n",
! 5482: name, NULL);
! 5483: if (!xmlDictOwns(ctxt->dict, name))
! 5484: xmlFree((xmlChar *) name);
! 5485: break;
! 5486: }
! 5487: tmp = tmp->next;
! 5488: }
! 5489: if (tmp == NULL) {
! 5490: cur = xmlCreateEnumeration(name);
! 5491: if (cur == NULL) {
! 5492: xmlFreeEnumeration(ret);
! 5493: return(NULL);
! 5494: }
! 5495: if (last == NULL) ret = last = cur;
! 5496: else {
! 5497: last->next = cur;
! 5498: last = cur;
! 5499: }
! 5500: }
! 5501: SKIP_BLANKS;
! 5502: } while (RAW == '|');
! 5503: if (RAW != ')') {
! 5504: xmlFatalErr(ctxt, XML_ERR_NOTATION_NOT_FINISHED, NULL);
! 5505: xmlFreeEnumeration(ret);
! 5506: return(NULL);
! 5507: }
! 5508: NEXT;
! 5509: return(ret);
! 5510: }
! 5511:
! 5512: /**
! 5513: * xmlParseEnumerationType:
! 5514: * @ctxt: an XML parser context
! 5515: *
! 5516: * parse an Enumeration attribute type.
! 5517: *
! 5518: * [59] Enumeration ::= '(' S? Nmtoken (S? '|' S? Nmtoken)* S? ')'
! 5519: *
! 5520: * [ VC: Enumeration ]
! 5521: * Values of this type must match one of the Nmtoken tokens in
! 5522: * the declaration
! 5523: *
! 5524: * Returns: the enumeration attribute tree built while parsing
! 5525: */
! 5526:
! 5527: xmlEnumerationPtr
! 5528: xmlParseEnumerationType(xmlParserCtxtPtr ctxt) {
! 5529: xmlChar *name;
! 5530: xmlEnumerationPtr ret = NULL, last = NULL, cur, tmp;
! 5531:
! 5532: if (RAW != '(') {
! 5533: xmlFatalErr(ctxt, XML_ERR_ATTLIST_NOT_STARTED, NULL);
! 5534: return(NULL);
! 5535: }
! 5536: SHRINK;
! 5537: do {
! 5538: NEXT;
! 5539: SKIP_BLANKS;
! 5540: name = xmlParseNmtoken(ctxt);
! 5541: if (name == NULL) {
! 5542: xmlFatalErr(ctxt, XML_ERR_NMTOKEN_REQUIRED, NULL);
! 5543: return(ret);
! 5544: }
! 5545: tmp = ret;
! 5546: while (tmp != NULL) {
! 5547: if (xmlStrEqual(name, tmp->name)) {
! 5548: xmlValidityError(ctxt, XML_DTD_DUP_TOKEN,
! 5549: "standalone: attribute enumeration value token %s duplicated\n",
! 5550: name, NULL);
! 5551: if (!xmlDictOwns(ctxt->dict, name))
! 5552: xmlFree(name);
! 5553: break;
! 5554: }
! 5555: tmp = tmp->next;
! 5556: }
! 5557: if (tmp == NULL) {
! 5558: cur = xmlCreateEnumeration(name);
! 5559: if (!xmlDictOwns(ctxt->dict, name))
! 5560: xmlFree(name);
! 5561: if (cur == NULL) {
! 5562: xmlFreeEnumeration(ret);
! 5563: return(NULL);
! 5564: }
! 5565: if (last == NULL) ret = last = cur;
! 5566: else {
! 5567: last->next = cur;
! 5568: last = cur;
! 5569: }
! 5570: }
! 5571: SKIP_BLANKS;
! 5572: } while (RAW == '|');
! 5573: if (RAW != ')') {
! 5574: xmlFatalErr(ctxt, XML_ERR_ATTLIST_NOT_FINISHED, NULL);
! 5575: return(ret);
! 5576: }
! 5577: NEXT;
! 5578: return(ret);
! 5579: }
! 5580:
! 5581: /**
! 5582: * xmlParseEnumeratedType:
! 5583: * @ctxt: an XML parser context
! 5584: * @tree: the enumeration tree built while parsing
! 5585: *
! 5586: * parse an Enumerated attribute type.
! 5587: *
! 5588: * [57] EnumeratedType ::= NotationType | Enumeration
! 5589: *
! 5590: * [58] NotationType ::= 'NOTATION' S '(' S? Name (S? '|' S? Name)* S? ')'
! 5591: *
! 5592: *
! 5593: * Returns: XML_ATTRIBUTE_ENUMERATION or XML_ATTRIBUTE_NOTATION
! 5594: */
! 5595:
! 5596: int
! 5597: xmlParseEnumeratedType(xmlParserCtxtPtr ctxt, xmlEnumerationPtr *tree) {
! 5598: if (CMP8(CUR_PTR, 'N', 'O', 'T', 'A', 'T', 'I', 'O', 'N')) {
! 5599: SKIP(8);
! 5600: if (!IS_BLANK_CH(CUR)) {
! 5601: xmlFatalErrMsg(ctxt, XML_ERR_SPACE_REQUIRED,
! 5602: "Space required after 'NOTATION'\n");
! 5603: return(0);
! 5604: }
! 5605: SKIP_BLANKS;
! 5606: *tree = xmlParseNotationType(ctxt);
! 5607: if (*tree == NULL) return(0);
! 5608: return(XML_ATTRIBUTE_NOTATION);
! 5609: }
! 5610: *tree = xmlParseEnumerationType(ctxt);
! 5611: if (*tree == NULL) return(0);
! 5612: return(XML_ATTRIBUTE_ENUMERATION);
! 5613: }
! 5614:
! 5615: /**
! 5616: * xmlParseAttributeType:
! 5617: * @ctxt: an XML parser context
! 5618: * @tree: the enumeration tree built while parsing
! 5619: *
! 5620: * parse the Attribute list def for an element
! 5621: *
! 5622: * [54] AttType ::= StringType | TokenizedType | EnumeratedType
! 5623: *
! 5624: * [55] StringType ::= 'CDATA'
! 5625: *
! 5626: * [56] TokenizedType ::= 'ID' | 'IDREF' | 'IDREFS' | 'ENTITY' |
! 5627: * 'ENTITIES' | 'NMTOKEN' | 'NMTOKENS'
! 5628: *
! 5629: * Validity constraints for attribute values syntax are checked in
! 5630: * xmlValidateAttributeValue()
! 5631: *
! 5632: * [ VC: ID ]
! 5633: * Values of type ID must match the Name production. A name must not
! 5634: * appear more than once in an XML document as a value of this type;
! 5635: * i.e., ID values must uniquely identify the elements which bear them.
! 5636: *
! 5637: * [ VC: One ID per Element Type ]
! 5638: * No element type may have more than one ID attribute specified.
! 5639: *
! 5640: * [ VC: ID Attribute Default ]
! 5641: * An ID attribute must have a declared default of #IMPLIED or #REQUIRED.
! 5642: *
! 5643: * [ VC: IDREF ]
! 5644: * Values of type IDREF must match the Name production, and values
! 5645: * of type IDREFS must match Names; each IDREF Name must match the value
! 5646: * of an ID attribute on some element in the XML document; i.e. IDREF
! 5647: * values must match the value of some ID attribute.
! 5648: *
! 5649: * [ VC: Entity Name ]
! 5650: * Values of type ENTITY must match the Name production, values
! 5651: * of type ENTITIES must match Names; each Entity Name must match the
! 5652: * name of an unparsed entity declared in the DTD.
! 5653: *
! 5654: * [ VC: Name Token ]
! 5655: * Values of type NMTOKEN must match the Nmtoken production; values
! 5656: * of type NMTOKENS must match Nmtokens.
! 5657: *
! 5658: * Returns the attribute type
! 5659: */
! 5660: int
! 5661: xmlParseAttributeType(xmlParserCtxtPtr ctxt, xmlEnumerationPtr *tree) {
! 5662: SHRINK;
! 5663: if (CMP5(CUR_PTR, 'C', 'D', 'A', 'T', 'A')) {
! 5664: SKIP(5);
! 5665: return(XML_ATTRIBUTE_CDATA);
! 5666: } else if (CMP6(CUR_PTR, 'I', 'D', 'R', 'E', 'F', 'S')) {
! 5667: SKIP(6);
! 5668: return(XML_ATTRIBUTE_IDREFS);
! 5669: } else if (CMP5(CUR_PTR, 'I', 'D', 'R', 'E', 'F')) {
! 5670: SKIP(5);
! 5671: return(XML_ATTRIBUTE_IDREF);
! 5672: } else if ((RAW == 'I') && (NXT(1) == 'D')) {
! 5673: SKIP(2);
! 5674: return(XML_ATTRIBUTE_ID);
! 5675: } else if (CMP6(CUR_PTR, 'E', 'N', 'T', 'I', 'T', 'Y')) {
! 5676: SKIP(6);
! 5677: return(XML_ATTRIBUTE_ENTITY);
! 5678: } else if (CMP8(CUR_PTR, 'E', 'N', 'T', 'I', 'T', 'I', 'E', 'S')) {
! 5679: SKIP(8);
! 5680: return(XML_ATTRIBUTE_ENTITIES);
! 5681: } else if (CMP8(CUR_PTR, 'N', 'M', 'T', 'O', 'K', 'E', 'N', 'S')) {
! 5682: SKIP(8);
! 5683: return(XML_ATTRIBUTE_NMTOKENS);
! 5684: } else if (CMP7(CUR_PTR, 'N', 'M', 'T', 'O', 'K', 'E', 'N')) {
! 5685: SKIP(7);
! 5686: return(XML_ATTRIBUTE_NMTOKEN);
! 5687: }
! 5688: return(xmlParseEnumeratedType(ctxt, tree));
! 5689: }
! 5690:
! 5691: /**
! 5692: * xmlParseAttributeListDecl:
! 5693: * @ctxt: an XML parser context
! 5694: *
! 5695: * : parse the Attribute list def for an element
! 5696: *
! 5697: * [52] AttlistDecl ::= '<!ATTLIST' S Name AttDef* S? '>'
! 5698: *
! 5699: * [53] AttDef ::= S Name S AttType S DefaultDecl
! 5700: *
! 5701: */
! 5702: void
! 5703: xmlParseAttributeListDecl(xmlParserCtxtPtr ctxt) {
! 5704: const xmlChar *elemName;
! 5705: const xmlChar *attrName;
! 5706: xmlEnumerationPtr tree;
! 5707:
! 5708: if (CMP9(CUR_PTR, '<', '!', 'A', 'T', 'T', 'L', 'I', 'S', 'T')) {
! 5709: xmlParserInputPtr input = ctxt->input;
! 5710:
! 5711: SKIP(9);
! 5712: if (!IS_BLANK_CH(CUR)) {
! 5713: xmlFatalErrMsg(ctxt, XML_ERR_SPACE_REQUIRED,
! 5714: "Space required after '<!ATTLIST'\n");
! 5715: }
! 5716: SKIP_BLANKS;
! 5717: elemName = xmlParseName(ctxt);
! 5718: if (elemName == NULL) {
! 5719: xmlFatalErrMsg(ctxt, XML_ERR_NAME_REQUIRED,
! 5720: "ATTLIST: no name for Element\n");
! 5721: return;
! 5722: }
! 5723: SKIP_BLANKS;
! 5724: GROW;
! 5725: while (RAW != '>') {
! 5726: const xmlChar *check = CUR_PTR;
! 5727: int type;
! 5728: int def;
! 5729: xmlChar *defaultValue = NULL;
! 5730:
! 5731: GROW;
! 5732: tree = NULL;
! 5733: attrName = xmlParseName(ctxt);
! 5734: if (attrName == NULL) {
! 5735: xmlFatalErrMsg(ctxt, XML_ERR_NAME_REQUIRED,
! 5736: "ATTLIST: no name for Attribute\n");
! 5737: break;
! 5738: }
! 5739: GROW;
! 5740: if (!IS_BLANK_CH(CUR)) {
! 5741: xmlFatalErrMsg(ctxt, XML_ERR_SPACE_REQUIRED,
! 5742: "Space required after the attribute name\n");
! 5743: break;
! 5744: }
! 5745: SKIP_BLANKS;
! 5746:
! 5747: type = xmlParseAttributeType(ctxt, &tree);
! 5748: if (type <= 0) {
! 5749: break;
! 5750: }
! 5751:
! 5752: GROW;
! 5753: if (!IS_BLANK_CH(CUR)) {
! 5754: xmlFatalErrMsg(ctxt, XML_ERR_SPACE_REQUIRED,
! 5755: "Space required after the attribute type\n");
! 5756: if (tree != NULL)
! 5757: xmlFreeEnumeration(tree);
! 5758: break;
! 5759: }
! 5760: SKIP_BLANKS;
! 5761:
! 5762: def = xmlParseDefaultDecl(ctxt, &defaultValue);
! 5763: if (def <= 0) {
! 5764: if (defaultValue != NULL)
! 5765: xmlFree(defaultValue);
! 5766: if (tree != NULL)
! 5767: xmlFreeEnumeration(tree);
! 5768: break;
! 5769: }
! 5770: if ((type != XML_ATTRIBUTE_CDATA) && (defaultValue != NULL))
! 5771: xmlAttrNormalizeSpace(defaultValue, defaultValue);
! 5772:
! 5773: GROW;
! 5774: if (RAW != '>') {
! 5775: if (!IS_BLANK_CH(CUR)) {
! 5776: xmlFatalErrMsg(ctxt, XML_ERR_SPACE_REQUIRED,
! 5777: "Space required after the attribute default value\n");
! 5778: if (defaultValue != NULL)
! 5779: xmlFree(defaultValue);
! 5780: if (tree != NULL)
! 5781: xmlFreeEnumeration(tree);
! 5782: break;
! 5783: }
! 5784: SKIP_BLANKS;
! 5785: }
! 5786: if (check == CUR_PTR) {
! 5787: xmlFatalErr(ctxt, XML_ERR_INTERNAL_ERROR,
! 5788: "in xmlParseAttributeListDecl\n");
! 5789: if (defaultValue != NULL)
! 5790: xmlFree(defaultValue);
! 5791: if (tree != NULL)
! 5792: xmlFreeEnumeration(tree);
! 5793: break;
! 5794: }
! 5795: if ((ctxt->sax != NULL) && (!ctxt->disableSAX) &&
! 5796: (ctxt->sax->attributeDecl != NULL))
! 5797: ctxt->sax->attributeDecl(ctxt->userData, elemName, attrName,
! 5798: type, def, defaultValue, tree);
! 5799: else if (tree != NULL)
! 5800: xmlFreeEnumeration(tree);
! 5801:
! 5802: if ((ctxt->sax2) && (defaultValue != NULL) &&
! 5803: (def != XML_ATTRIBUTE_IMPLIED) &&
! 5804: (def != XML_ATTRIBUTE_REQUIRED)) {
! 5805: xmlAddDefAttrs(ctxt, elemName, attrName, defaultValue);
! 5806: }
! 5807: if (ctxt->sax2) {
! 5808: xmlAddSpecialAttr(ctxt, elemName, attrName, type);
! 5809: }
! 5810: if (defaultValue != NULL)
! 5811: xmlFree(defaultValue);
! 5812: GROW;
! 5813: }
! 5814: if (RAW == '>') {
! 5815: if (input != ctxt->input) {
! 5816: xmlValidityError(ctxt, XML_ERR_ENTITY_BOUNDARY,
! 5817: "Attribute list declaration doesn't start and stop in the same entity\n",
! 5818: NULL, NULL);
! 5819: }
! 5820: NEXT;
! 5821: }
! 5822: }
! 5823: }
! 5824:
! 5825: /**
! 5826: * xmlParseElementMixedContentDecl:
! 5827: * @ctxt: an XML parser context
! 5828: * @inputchk: the input used for the current entity, needed for boundary checks
! 5829: *
! 5830: * parse the declaration for a Mixed Element content
! 5831: * The leading '(' and spaces have been skipped in xmlParseElementContentDecl
! 5832: *
! 5833: * [51] Mixed ::= '(' S? '#PCDATA' (S? '|' S? Name)* S? ')*' |
! 5834: * '(' S? '#PCDATA' S? ')'
! 5835: *
! 5836: * [ VC: Proper Group/PE Nesting ] applies to [51] too (see [49])
! 5837: *
! 5838: * [ VC: No Duplicate Types ]
! 5839: * The same name must not appear more than once in a single
! 5840: * mixed-content declaration.
! 5841: *
! 5842: * returns: the list of the xmlElementContentPtr describing the element choices
! 5843: */
! 5844: xmlElementContentPtr
! 5845: xmlParseElementMixedContentDecl(xmlParserCtxtPtr ctxt, int inputchk) {
! 5846: xmlElementContentPtr ret = NULL, cur = NULL, n;
! 5847: const xmlChar *elem = NULL;
! 5848:
! 5849: GROW;
! 5850: if (CMP7(CUR_PTR, '#', 'P', 'C', 'D', 'A', 'T', 'A')) {
! 5851: SKIP(7);
! 5852: SKIP_BLANKS;
! 5853: SHRINK;
! 5854: if (RAW == ')') {
! 5855: if ((ctxt->validate) && (ctxt->input->id != inputchk)) {
! 5856: xmlValidityError(ctxt, XML_ERR_ENTITY_BOUNDARY,
! 5857: "Element content declaration doesn't start and stop in the same entity\n",
! 5858: NULL, NULL);
! 5859: }
! 5860: NEXT;
! 5861: ret = xmlNewDocElementContent(ctxt->myDoc, NULL, XML_ELEMENT_CONTENT_PCDATA);
! 5862: if (ret == NULL)
! 5863: return(NULL);
! 5864: if (RAW == '*') {
! 5865: ret->ocur = XML_ELEMENT_CONTENT_MULT;
! 5866: NEXT;
! 5867: }
! 5868: return(ret);
! 5869: }
! 5870: if ((RAW == '(') || (RAW == '|')) {
! 5871: ret = cur = xmlNewDocElementContent(ctxt->myDoc, NULL, XML_ELEMENT_CONTENT_PCDATA);
! 5872: if (ret == NULL) return(NULL);
! 5873: }
! 5874: while (RAW == '|') {
! 5875: NEXT;
! 5876: if (elem == NULL) {
! 5877: ret = xmlNewDocElementContent(ctxt->myDoc, NULL, XML_ELEMENT_CONTENT_OR);
! 5878: if (ret == NULL) return(NULL);
! 5879: ret->c1 = cur;
! 5880: if (cur != NULL)
! 5881: cur->parent = ret;
! 5882: cur = ret;
! 5883: } else {
! 5884: n = xmlNewDocElementContent(ctxt->myDoc, NULL, XML_ELEMENT_CONTENT_OR);
! 5885: if (n == NULL) return(NULL);
! 5886: n->c1 = xmlNewDocElementContent(ctxt->myDoc, elem, XML_ELEMENT_CONTENT_ELEMENT);
! 5887: if (n->c1 != NULL)
! 5888: n->c1->parent = n;
! 5889: cur->c2 = n;
! 5890: if (n != NULL)
! 5891: n->parent = cur;
! 5892: cur = n;
! 5893: }
! 5894: SKIP_BLANKS;
! 5895: elem = xmlParseName(ctxt);
! 5896: if (elem == NULL) {
! 5897: xmlFatalErrMsg(ctxt, XML_ERR_NAME_REQUIRED,
! 5898: "xmlParseElementMixedContentDecl : Name expected\n");
! 5899: xmlFreeDocElementContent(ctxt->myDoc, cur);
! 5900: return(NULL);
! 5901: }
! 5902: SKIP_BLANKS;
! 5903: GROW;
! 5904: }
! 5905: if ((RAW == ')') && (NXT(1) == '*')) {
! 5906: if (elem != NULL) {
! 5907: cur->c2 = xmlNewDocElementContent(ctxt->myDoc, elem,
! 5908: XML_ELEMENT_CONTENT_ELEMENT);
! 5909: if (cur->c2 != NULL)
! 5910: cur->c2->parent = cur;
! 5911: }
! 5912: if (ret != NULL)
! 5913: ret->ocur = XML_ELEMENT_CONTENT_MULT;
! 5914: if ((ctxt->validate) && (ctxt->input->id != inputchk)) {
! 5915: xmlValidityError(ctxt, XML_ERR_ENTITY_BOUNDARY,
! 5916: "Element content declaration doesn't start and stop in the same entity\n",
! 5917: NULL, NULL);
! 5918: }
! 5919: SKIP(2);
! 5920: } else {
! 5921: xmlFreeDocElementContent(ctxt->myDoc, ret);
! 5922: xmlFatalErr(ctxt, XML_ERR_MIXED_NOT_STARTED, NULL);
! 5923: return(NULL);
! 5924: }
! 5925:
! 5926: } else {
! 5927: xmlFatalErr(ctxt, XML_ERR_PCDATA_REQUIRED, NULL);
! 5928: }
! 5929: return(ret);
! 5930: }
! 5931:
! 5932: /**
! 5933: * xmlParseElementChildrenContentDeclPriv:
! 5934: * @ctxt: an XML parser context
! 5935: * @inputchk: the input used for the current entity, needed for boundary checks
! 5936: * @depth: the level of recursion
! 5937: *
! 5938: * parse the declaration for a Mixed Element content
! 5939: * The leading '(' and spaces have been skipped in xmlParseElementContentDecl
! 5940: *
! 5941: *
! 5942: * [47] children ::= (choice | seq) ('?' | '*' | '+')?
! 5943: *
! 5944: * [48] cp ::= (Name | choice | seq) ('?' | '*' | '+')?
! 5945: *
! 5946: * [49] choice ::= '(' S? cp ( S? '|' S? cp )* S? ')'
! 5947: *
! 5948: * [50] seq ::= '(' S? cp ( S? ',' S? cp )* S? ')'
! 5949: *
! 5950: * [ VC: Proper Group/PE Nesting ] applies to [49] and [50]
! 5951: * TODO Parameter-entity replacement text must be properly nested
! 5952: * with parenthesized groups. That is to say, if either of the
! 5953: * opening or closing parentheses in a choice, seq, or Mixed
! 5954: * construct is contained in the replacement text for a parameter
! 5955: * entity, both must be contained in the same replacement text. For
! 5956: * interoperability, if a parameter-entity reference appears in a
! 5957: * choice, seq, or Mixed construct, its replacement text should not
! 5958: * be empty, and neither the first nor last non-blank character of
! 5959: * the replacement text should be a connector (| or ,).
! 5960: *
! 5961: * Returns the tree of xmlElementContentPtr describing the element
! 5962: * hierarchy.
! 5963: */
! 5964: static xmlElementContentPtr
! 5965: xmlParseElementChildrenContentDeclPriv(xmlParserCtxtPtr ctxt, int inputchk,
! 5966: int depth) {
! 5967: xmlElementContentPtr ret = NULL, cur = NULL, last = NULL, op = NULL;
! 5968: const xmlChar *elem;
! 5969: xmlChar type = 0;
! 5970:
! 5971: if (((depth > 128) && ((ctxt->options & XML_PARSE_HUGE) == 0)) ||
! 5972: (depth > 2048)) {
! 5973: xmlFatalErrMsgInt(ctxt, XML_ERR_ELEMCONTENT_NOT_FINISHED,
! 5974: "xmlParseElementChildrenContentDecl : depth %d too deep, use XML_PARSE_HUGE\n",
! 5975: depth);
! 5976: return(NULL);
! 5977: }
! 5978: SKIP_BLANKS;
! 5979: GROW;
! 5980: if (RAW == '(') {
! 5981: int inputid = ctxt->input->id;
! 5982:
! 5983: /* Recurse on first child */
! 5984: NEXT;
! 5985: SKIP_BLANKS;
! 5986: cur = ret = xmlParseElementChildrenContentDeclPriv(ctxt, inputid,
! 5987: depth + 1);
! 5988: SKIP_BLANKS;
! 5989: GROW;
! 5990: } else {
! 5991: elem = xmlParseName(ctxt);
! 5992: if (elem == NULL) {
! 5993: xmlFatalErr(ctxt, XML_ERR_ELEMCONTENT_NOT_STARTED, NULL);
! 5994: return(NULL);
! 5995: }
! 5996: cur = ret = xmlNewDocElementContent(ctxt->myDoc, elem, XML_ELEMENT_CONTENT_ELEMENT);
! 5997: if (cur == NULL) {
! 5998: xmlErrMemory(ctxt, NULL);
! 5999: return(NULL);
! 6000: }
! 6001: GROW;
! 6002: if (RAW == '?') {
! 6003: cur->ocur = XML_ELEMENT_CONTENT_OPT;
! 6004: NEXT;
! 6005: } else if (RAW == '*') {
! 6006: cur->ocur = XML_ELEMENT_CONTENT_MULT;
! 6007: NEXT;
! 6008: } else if (RAW == '+') {
! 6009: cur->ocur = XML_ELEMENT_CONTENT_PLUS;
! 6010: NEXT;
! 6011: } else {
! 6012: cur->ocur = XML_ELEMENT_CONTENT_ONCE;
! 6013: }
! 6014: GROW;
! 6015: }
! 6016: SKIP_BLANKS;
! 6017: SHRINK;
! 6018: while (RAW != ')') {
! 6019: /*
! 6020: * Each loop we parse one separator and one element.
! 6021: */
! 6022: if (RAW == ',') {
! 6023: if (type == 0) type = CUR;
! 6024:
! 6025: /*
! 6026: * Detect "Name | Name , Name" error
! 6027: */
! 6028: else if (type != CUR) {
! 6029: xmlFatalErrMsgInt(ctxt, XML_ERR_SEPARATOR_REQUIRED,
! 6030: "xmlParseElementChildrenContentDecl : '%c' expected\n",
! 6031: type);
! 6032: if ((last != NULL) && (last != ret))
! 6033: xmlFreeDocElementContent(ctxt->myDoc, last);
! 6034: if (ret != NULL)
! 6035: xmlFreeDocElementContent(ctxt->myDoc, ret);
! 6036: return(NULL);
! 6037: }
! 6038: NEXT;
! 6039:
! 6040: op = xmlNewDocElementContent(ctxt->myDoc, NULL, XML_ELEMENT_CONTENT_SEQ);
! 6041: if (op == NULL) {
! 6042: if ((last != NULL) && (last != ret))
! 6043: xmlFreeDocElementContent(ctxt->myDoc, last);
! 6044: xmlFreeDocElementContent(ctxt->myDoc, ret);
! 6045: return(NULL);
! 6046: }
! 6047: if (last == NULL) {
! 6048: op->c1 = ret;
! 6049: if (ret != NULL)
! 6050: ret->parent = op;
! 6051: ret = cur = op;
! 6052: } else {
! 6053: cur->c2 = op;
! 6054: if (op != NULL)
! 6055: op->parent = cur;
! 6056: op->c1 = last;
! 6057: if (last != NULL)
! 6058: last->parent = op;
! 6059: cur =op;
! 6060: last = NULL;
! 6061: }
! 6062: } else if (RAW == '|') {
! 6063: if (type == 0) type = CUR;
! 6064:
! 6065: /*
! 6066: * Detect "Name , Name | Name" error
! 6067: */
! 6068: else if (type != CUR) {
! 6069: xmlFatalErrMsgInt(ctxt, XML_ERR_SEPARATOR_REQUIRED,
! 6070: "xmlParseElementChildrenContentDecl : '%c' expected\n",
! 6071: type);
! 6072: if ((last != NULL) && (last != ret))
! 6073: xmlFreeDocElementContent(ctxt->myDoc, last);
! 6074: if (ret != NULL)
! 6075: xmlFreeDocElementContent(ctxt->myDoc, ret);
! 6076: return(NULL);
! 6077: }
! 6078: NEXT;
! 6079:
! 6080: op = xmlNewDocElementContent(ctxt->myDoc, NULL, XML_ELEMENT_CONTENT_OR);
! 6081: if (op == NULL) {
! 6082: if ((last != NULL) && (last != ret))
! 6083: xmlFreeDocElementContent(ctxt->myDoc, last);
! 6084: if (ret != NULL)
! 6085: xmlFreeDocElementContent(ctxt->myDoc, ret);
! 6086: return(NULL);
! 6087: }
! 6088: if (last == NULL) {
! 6089: op->c1 = ret;
! 6090: if (ret != NULL)
! 6091: ret->parent = op;
! 6092: ret = cur = op;
! 6093: } else {
! 6094: cur->c2 = op;
! 6095: if (op != NULL)
! 6096: op->parent = cur;
! 6097: op->c1 = last;
! 6098: if (last != NULL)
! 6099: last->parent = op;
! 6100: cur =op;
! 6101: last = NULL;
! 6102: }
! 6103: } else {
! 6104: xmlFatalErr(ctxt, XML_ERR_ELEMCONTENT_NOT_FINISHED, NULL);
! 6105: if ((last != NULL) && (last != ret))
! 6106: xmlFreeDocElementContent(ctxt->myDoc, last);
! 6107: if (ret != NULL)
! 6108: xmlFreeDocElementContent(ctxt->myDoc, ret);
! 6109: return(NULL);
! 6110: }
! 6111: GROW;
! 6112: SKIP_BLANKS;
! 6113: GROW;
! 6114: if (RAW == '(') {
! 6115: int inputid = ctxt->input->id;
! 6116: /* Recurse on second child */
! 6117: NEXT;
! 6118: SKIP_BLANKS;
! 6119: last = xmlParseElementChildrenContentDeclPriv(ctxt, inputid,
! 6120: depth + 1);
! 6121: SKIP_BLANKS;
! 6122: } else {
! 6123: elem = xmlParseName(ctxt);
! 6124: if (elem == NULL) {
! 6125: xmlFatalErr(ctxt, XML_ERR_ELEMCONTENT_NOT_STARTED, NULL);
! 6126: if (ret != NULL)
! 6127: xmlFreeDocElementContent(ctxt->myDoc, ret);
! 6128: return(NULL);
! 6129: }
! 6130: last = xmlNewDocElementContent(ctxt->myDoc, elem, XML_ELEMENT_CONTENT_ELEMENT);
! 6131: if (last == NULL) {
! 6132: if (ret != NULL)
! 6133: xmlFreeDocElementContent(ctxt->myDoc, ret);
! 6134: return(NULL);
! 6135: }
! 6136: if (RAW == '?') {
! 6137: last->ocur = XML_ELEMENT_CONTENT_OPT;
! 6138: NEXT;
! 6139: } else if (RAW == '*') {
! 6140: last->ocur = XML_ELEMENT_CONTENT_MULT;
! 6141: NEXT;
! 6142: } else if (RAW == '+') {
! 6143: last->ocur = XML_ELEMENT_CONTENT_PLUS;
! 6144: NEXT;
! 6145: } else {
! 6146: last->ocur = XML_ELEMENT_CONTENT_ONCE;
! 6147: }
! 6148: }
! 6149: SKIP_BLANKS;
! 6150: GROW;
! 6151: }
! 6152: if ((cur != NULL) && (last != NULL)) {
! 6153: cur->c2 = last;
! 6154: if (last != NULL)
! 6155: last->parent = cur;
! 6156: }
! 6157: if ((ctxt->validate) && (ctxt->input->id != inputchk)) {
! 6158: xmlValidityError(ctxt, XML_ERR_ENTITY_BOUNDARY,
! 6159: "Element content declaration doesn't start and stop in the same entity\n",
! 6160: NULL, NULL);
! 6161: }
! 6162: NEXT;
! 6163: if (RAW == '?') {
! 6164: if (ret != NULL) {
! 6165: if ((ret->ocur == XML_ELEMENT_CONTENT_PLUS) ||
! 6166: (ret->ocur == XML_ELEMENT_CONTENT_MULT))
! 6167: ret->ocur = XML_ELEMENT_CONTENT_MULT;
! 6168: else
! 6169: ret->ocur = XML_ELEMENT_CONTENT_OPT;
! 6170: }
! 6171: NEXT;
! 6172: } else if (RAW == '*') {
! 6173: if (ret != NULL) {
! 6174: ret->ocur = XML_ELEMENT_CONTENT_MULT;
! 6175: cur = ret;
! 6176: /*
! 6177: * Some normalization:
! 6178: * (a | b* | c?)* == (a | b | c)*
! 6179: */
! 6180: while ((cur != NULL) && (cur->type == XML_ELEMENT_CONTENT_OR)) {
! 6181: if ((cur->c1 != NULL) &&
! 6182: ((cur->c1->ocur == XML_ELEMENT_CONTENT_OPT) ||
! 6183: (cur->c1->ocur == XML_ELEMENT_CONTENT_MULT)))
! 6184: cur->c1->ocur = XML_ELEMENT_CONTENT_ONCE;
! 6185: if ((cur->c2 != NULL) &&
! 6186: ((cur->c2->ocur == XML_ELEMENT_CONTENT_OPT) ||
! 6187: (cur->c2->ocur == XML_ELEMENT_CONTENT_MULT)))
! 6188: cur->c2->ocur = XML_ELEMENT_CONTENT_ONCE;
! 6189: cur = cur->c2;
! 6190: }
! 6191: }
! 6192: NEXT;
! 6193: } else if (RAW == '+') {
! 6194: if (ret != NULL) {
! 6195: int found = 0;
! 6196:
! 6197: if ((ret->ocur == XML_ELEMENT_CONTENT_OPT) ||
! 6198: (ret->ocur == XML_ELEMENT_CONTENT_MULT))
! 6199: ret->ocur = XML_ELEMENT_CONTENT_MULT;
! 6200: else
! 6201: ret->ocur = XML_ELEMENT_CONTENT_PLUS;
! 6202: /*
! 6203: * Some normalization:
! 6204: * (a | b*)+ == (a | b)*
! 6205: * (a | b?)+ == (a | b)*
! 6206: */
! 6207: while ((cur != NULL) && (cur->type == XML_ELEMENT_CONTENT_OR)) {
! 6208: if ((cur->c1 != NULL) &&
! 6209: ((cur->c1->ocur == XML_ELEMENT_CONTENT_OPT) ||
! 6210: (cur->c1->ocur == XML_ELEMENT_CONTENT_MULT))) {
! 6211: cur->c1->ocur = XML_ELEMENT_CONTENT_ONCE;
! 6212: found = 1;
! 6213: }
! 6214: if ((cur->c2 != NULL) &&
! 6215: ((cur->c2->ocur == XML_ELEMENT_CONTENT_OPT) ||
! 6216: (cur->c2->ocur == XML_ELEMENT_CONTENT_MULT))) {
! 6217: cur->c2->ocur = XML_ELEMENT_CONTENT_ONCE;
! 6218: found = 1;
! 6219: }
! 6220: cur = cur->c2;
! 6221: }
! 6222: if (found)
! 6223: ret->ocur = XML_ELEMENT_CONTENT_MULT;
! 6224: }
! 6225: NEXT;
! 6226: }
! 6227: return(ret);
! 6228: }
! 6229:
! 6230: /**
! 6231: * xmlParseElementChildrenContentDecl:
! 6232: * @ctxt: an XML parser context
! 6233: * @inputchk: the input used for the current entity, needed for boundary checks
! 6234: *
! 6235: * parse the declaration for a Mixed Element content
! 6236: * The leading '(' and spaces have been skipped in xmlParseElementContentDecl
! 6237: *
! 6238: * [47] children ::= (choice | seq) ('?' | '*' | '+')?
! 6239: *
! 6240: * [48] cp ::= (Name | choice | seq) ('?' | '*' | '+')?
! 6241: *
! 6242: * [49] choice ::= '(' S? cp ( S? '|' S? cp )* S? ')'
! 6243: *
! 6244: * [50] seq ::= '(' S? cp ( S? ',' S? cp )* S? ')'
! 6245: *
! 6246: * [ VC: Proper Group/PE Nesting ] applies to [49] and [50]
! 6247: * TODO Parameter-entity replacement text must be properly nested
! 6248: * with parenthesized groups. That is to say, if either of the
! 6249: * opening or closing parentheses in a choice, seq, or Mixed
! 6250: * construct is contained in the replacement text for a parameter
! 6251: * entity, both must be contained in the same replacement text. For
! 6252: * interoperability, if a parameter-entity reference appears in a
! 6253: * choice, seq, or Mixed construct, its replacement text should not
! 6254: * be empty, and neither the first nor last non-blank character of
! 6255: * the replacement text should be a connector (| or ,).
! 6256: *
! 6257: * Returns the tree of xmlElementContentPtr describing the element
! 6258: * hierarchy.
! 6259: */
! 6260: xmlElementContentPtr
! 6261: xmlParseElementChildrenContentDecl(xmlParserCtxtPtr ctxt, int inputchk) {
! 6262: /* stub left for API/ABI compat */
! 6263: return(xmlParseElementChildrenContentDeclPriv(ctxt, inputchk, 1));
! 6264: }
! 6265:
! 6266: /**
! 6267: * xmlParseElementContentDecl:
! 6268: * @ctxt: an XML parser context
! 6269: * @name: the name of the element being defined.
! 6270: * @result: the Element Content pointer will be stored here if any
! 6271: *
! 6272: * parse the declaration for an Element content either Mixed or Children,
! 6273: * the cases EMPTY and ANY are handled directly in xmlParseElementDecl
! 6274: *
! 6275: * [46] contentspec ::= 'EMPTY' | 'ANY' | Mixed | children
! 6276: *
! 6277: * returns: the type of element content XML_ELEMENT_TYPE_xxx
! 6278: */
! 6279:
! 6280: int
! 6281: xmlParseElementContentDecl(xmlParserCtxtPtr ctxt, const xmlChar *name,
! 6282: xmlElementContentPtr *result) {
! 6283:
! 6284: xmlElementContentPtr tree = NULL;
! 6285: int inputid = ctxt->input->id;
! 6286: int res;
! 6287:
! 6288: *result = NULL;
! 6289:
! 6290: if (RAW != '(') {
! 6291: xmlFatalErrMsgStr(ctxt, XML_ERR_ELEMCONTENT_NOT_STARTED,
! 6292: "xmlParseElementContentDecl : %s '(' expected\n", name);
! 6293: return(-1);
! 6294: }
! 6295: NEXT;
! 6296: GROW;
! 6297: SKIP_BLANKS;
! 6298: if (CMP7(CUR_PTR, '#', 'P', 'C', 'D', 'A', 'T', 'A')) {
! 6299: tree = xmlParseElementMixedContentDecl(ctxt, inputid);
! 6300: res = XML_ELEMENT_TYPE_MIXED;
! 6301: } else {
! 6302: tree = xmlParseElementChildrenContentDeclPriv(ctxt, inputid, 1);
! 6303: res = XML_ELEMENT_TYPE_ELEMENT;
! 6304: }
! 6305: SKIP_BLANKS;
! 6306: *result = tree;
! 6307: return(res);
! 6308: }
! 6309:
! 6310: /**
! 6311: * xmlParseElementDecl:
! 6312: * @ctxt: an XML parser context
! 6313: *
! 6314: * parse an Element declaration.
! 6315: *
! 6316: * [45] elementdecl ::= '<!ELEMENT' S Name S contentspec S? '>'
! 6317: *
! 6318: * [ VC: Unique Element Type Declaration ]
! 6319: * No element type may be declared more than once
! 6320: *
! 6321: * Returns the type of the element, or -1 in case of error
! 6322: */
! 6323: int
! 6324: xmlParseElementDecl(xmlParserCtxtPtr ctxt) {
! 6325: const xmlChar *name;
! 6326: int ret = -1;
! 6327: xmlElementContentPtr content = NULL;
! 6328:
! 6329: /* GROW; done in the caller */
! 6330: if (CMP9(CUR_PTR, '<', '!', 'E', 'L', 'E', 'M', 'E', 'N', 'T')) {
! 6331: xmlParserInputPtr input = ctxt->input;
! 6332:
! 6333: SKIP(9);
! 6334: if (!IS_BLANK_CH(CUR)) {
! 6335: xmlFatalErrMsg(ctxt, XML_ERR_SPACE_REQUIRED,
! 6336: "Space required after 'ELEMENT'\n");
! 6337: }
! 6338: SKIP_BLANKS;
! 6339: name = xmlParseName(ctxt);
! 6340: if (name == NULL) {
! 6341: xmlFatalErrMsg(ctxt, XML_ERR_NAME_REQUIRED,
! 6342: "xmlParseElementDecl: no name for Element\n");
! 6343: return(-1);
! 6344: }
! 6345: while ((RAW == 0) && (ctxt->inputNr > 1))
! 6346: xmlPopInput(ctxt);
! 6347: if (!IS_BLANK_CH(CUR)) {
! 6348: xmlFatalErrMsg(ctxt, XML_ERR_SPACE_REQUIRED,
! 6349: "Space required after the element name\n");
! 6350: }
! 6351: SKIP_BLANKS;
! 6352: if (CMP5(CUR_PTR, 'E', 'M', 'P', 'T', 'Y')) {
! 6353: SKIP(5);
! 6354: /*
! 6355: * Element must always be empty.
! 6356: */
! 6357: ret = XML_ELEMENT_TYPE_EMPTY;
! 6358: } else if ((RAW == 'A') && (NXT(1) == 'N') &&
! 6359: (NXT(2) == 'Y')) {
! 6360: SKIP(3);
! 6361: /*
! 6362: * Element is a generic container.
! 6363: */
! 6364: ret = XML_ELEMENT_TYPE_ANY;
! 6365: } else if (RAW == '(') {
! 6366: ret = xmlParseElementContentDecl(ctxt, name, &content);
! 6367: } else {
! 6368: /*
! 6369: * [ WFC: PEs in Internal Subset ] error handling.
! 6370: */
! 6371: if ((RAW == '%') && (ctxt->external == 0) &&
! 6372: (ctxt->inputNr == 1)) {
! 6373: xmlFatalErrMsg(ctxt, XML_ERR_PEREF_IN_INT_SUBSET,
! 6374: "PEReference: forbidden within markup decl in internal subset\n");
! 6375: } else {
! 6376: xmlFatalErrMsg(ctxt, XML_ERR_ELEMCONTENT_NOT_STARTED,
! 6377: "xmlParseElementDecl: 'EMPTY', 'ANY' or '(' expected\n");
! 6378: }
! 6379: return(-1);
! 6380: }
! 6381:
! 6382: SKIP_BLANKS;
! 6383: /*
! 6384: * Pop-up of finished entities.
! 6385: */
! 6386: while ((RAW == 0) && (ctxt->inputNr > 1))
! 6387: xmlPopInput(ctxt);
! 6388: SKIP_BLANKS;
! 6389:
! 6390: if (RAW != '>') {
! 6391: xmlFatalErr(ctxt, XML_ERR_GT_REQUIRED, NULL);
! 6392: if (content != NULL) {
! 6393: xmlFreeDocElementContent(ctxt->myDoc, content);
! 6394: }
! 6395: } else {
! 6396: if (input != ctxt->input) {
! 6397: xmlFatalErrMsg(ctxt, XML_ERR_ENTITY_BOUNDARY,
! 6398: "Element declaration doesn't start and stop in the same entity\n");
! 6399: }
! 6400:
! 6401: NEXT;
! 6402: if ((ctxt->sax != NULL) && (!ctxt->disableSAX) &&
! 6403: (ctxt->sax->elementDecl != NULL)) {
! 6404: if (content != NULL)
! 6405: content->parent = NULL;
! 6406: ctxt->sax->elementDecl(ctxt->userData, name, ret,
! 6407: content);
! 6408: if ((content != NULL) && (content->parent == NULL)) {
! 6409: /*
! 6410: * this is a trick: if xmlAddElementDecl is called,
! 6411: * instead of copying the full tree it is plugged directly
! 6412: * if called from the parser. Avoid duplicating the
! 6413: * interfaces or change the API/ABI
! 6414: */
! 6415: xmlFreeDocElementContent(ctxt->myDoc, content);
! 6416: }
! 6417: } else if (content != NULL) {
! 6418: xmlFreeDocElementContent(ctxt->myDoc, content);
! 6419: }
! 6420: }
! 6421: }
! 6422: return(ret);
! 6423: }
! 6424:
! 6425: /**
! 6426: * xmlParseConditionalSections
! 6427: * @ctxt: an XML parser context
! 6428: *
! 6429: * [61] conditionalSect ::= includeSect | ignoreSect
! 6430: * [62] includeSect ::= '<![' S? 'INCLUDE' S? '[' extSubsetDecl ']]>'
! 6431: * [63] ignoreSect ::= '<![' S? 'IGNORE' S? '[' ignoreSectContents* ']]>'
! 6432: * [64] ignoreSectContents ::= Ignore ('<![' ignoreSectContents ']]>' Ignore)*
! 6433: * [65] Ignore ::= Char* - (Char* ('<![' | ']]>') Char*)
! 6434: */
! 6435:
! 6436: static void
! 6437: xmlParseConditionalSections(xmlParserCtxtPtr ctxt) {
! 6438: int id = ctxt->input->id;
! 6439:
! 6440: SKIP(3);
! 6441: SKIP_BLANKS;
! 6442: if (CMP7(CUR_PTR, 'I', 'N', 'C', 'L', 'U', 'D', 'E')) {
! 6443: SKIP(7);
! 6444: SKIP_BLANKS;
! 6445: if (RAW != '[') {
! 6446: xmlFatalErr(ctxt, XML_ERR_CONDSEC_INVALID, NULL);
! 6447: } else {
! 6448: if (ctxt->input->id != id) {
! 6449: xmlValidityError(ctxt, XML_ERR_ENTITY_BOUNDARY,
! 6450: "All markup of the conditional section is not in the same entity\n",
! 6451: NULL, NULL);
! 6452: }
! 6453: NEXT;
! 6454: }
! 6455: if (xmlParserDebugEntities) {
! 6456: if ((ctxt->input != NULL) && (ctxt->input->filename))
! 6457: xmlGenericError(xmlGenericErrorContext,
! 6458: "%s(%d): ", ctxt->input->filename,
! 6459: ctxt->input->line);
! 6460: xmlGenericError(xmlGenericErrorContext,
! 6461: "Entering INCLUDE Conditional Section\n");
! 6462: }
! 6463:
! 6464: while ((RAW != 0) && ((RAW != ']') || (NXT(1) != ']') ||
! 6465: (NXT(2) != '>'))) {
! 6466: const xmlChar *check = CUR_PTR;
! 6467: unsigned int cons = ctxt->input->consumed;
! 6468:
! 6469: if ((RAW == '<') && (NXT(1) == '!') && (NXT(2) == '[')) {
! 6470: xmlParseConditionalSections(ctxt);
! 6471: } else if (IS_BLANK_CH(CUR)) {
! 6472: NEXT;
! 6473: } else if (RAW == '%') {
! 6474: xmlParsePEReference(ctxt);
! 6475: } else
! 6476: xmlParseMarkupDecl(ctxt);
! 6477:
! 6478: /*
! 6479: * Pop-up of finished entities.
! 6480: */
! 6481: while ((RAW == 0) && (ctxt->inputNr > 1))
! 6482: xmlPopInput(ctxt);
! 6483:
! 6484: if ((CUR_PTR == check) && (cons == ctxt->input->consumed)) {
! 6485: xmlFatalErr(ctxt, XML_ERR_EXT_SUBSET_NOT_FINISHED, NULL);
! 6486: break;
! 6487: }
! 6488: }
! 6489: if (xmlParserDebugEntities) {
! 6490: if ((ctxt->input != NULL) && (ctxt->input->filename))
! 6491: xmlGenericError(xmlGenericErrorContext,
! 6492: "%s(%d): ", ctxt->input->filename,
! 6493: ctxt->input->line);
! 6494: xmlGenericError(xmlGenericErrorContext,
! 6495: "Leaving INCLUDE Conditional Section\n");
! 6496: }
! 6497:
! 6498: } else if (CMP6(CUR_PTR, 'I', 'G', 'N', 'O', 'R', 'E')) {
! 6499: int state;
! 6500: xmlParserInputState instate;
! 6501: int depth = 0;
! 6502:
! 6503: SKIP(6);
! 6504: SKIP_BLANKS;
! 6505: if (RAW != '[') {
! 6506: xmlFatalErr(ctxt, XML_ERR_CONDSEC_INVALID, NULL);
! 6507: } else {
! 6508: if (ctxt->input->id != id) {
! 6509: xmlValidityError(ctxt, XML_ERR_ENTITY_BOUNDARY,
! 6510: "All markup of the conditional section is not in the same entity\n",
! 6511: NULL, NULL);
! 6512: }
! 6513: NEXT;
! 6514: }
! 6515: if (xmlParserDebugEntities) {
! 6516: if ((ctxt->input != NULL) && (ctxt->input->filename))
! 6517: xmlGenericError(xmlGenericErrorContext,
! 6518: "%s(%d): ", ctxt->input->filename,
! 6519: ctxt->input->line);
! 6520: xmlGenericError(xmlGenericErrorContext,
! 6521: "Entering IGNORE Conditional Section\n");
! 6522: }
! 6523:
! 6524: /*
! 6525: * Parse up to the end of the conditional section
! 6526: * But disable SAX event generating DTD building in the meantime
! 6527: */
! 6528: state = ctxt->disableSAX;
! 6529: instate = ctxt->instate;
! 6530: if (ctxt->recovery == 0) ctxt->disableSAX = 1;
! 6531: ctxt->instate = XML_PARSER_IGNORE;
! 6532:
! 6533: while ((depth >= 0) && (RAW != 0)) {
! 6534: if ((RAW == '<') && (NXT(1) == '!') && (NXT(2) == '[')) {
! 6535: depth++;
! 6536: SKIP(3);
! 6537: continue;
! 6538: }
! 6539: if ((RAW == ']') && (NXT(1) == ']') && (NXT(2) == '>')) {
! 6540: if (--depth >= 0) SKIP(3);
! 6541: continue;
! 6542: }
! 6543: NEXT;
! 6544: continue;
! 6545: }
! 6546:
! 6547: ctxt->disableSAX = state;
! 6548: ctxt->instate = instate;
! 6549:
! 6550: if (xmlParserDebugEntities) {
! 6551: if ((ctxt->input != NULL) && (ctxt->input->filename))
! 6552: xmlGenericError(xmlGenericErrorContext,
! 6553: "%s(%d): ", ctxt->input->filename,
! 6554: ctxt->input->line);
! 6555: xmlGenericError(xmlGenericErrorContext,
! 6556: "Leaving IGNORE Conditional Section\n");
! 6557: }
! 6558:
! 6559: } else {
! 6560: xmlFatalErr(ctxt, XML_ERR_CONDSEC_INVALID_KEYWORD, NULL);
! 6561: }
! 6562:
! 6563: if (RAW == 0)
! 6564: SHRINK;
! 6565:
! 6566: if (RAW == 0) {
! 6567: xmlFatalErr(ctxt, XML_ERR_CONDSEC_NOT_FINISHED, NULL);
! 6568: } else {
! 6569: if (ctxt->input->id != id) {
! 6570: xmlValidityError(ctxt, XML_ERR_ENTITY_BOUNDARY,
! 6571: "All markup of the conditional section is not in the same entity\n",
! 6572: NULL, NULL);
! 6573: }
! 6574: SKIP(3);
! 6575: }
! 6576: }
! 6577:
! 6578: /**
! 6579: * xmlParseMarkupDecl:
! 6580: * @ctxt: an XML parser context
! 6581: *
! 6582: * parse Markup declarations
! 6583: *
! 6584: * [29] markupdecl ::= elementdecl | AttlistDecl | EntityDecl |
! 6585: * NotationDecl | PI | Comment
! 6586: *
! 6587: * [ VC: Proper Declaration/PE Nesting ]
! 6588: * Parameter-entity replacement text must be properly nested with
! 6589: * markup declarations. That is to say, if either the first character
! 6590: * or the last character of a markup declaration (markupdecl above) is
! 6591: * contained in the replacement text for a parameter-entity reference,
! 6592: * both must be contained in the same replacement text.
! 6593: *
! 6594: * [ WFC: PEs in Internal Subset ]
! 6595: * In the internal DTD subset, parameter-entity references can occur
! 6596: * only where markup declarations can occur, not within markup declarations.
! 6597: * (This does not apply to references that occur in external parameter
! 6598: * entities or to the external subset.)
! 6599: */
! 6600: void
! 6601: xmlParseMarkupDecl(xmlParserCtxtPtr ctxt) {
! 6602: GROW;
! 6603: if (CUR == '<') {
! 6604: if (NXT(1) == '!') {
! 6605: switch (NXT(2)) {
! 6606: case 'E':
! 6607: if (NXT(3) == 'L')
! 6608: xmlParseElementDecl(ctxt);
! 6609: else if (NXT(3) == 'N')
! 6610: xmlParseEntityDecl(ctxt);
! 6611: break;
! 6612: case 'A':
! 6613: xmlParseAttributeListDecl(ctxt);
! 6614: break;
! 6615: case 'N':
! 6616: xmlParseNotationDecl(ctxt);
! 6617: break;
! 6618: case '-':
! 6619: xmlParseComment(ctxt);
! 6620: break;
! 6621: default:
! 6622: /* there is an error but it will be detected later */
! 6623: break;
! 6624: }
! 6625: } else if (NXT(1) == '?') {
! 6626: xmlParsePI(ctxt);
! 6627: }
! 6628: }
! 6629: /*
! 6630: * This is only for internal subset. On external entities,
! 6631: * the replacement is done before parsing stage
! 6632: */
! 6633: if ((ctxt->external == 0) && (ctxt->inputNr == 1))
! 6634: xmlParsePEReference(ctxt);
! 6635:
! 6636: /*
! 6637: * Conditional sections are allowed from entities included
! 6638: * by PE References in the internal subset.
! 6639: */
! 6640: if ((ctxt->external == 0) && (ctxt->inputNr > 1)) {
! 6641: if ((RAW == '<') && (NXT(1) == '!') && (NXT(2) == '[')) {
! 6642: xmlParseConditionalSections(ctxt);
! 6643: }
! 6644: }
! 6645:
! 6646: ctxt->instate = XML_PARSER_DTD;
! 6647: }
! 6648:
! 6649: /**
! 6650: * xmlParseTextDecl:
! 6651: * @ctxt: an XML parser context
! 6652: *
! 6653: * parse an XML declaration header for external entities
! 6654: *
! 6655: * [77] TextDecl ::= '<?xml' VersionInfo? EncodingDecl S? '?>'
! 6656: */
! 6657:
! 6658: void
! 6659: xmlParseTextDecl(xmlParserCtxtPtr ctxt) {
! 6660: xmlChar *version;
! 6661: const xmlChar *encoding;
! 6662:
! 6663: /*
! 6664: * We know that '<?xml' is here.
! 6665: */
! 6666: if ((CMP5(CUR_PTR, '<', '?', 'x', 'm', 'l')) && (IS_BLANK_CH(NXT(5)))) {
! 6667: SKIP(5);
! 6668: } else {
! 6669: xmlFatalErr(ctxt, XML_ERR_XMLDECL_NOT_STARTED, NULL);
! 6670: return;
! 6671: }
! 6672:
! 6673: if (!IS_BLANK_CH(CUR)) {
! 6674: xmlFatalErrMsg(ctxt, XML_ERR_SPACE_REQUIRED,
! 6675: "Space needed after '<?xml'\n");
! 6676: }
! 6677: SKIP_BLANKS;
! 6678:
! 6679: /*
! 6680: * We may have the VersionInfo here.
! 6681: */
! 6682: version = xmlParseVersionInfo(ctxt);
! 6683: if (version == NULL)
! 6684: version = xmlCharStrdup(XML_DEFAULT_VERSION);
! 6685: else {
! 6686: if (!IS_BLANK_CH(CUR)) {
! 6687: xmlFatalErrMsg(ctxt, XML_ERR_SPACE_REQUIRED,
! 6688: "Space needed here\n");
! 6689: }
! 6690: }
! 6691: ctxt->input->version = version;
! 6692:
! 6693: /*
! 6694: * We must have the encoding declaration
! 6695: */
! 6696: encoding = xmlParseEncodingDecl(ctxt);
! 6697: if (ctxt->errNo == XML_ERR_UNSUPPORTED_ENCODING) {
! 6698: /*
! 6699: * The XML REC instructs us to stop parsing right here
! 6700: */
! 6701: return;
! 6702: }
! 6703: if ((encoding == NULL) && (ctxt->errNo == XML_ERR_OK)) {
! 6704: xmlFatalErrMsg(ctxt, XML_ERR_MISSING_ENCODING,
! 6705: "Missing encoding in text declaration\n");
! 6706: }
! 6707:
! 6708: SKIP_BLANKS;
! 6709: if ((RAW == '?') && (NXT(1) == '>')) {
! 6710: SKIP(2);
! 6711: } else if (RAW == '>') {
! 6712: /* Deprecated old WD ... */
! 6713: xmlFatalErr(ctxt, XML_ERR_XMLDECL_NOT_FINISHED, NULL);
! 6714: NEXT;
! 6715: } else {
! 6716: xmlFatalErr(ctxt, XML_ERR_XMLDECL_NOT_FINISHED, NULL);
! 6717: MOVETO_ENDTAG(CUR_PTR);
! 6718: NEXT;
! 6719: }
! 6720: }
! 6721:
! 6722: /**
! 6723: * xmlParseExternalSubset:
! 6724: * @ctxt: an XML parser context
! 6725: * @ExternalID: the external identifier
! 6726: * @SystemID: the system identifier (or URL)
! 6727: *
! 6728: * parse Markup declarations from an external subset
! 6729: *
! 6730: * [30] extSubset ::= textDecl? extSubsetDecl
! 6731: *
! 6732: * [31] extSubsetDecl ::= (markupdecl | conditionalSect | PEReference | S) *
! 6733: */
! 6734: void
! 6735: xmlParseExternalSubset(xmlParserCtxtPtr ctxt, const xmlChar *ExternalID,
! 6736: const xmlChar *SystemID) {
! 6737: xmlDetectSAX2(ctxt);
! 6738: GROW;
! 6739:
! 6740: if ((ctxt->encoding == NULL) &&
! 6741: (ctxt->input->end - ctxt->input->cur >= 4)) {
! 6742: xmlChar start[4];
! 6743: xmlCharEncoding enc;
! 6744:
! 6745: start[0] = RAW;
! 6746: start[1] = NXT(1);
! 6747: start[2] = NXT(2);
! 6748: start[3] = NXT(3);
! 6749: enc = xmlDetectCharEncoding(start, 4);
! 6750: if (enc != XML_CHAR_ENCODING_NONE)
! 6751: xmlSwitchEncoding(ctxt, enc);
! 6752: }
! 6753:
! 6754: if (CMP5(CUR_PTR, '<', '?', 'x', 'm', 'l')) {
! 6755: xmlParseTextDecl(ctxt);
! 6756: if (ctxt->errNo == XML_ERR_UNSUPPORTED_ENCODING) {
! 6757: /*
! 6758: * The XML REC instructs us to stop parsing right here
! 6759: */
! 6760: ctxt->instate = XML_PARSER_EOF;
! 6761: return;
! 6762: }
! 6763: }
! 6764: if (ctxt->myDoc == NULL) {
! 6765: ctxt->myDoc = xmlNewDoc(BAD_CAST "1.0");
! 6766: if (ctxt->myDoc == NULL) {
! 6767: xmlErrMemory(ctxt, "New Doc failed");
! 6768: return;
! 6769: }
! 6770: ctxt->myDoc->properties = XML_DOC_INTERNAL;
! 6771: }
! 6772: if ((ctxt->myDoc != NULL) && (ctxt->myDoc->intSubset == NULL))
! 6773: xmlCreateIntSubset(ctxt->myDoc, NULL, ExternalID, SystemID);
! 6774:
! 6775: ctxt->instate = XML_PARSER_DTD;
! 6776: ctxt->external = 1;
! 6777: while (((RAW == '<') && (NXT(1) == '?')) ||
! 6778: ((RAW == '<') && (NXT(1) == '!')) ||
! 6779: (RAW == '%') || IS_BLANK_CH(CUR)) {
! 6780: const xmlChar *check = CUR_PTR;
! 6781: unsigned int cons = ctxt->input->consumed;
! 6782:
! 6783: GROW;
! 6784: if ((RAW == '<') && (NXT(1) == '!') && (NXT(2) == '[')) {
! 6785: xmlParseConditionalSections(ctxt);
! 6786: } else if (IS_BLANK_CH(CUR)) {
! 6787: NEXT;
! 6788: } else if (RAW == '%') {
! 6789: xmlParsePEReference(ctxt);
! 6790: } else
! 6791: xmlParseMarkupDecl(ctxt);
! 6792:
! 6793: /*
! 6794: * Pop-up of finished entities.
! 6795: */
! 6796: while ((RAW == 0) && (ctxt->inputNr > 1))
! 6797: xmlPopInput(ctxt);
! 6798:
! 6799: if ((CUR_PTR == check) && (cons == ctxt->input->consumed)) {
! 6800: xmlFatalErr(ctxt, XML_ERR_EXT_SUBSET_NOT_FINISHED, NULL);
! 6801: break;
! 6802: }
! 6803: }
! 6804:
! 6805: if (RAW != 0) {
! 6806: xmlFatalErr(ctxt, XML_ERR_EXT_SUBSET_NOT_FINISHED, NULL);
! 6807: }
! 6808:
! 6809: }
! 6810:
! 6811: /**
! 6812: * xmlParseReference:
! 6813: * @ctxt: an XML parser context
! 6814: *
! 6815: * parse and handle entity references in content, depending on the SAX
! 6816: * interface, this may end-up in a call to character() if this is a
! 6817: * CharRef, a predefined entity, if there is no reference() callback.
! 6818: * or if the parser was asked to switch to that mode.
! 6819: *
! 6820: * [67] Reference ::= EntityRef | CharRef
! 6821: */
! 6822: void
! 6823: xmlParseReference(xmlParserCtxtPtr ctxt) {
! 6824: xmlEntityPtr ent;
! 6825: xmlChar *val;
! 6826: int was_checked;
! 6827: xmlNodePtr list = NULL;
! 6828: xmlParserErrors ret = XML_ERR_OK;
! 6829:
! 6830:
! 6831: if (RAW != '&')
! 6832: return;
! 6833:
! 6834: /*
! 6835: * Simple case of a CharRef
! 6836: */
! 6837: if (NXT(1) == '#') {
! 6838: int i = 0;
! 6839: xmlChar out[10];
! 6840: int hex = NXT(2);
! 6841: int value = xmlParseCharRef(ctxt);
! 6842:
! 6843: if (value == 0)
! 6844: return;
! 6845: if (ctxt->charset != XML_CHAR_ENCODING_UTF8) {
! 6846: /*
! 6847: * So we are using non-UTF-8 buffers
! 6848: * Check that the char fit on 8bits, if not
! 6849: * generate a CharRef.
! 6850: */
! 6851: if (value <= 0xFF) {
! 6852: out[0] = value;
! 6853: out[1] = 0;
! 6854: if ((ctxt->sax != NULL) && (ctxt->sax->characters != NULL) &&
! 6855: (!ctxt->disableSAX))
! 6856: ctxt->sax->characters(ctxt->userData, out, 1);
! 6857: } else {
! 6858: if ((hex == 'x') || (hex == 'X'))
! 6859: snprintf((char *)out, sizeof(out), "#x%X", value);
! 6860: else
! 6861: snprintf((char *)out, sizeof(out), "#%d", value);
! 6862: if ((ctxt->sax != NULL) && (ctxt->sax->reference != NULL) &&
! 6863: (!ctxt->disableSAX))
! 6864: ctxt->sax->reference(ctxt->userData, out);
! 6865: }
! 6866: } else {
! 6867: /*
! 6868: * Just encode the value in UTF-8
! 6869: */
! 6870: COPY_BUF(0 ,out, i, value);
! 6871: out[i] = 0;
! 6872: if ((ctxt->sax != NULL) && (ctxt->sax->characters != NULL) &&
! 6873: (!ctxt->disableSAX))
! 6874: ctxt->sax->characters(ctxt->userData, out, i);
! 6875: }
! 6876: return;
! 6877: }
! 6878:
! 6879: /*
! 6880: * We are seeing an entity reference
! 6881: */
! 6882: ent = xmlParseEntityRef(ctxt);
! 6883: if (ent == NULL) return;
! 6884: if (!ctxt->wellFormed)
! 6885: return;
! 6886: was_checked = ent->checked;
! 6887:
! 6888: /* special case of predefined entities */
! 6889: if ((ent->name == NULL) ||
! 6890: (ent->etype == XML_INTERNAL_PREDEFINED_ENTITY)) {
! 6891: val = ent->content;
! 6892: if (val == NULL) return;
! 6893: /*
! 6894: * inline the entity.
! 6895: */
! 6896: if ((ctxt->sax != NULL) && (ctxt->sax->characters != NULL) &&
! 6897: (!ctxt->disableSAX))
! 6898: ctxt->sax->characters(ctxt->userData, val, xmlStrlen(val));
! 6899: return;
! 6900: }
! 6901:
! 6902: /*
! 6903: * The first reference to the entity trigger a parsing phase
! 6904: * where the ent->children is filled with the result from
! 6905: * the parsing.
! 6906: */
! 6907: if (ent->checked == 0) {
! 6908: unsigned long oldnbent = ctxt->nbentities;
! 6909:
! 6910: /*
! 6911: * This is a bit hackish but this seems the best
! 6912: * way to make sure both SAX and DOM entity support
! 6913: * behaves okay.
! 6914: */
! 6915: void *user_data;
! 6916: if (ctxt->userData == ctxt)
! 6917: user_data = NULL;
! 6918: else
! 6919: user_data = ctxt->userData;
! 6920:
! 6921: /*
! 6922: * Check that this entity is well formed
! 6923: * 4.3.2: An internal general parsed entity is well-formed
! 6924: * if its replacement text matches the production labeled
! 6925: * content.
! 6926: */
! 6927: if (ent->etype == XML_INTERNAL_GENERAL_ENTITY) {
! 6928: ctxt->depth++;
! 6929: ret = xmlParseBalancedChunkMemoryInternal(ctxt, ent->content,
! 6930: user_data, &list);
! 6931: ctxt->depth--;
! 6932:
! 6933: } else if (ent->etype == XML_EXTERNAL_GENERAL_PARSED_ENTITY) {
! 6934: ctxt->depth++;
! 6935: ret = xmlParseExternalEntityPrivate(ctxt->myDoc, ctxt, ctxt->sax,
! 6936: user_data, ctxt->depth, ent->URI,
! 6937: ent->ExternalID, &list);
! 6938: ctxt->depth--;
! 6939: } else {
! 6940: ret = XML_ERR_ENTITY_PE_INTERNAL;
! 6941: xmlErrMsgStr(ctxt, XML_ERR_INTERNAL_ERROR,
! 6942: "invalid entity type found\n", NULL);
! 6943: }
! 6944:
! 6945: /*
! 6946: * Store the number of entities needing parsing for this entity
! 6947: * content and do checkings
! 6948: */
! 6949: ent->checked = ctxt->nbentities - oldnbent;
! 6950: if (ret == XML_ERR_ENTITY_LOOP) {
! 6951: xmlFatalErr(ctxt, XML_ERR_ENTITY_LOOP, NULL);
! 6952: xmlFreeNodeList(list);
! 6953: return;
! 6954: }
! 6955: if (xmlParserEntityCheck(ctxt, 0, ent)) {
! 6956: xmlFreeNodeList(list);
! 6957: return;
! 6958: }
! 6959:
! 6960: if ((ret == XML_ERR_OK) && (list != NULL)) {
! 6961: if (((ent->etype == XML_INTERNAL_GENERAL_ENTITY) ||
! 6962: (ent->etype == XML_EXTERNAL_GENERAL_PARSED_ENTITY))&&
! 6963: (ent->children == NULL)) {
! 6964: ent->children = list;
! 6965: if (ctxt->replaceEntities) {
! 6966: /*
! 6967: * Prune it directly in the generated document
! 6968: * except for single text nodes.
! 6969: */
! 6970: if (((list->type == XML_TEXT_NODE) &&
! 6971: (list->next == NULL)) ||
! 6972: (ctxt->parseMode == XML_PARSE_READER)) {
! 6973: list->parent = (xmlNodePtr) ent;
! 6974: list = NULL;
! 6975: ent->owner = 1;
! 6976: } else {
! 6977: ent->owner = 0;
! 6978: while (list != NULL) {
! 6979: list->parent = (xmlNodePtr) ctxt->node;
! 6980: list->doc = ctxt->myDoc;
! 6981: if (list->next == NULL)
! 6982: ent->last = list;
! 6983: list = list->next;
! 6984: }
! 6985: list = ent->children;
! 6986: #ifdef LIBXML_LEGACY_ENABLED
! 6987: if (ent->etype == XML_EXTERNAL_GENERAL_PARSED_ENTITY)
! 6988: xmlAddEntityReference(ent, list, NULL);
! 6989: #endif /* LIBXML_LEGACY_ENABLED */
! 6990: }
! 6991: } else {
! 6992: ent->owner = 1;
! 6993: while (list != NULL) {
! 6994: list->parent = (xmlNodePtr) ent;
! 6995: if (list->next == NULL)
! 6996: ent->last = list;
! 6997: list = list->next;
! 6998: }
! 6999: }
! 7000: } else {
! 7001: xmlFreeNodeList(list);
! 7002: list = NULL;
! 7003: }
! 7004: } else if ((ret != XML_ERR_OK) &&
! 7005: (ret != XML_WAR_UNDECLARED_ENTITY)) {
! 7006: xmlFatalErrMsgStr(ctxt, XML_ERR_UNDECLARED_ENTITY,
! 7007: "Entity '%s' failed to parse\n", ent->name);
! 7008: } else if (list != NULL) {
! 7009: xmlFreeNodeList(list);
! 7010: list = NULL;
! 7011: }
! 7012: if (ent->checked == 0)
! 7013: ent->checked = 1;
! 7014: } else if (ent->checked != 1) {
! 7015: ctxt->nbentities += ent->checked;
! 7016: }
! 7017:
! 7018: /*
! 7019: * Now that the entity content has been gathered
! 7020: * provide it to the application, this can take different forms based
! 7021: * on the parsing modes.
! 7022: */
! 7023: if (ent->children == NULL) {
! 7024: /*
! 7025: * Probably running in SAX mode and the callbacks don't
! 7026: * build the entity content. So unless we already went
! 7027: * though parsing for first checking go though the entity
! 7028: * content to generate callbacks associated to the entity
! 7029: */
! 7030: if (was_checked != 0) {
! 7031: void *user_data;
! 7032: /*
! 7033: * This is a bit hackish but this seems the best
! 7034: * way to make sure both SAX and DOM entity support
! 7035: * behaves okay.
! 7036: */
! 7037: if (ctxt->userData == ctxt)
! 7038: user_data = NULL;
! 7039: else
! 7040: user_data = ctxt->userData;
! 7041:
! 7042: if (ent->etype == XML_INTERNAL_GENERAL_ENTITY) {
! 7043: ctxt->depth++;
! 7044: ret = xmlParseBalancedChunkMemoryInternal(ctxt,
! 7045: ent->content, user_data, NULL);
! 7046: ctxt->depth--;
! 7047: } else if (ent->etype ==
! 7048: XML_EXTERNAL_GENERAL_PARSED_ENTITY) {
! 7049: ctxt->depth++;
! 7050: ret = xmlParseExternalEntityPrivate(ctxt->myDoc, ctxt,
! 7051: ctxt->sax, user_data, ctxt->depth,
! 7052: ent->URI, ent->ExternalID, NULL);
! 7053: ctxt->depth--;
! 7054: } else {
! 7055: ret = XML_ERR_ENTITY_PE_INTERNAL;
! 7056: xmlErrMsgStr(ctxt, XML_ERR_INTERNAL_ERROR,
! 7057: "invalid entity type found\n", NULL);
! 7058: }
! 7059: if (ret == XML_ERR_ENTITY_LOOP) {
! 7060: xmlFatalErr(ctxt, XML_ERR_ENTITY_LOOP, NULL);
! 7061: return;
! 7062: }
! 7063: }
! 7064: if ((ctxt->sax != NULL) && (ctxt->sax->reference != NULL) &&
! 7065: (ctxt->replaceEntities == 0) && (!ctxt->disableSAX)) {
! 7066: /*
! 7067: * Entity reference callback comes second, it's somewhat
! 7068: * superfluous but a compatibility to historical behaviour
! 7069: */
! 7070: ctxt->sax->reference(ctxt->userData, ent->name);
! 7071: }
! 7072: return;
! 7073: }
! 7074:
! 7075: /*
! 7076: * If we didn't get any children for the entity being built
! 7077: */
! 7078: if ((ctxt->sax != NULL) && (ctxt->sax->reference != NULL) &&
! 7079: (ctxt->replaceEntities == 0) && (!ctxt->disableSAX)) {
! 7080: /*
! 7081: * Create a node.
! 7082: */
! 7083: ctxt->sax->reference(ctxt->userData, ent->name);
! 7084: return;
! 7085: }
! 7086:
! 7087: if ((ctxt->replaceEntities) || (ent->children == NULL)) {
! 7088: /*
! 7089: * There is a problem on the handling of _private for entities
! 7090: * (bug 155816): Should we copy the content of the field from
! 7091: * the entity (possibly overwriting some value set by the user
! 7092: * when a copy is created), should we leave it alone, or should
! 7093: * we try to take care of different situations? The problem
! 7094: * is exacerbated by the usage of this field by the xmlReader.
! 7095: * To fix this bug, we look at _private on the created node
! 7096: * and, if it's NULL, we copy in whatever was in the entity.
! 7097: * If it's not NULL we leave it alone. This is somewhat of a
! 7098: * hack - maybe we should have further tests to determine
! 7099: * what to do.
! 7100: */
! 7101: if ((ctxt->node != NULL) && (ent->children != NULL)) {
! 7102: /*
! 7103: * Seems we are generating the DOM content, do
! 7104: * a simple tree copy for all references except the first
! 7105: * In the first occurrence list contains the replacement.
! 7106: * progressive == 2 means we are operating on the Reader
! 7107: * and since nodes are discarded we must copy all the time.
! 7108: */
! 7109: if (((list == NULL) && (ent->owner == 0)) ||
! 7110: (ctxt->parseMode == XML_PARSE_READER)) {
! 7111: xmlNodePtr nw = NULL, cur, firstChild = NULL;
! 7112:
! 7113: /*
! 7114: * when operating on a reader, the entities definitions
! 7115: * are always owning the entities subtree.
! 7116: if (ctxt->parseMode == XML_PARSE_READER)
! 7117: ent->owner = 1;
! 7118: */
! 7119:
! 7120: cur = ent->children;
! 7121: while (cur != NULL) {
! 7122: nw = xmlDocCopyNode(cur, ctxt->myDoc, 1);
! 7123: if (nw != NULL) {
! 7124: if (nw->_private == NULL)
! 7125: nw->_private = cur->_private;
! 7126: if (firstChild == NULL){
! 7127: firstChild = nw;
! 7128: }
! 7129: nw = xmlAddChild(ctxt->node, nw);
! 7130: }
! 7131: if (cur == ent->last) {
! 7132: /*
! 7133: * needed to detect some strange empty
! 7134: * node cases in the reader tests
! 7135: */
! 7136: if ((ctxt->parseMode == XML_PARSE_READER) &&
! 7137: (nw != NULL) &&
! 7138: (nw->type == XML_ELEMENT_NODE) &&
! 7139: (nw->children == NULL))
! 7140: nw->extra = 1;
! 7141:
! 7142: break;
! 7143: }
! 7144: cur = cur->next;
! 7145: }
! 7146: #ifdef LIBXML_LEGACY_ENABLED
! 7147: if (ent->etype == XML_EXTERNAL_GENERAL_PARSED_ENTITY)
! 7148: xmlAddEntityReference(ent, firstChild, nw);
! 7149: #endif /* LIBXML_LEGACY_ENABLED */
! 7150: } else if (list == NULL) {
! 7151: xmlNodePtr nw = NULL, cur, next, last,
! 7152: firstChild = NULL;
! 7153: /*
! 7154: * Copy the entity child list and make it the new
! 7155: * entity child list. The goal is to make sure any
! 7156: * ID or REF referenced will be the one from the
! 7157: * document content and not the entity copy.
! 7158: */
! 7159: cur = ent->children;
! 7160: ent->children = NULL;
! 7161: last = ent->last;
! 7162: ent->last = NULL;
! 7163: while (cur != NULL) {
! 7164: next = cur->next;
! 7165: cur->next = NULL;
! 7166: cur->parent = NULL;
! 7167: nw = xmlDocCopyNode(cur, ctxt->myDoc, 1);
! 7168: if (nw != NULL) {
! 7169: if (nw->_private == NULL)
! 7170: nw->_private = cur->_private;
! 7171: if (firstChild == NULL){
! 7172: firstChild = cur;
! 7173: }
! 7174: xmlAddChild((xmlNodePtr) ent, nw);
! 7175: xmlAddChild(ctxt->node, cur);
! 7176: }
! 7177: if (cur == last)
! 7178: break;
! 7179: cur = next;
! 7180: }
! 7181: if (ent->owner == 0)
! 7182: ent->owner = 1;
! 7183: #ifdef LIBXML_LEGACY_ENABLED
! 7184: if (ent->etype == XML_EXTERNAL_GENERAL_PARSED_ENTITY)
! 7185: xmlAddEntityReference(ent, firstChild, nw);
! 7186: #endif /* LIBXML_LEGACY_ENABLED */
! 7187: } else {
! 7188: const xmlChar *nbktext;
! 7189:
! 7190: /*
! 7191: * the name change is to avoid coalescing of the
! 7192: * node with a possible previous text one which
! 7193: * would make ent->children a dangling pointer
! 7194: */
! 7195: nbktext = xmlDictLookup(ctxt->dict, BAD_CAST "nbktext",
! 7196: -1);
! 7197: if (ent->children->type == XML_TEXT_NODE)
! 7198: ent->children->name = nbktext;
! 7199: if ((ent->last != ent->children) &&
! 7200: (ent->last->type == XML_TEXT_NODE))
! 7201: ent->last->name = nbktext;
! 7202: xmlAddChildList(ctxt->node, ent->children);
! 7203: }
! 7204:
! 7205: /*
! 7206: * This is to avoid a nasty side effect, see
! 7207: * characters() in SAX.c
! 7208: */
! 7209: ctxt->nodemem = 0;
! 7210: ctxt->nodelen = 0;
! 7211: return;
! 7212: }
! 7213: }
! 7214: }
! 7215:
! 7216: /**
! 7217: * xmlParseEntityRef:
! 7218: * @ctxt: an XML parser context
! 7219: *
! 7220: * parse ENTITY references declarations
! 7221: *
! 7222: * [68] EntityRef ::= '&' Name ';'
! 7223: *
! 7224: * [ WFC: Entity Declared ]
! 7225: * In a document without any DTD, a document with only an internal DTD
! 7226: * subset which contains no parameter entity references, or a document
! 7227: * with "standalone='yes'", the Name given in the entity reference
! 7228: * must match that in an entity declaration, except that well-formed
! 7229: * documents need not declare any of the following entities: amp, lt,
! 7230: * gt, apos, quot. The declaration of a parameter entity must precede
! 7231: * any reference to it. Similarly, the declaration of a general entity
! 7232: * must precede any reference to it which appears in a default value in an
! 7233: * attribute-list declaration. Note that if entities are declared in the
! 7234: * external subset or in external parameter entities, a non-validating
! 7235: * processor is not obligated to read and process their declarations;
! 7236: * for such documents, the rule that an entity must be declared is a
! 7237: * well-formedness constraint only if standalone='yes'.
! 7238: *
! 7239: * [ WFC: Parsed Entity ]
! 7240: * An entity reference must not contain the name of an unparsed entity
! 7241: *
! 7242: * Returns the xmlEntityPtr if found, or NULL otherwise.
! 7243: */
! 7244: xmlEntityPtr
! 7245: xmlParseEntityRef(xmlParserCtxtPtr ctxt) {
! 7246: const xmlChar *name;
! 7247: xmlEntityPtr ent = NULL;
! 7248:
! 7249: GROW;
! 7250:
! 7251: if (RAW != '&')
! 7252: return(NULL);
! 7253: NEXT;
! 7254: name = xmlParseName(ctxt);
! 7255: if (name == NULL) {
! 7256: xmlFatalErrMsg(ctxt, XML_ERR_NAME_REQUIRED,
! 7257: "xmlParseEntityRef: no name\n");
! 7258: return(NULL);
! 7259: }
! 7260: if (RAW != ';') {
! 7261: xmlFatalErr(ctxt, XML_ERR_ENTITYREF_SEMICOL_MISSING, NULL);
! 7262: return(NULL);
! 7263: }
! 7264: NEXT;
! 7265:
! 7266: /*
! 7267: * Predefined entites override any extra definition
! 7268: */
! 7269: if ((ctxt->options & XML_PARSE_OLDSAX) == 0) {
! 7270: ent = xmlGetPredefinedEntity(name);
! 7271: if (ent != NULL)
! 7272: return(ent);
! 7273: }
! 7274:
! 7275: /*
! 7276: * Increate the number of entity references parsed
! 7277: */
! 7278: ctxt->nbentities++;
! 7279:
! 7280: /*
! 7281: * Ask first SAX for entity resolution, otherwise try the
! 7282: * entities which may have stored in the parser context.
! 7283: */
! 7284: if (ctxt->sax != NULL) {
! 7285: if (ctxt->sax->getEntity != NULL)
! 7286: ent = ctxt->sax->getEntity(ctxt->userData, name);
! 7287: if ((ctxt->wellFormed == 1 ) && (ent == NULL) &&
! 7288: (ctxt->options & XML_PARSE_OLDSAX))
! 7289: ent = xmlGetPredefinedEntity(name);
! 7290: if ((ctxt->wellFormed == 1 ) && (ent == NULL) &&
! 7291: (ctxt->userData==ctxt)) {
! 7292: ent = xmlSAX2GetEntity(ctxt, name);
! 7293: }
! 7294: }
! 7295: /*
! 7296: * [ WFC: Entity Declared ]
! 7297: * In a document without any DTD, a document with only an
! 7298: * internal DTD subset which contains no parameter entity
! 7299: * references, or a document with "standalone='yes'", the
! 7300: * Name given in the entity reference must match that in an
! 7301: * entity declaration, except that well-formed documents
! 7302: * need not declare any of the following entities: amp, lt,
! 7303: * gt, apos, quot.
! 7304: * The declaration of a parameter entity must precede any
! 7305: * reference to it.
! 7306: * Similarly, the declaration of a general entity must
! 7307: * precede any reference to it which appears in a default
! 7308: * value in an attribute-list declaration. Note that if
! 7309: * entities are declared in the external subset or in
! 7310: * external parameter entities, a non-validating processor
! 7311: * is not obligated to read and process their declarations;
! 7312: * for such documents, the rule that an entity must be
! 7313: * declared is a well-formedness constraint only if
! 7314: * standalone='yes'.
! 7315: */
! 7316: if (ent == NULL) {
! 7317: if ((ctxt->standalone == 1) ||
! 7318: ((ctxt->hasExternalSubset == 0) &&
! 7319: (ctxt->hasPErefs == 0))) {
! 7320: xmlFatalErrMsgStr(ctxt, XML_ERR_UNDECLARED_ENTITY,
! 7321: "Entity '%s' not defined\n", name);
! 7322: } else {
! 7323: xmlErrMsgStr(ctxt, XML_WAR_UNDECLARED_ENTITY,
! 7324: "Entity '%s' not defined\n", name);
! 7325: if ((ctxt->inSubset == 0) &&
! 7326: (ctxt->sax != NULL) &&
! 7327: (ctxt->sax->reference != NULL)) {
! 7328: ctxt->sax->reference(ctxt->userData, name);
! 7329: }
! 7330: }
! 7331: ctxt->valid = 0;
! 7332: }
! 7333:
! 7334: /*
! 7335: * [ WFC: Parsed Entity ]
! 7336: * An entity reference must not contain the name of an
! 7337: * unparsed entity
! 7338: */
! 7339: else if (ent->etype == XML_EXTERNAL_GENERAL_UNPARSED_ENTITY) {
! 7340: xmlFatalErrMsgStr(ctxt, XML_ERR_UNPARSED_ENTITY,
! 7341: "Entity reference to unparsed entity %s\n", name);
! 7342: }
! 7343:
! 7344: /*
! 7345: * [ WFC: No External Entity References ]
! 7346: * Attribute values cannot contain direct or indirect
! 7347: * entity references to external entities.
! 7348: */
! 7349: else if ((ctxt->instate == XML_PARSER_ATTRIBUTE_VALUE) &&
! 7350: (ent->etype == XML_EXTERNAL_GENERAL_PARSED_ENTITY)) {
! 7351: xmlFatalErrMsgStr(ctxt, XML_ERR_ENTITY_IS_EXTERNAL,
! 7352: "Attribute references external entity '%s'\n", name);
! 7353: }
! 7354: /*
! 7355: * [ WFC: No < in Attribute Values ]
! 7356: * The replacement text of any entity referred to directly or
! 7357: * indirectly in an attribute value (other than "<") must
! 7358: * not contain a <.
! 7359: */
! 7360: else if ((ctxt->instate == XML_PARSER_ATTRIBUTE_VALUE) &&
! 7361: (ent != NULL) && (ent->content != NULL) &&
! 7362: (ent->etype != XML_INTERNAL_PREDEFINED_ENTITY) &&
! 7363: (xmlStrchr(ent->content, '<'))) {
! 7364: xmlFatalErrMsgStr(ctxt, XML_ERR_LT_IN_ATTRIBUTE,
! 7365: "'<' in entity '%s' is not allowed in attributes values\n", name);
! 7366: }
! 7367:
! 7368: /*
! 7369: * Internal check, no parameter entities here ...
! 7370: */
! 7371: else {
! 7372: switch (ent->etype) {
! 7373: case XML_INTERNAL_PARAMETER_ENTITY:
! 7374: case XML_EXTERNAL_PARAMETER_ENTITY:
! 7375: xmlFatalErrMsgStr(ctxt, XML_ERR_ENTITY_IS_PARAMETER,
! 7376: "Attempt to reference the parameter entity '%s'\n",
! 7377: name);
! 7378: break;
! 7379: default:
! 7380: break;
! 7381: }
! 7382: }
! 7383:
! 7384: /*
! 7385: * [ WFC: No Recursion ]
! 7386: * A parsed entity must not contain a recursive reference
! 7387: * to itself, either directly or indirectly.
! 7388: * Done somewhere else
! 7389: */
! 7390: return(ent);
! 7391: }
! 7392:
! 7393: /**
! 7394: * xmlParseStringEntityRef:
! 7395: * @ctxt: an XML parser context
! 7396: * @str: a pointer to an index in the string
! 7397: *
! 7398: * parse ENTITY references declarations, but this version parses it from
! 7399: * a string value.
! 7400: *
! 7401: * [68] EntityRef ::= '&' Name ';'
! 7402: *
! 7403: * [ WFC: Entity Declared ]
! 7404: * In a document without any DTD, a document with only an internal DTD
! 7405: * subset which contains no parameter entity references, or a document
! 7406: * with "standalone='yes'", the Name given in the entity reference
! 7407: * must match that in an entity declaration, except that well-formed
! 7408: * documents need not declare any of the following entities: amp, lt,
! 7409: * gt, apos, quot. The declaration of a parameter entity must precede
! 7410: * any reference to it. Similarly, the declaration of a general entity
! 7411: * must precede any reference to it which appears in a default value in an
! 7412: * attribute-list declaration. Note that if entities are declared in the
! 7413: * external subset or in external parameter entities, a non-validating
! 7414: * processor is not obligated to read and process their declarations;
! 7415: * for such documents, the rule that an entity must be declared is a
! 7416: * well-formedness constraint only if standalone='yes'.
! 7417: *
! 7418: * [ WFC: Parsed Entity ]
! 7419: * An entity reference must not contain the name of an unparsed entity
! 7420: *
! 7421: * Returns the xmlEntityPtr if found, or NULL otherwise. The str pointer
! 7422: * is updated to the current location in the string.
! 7423: */
! 7424: static xmlEntityPtr
! 7425: xmlParseStringEntityRef(xmlParserCtxtPtr ctxt, const xmlChar ** str) {
! 7426: xmlChar *name;
! 7427: const xmlChar *ptr;
! 7428: xmlChar cur;
! 7429: xmlEntityPtr ent = NULL;
! 7430:
! 7431: if ((str == NULL) || (*str == NULL))
! 7432: return(NULL);
! 7433: ptr = *str;
! 7434: cur = *ptr;
! 7435: if (cur != '&')
! 7436: return(NULL);
! 7437:
! 7438: ptr++;
! 7439: name = xmlParseStringName(ctxt, &ptr);
! 7440: if (name == NULL) {
! 7441: xmlFatalErrMsg(ctxt, XML_ERR_NAME_REQUIRED,
! 7442: "xmlParseStringEntityRef: no name\n");
! 7443: *str = ptr;
! 7444: return(NULL);
! 7445: }
! 7446: if (*ptr != ';') {
! 7447: xmlFatalErr(ctxt, XML_ERR_ENTITYREF_SEMICOL_MISSING, NULL);
! 7448: xmlFree(name);
! 7449: *str = ptr;
! 7450: return(NULL);
! 7451: }
! 7452: ptr++;
! 7453:
! 7454:
! 7455: /*
! 7456: * Predefined entites override any extra definition
! 7457: */
! 7458: if ((ctxt->options & XML_PARSE_OLDSAX) == 0) {
! 7459: ent = xmlGetPredefinedEntity(name);
! 7460: if (ent != NULL) {
! 7461: xmlFree(name);
! 7462: *str = ptr;
! 7463: return(ent);
! 7464: }
! 7465: }
! 7466:
! 7467: /*
! 7468: * Increate the number of entity references parsed
! 7469: */
! 7470: ctxt->nbentities++;
! 7471:
! 7472: /*
! 7473: * Ask first SAX for entity resolution, otherwise try the
! 7474: * entities which may have stored in the parser context.
! 7475: */
! 7476: if (ctxt->sax != NULL) {
! 7477: if (ctxt->sax->getEntity != NULL)
! 7478: ent = ctxt->sax->getEntity(ctxt->userData, name);
! 7479: if ((ent == NULL) && (ctxt->options & XML_PARSE_OLDSAX))
! 7480: ent = xmlGetPredefinedEntity(name);
! 7481: if ((ent == NULL) && (ctxt->userData==ctxt)) {
! 7482: ent = xmlSAX2GetEntity(ctxt, name);
! 7483: }
! 7484: }
! 7485:
! 7486: /*
! 7487: * [ WFC: Entity Declared ]
! 7488: * In a document without any DTD, a document with only an
! 7489: * internal DTD subset which contains no parameter entity
! 7490: * references, or a document with "standalone='yes'", the
! 7491: * Name given in the entity reference must match that in an
! 7492: * entity declaration, except that well-formed documents
! 7493: * need not declare any of the following entities: amp, lt,
! 7494: * gt, apos, quot.
! 7495: * The declaration of a parameter entity must precede any
! 7496: * reference to it.
! 7497: * Similarly, the declaration of a general entity must
! 7498: * precede any reference to it which appears in a default
! 7499: * value in an attribute-list declaration. Note that if
! 7500: * entities are declared in the external subset or in
! 7501: * external parameter entities, a non-validating processor
! 7502: * is not obligated to read and process their declarations;
! 7503: * for such documents, the rule that an entity must be
! 7504: * declared is a well-formedness constraint only if
! 7505: * standalone='yes'.
! 7506: */
! 7507: if (ent == NULL) {
! 7508: if ((ctxt->standalone == 1) ||
! 7509: ((ctxt->hasExternalSubset == 0) &&
! 7510: (ctxt->hasPErefs == 0))) {
! 7511: xmlFatalErrMsgStr(ctxt, XML_ERR_UNDECLARED_ENTITY,
! 7512: "Entity '%s' not defined\n", name);
! 7513: } else {
! 7514: xmlErrMsgStr(ctxt, XML_WAR_UNDECLARED_ENTITY,
! 7515: "Entity '%s' not defined\n",
! 7516: name);
! 7517: }
! 7518: /* TODO ? check regressions ctxt->valid = 0; */
! 7519: }
! 7520:
! 7521: /*
! 7522: * [ WFC: Parsed Entity ]
! 7523: * An entity reference must not contain the name of an
! 7524: * unparsed entity
! 7525: */
! 7526: else if (ent->etype == XML_EXTERNAL_GENERAL_UNPARSED_ENTITY) {
! 7527: xmlFatalErrMsgStr(ctxt, XML_ERR_UNPARSED_ENTITY,
! 7528: "Entity reference to unparsed entity %s\n", name);
! 7529: }
! 7530:
! 7531: /*
! 7532: * [ WFC: No External Entity References ]
! 7533: * Attribute values cannot contain direct or indirect
! 7534: * entity references to external entities.
! 7535: */
! 7536: else if ((ctxt->instate == XML_PARSER_ATTRIBUTE_VALUE) &&
! 7537: (ent->etype == XML_EXTERNAL_GENERAL_PARSED_ENTITY)) {
! 7538: xmlFatalErrMsgStr(ctxt, XML_ERR_ENTITY_IS_EXTERNAL,
! 7539: "Attribute references external entity '%s'\n", name);
! 7540: }
! 7541: /*
! 7542: * [ WFC: No < in Attribute Values ]
! 7543: * The replacement text of any entity referred to directly or
! 7544: * indirectly in an attribute value (other than "<") must
! 7545: * not contain a <.
! 7546: */
! 7547: else if ((ctxt->instate == XML_PARSER_ATTRIBUTE_VALUE) &&
! 7548: (ent != NULL) && (ent->content != NULL) &&
! 7549: (ent->etype != XML_INTERNAL_PREDEFINED_ENTITY) &&
! 7550: (xmlStrchr(ent->content, '<'))) {
! 7551: xmlFatalErrMsgStr(ctxt, XML_ERR_LT_IN_ATTRIBUTE,
! 7552: "'<' in entity '%s' is not allowed in attributes values\n",
! 7553: name);
! 7554: }
! 7555:
! 7556: /*
! 7557: * Internal check, no parameter entities here ...
! 7558: */
! 7559: else {
! 7560: switch (ent->etype) {
! 7561: case XML_INTERNAL_PARAMETER_ENTITY:
! 7562: case XML_EXTERNAL_PARAMETER_ENTITY:
! 7563: xmlFatalErrMsgStr(ctxt, XML_ERR_ENTITY_IS_PARAMETER,
! 7564: "Attempt to reference the parameter entity '%s'\n",
! 7565: name);
! 7566: break;
! 7567: default:
! 7568: break;
! 7569: }
! 7570: }
! 7571:
! 7572: /*
! 7573: * [ WFC: No Recursion ]
! 7574: * A parsed entity must not contain a recursive reference
! 7575: * to itself, either directly or indirectly.
! 7576: * Done somewhere else
! 7577: */
! 7578:
! 7579: xmlFree(name);
! 7580: *str = ptr;
! 7581: return(ent);
! 7582: }
! 7583:
! 7584: /**
! 7585: * xmlParsePEReference:
! 7586: * @ctxt: an XML parser context
! 7587: *
! 7588: * parse PEReference declarations
! 7589: * The entity content is handled directly by pushing it's content as
! 7590: * a new input stream.
! 7591: *
! 7592: * [69] PEReference ::= '%' Name ';'
! 7593: *
! 7594: * [ WFC: No Recursion ]
! 7595: * A parsed entity must not contain a recursive
! 7596: * reference to itself, either directly or indirectly.
! 7597: *
! 7598: * [ WFC: Entity Declared ]
! 7599: * In a document without any DTD, a document with only an internal DTD
! 7600: * subset which contains no parameter entity references, or a document
! 7601: * with "standalone='yes'", ... ... The declaration of a parameter
! 7602: * entity must precede any reference to it...
! 7603: *
! 7604: * [ VC: Entity Declared ]
! 7605: * In a document with an external subset or external parameter entities
! 7606: * with "standalone='no'", ... ... The declaration of a parameter entity
! 7607: * must precede any reference to it...
! 7608: *
! 7609: * [ WFC: In DTD ]
! 7610: * Parameter-entity references may only appear in the DTD.
! 7611: * NOTE: misleading but this is handled.
! 7612: */
! 7613: void
! 7614: xmlParsePEReference(xmlParserCtxtPtr ctxt)
! 7615: {
! 7616: const xmlChar *name;
! 7617: xmlEntityPtr entity = NULL;
! 7618: xmlParserInputPtr input;
! 7619:
! 7620: if (RAW != '%')
! 7621: return;
! 7622: NEXT;
! 7623: name = xmlParseName(ctxt);
! 7624: if (name == NULL) {
! 7625: xmlFatalErrMsg(ctxt, XML_ERR_NAME_REQUIRED,
! 7626: "xmlParsePEReference: no name\n");
! 7627: return;
! 7628: }
! 7629: if (RAW != ';') {
! 7630: xmlFatalErr(ctxt, XML_ERR_ENTITYREF_SEMICOL_MISSING, NULL);
! 7631: return;
! 7632: }
! 7633:
! 7634: NEXT;
! 7635:
! 7636: /*
! 7637: * Increate the number of entity references parsed
! 7638: */
! 7639: ctxt->nbentities++;
! 7640:
! 7641: /*
! 7642: * Request the entity from SAX
! 7643: */
! 7644: if ((ctxt->sax != NULL) &&
! 7645: (ctxt->sax->getParameterEntity != NULL))
! 7646: entity = ctxt->sax->getParameterEntity(ctxt->userData,
! 7647: name);
! 7648: if (entity == NULL) {
! 7649: /*
! 7650: * [ WFC: Entity Declared ]
! 7651: * In a document without any DTD, a document with only an
! 7652: * internal DTD subset which contains no parameter entity
! 7653: * references, or a document with "standalone='yes'", ...
! 7654: * ... The declaration of a parameter entity must precede
! 7655: * any reference to it...
! 7656: */
! 7657: if ((ctxt->standalone == 1) ||
! 7658: ((ctxt->hasExternalSubset == 0) &&
! 7659: (ctxt->hasPErefs == 0))) {
! 7660: xmlFatalErrMsgStr(ctxt, XML_ERR_UNDECLARED_ENTITY,
! 7661: "PEReference: %%%s; not found\n",
! 7662: name);
! 7663: } else {
! 7664: /*
! 7665: * [ VC: Entity Declared ]
! 7666: * In a document with an external subset or external
! 7667: * parameter entities with "standalone='no'", ...
! 7668: * ... The declaration of a parameter entity must
! 7669: * precede any reference to it...
! 7670: */
! 7671: xmlWarningMsg(ctxt, XML_WAR_UNDECLARED_ENTITY,
! 7672: "PEReference: %%%s; not found\n",
! 7673: name, NULL);
! 7674: ctxt->valid = 0;
! 7675: }
! 7676: } else {
! 7677: /*
! 7678: * Internal checking in case the entity quest barfed
! 7679: */
! 7680: if ((entity->etype != XML_INTERNAL_PARAMETER_ENTITY) &&
! 7681: (entity->etype != XML_EXTERNAL_PARAMETER_ENTITY)) {
! 7682: xmlWarningMsg(ctxt, XML_WAR_UNDECLARED_ENTITY,
! 7683: "Internal: %%%s; is not a parameter entity\n",
! 7684: name, NULL);
! 7685: } else if (ctxt->input->free != deallocblankswrapper) {
! 7686: input = xmlNewBlanksWrapperInputStream(ctxt, entity);
! 7687: if (xmlPushInput(ctxt, input) < 0)
! 7688: return;
! 7689: } else {
! 7690: /*
! 7691: * TODO !!!
! 7692: * handle the extra spaces added before and after
! 7693: * c.f. http://www.w3.org/TR/REC-xml#as-PE
! 7694: */
! 7695: input = xmlNewEntityInputStream(ctxt, entity);
! 7696: if (xmlPushInput(ctxt, input) < 0)
! 7697: return;
! 7698: if ((entity->etype == XML_EXTERNAL_PARAMETER_ENTITY) &&
! 7699: (CMP5(CUR_PTR, '<', '?', 'x', 'm', 'l')) &&
! 7700: (IS_BLANK_CH(NXT(5)))) {
! 7701: xmlParseTextDecl(ctxt);
! 7702: if (ctxt->errNo ==
! 7703: XML_ERR_UNSUPPORTED_ENCODING) {
! 7704: /*
! 7705: * The XML REC instructs us to stop parsing
! 7706: * right here
! 7707: */
! 7708: ctxt->instate = XML_PARSER_EOF;
! 7709: return;
! 7710: }
! 7711: }
! 7712: }
! 7713: }
! 7714: ctxt->hasPErefs = 1;
! 7715: }
! 7716:
! 7717: /**
! 7718: * xmlLoadEntityContent:
! 7719: * @ctxt: an XML parser context
! 7720: * @entity: an unloaded system entity
! 7721: *
! 7722: * Load the original content of the given system entity from the
! 7723: * ExternalID/SystemID given. This is to be used for Included in Literal
! 7724: * http://www.w3.org/TR/REC-xml/#inliteral processing of entities references
! 7725: *
! 7726: * Returns 0 in case of success and -1 in case of failure
! 7727: */
! 7728: static int
! 7729: xmlLoadEntityContent(xmlParserCtxtPtr ctxt, xmlEntityPtr entity) {
! 7730: xmlParserInputPtr input;
! 7731: xmlBufferPtr buf;
! 7732: int l, c;
! 7733: int count = 0;
! 7734:
! 7735: if ((ctxt == NULL) || (entity == NULL) ||
! 7736: ((entity->etype != XML_EXTERNAL_PARAMETER_ENTITY) &&
! 7737: (entity->etype != XML_EXTERNAL_GENERAL_PARSED_ENTITY)) ||
! 7738: (entity->content != NULL)) {
! 7739: xmlFatalErr(ctxt, XML_ERR_INTERNAL_ERROR,
! 7740: "xmlLoadEntityContent parameter error");
! 7741: return(-1);
! 7742: }
! 7743:
! 7744: if (xmlParserDebugEntities)
! 7745: xmlGenericError(xmlGenericErrorContext,
! 7746: "Reading %s entity content input\n", entity->name);
! 7747:
! 7748: buf = xmlBufferCreate();
! 7749: if (buf == NULL) {
! 7750: xmlFatalErr(ctxt, XML_ERR_INTERNAL_ERROR,
! 7751: "xmlLoadEntityContent parameter error");
! 7752: return(-1);
! 7753: }
! 7754:
! 7755: input = xmlNewEntityInputStream(ctxt, entity);
! 7756: if (input == NULL) {
! 7757: xmlFatalErr(ctxt, XML_ERR_INTERNAL_ERROR,
! 7758: "xmlLoadEntityContent input error");
! 7759: xmlBufferFree(buf);
! 7760: return(-1);
! 7761: }
! 7762:
! 7763: /*
! 7764: * Push the entity as the current input, read char by char
! 7765: * saving to the buffer until the end of the entity or an error
! 7766: */
! 7767: if (xmlPushInput(ctxt, input) < 0) {
! 7768: xmlBufferFree(buf);
! 7769: return(-1);
! 7770: }
! 7771:
! 7772: GROW;
! 7773: c = CUR_CHAR(l);
! 7774: while ((ctxt->input == input) && (ctxt->input->cur < ctxt->input->end) &&
! 7775: (IS_CHAR(c))) {
! 7776: xmlBufferAdd(buf, ctxt->input->cur, l);
! 7777: if (count++ > 100) {
! 7778: count = 0;
! 7779: GROW;
! 7780: }
! 7781: NEXTL(l);
! 7782: c = CUR_CHAR(l);
! 7783: }
! 7784:
! 7785: if ((ctxt->input == input) && (ctxt->input->cur >= ctxt->input->end)) {
! 7786: xmlPopInput(ctxt);
! 7787: } else if (!IS_CHAR(c)) {
! 7788: xmlFatalErrMsgInt(ctxt, XML_ERR_INVALID_CHAR,
! 7789: "xmlLoadEntityContent: invalid char value %d\n",
! 7790: c);
! 7791: xmlBufferFree(buf);
! 7792: return(-1);
! 7793: }
! 7794: entity->content = buf->content;
! 7795: buf->content = NULL;
! 7796: xmlBufferFree(buf);
! 7797:
! 7798: return(0);
! 7799: }
! 7800:
! 7801: /**
! 7802: * xmlParseStringPEReference:
! 7803: * @ctxt: an XML parser context
! 7804: * @str: a pointer to an index in the string
! 7805: *
! 7806: * parse PEReference declarations
! 7807: *
! 7808: * [69] PEReference ::= '%' Name ';'
! 7809: *
! 7810: * [ WFC: No Recursion ]
! 7811: * A parsed entity must not contain a recursive
! 7812: * reference to itself, either directly or indirectly.
! 7813: *
! 7814: * [ WFC: Entity Declared ]
! 7815: * In a document without any DTD, a document with only an internal DTD
! 7816: * subset which contains no parameter entity references, or a document
! 7817: * with "standalone='yes'", ... ... The declaration of a parameter
! 7818: * entity must precede any reference to it...
! 7819: *
! 7820: * [ VC: Entity Declared ]
! 7821: * In a document with an external subset or external parameter entities
! 7822: * with "standalone='no'", ... ... The declaration of a parameter entity
! 7823: * must precede any reference to it...
! 7824: *
! 7825: * [ WFC: In DTD ]
! 7826: * Parameter-entity references may only appear in the DTD.
! 7827: * NOTE: misleading but this is handled.
! 7828: *
! 7829: * Returns the string of the entity content.
! 7830: * str is updated to the current value of the index
! 7831: */
! 7832: static xmlEntityPtr
! 7833: xmlParseStringPEReference(xmlParserCtxtPtr ctxt, const xmlChar **str) {
! 7834: const xmlChar *ptr;
! 7835: xmlChar cur;
! 7836: xmlChar *name;
! 7837: xmlEntityPtr entity = NULL;
! 7838:
! 7839: if ((str == NULL) || (*str == NULL)) return(NULL);
! 7840: ptr = *str;
! 7841: cur = *ptr;
! 7842: if (cur != '%')
! 7843: return(NULL);
! 7844: ptr++;
! 7845: name = xmlParseStringName(ctxt, &ptr);
! 7846: if (name == NULL) {
! 7847: xmlFatalErrMsg(ctxt, XML_ERR_NAME_REQUIRED,
! 7848: "xmlParseStringPEReference: no name\n");
! 7849: *str = ptr;
! 7850: return(NULL);
! 7851: }
! 7852: cur = *ptr;
! 7853: if (cur != ';') {
! 7854: xmlFatalErr(ctxt, XML_ERR_ENTITYREF_SEMICOL_MISSING, NULL);
! 7855: xmlFree(name);
! 7856: *str = ptr;
! 7857: return(NULL);
! 7858: }
! 7859: ptr++;
! 7860:
! 7861: /*
! 7862: * Increate the number of entity references parsed
! 7863: */
! 7864: ctxt->nbentities++;
! 7865:
! 7866: /*
! 7867: * Request the entity from SAX
! 7868: */
! 7869: if ((ctxt->sax != NULL) &&
! 7870: (ctxt->sax->getParameterEntity != NULL))
! 7871: entity = ctxt->sax->getParameterEntity(ctxt->userData,
! 7872: name);
! 7873: if (entity == NULL) {
! 7874: /*
! 7875: * [ WFC: Entity Declared ]
! 7876: * In a document without any DTD, a document with only an
! 7877: * internal DTD subset which contains no parameter entity
! 7878: * references, or a document with "standalone='yes'", ...
! 7879: * ... The declaration of a parameter entity must precede
! 7880: * any reference to it...
! 7881: */
! 7882: if ((ctxt->standalone == 1) ||
! 7883: ((ctxt->hasExternalSubset == 0) && (ctxt->hasPErefs == 0))) {
! 7884: xmlFatalErrMsgStr(ctxt, XML_ERR_UNDECLARED_ENTITY,
! 7885: "PEReference: %%%s; not found\n", name);
! 7886: } else {
! 7887: /*
! 7888: * [ VC: Entity Declared ]
! 7889: * In a document with an external subset or external
! 7890: * parameter entities with "standalone='no'", ...
! 7891: * ... The declaration of a parameter entity must
! 7892: * precede any reference to it...
! 7893: */
! 7894: xmlWarningMsg(ctxt, XML_WAR_UNDECLARED_ENTITY,
! 7895: "PEReference: %%%s; not found\n",
! 7896: name, NULL);
! 7897: ctxt->valid = 0;
! 7898: }
! 7899: } else {
! 7900: /*
! 7901: * Internal checking in case the entity quest barfed
! 7902: */
! 7903: if ((entity->etype != XML_INTERNAL_PARAMETER_ENTITY) &&
! 7904: (entity->etype != XML_EXTERNAL_PARAMETER_ENTITY)) {
! 7905: xmlWarningMsg(ctxt, XML_WAR_UNDECLARED_ENTITY,
! 7906: "%%%s; is not a parameter entity\n",
! 7907: name, NULL);
! 7908: }
! 7909: }
! 7910: ctxt->hasPErefs = 1;
! 7911: xmlFree(name);
! 7912: *str = ptr;
! 7913: return(entity);
! 7914: }
! 7915:
! 7916: /**
! 7917: * xmlParseDocTypeDecl:
! 7918: * @ctxt: an XML parser context
! 7919: *
! 7920: * parse a DOCTYPE declaration
! 7921: *
! 7922: * [28] doctypedecl ::= '<!DOCTYPE' S Name (S ExternalID)? S?
! 7923: * ('[' (markupdecl | PEReference | S)* ']' S?)? '>'
! 7924: *
! 7925: * [ VC: Root Element Type ]
! 7926: * The Name in the document type declaration must match the element
! 7927: * type of the root element.
! 7928: */
! 7929:
! 7930: void
! 7931: xmlParseDocTypeDecl(xmlParserCtxtPtr ctxt) {
! 7932: const xmlChar *name = NULL;
! 7933: xmlChar *ExternalID = NULL;
! 7934: xmlChar *URI = NULL;
! 7935:
! 7936: /*
! 7937: * We know that '<!DOCTYPE' has been detected.
! 7938: */
! 7939: SKIP(9);
! 7940:
! 7941: SKIP_BLANKS;
! 7942:
! 7943: /*
! 7944: * Parse the DOCTYPE name.
! 7945: */
! 7946: name = xmlParseName(ctxt);
! 7947: if (name == NULL) {
! 7948: xmlFatalErrMsg(ctxt, XML_ERR_NAME_REQUIRED,
! 7949: "xmlParseDocTypeDecl : no DOCTYPE name !\n");
! 7950: }
! 7951: ctxt->intSubName = name;
! 7952:
! 7953: SKIP_BLANKS;
! 7954:
! 7955: /*
! 7956: * Check for SystemID and ExternalID
! 7957: */
! 7958: URI = xmlParseExternalID(ctxt, &ExternalID, 1);
! 7959:
! 7960: if ((URI != NULL) || (ExternalID != NULL)) {
! 7961: ctxt->hasExternalSubset = 1;
! 7962: }
! 7963: ctxt->extSubURI = URI;
! 7964: ctxt->extSubSystem = ExternalID;
! 7965:
! 7966: SKIP_BLANKS;
! 7967:
! 7968: /*
! 7969: * Create and update the internal subset.
! 7970: */
! 7971: if ((ctxt->sax != NULL) && (ctxt->sax->internalSubset != NULL) &&
! 7972: (!ctxt->disableSAX))
! 7973: ctxt->sax->internalSubset(ctxt->userData, name, ExternalID, URI);
! 7974:
! 7975: /*
! 7976: * Is there any internal subset declarations ?
! 7977: * they are handled separately in xmlParseInternalSubset()
! 7978: */
! 7979: if (RAW == '[')
! 7980: return;
! 7981:
! 7982: /*
! 7983: * We should be at the end of the DOCTYPE declaration.
! 7984: */
! 7985: if (RAW != '>') {
! 7986: xmlFatalErr(ctxt, XML_ERR_DOCTYPE_NOT_FINISHED, NULL);
! 7987: }
! 7988: NEXT;
! 7989: }
! 7990:
! 7991: /**
! 7992: * xmlParseInternalSubset:
! 7993: * @ctxt: an XML parser context
! 7994: *
! 7995: * parse the internal subset declaration
! 7996: *
! 7997: * [28 end] ('[' (markupdecl | PEReference | S)* ']' S?)? '>'
! 7998: */
! 7999:
! 8000: static void
! 8001: xmlParseInternalSubset(xmlParserCtxtPtr ctxt) {
! 8002: /*
! 8003: * Is there any DTD definition ?
! 8004: */
! 8005: if (RAW == '[') {
! 8006: ctxt->instate = XML_PARSER_DTD;
! 8007: NEXT;
! 8008: /*
! 8009: * Parse the succession of Markup declarations and
! 8010: * PEReferences.
! 8011: * Subsequence (markupdecl | PEReference | S)*
! 8012: */
! 8013: while (RAW != ']') {
! 8014: const xmlChar *check = CUR_PTR;
! 8015: unsigned int cons = ctxt->input->consumed;
! 8016:
! 8017: SKIP_BLANKS;
! 8018: xmlParseMarkupDecl(ctxt);
! 8019: xmlParsePEReference(ctxt);
! 8020:
! 8021: /*
! 8022: * Pop-up of finished entities.
! 8023: */
! 8024: while ((RAW == 0) && (ctxt->inputNr > 1))
! 8025: xmlPopInput(ctxt);
! 8026:
! 8027: if ((CUR_PTR == check) && (cons == ctxt->input->consumed)) {
! 8028: xmlFatalErr(ctxt, XML_ERR_INTERNAL_ERROR,
! 8029: "xmlParseInternalSubset: error detected in Markup declaration\n");
! 8030: break;
! 8031: }
! 8032: }
! 8033: if (RAW == ']') {
! 8034: NEXT;
! 8035: SKIP_BLANKS;
! 8036: }
! 8037: }
! 8038:
! 8039: /*
! 8040: * We should be at the end of the DOCTYPE declaration.
! 8041: */
! 8042: if (RAW != '>') {
! 8043: xmlFatalErr(ctxt, XML_ERR_DOCTYPE_NOT_FINISHED, NULL);
! 8044: }
! 8045: NEXT;
! 8046: }
! 8047:
! 8048: #ifdef LIBXML_SAX1_ENABLED
! 8049: /**
! 8050: * xmlParseAttribute:
! 8051: * @ctxt: an XML parser context
! 8052: * @value: a xmlChar ** used to store the value of the attribute
! 8053: *
! 8054: * parse an attribute
! 8055: *
! 8056: * [41] Attribute ::= Name Eq AttValue
! 8057: *
! 8058: * [ WFC: No External Entity References ]
! 8059: * Attribute values cannot contain direct or indirect entity references
! 8060: * to external entities.
! 8061: *
! 8062: * [ WFC: No < in Attribute Values ]
! 8063: * The replacement text of any entity referred to directly or indirectly in
! 8064: * an attribute value (other than "<") must not contain a <.
! 8065: *
! 8066: * [ VC: Attribute Value Type ]
! 8067: * The attribute must have been declared; the value must be of the type
! 8068: * declared for it.
! 8069: *
! 8070: * [25] Eq ::= S? '=' S?
! 8071: *
! 8072: * With namespace:
! 8073: *
! 8074: * [NS 11] Attribute ::= QName Eq AttValue
! 8075: *
! 8076: * Also the case QName == xmlns:??? is handled independently as a namespace
! 8077: * definition.
! 8078: *
! 8079: * Returns the attribute name, and the value in *value.
! 8080: */
! 8081:
! 8082: const xmlChar *
! 8083: xmlParseAttribute(xmlParserCtxtPtr ctxt, xmlChar **value) {
! 8084: const xmlChar *name;
! 8085: xmlChar *val;
! 8086:
! 8087: *value = NULL;
! 8088: GROW;
! 8089: name = xmlParseName(ctxt);
! 8090: if (name == NULL) {
! 8091: xmlFatalErrMsg(ctxt, XML_ERR_NAME_REQUIRED,
! 8092: "error parsing attribute name\n");
! 8093: return(NULL);
! 8094: }
! 8095:
! 8096: /*
! 8097: * read the value
! 8098: */
! 8099: SKIP_BLANKS;
! 8100: if (RAW == '=') {
! 8101: NEXT;
! 8102: SKIP_BLANKS;
! 8103: val = xmlParseAttValue(ctxt);
! 8104: ctxt->instate = XML_PARSER_CONTENT;
! 8105: } else {
! 8106: xmlFatalErrMsgStr(ctxt, XML_ERR_ATTRIBUTE_WITHOUT_VALUE,
! 8107: "Specification mandate value for attribute %s\n", name);
! 8108: return(NULL);
! 8109: }
! 8110:
! 8111: /*
! 8112: * Check that xml:lang conforms to the specification
! 8113: * No more registered as an error, just generate a warning now
! 8114: * since this was deprecated in XML second edition
! 8115: */
! 8116: if ((ctxt->pedantic) && (xmlStrEqual(name, BAD_CAST "xml:lang"))) {
! 8117: if (!xmlCheckLanguageID(val)) {
! 8118: xmlWarningMsg(ctxt, XML_WAR_LANG_VALUE,
! 8119: "Malformed value for xml:lang : %s\n",
! 8120: val, NULL);
! 8121: }
! 8122: }
! 8123:
! 8124: /*
! 8125: * Check that xml:space conforms to the specification
! 8126: */
! 8127: if (xmlStrEqual(name, BAD_CAST "xml:space")) {
! 8128: if (xmlStrEqual(val, BAD_CAST "default"))
! 8129: *(ctxt->space) = 0;
! 8130: else if (xmlStrEqual(val, BAD_CAST "preserve"))
! 8131: *(ctxt->space) = 1;
! 8132: else {
! 8133: xmlWarningMsg(ctxt, XML_WAR_SPACE_VALUE,
! 8134: "Invalid value \"%s\" for xml:space : \"default\" or \"preserve\" expected\n",
! 8135: val, NULL);
! 8136: }
! 8137: }
! 8138:
! 8139: *value = val;
! 8140: return(name);
! 8141: }
! 8142:
! 8143: /**
! 8144: * xmlParseStartTag:
! 8145: * @ctxt: an XML parser context
! 8146: *
! 8147: * parse a start of tag either for rule element or
! 8148: * EmptyElement. In both case we don't parse the tag closing chars.
! 8149: *
! 8150: * [40] STag ::= '<' Name (S Attribute)* S? '>'
! 8151: *
! 8152: * [ WFC: Unique Att Spec ]
! 8153: * No attribute name may appear more than once in the same start-tag or
! 8154: * empty-element tag.
! 8155: *
! 8156: * [44] EmptyElemTag ::= '<' Name (S Attribute)* S? '/>'
! 8157: *
! 8158: * [ WFC: Unique Att Spec ]
! 8159: * No attribute name may appear more than once in the same start-tag or
! 8160: * empty-element tag.
! 8161: *
! 8162: * With namespace:
! 8163: *
! 8164: * [NS 8] STag ::= '<' QName (S Attribute)* S? '>'
! 8165: *
! 8166: * [NS 10] EmptyElement ::= '<' QName (S Attribute)* S? '/>'
! 8167: *
! 8168: * Returns the element name parsed
! 8169: */
! 8170:
! 8171: const xmlChar *
! 8172: xmlParseStartTag(xmlParserCtxtPtr ctxt) {
! 8173: const xmlChar *name;
! 8174: const xmlChar *attname;
! 8175: xmlChar *attvalue;
! 8176: const xmlChar **atts = ctxt->atts;
! 8177: int nbatts = 0;
! 8178: int maxatts = ctxt->maxatts;
! 8179: int i;
! 8180:
! 8181: if (RAW != '<') return(NULL);
! 8182: NEXT1;
! 8183:
! 8184: name = xmlParseName(ctxt);
! 8185: if (name == NULL) {
! 8186: xmlFatalErrMsg(ctxt, XML_ERR_NAME_REQUIRED,
! 8187: "xmlParseStartTag: invalid element name\n");
! 8188: return(NULL);
! 8189: }
! 8190:
! 8191: /*
! 8192: * Now parse the attributes, it ends up with the ending
! 8193: *
! 8194: * (S Attribute)* S?
! 8195: */
! 8196: SKIP_BLANKS;
! 8197: GROW;
! 8198:
! 8199: while ((RAW != '>') &&
! 8200: ((RAW != '/') || (NXT(1) != '>')) &&
! 8201: (IS_BYTE_CHAR(RAW))) {
! 8202: const xmlChar *q = CUR_PTR;
! 8203: unsigned int cons = ctxt->input->consumed;
! 8204:
! 8205: attname = xmlParseAttribute(ctxt, &attvalue);
! 8206: if ((attname != NULL) && (attvalue != NULL)) {
! 8207: /*
! 8208: * [ WFC: Unique Att Spec ]
! 8209: * No attribute name may appear more than once in the same
! 8210: * start-tag or empty-element tag.
! 8211: */
! 8212: for (i = 0; i < nbatts;i += 2) {
! 8213: if (xmlStrEqual(atts[i], attname)) {
! 8214: xmlErrAttributeDup(ctxt, NULL, attname);
! 8215: xmlFree(attvalue);
! 8216: goto failed;
! 8217: }
! 8218: }
! 8219: /*
! 8220: * Add the pair to atts
! 8221: */
! 8222: if (atts == NULL) {
! 8223: maxatts = 22; /* allow for 10 attrs by default */
! 8224: atts = (const xmlChar **)
! 8225: xmlMalloc(maxatts * sizeof(xmlChar *));
! 8226: if (atts == NULL) {
! 8227: xmlErrMemory(ctxt, NULL);
! 8228: if (attvalue != NULL)
! 8229: xmlFree(attvalue);
! 8230: goto failed;
! 8231: }
! 8232: ctxt->atts = atts;
! 8233: ctxt->maxatts = maxatts;
! 8234: } else if (nbatts + 4 > maxatts) {
! 8235: const xmlChar **n;
! 8236:
! 8237: maxatts *= 2;
! 8238: n = (const xmlChar **) xmlRealloc((void *) atts,
! 8239: maxatts * sizeof(const xmlChar *));
! 8240: if (n == NULL) {
! 8241: xmlErrMemory(ctxt, NULL);
! 8242: if (attvalue != NULL)
! 8243: xmlFree(attvalue);
! 8244: goto failed;
! 8245: }
! 8246: atts = n;
! 8247: ctxt->atts = atts;
! 8248: ctxt->maxatts = maxatts;
! 8249: }
! 8250: atts[nbatts++] = attname;
! 8251: atts[nbatts++] = attvalue;
! 8252: atts[nbatts] = NULL;
! 8253: atts[nbatts + 1] = NULL;
! 8254: } else {
! 8255: if (attvalue != NULL)
! 8256: xmlFree(attvalue);
! 8257: }
! 8258:
! 8259: failed:
! 8260:
! 8261: GROW
! 8262: if ((RAW == '>') || (((RAW == '/') && (NXT(1) == '>'))))
! 8263: break;
! 8264: if (!IS_BLANK_CH(RAW)) {
! 8265: xmlFatalErrMsg(ctxt, XML_ERR_SPACE_REQUIRED,
! 8266: "attributes construct error\n");
! 8267: }
! 8268: SKIP_BLANKS;
! 8269: if ((cons == ctxt->input->consumed) && (q == CUR_PTR) &&
! 8270: (attname == NULL) && (attvalue == NULL)) {
! 8271: xmlFatalErrMsg(ctxt, XML_ERR_INTERNAL_ERROR,
! 8272: "xmlParseStartTag: problem parsing attributes\n");
! 8273: break;
! 8274: }
! 8275: SHRINK;
! 8276: GROW;
! 8277: }
! 8278:
! 8279: /*
! 8280: * SAX: Start of Element !
! 8281: */
! 8282: if ((ctxt->sax != NULL) && (ctxt->sax->startElement != NULL) &&
! 8283: (!ctxt->disableSAX)) {
! 8284: if (nbatts > 0)
! 8285: ctxt->sax->startElement(ctxt->userData, name, atts);
! 8286: else
! 8287: ctxt->sax->startElement(ctxt->userData, name, NULL);
! 8288: }
! 8289:
! 8290: if (atts != NULL) {
! 8291: /* Free only the content strings */
! 8292: for (i = 1;i < nbatts;i+=2)
! 8293: if (atts[i] != NULL)
! 8294: xmlFree((xmlChar *) atts[i]);
! 8295: }
! 8296: return(name);
! 8297: }
! 8298:
! 8299: /**
! 8300: * xmlParseEndTag1:
! 8301: * @ctxt: an XML parser context
! 8302: * @line: line of the start tag
! 8303: * @nsNr: number of namespaces on the start tag
! 8304: *
! 8305: * parse an end of tag
! 8306: *
! 8307: * [42] ETag ::= '</' Name S? '>'
! 8308: *
! 8309: * With namespace
! 8310: *
! 8311: * [NS 9] ETag ::= '</' QName S? '>'
! 8312: */
! 8313:
! 8314: static void
! 8315: xmlParseEndTag1(xmlParserCtxtPtr ctxt, int line) {
! 8316: const xmlChar *name;
! 8317:
! 8318: GROW;
! 8319: if ((RAW != '<') || (NXT(1) != '/')) {
! 8320: xmlFatalErrMsg(ctxt, XML_ERR_LTSLASH_REQUIRED,
! 8321: "xmlParseEndTag: '</' not found\n");
! 8322: return;
! 8323: }
! 8324: SKIP(2);
! 8325:
! 8326: name = xmlParseNameAndCompare(ctxt,ctxt->name);
! 8327:
! 8328: /*
! 8329: * We should definitely be at the ending "S? '>'" part
! 8330: */
! 8331: GROW;
! 8332: SKIP_BLANKS;
! 8333: if ((!IS_BYTE_CHAR(RAW)) || (RAW != '>')) {
! 8334: xmlFatalErr(ctxt, XML_ERR_GT_REQUIRED, NULL);
! 8335: } else
! 8336: NEXT1;
! 8337:
! 8338: /*
! 8339: * [ WFC: Element Type Match ]
! 8340: * The Name in an element's end-tag must match the element type in the
! 8341: * start-tag.
! 8342: *
! 8343: */
! 8344: if (name != (xmlChar*)1) {
! 8345: if (name == NULL) name = BAD_CAST "unparseable";
! 8346: xmlFatalErrMsgStrIntStr(ctxt, XML_ERR_TAG_NAME_MISMATCH,
! 8347: "Opening and ending tag mismatch: %s line %d and %s\n",
! 8348: ctxt->name, line, name);
! 8349: }
! 8350:
! 8351: /*
! 8352: * SAX: End of Tag
! 8353: */
! 8354: if ((ctxt->sax != NULL) && (ctxt->sax->endElement != NULL) &&
! 8355: (!ctxt->disableSAX))
! 8356: ctxt->sax->endElement(ctxt->userData, ctxt->name);
! 8357:
! 8358: namePop(ctxt);
! 8359: spacePop(ctxt);
! 8360: return;
! 8361: }
! 8362:
! 8363: /**
! 8364: * xmlParseEndTag:
! 8365: * @ctxt: an XML parser context
! 8366: *
! 8367: * parse an end of tag
! 8368: *
! 8369: * [42] ETag ::= '</' Name S? '>'
! 8370: *
! 8371: * With namespace
! 8372: *
! 8373: * [NS 9] ETag ::= '</' QName S? '>'
! 8374: */
! 8375:
! 8376: void
! 8377: xmlParseEndTag(xmlParserCtxtPtr ctxt) {
! 8378: xmlParseEndTag1(ctxt, 0);
! 8379: }
! 8380: #endif /* LIBXML_SAX1_ENABLED */
! 8381:
! 8382: /************************************************************************
! 8383: * *
! 8384: * SAX 2 specific operations *
! 8385: * *
! 8386: ************************************************************************/
! 8387:
! 8388: /*
! 8389: * xmlGetNamespace:
! 8390: * @ctxt: an XML parser context
! 8391: * @prefix: the prefix to lookup
! 8392: *
! 8393: * Lookup the namespace name for the @prefix (which ca be NULL)
! 8394: * The prefix must come from the @ctxt->dict dictionnary
! 8395: *
! 8396: * Returns the namespace name or NULL if not bound
! 8397: */
! 8398: static const xmlChar *
! 8399: xmlGetNamespace(xmlParserCtxtPtr ctxt, const xmlChar *prefix) {
! 8400: int i;
! 8401:
! 8402: if (prefix == ctxt->str_xml) return(ctxt->str_xml_ns);
! 8403: for (i = ctxt->nsNr - 2;i >= 0;i-=2)
! 8404: if (ctxt->nsTab[i] == prefix) {
! 8405: if ((prefix == NULL) && (*ctxt->nsTab[i + 1] == 0))
! 8406: return(NULL);
! 8407: return(ctxt->nsTab[i + 1]);
! 8408: }
! 8409: return(NULL);
! 8410: }
! 8411:
! 8412: /**
! 8413: * xmlParseQName:
! 8414: * @ctxt: an XML parser context
! 8415: * @prefix: pointer to store the prefix part
! 8416: *
! 8417: * parse an XML Namespace QName
! 8418: *
! 8419: * [6] QName ::= (Prefix ':')? LocalPart
! 8420: * [7] Prefix ::= NCName
! 8421: * [8] LocalPart ::= NCName
! 8422: *
! 8423: * Returns the Name parsed or NULL
! 8424: */
! 8425:
! 8426: static const xmlChar *
! 8427: xmlParseQName(xmlParserCtxtPtr ctxt, const xmlChar **prefix) {
! 8428: const xmlChar *l, *p;
! 8429:
! 8430: GROW;
! 8431:
! 8432: l = xmlParseNCName(ctxt);
! 8433: if (l == NULL) {
! 8434: if (CUR == ':') {
! 8435: l = xmlParseName(ctxt);
! 8436: if (l != NULL) {
! 8437: xmlNsErr(ctxt, XML_NS_ERR_QNAME,
! 8438: "Failed to parse QName '%s'\n", l, NULL, NULL);
! 8439: *prefix = NULL;
! 8440: return(l);
! 8441: }
! 8442: }
! 8443: return(NULL);
! 8444: }
! 8445: if (CUR == ':') {
! 8446: NEXT;
! 8447: p = l;
! 8448: l = xmlParseNCName(ctxt);
! 8449: if (l == NULL) {
! 8450: xmlChar *tmp;
! 8451:
! 8452: xmlNsErr(ctxt, XML_NS_ERR_QNAME,
! 8453: "Failed to parse QName '%s:'\n", p, NULL, NULL);
! 8454: l = xmlParseNmtoken(ctxt);
! 8455: if (l == NULL)
! 8456: tmp = xmlBuildQName(BAD_CAST "", p, NULL, 0);
! 8457: else {
! 8458: tmp = xmlBuildQName(l, p, NULL, 0);
! 8459: xmlFree((char *)l);
! 8460: }
! 8461: p = xmlDictLookup(ctxt->dict, tmp, -1);
! 8462: if (tmp != NULL) xmlFree(tmp);
! 8463: *prefix = NULL;
! 8464: return(p);
! 8465: }
! 8466: if (CUR == ':') {
! 8467: xmlChar *tmp;
! 8468:
! 8469: xmlNsErr(ctxt, XML_NS_ERR_QNAME,
! 8470: "Failed to parse QName '%s:%s:'\n", p, l, NULL);
! 8471: NEXT;
! 8472: tmp = (xmlChar *) xmlParseName(ctxt);
! 8473: if (tmp != NULL) {
! 8474: tmp = xmlBuildQName(tmp, l, NULL, 0);
! 8475: l = xmlDictLookup(ctxt->dict, tmp, -1);
! 8476: if (tmp != NULL) xmlFree(tmp);
! 8477: *prefix = p;
! 8478: return(l);
! 8479: }
! 8480: tmp = xmlBuildQName(BAD_CAST "", l, NULL, 0);
! 8481: l = xmlDictLookup(ctxt->dict, tmp, -1);
! 8482: if (tmp != NULL) xmlFree(tmp);
! 8483: *prefix = p;
! 8484: return(l);
! 8485: }
! 8486: *prefix = p;
! 8487: } else
! 8488: *prefix = NULL;
! 8489: return(l);
! 8490: }
! 8491:
! 8492: /**
! 8493: * xmlParseQNameAndCompare:
! 8494: * @ctxt: an XML parser context
! 8495: * @name: the localname
! 8496: * @prefix: the prefix, if any.
! 8497: *
! 8498: * parse an XML name and compares for match
! 8499: * (specialized for endtag parsing)
! 8500: *
! 8501: * Returns NULL for an illegal name, (xmlChar*) 1 for success
! 8502: * and the name for mismatch
! 8503: */
! 8504:
! 8505: static const xmlChar *
! 8506: xmlParseQNameAndCompare(xmlParserCtxtPtr ctxt, xmlChar const *name,
! 8507: xmlChar const *prefix) {
! 8508: const xmlChar *cmp;
! 8509: const xmlChar *in;
! 8510: const xmlChar *ret;
! 8511: const xmlChar *prefix2;
! 8512:
! 8513: if (prefix == NULL) return(xmlParseNameAndCompare(ctxt, name));
! 8514:
! 8515: GROW;
! 8516: in = ctxt->input->cur;
! 8517:
! 8518: cmp = prefix;
! 8519: while (*in != 0 && *in == *cmp) {
! 8520: ++in;
! 8521: ++cmp;
! 8522: }
! 8523: if ((*cmp == 0) && (*in == ':')) {
! 8524: in++;
! 8525: cmp = name;
! 8526: while (*in != 0 && *in == *cmp) {
! 8527: ++in;
! 8528: ++cmp;
! 8529: }
! 8530: if (*cmp == 0 && (*in == '>' || IS_BLANK_CH (*in))) {
! 8531: /* success */
! 8532: ctxt->input->cur = in;
! 8533: return((const xmlChar*) 1);
! 8534: }
! 8535: }
! 8536: /*
! 8537: * all strings coms from the dictionary, equality can be done directly
! 8538: */
! 8539: ret = xmlParseQName (ctxt, &prefix2);
! 8540: if ((ret == name) && (prefix == prefix2))
! 8541: return((const xmlChar*) 1);
! 8542: return ret;
! 8543: }
! 8544:
! 8545: /**
! 8546: * xmlParseAttValueInternal:
! 8547: * @ctxt: an XML parser context
! 8548: * @len: attribute len result
! 8549: * @alloc: whether the attribute was reallocated as a new string
! 8550: * @normalize: if 1 then further non-CDATA normalization must be done
! 8551: *
! 8552: * parse a value for an attribute.
! 8553: * NOTE: if no normalization is needed, the routine will return pointers
! 8554: * directly from the data buffer.
! 8555: *
! 8556: * 3.3.3 Attribute-Value Normalization:
! 8557: * Before the value of an attribute is passed to the application or
! 8558: * checked for validity, the XML processor must normalize it as follows:
! 8559: * - a character reference is processed by appending the referenced
! 8560: * character to the attribute value
! 8561: * - an entity reference is processed by recursively processing the
! 8562: * replacement text of the entity
! 8563: * - a whitespace character (#x20, #xD, #xA, #x9) is processed by
! 8564: * appending #x20 to the normalized value, except that only a single
! 8565: * #x20 is appended for a "#xD#xA" sequence that is part of an external
! 8566: * parsed entity or the literal entity value of an internal parsed entity
! 8567: * - other characters are processed by appending them to the normalized value
! 8568: * If the declared value is not CDATA, then the XML processor must further
! 8569: * process the normalized attribute value by discarding any leading and
! 8570: * trailing space (#x20) characters, and by replacing sequences of space
! 8571: * (#x20) characters by a single space (#x20) character.
! 8572: * All attributes for which no declaration has been read should be treated
! 8573: * by a non-validating parser as if declared CDATA.
! 8574: *
! 8575: * Returns the AttValue parsed or NULL. The value has to be freed by the
! 8576: * caller if it was copied, this can be detected by val[*len] == 0.
! 8577: */
! 8578:
! 8579: static xmlChar *
! 8580: xmlParseAttValueInternal(xmlParserCtxtPtr ctxt, int *len, int *alloc,
! 8581: int normalize)
! 8582: {
! 8583: xmlChar limit = 0;
! 8584: const xmlChar *in = NULL, *start, *end, *last;
! 8585: xmlChar *ret = NULL;
! 8586:
! 8587: GROW;
! 8588: in = (xmlChar *) CUR_PTR;
! 8589: if (*in != '"' && *in != '\'') {
! 8590: xmlFatalErr(ctxt, XML_ERR_ATTRIBUTE_NOT_STARTED, NULL);
! 8591: return (NULL);
! 8592: }
! 8593: ctxt->instate = XML_PARSER_ATTRIBUTE_VALUE;
! 8594:
! 8595: /*
! 8596: * try to handle in this routine the most common case where no
! 8597: * allocation of a new string is required and where content is
! 8598: * pure ASCII.
! 8599: */
! 8600: limit = *in++;
! 8601: end = ctxt->input->end;
! 8602: start = in;
! 8603: if (in >= end) {
! 8604: const xmlChar *oldbase = ctxt->input->base;
! 8605: GROW;
! 8606: if (oldbase != ctxt->input->base) {
! 8607: long delta = ctxt->input->base - oldbase;
! 8608: start = start + delta;
! 8609: in = in + delta;
! 8610: }
! 8611: end = ctxt->input->end;
! 8612: }
! 8613: if (normalize) {
! 8614: /*
! 8615: * Skip any leading spaces
! 8616: */
! 8617: while ((in < end) && (*in != limit) &&
! 8618: ((*in == 0x20) || (*in == 0x9) ||
! 8619: (*in == 0xA) || (*in == 0xD))) {
! 8620: in++;
! 8621: start = in;
! 8622: if (in >= end) {
! 8623: const xmlChar *oldbase = ctxt->input->base;
! 8624: GROW;
! 8625: if (oldbase != ctxt->input->base) {
! 8626: long delta = ctxt->input->base - oldbase;
! 8627: start = start + delta;
! 8628: in = in + delta;
! 8629: }
! 8630: end = ctxt->input->end;
! 8631: }
! 8632: }
! 8633: while ((in < end) && (*in != limit) && (*in >= 0x20) &&
! 8634: (*in <= 0x7f) && (*in != '&') && (*in != '<')) {
! 8635: if ((*in++ == 0x20) && (*in == 0x20)) break;
! 8636: if (in >= end) {
! 8637: const xmlChar *oldbase = ctxt->input->base;
! 8638: GROW;
! 8639: if (oldbase != ctxt->input->base) {
! 8640: long delta = ctxt->input->base - oldbase;
! 8641: start = start + delta;
! 8642: in = in + delta;
! 8643: }
! 8644: end = ctxt->input->end;
! 8645: }
! 8646: }
! 8647: last = in;
! 8648: /*
! 8649: * skip the trailing blanks
! 8650: */
! 8651: while ((last[-1] == 0x20) && (last > start)) last--;
! 8652: while ((in < end) && (*in != limit) &&
! 8653: ((*in == 0x20) || (*in == 0x9) ||
! 8654: (*in == 0xA) || (*in == 0xD))) {
! 8655: in++;
! 8656: if (in >= end) {
! 8657: const xmlChar *oldbase = ctxt->input->base;
! 8658: GROW;
! 8659: if (oldbase != ctxt->input->base) {
! 8660: long delta = ctxt->input->base - oldbase;
! 8661: start = start + delta;
! 8662: in = in + delta;
! 8663: last = last + delta;
! 8664: }
! 8665: end = ctxt->input->end;
! 8666: }
! 8667: }
! 8668: if (*in != limit) goto need_complex;
! 8669: } else {
! 8670: while ((in < end) && (*in != limit) && (*in >= 0x20) &&
! 8671: (*in <= 0x7f) && (*in != '&') && (*in != '<')) {
! 8672: in++;
! 8673: if (in >= end) {
! 8674: const xmlChar *oldbase = ctxt->input->base;
! 8675: GROW;
! 8676: if (oldbase != ctxt->input->base) {
! 8677: long delta = ctxt->input->base - oldbase;
! 8678: start = start + delta;
! 8679: in = in + delta;
! 8680: }
! 8681: end = ctxt->input->end;
! 8682: }
! 8683: }
! 8684: last = in;
! 8685: if (*in != limit) goto need_complex;
! 8686: }
! 8687: in++;
! 8688: if (len != NULL) {
! 8689: *len = last - start;
! 8690: ret = (xmlChar *) start;
! 8691: } else {
! 8692: if (alloc) *alloc = 1;
! 8693: ret = xmlStrndup(start, last - start);
! 8694: }
! 8695: CUR_PTR = in;
! 8696: if (alloc) *alloc = 0;
! 8697: return ret;
! 8698: need_complex:
! 8699: if (alloc) *alloc = 1;
! 8700: return xmlParseAttValueComplex(ctxt, len, normalize);
! 8701: }
! 8702:
! 8703: /**
! 8704: * xmlParseAttribute2:
! 8705: * @ctxt: an XML parser context
! 8706: * @pref: the element prefix
! 8707: * @elem: the element name
! 8708: * @prefix: a xmlChar ** used to store the value of the attribute prefix
! 8709: * @value: a xmlChar ** used to store the value of the attribute
! 8710: * @len: an int * to save the length of the attribute
! 8711: * @alloc: an int * to indicate if the attribute was allocated
! 8712: *
! 8713: * parse an attribute in the new SAX2 framework.
! 8714: *
! 8715: * Returns the attribute name, and the value in *value, .
! 8716: */
! 8717:
! 8718: static const xmlChar *
! 8719: xmlParseAttribute2(xmlParserCtxtPtr ctxt,
! 8720: const xmlChar * pref, const xmlChar * elem,
! 8721: const xmlChar ** prefix, xmlChar ** value,
! 8722: int *len, int *alloc)
! 8723: {
! 8724: const xmlChar *name;
! 8725: xmlChar *val, *internal_val = NULL;
! 8726: int normalize = 0;
! 8727:
! 8728: *value = NULL;
! 8729: GROW;
! 8730: name = xmlParseQName(ctxt, prefix);
! 8731: if (name == NULL) {
! 8732: xmlFatalErrMsg(ctxt, XML_ERR_NAME_REQUIRED,
! 8733: "error parsing attribute name\n");
! 8734: return (NULL);
! 8735: }
! 8736:
! 8737: /*
! 8738: * get the type if needed
! 8739: */
! 8740: if (ctxt->attsSpecial != NULL) {
! 8741: int type;
! 8742:
! 8743: type = (int) (long) xmlHashQLookup2(ctxt->attsSpecial,
! 8744: pref, elem, *prefix, name);
! 8745: if (type != 0)
! 8746: normalize = 1;
! 8747: }
! 8748:
! 8749: /*
! 8750: * read the value
! 8751: */
! 8752: SKIP_BLANKS;
! 8753: if (RAW == '=') {
! 8754: NEXT;
! 8755: SKIP_BLANKS;
! 8756: val = xmlParseAttValueInternal(ctxt, len, alloc, normalize);
! 8757: if (normalize) {
! 8758: /*
! 8759: * Sometimes a second normalisation pass for spaces is needed
! 8760: * but that only happens if charrefs or entities refernces
! 8761: * have been used in the attribute value, i.e. the attribute
! 8762: * value have been extracted in an allocated string already.
! 8763: */
! 8764: if (*alloc) {
! 8765: const xmlChar *val2;
! 8766:
! 8767: val2 = xmlAttrNormalizeSpace2(ctxt, val, len);
! 8768: if ((val2 != NULL) && (val2 != val)) {
! 8769: xmlFree(val);
! 8770: val = (xmlChar *) val2;
! 8771: }
! 8772: }
! 8773: }
! 8774: ctxt->instate = XML_PARSER_CONTENT;
! 8775: } else {
! 8776: xmlFatalErrMsgStr(ctxt, XML_ERR_ATTRIBUTE_WITHOUT_VALUE,
! 8777: "Specification mandate value for attribute %s\n",
! 8778: name);
! 8779: return (NULL);
! 8780: }
! 8781:
! 8782: if (*prefix == ctxt->str_xml) {
! 8783: /*
! 8784: * Check that xml:lang conforms to the specification
! 8785: * No more registered as an error, just generate a warning now
! 8786: * since this was deprecated in XML second edition
! 8787: */
! 8788: if ((ctxt->pedantic) && (xmlStrEqual(name, BAD_CAST "lang"))) {
! 8789: internal_val = xmlStrndup(val, *len);
! 8790: if (!xmlCheckLanguageID(internal_val)) {
! 8791: xmlWarningMsg(ctxt, XML_WAR_LANG_VALUE,
! 8792: "Malformed value for xml:lang : %s\n",
! 8793: internal_val, NULL);
! 8794: }
! 8795: }
! 8796:
! 8797: /*
! 8798: * Check that xml:space conforms to the specification
! 8799: */
! 8800: if (xmlStrEqual(name, BAD_CAST "space")) {
! 8801: internal_val = xmlStrndup(val, *len);
! 8802: if (xmlStrEqual(internal_val, BAD_CAST "default"))
! 8803: *(ctxt->space) = 0;
! 8804: else if (xmlStrEqual(internal_val, BAD_CAST "preserve"))
! 8805: *(ctxt->space) = 1;
! 8806: else {
! 8807: xmlWarningMsg(ctxt, XML_WAR_SPACE_VALUE,
! 8808: "Invalid value \"%s\" for xml:space : \"default\" or \"preserve\" expected\n",
! 8809: internal_val, NULL);
! 8810: }
! 8811: }
! 8812: if (internal_val) {
! 8813: xmlFree(internal_val);
! 8814: }
! 8815: }
! 8816:
! 8817: *value = val;
! 8818: return (name);
! 8819: }
! 8820: /**
! 8821: * xmlParseStartTag2:
! 8822: * @ctxt: an XML parser context
! 8823: *
! 8824: * parse a start of tag either for rule element or
! 8825: * EmptyElement. In both case we don't parse the tag closing chars.
! 8826: * This routine is called when running SAX2 parsing
! 8827: *
! 8828: * [40] STag ::= '<' Name (S Attribute)* S? '>'
! 8829: *
! 8830: * [ WFC: Unique Att Spec ]
! 8831: * No attribute name may appear more than once in the same start-tag or
! 8832: * empty-element tag.
! 8833: *
! 8834: * [44] EmptyElemTag ::= '<' Name (S Attribute)* S? '/>'
! 8835: *
! 8836: * [ WFC: Unique Att Spec ]
! 8837: * No attribute name may appear more than once in the same start-tag or
! 8838: * empty-element tag.
! 8839: *
! 8840: * With namespace:
! 8841: *
! 8842: * [NS 8] STag ::= '<' QName (S Attribute)* S? '>'
! 8843: *
! 8844: * [NS 10] EmptyElement ::= '<' QName (S Attribute)* S? '/>'
! 8845: *
! 8846: * Returns the element name parsed
! 8847: */
! 8848:
! 8849: static const xmlChar *
! 8850: xmlParseStartTag2(xmlParserCtxtPtr ctxt, const xmlChar **pref,
! 8851: const xmlChar **URI, int *tlen) {
! 8852: const xmlChar *localname;
! 8853: const xmlChar *prefix;
! 8854: const xmlChar *attname;
! 8855: const xmlChar *aprefix;
! 8856: const xmlChar *nsname;
! 8857: xmlChar *attvalue;
! 8858: const xmlChar **atts = ctxt->atts;
! 8859: int maxatts = ctxt->maxatts;
! 8860: int nratts, nbatts, nbdef;
! 8861: int i, j, nbNs, attval, oldline, oldcol;
! 8862: const xmlChar *base;
! 8863: unsigned long cur;
! 8864: int nsNr = ctxt->nsNr;
! 8865:
! 8866: if (RAW != '<') return(NULL);
! 8867: NEXT1;
! 8868:
! 8869: /*
! 8870: * NOTE: it is crucial with the SAX2 API to never call SHRINK beyond that
! 8871: * point since the attribute values may be stored as pointers to
! 8872: * the buffer and calling SHRINK would destroy them !
! 8873: * The Shrinking is only possible once the full set of attribute
! 8874: * callbacks have been done.
! 8875: */
! 8876: reparse:
! 8877: SHRINK;
! 8878: base = ctxt->input->base;
! 8879: cur = ctxt->input->cur - ctxt->input->base;
! 8880: oldline = ctxt->input->line;
! 8881: oldcol = ctxt->input->col;
! 8882: nbatts = 0;
! 8883: nratts = 0;
! 8884: nbdef = 0;
! 8885: nbNs = 0;
! 8886: attval = 0;
! 8887: /* Forget any namespaces added during an earlier parse of this element. */
! 8888: ctxt->nsNr = nsNr;
! 8889:
! 8890: localname = xmlParseQName(ctxt, &prefix);
! 8891: if (localname == NULL) {
! 8892: xmlFatalErrMsg(ctxt, XML_ERR_NAME_REQUIRED,
! 8893: "StartTag: invalid element name\n");
! 8894: return(NULL);
! 8895: }
! 8896: *tlen = ctxt->input->cur - ctxt->input->base - cur;
! 8897:
! 8898: /*
! 8899: * Now parse the attributes, it ends up with the ending
! 8900: *
! 8901: * (S Attribute)* S?
! 8902: */
! 8903: SKIP_BLANKS;
! 8904: GROW;
! 8905: if (ctxt->input->base != base) goto base_changed;
! 8906:
! 8907: while ((RAW != '>') &&
! 8908: ((RAW != '/') || (NXT(1) != '>')) &&
! 8909: (IS_BYTE_CHAR(RAW))) {
! 8910: const xmlChar *q = CUR_PTR;
! 8911: unsigned int cons = ctxt->input->consumed;
! 8912: int len = -1, alloc = 0;
! 8913:
! 8914: attname = xmlParseAttribute2(ctxt, prefix, localname,
! 8915: &aprefix, &attvalue, &len, &alloc);
! 8916: if (ctxt->input->base != base) {
! 8917: if ((attvalue != NULL) && (alloc != 0))
! 8918: xmlFree(attvalue);
! 8919: attvalue = NULL;
! 8920: goto base_changed;
! 8921: }
! 8922: if ((attname != NULL) && (attvalue != NULL)) {
! 8923: if (len < 0) len = xmlStrlen(attvalue);
! 8924: if ((attname == ctxt->str_xmlns) && (aprefix == NULL)) {
! 8925: const xmlChar *URL = xmlDictLookup(ctxt->dict, attvalue, len);
! 8926: xmlURIPtr uri;
! 8927:
! 8928: if (*URL != 0) {
! 8929: uri = xmlParseURI((const char *) URL);
! 8930: if (uri == NULL) {
! 8931: xmlNsErr(ctxt, XML_WAR_NS_URI,
! 8932: "xmlns: '%s' is not a valid URI\n",
! 8933: URL, NULL, NULL);
! 8934: } else {
! 8935: if (uri->scheme == NULL) {
! 8936: xmlNsWarn(ctxt, XML_WAR_NS_URI_RELATIVE,
! 8937: "xmlns: URI %s is not absolute\n",
! 8938: URL, NULL, NULL);
! 8939: }
! 8940: xmlFreeURI(uri);
! 8941: }
! 8942: if (URL == ctxt->str_xml_ns) {
! 8943: if (attname != ctxt->str_xml) {
! 8944: xmlNsErr(ctxt, XML_NS_ERR_XML_NAMESPACE,
! 8945: "xml namespace URI cannot be the default namespace\n",
! 8946: NULL, NULL, NULL);
! 8947: }
! 8948: goto skip_default_ns;
! 8949: }
! 8950: if ((len == 29) &&
! 8951: (xmlStrEqual(URL,
! 8952: BAD_CAST "http://www.w3.org/2000/xmlns/"))) {
! 8953: xmlNsErr(ctxt, XML_NS_ERR_XML_NAMESPACE,
! 8954: "reuse of the xmlns namespace name is forbidden\n",
! 8955: NULL, NULL, NULL);
! 8956: goto skip_default_ns;
! 8957: }
! 8958: }
! 8959: /*
! 8960: * check that it's not a defined namespace
! 8961: */
! 8962: for (j = 1;j <= nbNs;j++)
! 8963: if (ctxt->nsTab[ctxt->nsNr - 2 * j] == NULL)
! 8964: break;
! 8965: if (j <= nbNs)
! 8966: xmlErrAttributeDup(ctxt, NULL, attname);
! 8967: else
! 8968: if (nsPush(ctxt, NULL, URL) > 0) nbNs++;
! 8969: skip_default_ns:
! 8970: if (alloc != 0) xmlFree(attvalue);
! 8971: SKIP_BLANKS;
! 8972: continue;
! 8973: }
! 8974: if (aprefix == ctxt->str_xmlns) {
! 8975: const xmlChar *URL = xmlDictLookup(ctxt->dict, attvalue, len);
! 8976: xmlURIPtr uri;
! 8977:
! 8978: if (attname == ctxt->str_xml) {
! 8979: if (URL != ctxt->str_xml_ns) {
! 8980: xmlNsErr(ctxt, XML_NS_ERR_XML_NAMESPACE,
! 8981: "xml namespace prefix mapped to wrong URI\n",
! 8982: NULL, NULL, NULL);
! 8983: }
! 8984: /*
! 8985: * Do not keep a namespace definition node
! 8986: */
! 8987: goto skip_ns;
! 8988: }
! 8989: if (URL == ctxt->str_xml_ns) {
! 8990: if (attname != ctxt->str_xml) {
! 8991: xmlNsErr(ctxt, XML_NS_ERR_XML_NAMESPACE,
! 8992: "xml namespace URI mapped to wrong prefix\n",
! 8993: NULL, NULL, NULL);
! 8994: }
! 8995: goto skip_ns;
! 8996: }
! 8997: if (attname == ctxt->str_xmlns) {
! 8998: xmlNsErr(ctxt, XML_NS_ERR_XML_NAMESPACE,
! 8999: "redefinition of the xmlns prefix is forbidden\n",
! 9000: NULL, NULL, NULL);
! 9001: goto skip_ns;
! 9002: }
! 9003: if ((len == 29) &&
! 9004: (xmlStrEqual(URL,
! 9005: BAD_CAST "http://www.w3.org/2000/xmlns/"))) {
! 9006: xmlNsErr(ctxt, XML_NS_ERR_XML_NAMESPACE,
! 9007: "reuse of the xmlns namespace name is forbidden\n",
! 9008: NULL, NULL, NULL);
! 9009: goto skip_ns;
! 9010: }
! 9011: if ((URL == NULL) || (URL[0] == 0)) {
! 9012: xmlNsErr(ctxt, XML_NS_ERR_XML_NAMESPACE,
! 9013: "xmlns:%s: Empty XML namespace is not allowed\n",
! 9014: attname, NULL, NULL);
! 9015: goto skip_ns;
! 9016: } else {
! 9017: uri = xmlParseURI((const char *) URL);
! 9018: if (uri == NULL) {
! 9019: xmlNsErr(ctxt, XML_WAR_NS_URI,
! 9020: "xmlns:%s: '%s' is not a valid URI\n",
! 9021: attname, URL, NULL);
! 9022: } else {
! 9023: if ((ctxt->pedantic) && (uri->scheme == NULL)) {
! 9024: xmlNsWarn(ctxt, XML_WAR_NS_URI_RELATIVE,
! 9025: "xmlns:%s: URI %s is not absolute\n",
! 9026: attname, URL, NULL);
! 9027: }
! 9028: xmlFreeURI(uri);
! 9029: }
! 9030: }
! 9031:
! 9032: /*
! 9033: * check that it's not a defined namespace
! 9034: */
! 9035: for (j = 1;j <= nbNs;j++)
! 9036: if (ctxt->nsTab[ctxt->nsNr - 2 * j] == attname)
! 9037: break;
! 9038: if (j <= nbNs)
! 9039: xmlErrAttributeDup(ctxt, aprefix, attname);
! 9040: else
! 9041: if (nsPush(ctxt, attname, URL) > 0) nbNs++;
! 9042: skip_ns:
! 9043: if (alloc != 0) xmlFree(attvalue);
! 9044: SKIP_BLANKS;
! 9045: if (ctxt->input->base != base) goto base_changed;
! 9046: continue;
! 9047: }
! 9048:
! 9049: /*
! 9050: * Add the pair to atts
! 9051: */
! 9052: if ((atts == NULL) || (nbatts + 5 > maxatts)) {
! 9053: if (xmlCtxtGrowAttrs(ctxt, nbatts + 5) < 0) {
! 9054: if (attvalue[len] == 0)
! 9055: xmlFree(attvalue);
! 9056: goto failed;
! 9057: }
! 9058: maxatts = ctxt->maxatts;
! 9059: atts = ctxt->atts;
! 9060: }
! 9061: ctxt->attallocs[nratts++] = alloc;
! 9062: atts[nbatts++] = attname;
! 9063: atts[nbatts++] = aprefix;
! 9064: atts[nbatts++] = NULL; /* the URI will be fetched later */
! 9065: atts[nbatts++] = attvalue;
! 9066: attvalue += len;
! 9067: atts[nbatts++] = attvalue;
! 9068: /*
! 9069: * tag if some deallocation is needed
! 9070: */
! 9071: if (alloc != 0) attval = 1;
! 9072: } else {
! 9073: if ((attvalue != NULL) && (attvalue[len] == 0))
! 9074: xmlFree(attvalue);
! 9075: }
! 9076:
! 9077: failed:
! 9078:
! 9079: GROW
! 9080: if (ctxt->input->base != base) goto base_changed;
! 9081: if ((RAW == '>') || (((RAW == '/') && (NXT(1) == '>'))))
! 9082: break;
! 9083: if (!IS_BLANK_CH(RAW)) {
! 9084: xmlFatalErrMsg(ctxt, XML_ERR_SPACE_REQUIRED,
! 9085: "attributes construct error\n");
! 9086: break;
! 9087: }
! 9088: SKIP_BLANKS;
! 9089: if ((cons == ctxt->input->consumed) && (q == CUR_PTR) &&
! 9090: (attname == NULL) && (attvalue == NULL)) {
! 9091: xmlFatalErr(ctxt, XML_ERR_INTERNAL_ERROR,
! 9092: "xmlParseStartTag: problem parsing attributes\n");
! 9093: break;
! 9094: }
! 9095: GROW;
! 9096: if (ctxt->input->base != base) goto base_changed;
! 9097: }
! 9098:
! 9099: /*
! 9100: * The attributes defaulting
! 9101: */
! 9102: if (ctxt->attsDefault != NULL) {
! 9103: xmlDefAttrsPtr defaults;
! 9104:
! 9105: defaults = xmlHashLookup2(ctxt->attsDefault, localname, prefix);
! 9106: if (defaults != NULL) {
! 9107: for (i = 0;i < defaults->nbAttrs;i++) {
! 9108: attname = defaults->values[5 * i];
! 9109: aprefix = defaults->values[5 * i + 1];
! 9110:
! 9111: /*
! 9112: * special work for namespaces defaulted defs
! 9113: */
! 9114: if ((attname == ctxt->str_xmlns) && (aprefix == NULL)) {
! 9115: /*
! 9116: * check that it's not a defined namespace
! 9117: */
! 9118: for (j = 1;j <= nbNs;j++)
! 9119: if (ctxt->nsTab[ctxt->nsNr - 2 * j] == NULL)
! 9120: break;
! 9121: if (j <= nbNs) continue;
! 9122:
! 9123: nsname = xmlGetNamespace(ctxt, NULL);
! 9124: if (nsname != defaults->values[5 * i + 2]) {
! 9125: if (nsPush(ctxt, NULL,
! 9126: defaults->values[5 * i + 2]) > 0)
! 9127: nbNs++;
! 9128: }
! 9129: } else if (aprefix == ctxt->str_xmlns) {
! 9130: /*
! 9131: * check that it's not a defined namespace
! 9132: */
! 9133: for (j = 1;j <= nbNs;j++)
! 9134: if (ctxt->nsTab[ctxt->nsNr - 2 * j] == attname)
! 9135: break;
! 9136: if (j <= nbNs) continue;
! 9137:
! 9138: nsname = xmlGetNamespace(ctxt, attname);
! 9139: if (nsname != defaults->values[2]) {
! 9140: if (nsPush(ctxt, attname,
! 9141: defaults->values[5 * i + 2]) > 0)
! 9142: nbNs++;
! 9143: }
! 9144: } else {
! 9145: /*
! 9146: * check that it's not a defined attribute
! 9147: */
! 9148: for (j = 0;j < nbatts;j+=5) {
! 9149: if ((attname == atts[j]) && (aprefix == atts[j+1]))
! 9150: break;
! 9151: }
! 9152: if (j < nbatts) continue;
! 9153:
! 9154: if ((atts == NULL) || (nbatts + 5 > maxatts)) {
! 9155: if (xmlCtxtGrowAttrs(ctxt, nbatts + 5) < 0) {
! 9156: return(NULL);
! 9157: }
! 9158: maxatts = ctxt->maxatts;
! 9159: atts = ctxt->atts;
! 9160: }
! 9161: atts[nbatts++] = attname;
! 9162: atts[nbatts++] = aprefix;
! 9163: if (aprefix == NULL)
! 9164: atts[nbatts++] = NULL;
! 9165: else
! 9166: atts[nbatts++] = xmlGetNamespace(ctxt, aprefix);
! 9167: atts[nbatts++] = defaults->values[5 * i + 2];
! 9168: atts[nbatts++] = defaults->values[5 * i + 3];
! 9169: if ((ctxt->standalone == 1) &&
! 9170: (defaults->values[5 * i + 4] != NULL)) {
! 9171: xmlValidityError(ctxt, XML_DTD_STANDALONE_DEFAULTED,
! 9172: "standalone: attribute %s on %s defaulted from external subset\n",
! 9173: attname, localname);
! 9174: }
! 9175: nbdef++;
! 9176: }
! 9177: }
! 9178: }
! 9179: }
! 9180:
! 9181: /*
! 9182: * The attributes checkings
! 9183: */
! 9184: for (i = 0; i < nbatts;i += 5) {
! 9185: /*
! 9186: * The default namespace does not apply to attribute names.
! 9187: */
! 9188: if (atts[i + 1] != NULL) {
! 9189: nsname = xmlGetNamespace(ctxt, atts[i + 1]);
! 9190: if (nsname == NULL) {
! 9191: xmlNsErr(ctxt, XML_NS_ERR_UNDEFINED_NAMESPACE,
! 9192: "Namespace prefix %s for %s on %s is not defined\n",
! 9193: atts[i + 1], atts[i], localname);
! 9194: }
! 9195: atts[i + 2] = nsname;
! 9196: } else
! 9197: nsname = NULL;
! 9198: /*
! 9199: * [ WFC: Unique Att Spec ]
! 9200: * No attribute name may appear more than once in the same
! 9201: * start-tag or empty-element tag.
! 9202: * As extended by the Namespace in XML REC.
! 9203: */
! 9204: for (j = 0; j < i;j += 5) {
! 9205: if (atts[i] == atts[j]) {
! 9206: if (atts[i+1] == atts[j+1]) {
! 9207: xmlErrAttributeDup(ctxt, atts[i+1], atts[i]);
! 9208: break;
! 9209: }
! 9210: if ((nsname != NULL) && (atts[j + 2] == nsname)) {
! 9211: xmlNsErr(ctxt, XML_NS_ERR_ATTRIBUTE_REDEFINED,
! 9212: "Namespaced Attribute %s in '%s' redefined\n",
! 9213: atts[i], nsname, NULL);
! 9214: break;
! 9215: }
! 9216: }
! 9217: }
! 9218: }
! 9219:
! 9220: nsname = xmlGetNamespace(ctxt, prefix);
! 9221: if ((prefix != NULL) && (nsname == NULL)) {
! 9222: xmlNsErr(ctxt, XML_NS_ERR_UNDEFINED_NAMESPACE,
! 9223: "Namespace prefix %s on %s is not defined\n",
! 9224: prefix, localname, NULL);
! 9225: }
! 9226: *pref = prefix;
! 9227: *URI = nsname;
! 9228:
! 9229: /*
! 9230: * SAX: Start of Element !
! 9231: */
! 9232: if ((ctxt->sax != NULL) && (ctxt->sax->startElementNs != NULL) &&
! 9233: (!ctxt->disableSAX)) {
! 9234: if (nbNs > 0)
! 9235: ctxt->sax->startElementNs(ctxt->userData, localname, prefix,
! 9236: nsname, nbNs, &ctxt->nsTab[ctxt->nsNr - 2 * nbNs],
! 9237: nbatts / 5, nbdef, atts);
! 9238: else
! 9239: ctxt->sax->startElementNs(ctxt->userData, localname, prefix,
! 9240: nsname, 0, NULL, nbatts / 5, nbdef, atts);
! 9241: }
! 9242:
! 9243: /*
! 9244: * Free up attribute allocated strings if needed
! 9245: */
! 9246: if (attval != 0) {
! 9247: for (i = 3,j = 0; j < nratts;i += 5,j++)
! 9248: if ((ctxt->attallocs[j] != 0) && (atts[i] != NULL))
! 9249: xmlFree((xmlChar *) atts[i]);
! 9250: }
! 9251:
! 9252: return(localname);
! 9253:
! 9254: base_changed:
! 9255: /*
! 9256: * the attribute strings are valid iif the base didn't changed
! 9257: */
! 9258: if (attval != 0) {
! 9259: for (i = 3,j = 0; j < nratts;i += 5,j++)
! 9260: if ((ctxt->attallocs[j] != 0) && (atts[i] != NULL))
! 9261: xmlFree((xmlChar *) atts[i]);
! 9262: }
! 9263: ctxt->input->cur = ctxt->input->base + cur;
! 9264: ctxt->input->line = oldline;
! 9265: ctxt->input->col = oldcol;
! 9266: if (ctxt->wellFormed == 1) {
! 9267: goto reparse;
! 9268: }
! 9269: return(NULL);
! 9270: }
! 9271:
! 9272: /**
! 9273: * xmlParseEndTag2:
! 9274: * @ctxt: an XML parser context
! 9275: * @line: line of the start tag
! 9276: * @nsNr: number of namespaces on the start tag
! 9277: *
! 9278: * parse an end of tag
! 9279: *
! 9280: * [42] ETag ::= '</' Name S? '>'
! 9281: *
! 9282: * With namespace
! 9283: *
! 9284: * [NS 9] ETag ::= '</' QName S? '>'
! 9285: */
! 9286:
! 9287: static void
! 9288: xmlParseEndTag2(xmlParserCtxtPtr ctxt, const xmlChar *prefix,
! 9289: const xmlChar *URI, int line, int nsNr, int tlen) {
! 9290: const xmlChar *name;
! 9291:
! 9292: GROW;
! 9293: if ((RAW != '<') || (NXT(1) != '/')) {
! 9294: xmlFatalErr(ctxt, XML_ERR_LTSLASH_REQUIRED, NULL);
! 9295: return;
! 9296: }
! 9297: SKIP(2);
! 9298:
! 9299: if ((tlen > 0) && (xmlStrncmp(ctxt->input->cur, ctxt->name, tlen) == 0)) {
! 9300: if (ctxt->input->cur[tlen] == '>') {
! 9301: ctxt->input->cur += tlen + 1;
! 9302: goto done;
! 9303: }
! 9304: ctxt->input->cur += tlen;
! 9305: name = (xmlChar*)1;
! 9306: } else {
! 9307: if (prefix == NULL)
! 9308: name = xmlParseNameAndCompare(ctxt, ctxt->name);
! 9309: else
! 9310: name = xmlParseQNameAndCompare(ctxt, ctxt->name, prefix);
! 9311: }
! 9312:
! 9313: /*
! 9314: * We should definitely be at the ending "S? '>'" part
! 9315: */
! 9316: GROW;
! 9317: SKIP_BLANKS;
! 9318: if ((!IS_BYTE_CHAR(RAW)) || (RAW != '>')) {
! 9319: xmlFatalErr(ctxt, XML_ERR_GT_REQUIRED, NULL);
! 9320: } else
! 9321: NEXT1;
! 9322:
! 9323: /*
! 9324: * [ WFC: Element Type Match ]
! 9325: * The Name in an element's end-tag must match the element type in the
! 9326: * start-tag.
! 9327: *
! 9328: */
! 9329: if (name != (xmlChar*)1) {
! 9330: if (name == NULL) name = BAD_CAST "unparseable";
! 9331: if ((line == 0) && (ctxt->node != NULL))
! 9332: line = ctxt->node->line;
! 9333: xmlFatalErrMsgStrIntStr(ctxt, XML_ERR_TAG_NAME_MISMATCH,
! 9334: "Opening and ending tag mismatch: %s line %d and %s\n",
! 9335: ctxt->name, line, name);
! 9336: }
! 9337:
! 9338: /*
! 9339: * SAX: End of Tag
! 9340: */
! 9341: done:
! 9342: if ((ctxt->sax != NULL) && (ctxt->sax->endElementNs != NULL) &&
! 9343: (!ctxt->disableSAX))
! 9344: ctxt->sax->endElementNs(ctxt->userData, ctxt->name, prefix, URI);
! 9345:
! 9346: spacePop(ctxt);
! 9347: if (nsNr != 0)
! 9348: nsPop(ctxt, nsNr);
! 9349: return;
! 9350: }
! 9351:
! 9352: /**
! 9353: * xmlParseCDSect:
! 9354: * @ctxt: an XML parser context
! 9355: *
! 9356: * Parse escaped pure raw content.
! 9357: *
! 9358: * [18] CDSect ::= CDStart CData CDEnd
! 9359: *
! 9360: * [19] CDStart ::= '<![CDATA['
! 9361: *
! 9362: * [20] Data ::= (Char* - (Char* ']]>' Char*))
! 9363: *
! 9364: * [21] CDEnd ::= ']]>'
! 9365: */
! 9366: void
! 9367: xmlParseCDSect(xmlParserCtxtPtr ctxt) {
! 9368: xmlChar *buf = NULL;
! 9369: int len = 0;
! 9370: int size = XML_PARSER_BUFFER_SIZE;
! 9371: int r, rl;
! 9372: int s, sl;
! 9373: int cur, l;
! 9374: int count = 0;
! 9375:
! 9376: /* Check 2.6.0 was NXT(0) not RAW */
! 9377: if (CMP9(CUR_PTR, '<', '!', '[', 'C', 'D', 'A', 'T', 'A', '[')) {
! 9378: SKIP(9);
! 9379: } else
! 9380: return;
! 9381:
! 9382: ctxt->instate = XML_PARSER_CDATA_SECTION;
! 9383: r = CUR_CHAR(rl);
! 9384: if (!IS_CHAR(r)) {
! 9385: xmlFatalErr(ctxt, XML_ERR_CDATA_NOT_FINISHED, NULL);
! 9386: ctxt->instate = XML_PARSER_CONTENT;
! 9387: return;
! 9388: }
! 9389: NEXTL(rl);
! 9390: s = CUR_CHAR(sl);
! 9391: if (!IS_CHAR(s)) {
! 9392: xmlFatalErr(ctxt, XML_ERR_CDATA_NOT_FINISHED, NULL);
! 9393: ctxt->instate = XML_PARSER_CONTENT;
! 9394: return;
! 9395: }
! 9396: NEXTL(sl);
! 9397: cur = CUR_CHAR(l);
! 9398: buf = (xmlChar *) xmlMallocAtomic(size * sizeof(xmlChar));
! 9399: if (buf == NULL) {
! 9400: xmlErrMemory(ctxt, NULL);
! 9401: return;
! 9402: }
! 9403: while (IS_CHAR(cur) &&
! 9404: ((r != ']') || (s != ']') || (cur != '>'))) {
! 9405: if (len + 5 >= size) {
! 9406: xmlChar *tmp;
! 9407:
! 9408: size *= 2;
! 9409: tmp = (xmlChar *) xmlRealloc(buf, size * sizeof(xmlChar));
! 9410: if (tmp == NULL) {
! 9411: xmlFree(buf);
! 9412: xmlErrMemory(ctxt, NULL);
! 9413: return;
! 9414: }
! 9415: buf = tmp;
! 9416: }
! 9417: COPY_BUF(rl,buf,len,r);
! 9418: r = s;
! 9419: rl = sl;
! 9420: s = cur;
! 9421: sl = l;
! 9422: count++;
! 9423: if (count > 50) {
! 9424: GROW;
! 9425: count = 0;
! 9426: }
! 9427: NEXTL(l);
! 9428: cur = CUR_CHAR(l);
! 9429: }
! 9430: buf[len] = 0;
! 9431: ctxt->instate = XML_PARSER_CONTENT;
! 9432: if (cur != '>') {
! 9433: xmlFatalErrMsgStr(ctxt, XML_ERR_CDATA_NOT_FINISHED,
! 9434: "CData section not finished\n%.50s\n", buf);
! 9435: xmlFree(buf);
! 9436: return;
! 9437: }
! 9438: NEXTL(l);
! 9439:
! 9440: /*
! 9441: * OK the buffer is to be consumed as cdata.
! 9442: */
! 9443: if ((ctxt->sax != NULL) && (!ctxt->disableSAX)) {
! 9444: if (ctxt->sax->cdataBlock != NULL)
! 9445: ctxt->sax->cdataBlock(ctxt->userData, buf, len);
! 9446: else if (ctxt->sax->characters != NULL)
! 9447: ctxt->sax->characters(ctxt->userData, buf, len);
! 9448: }
! 9449: xmlFree(buf);
! 9450: }
! 9451:
! 9452: /**
! 9453: * xmlParseContent:
! 9454: * @ctxt: an XML parser context
! 9455: *
! 9456: * Parse a content:
! 9457: *
! 9458: * [43] content ::= (element | CharData | Reference | CDSect | PI | Comment)*
! 9459: */
! 9460:
! 9461: void
! 9462: xmlParseContent(xmlParserCtxtPtr ctxt) {
! 9463: GROW;
! 9464: while ((RAW != 0) &&
! 9465: ((RAW != '<') || (NXT(1) != '/')) &&
! 9466: (ctxt->instate != XML_PARSER_EOF)) {
! 9467: const xmlChar *test = CUR_PTR;
! 9468: unsigned int cons = ctxt->input->consumed;
! 9469: const xmlChar *cur = ctxt->input->cur;
! 9470:
! 9471: /*
! 9472: * First case : a Processing Instruction.
! 9473: */
! 9474: if ((*cur == '<') && (cur[1] == '?')) {
! 9475: xmlParsePI(ctxt);
! 9476: }
! 9477:
! 9478: /*
! 9479: * Second case : a CDSection
! 9480: */
! 9481: /* 2.6.0 test was *cur not RAW */
! 9482: else if (CMP9(CUR_PTR, '<', '!', '[', 'C', 'D', 'A', 'T', 'A', '[')) {
! 9483: xmlParseCDSect(ctxt);
! 9484: }
! 9485:
! 9486: /*
! 9487: * Third case : a comment
! 9488: */
! 9489: else if ((*cur == '<') && (NXT(1) == '!') &&
! 9490: (NXT(2) == '-') && (NXT(3) == '-')) {
! 9491: xmlParseComment(ctxt);
! 9492: ctxt->instate = XML_PARSER_CONTENT;
! 9493: }
! 9494:
! 9495: /*
! 9496: * Fourth case : a sub-element.
! 9497: */
! 9498: else if (*cur == '<') {
! 9499: xmlParseElement(ctxt);
! 9500: }
! 9501:
! 9502: /*
! 9503: * Fifth case : a reference. If if has not been resolved,
! 9504: * parsing returns it's Name, create the node
! 9505: */
! 9506:
! 9507: else if (*cur == '&') {
! 9508: xmlParseReference(ctxt);
! 9509: }
! 9510:
! 9511: /*
! 9512: * Last case, text. Note that References are handled directly.
! 9513: */
! 9514: else {
! 9515: xmlParseCharData(ctxt, 0);
! 9516: }
! 9517:
! 9518: GROW;
! 9519: /*
! 9520: * Pop-up of finished entities.
! 9521: */
! 9522: while ((RAW == 0) && (ctxt->inputNr > 1))
! 9523: xmlPopInput(ctxt);
! 9524: SHRINK;
! 9525:
! 9526: if ((cons == ctxt->input->consumed) && (test == CUR_PTR)) {
! 9527: xmlFatalErr(ctxt, XML_ERR_INTERNAL_ERROR,
! 9528: "detected an error in element content\n");
! 9529: ctxt->instate = XML_PARSER_EOF;
! 9530: break;
! 9531: }
! 9532: }
! 9533: }
! 9534:
! 9535: /**
! 9536: * xmlParseElement:
! 9537: * @ctxt: an XML parser context
! 9538: *
! 9539: * parse an XML element, this is highly recursive
! 9540: *
! 9541: * [39] element ::= EmptyElemTag | STag content ETag
! 9542: *
! 9543: * [ WFC: Element Type Match ]
! 9544: * The Name in an element's end-tag must match the element type in the
! 9545: * start-tag.
! 9546: *
! 9547: */
! 9548:
! 9549: void
! 9550: xmlParseElement(xmlParserCtxtPtr ctxt) {
! 9551: const xmlChar *name;
! 9552: const xmlChar *prefix = NULL;
! 9553: const xmlChar *URI = NULL;
! 9554: xmlParserNodeInfo node_info;
! 9555: int line, tlen;
! 9556: xmlNodePtr ret;
! 9557: int nsNr = ctxt->nsNr;
! 9558:
! 9559: if (((unsigned int) ctxt->nameNr > xmlParserMaxDepth) &&
! 9560: ((ctxt->options & XML_PARSE_HUGE) == 0)) {
! 9561: xmlFatalErrMsgInt(ctxt, XML_ERR_INTERNAL_ERROR,
! 9562: "Excessive depth in document: %d use XML_PARSE_HUGE option\n",
! 9563: xmlParserMaxDepth);
! 9564: ctxt->instate = XML_PARSER_EOF;
! 9565: return;
! 9566: }
! 9567:
! 9568: /* Capture start position */
! 9569: if (ctxt->record_info) {
! 9570: node_info.begin_pos = ctxt->input->consumed +
! 9571: (CUR_PTR - ctxt->input->base);
! 9572: node_info.begin_line = ctxt->input->line;
! 9573: }
! 9574:
! 9575: if (ctxt->spaceNr == 0)
! 9576: spacePush(ctxt, -1);
! 9577: else if (*ctxt->space == -2)
! 9578: spacePush(ctxt, -1);
! 9579: else
! 9580: spacePush(ctxt, *ctxt->space);
! 9581:
! 9582: line = ctxt->input->line;
! 9583: #ifdef LIBXML_SAX1_ENABLED
! 9584: if (ctxt->sax2)
! 9585: #endif /* LIBXML_SAX1_ENABLED */
! 9586: name = xmlParseStartTag2(ctxt, &prefix, &URI, &tlen);
! 9587: #ifdef LIBXML_SAX1_ENABLED
! 9588: else
! 9589: name = xmlParseStartTag(ctxt);
! 9590: #endif /* LIBXML_SAX1_ENABLED */
! 9591: if (name == NULL) {
! 9592: spacePop(ctxt);
! 9593: return;
! 9594: }
! 9595: namePush(ctxt, name);
! 9596: ret = ctxt->node;
! 9597:
! 9598: #ifdef LIBXML_VALID_ENABLED
! 9599: /*
! 9600: * [ VC: Root Element Type ]
! 9601: * The Name in the document type declaration must match the element
! 9602: * type of the root element.
! 9603: */
! 9604: if (ctxt->validate && ctxt->wellFormed && ctxt->myDoc &&
! 9605: ctxt->node && (ctxt->node == ctxt->myDoc->children))
! 9606: ctxt->valid &= xmlValidateRoot(&ctxt->vctxt, ctxt->myDoc);
! 9607: #endif /* LIBXML_VALID_ENABLED */
! 9608:
! 9609: /*
! 9610: * Check for an Empty Element.
! 9611: */
! 9612: if ((RAW == '/') && (NXT(1) == '>')) {
! 9613: SKIP(2);
! 9614: if (ctxt->sax2) {
! 9615: if ((ctxt->sax != NULL) && (ctxt->sax->endElementNs != NULL) &&
! 9616: (!ctxt->disableSAX))
! 9617: ctxt->sax->endElementNs(ctxt->userData, name, prefix, URI);
! 9618: #ifdef LIBXML_SAX1_ENABLED
! 9619: } else {
! 9620: if ((ctxt->sax != NULL) && (ctxt->sax->endElement != NULL) &&
! 9621: (!ctxt->disableSAX))
! 9622: ctxt->sax->endElement(ctxt->userData, name);
! 9623: #endif /* LIBXML_SAX1_ENABLED */
! 9624: }
! 9625: namePop(ctxt);
! 9626: spacePop(ctxt);
! 9627: if (nsNr != ctxt->nsNr)
! 9628: nsPop(ctxt, ctxt->nsNr - nsNr);
! 9629: if ( ret != NULL && ctxt->record_info ) {
! 9630: node_info.end_pos = ctxt->input->consumed +
! 9631: (CUR_PTR - ctxt->input->base);
! 9632: node_info.end_line = ctxt->input->line;
! 9633: node_info.node = ret;
! 9634: xmlParserAddNodeInfo(ctxt, &node_info);
! 9635: }
! 9636: return;
! 9637: }
! 9638: if (RAW == '>') {
! 9639: NEXT1;
! 9640: } else {
! 9641: xmlFatalErrMsgStrIntStr(ctxt, XML_ERR_GT_REQUIRED,
! 9642: "Couldn't find end of Start Tag %s line %d\n",
! 9643: name, line, NULL);
! 9644:
! 9645: /*
! 9646: * end of parsing of this node.
! 9647: */
! 9648: nodePop(ctxt);
! 9649: namePop(ctxt);
! 9650: spacePop(ctxt);
! 9651: if (nsNr != ctxt->nsNr)
! 9652: nsPop(ctxt, ctxt->nsNr - nsNr);
! 9653:
! 9654: /*
! 9655: * Capture end position and add node
! 9656: */
! 9657: if ( ret != NULL && ctxt->record_info ) {
! 9658: node_info.end_pos = ctxt->input->consumed +
! 9659: (CUR_PTR - ctxt->input->base);
! 9660: node_info.end_line = ctxt->input->line;
! 9661: node_info.node = ret;
! 9662: xmlParserAddNodeInfo(ctxt, &node_info);
! 9663: }
! 9664: return;
! 9665: }
! 9666:
! 9667: /*
! 9668: * Parse the content of the element:
! 9669: */
! 9670: xmlParseContent(ctxt);
! 9671: if (!IS_BYTE_CHAR(RAW)) {
! 9672: xmlFatalErrMsgStrIntStr(ctxt, XML_ERR_TAG_NOT_FINISHED,
! 9673: "Premature end of data in tag %s line %d\n",
! 9674: name, line, NULL);
! 9675:
! 9676: /*
! 9677: * end of parsing of this node.
! 9678: */
! 9679: nodePop(ctxt);
! 9680: namePop(ctxt);
! 9681: spacePop(ctxt);
! 9682: if (nsNr != ctxt->nsNr)
! 9683: nsPop(ctxt, ctxt->nsNr - nsNr);
! 9684: return;
! 9685: }
! 9686:
! 9687: /*
! 9688: * parse the end of tag: '</' should be here.
! 9689: */
! 9690: if (ctxt->sax2) {
! 9691: xmlParseEndTag2(ctxt, prefix, URI, line, ctxt->nsNr - nsNr, tlen);
! 9692: namePop(ctxt);
! 9693: }
! 9694: #ifdef LIBXML_SAX1_ENABLED
! 9695: else
! 9696: xmlParseEndTag1(ctxt, line);
! 9697: #endif /* LIBXML_SAX1_ENABLED */
! 9698:
! 9699: /*
! 9700: * Capture end position and add node
! 9701: */
! 9702: if ( ret != NULL && ctxt->record_info ) {
! 9703: node_info.end_pos = ctxt->input->consumed +
! 9704: (CUR_PTR - ctxt->input->base);
! 9705: node_info.end_line = ctxt->input->line;
! 9706: node_info.node = ret;
! 9707: xmlParserAddNodeInfo(ctxt, &node_info);
! 9708: }
! 9709: }
! 9710:
! 9711: /**
! 9712: * xmlParseVersionNum:
! 9713: * @ctxt: an XML parser context
! 9714: *
! 9715: * parse the XML version value.
! 9716: *
! 9717: * [26] VersionNum ::= '1.' [0-9]+
! 9718: *
! 9719: * In practice allow [0-9].[0-9]+ at that level
! 9720: *
! 9721: * Returns the string giving the XML version number, or NULL
! 9722: */
! 9723: xmlChar *
! 9724: xmlParseVersionNum(xmlParserCtxtPtr ctxt) {
! 9725: xmlChar *buf = NULL;
! 9726: int len = 0;
! 9727: int size = 10;
! 9728: xmlChar cur;
! 9729:
! 9730: buf = (xmlChar *) xmlMallocAtomic(size * sizeof(xmlChar));
! 9731: if (buf == NULL) {
! 9732: xmlErrMemory(ctxt, NULL);
! 9733: return(NULL);
! 9734: }
! 9735: cur = CUR;
! 9736: if (!((cur >= '0') && (cur <= '9'))) {
! 9737: xmlFree(buf);
! 9738: return(NULL);
! 9739: }
! 9740: buf[len++] = cur;
! 9741: NEXT;
! 9742: cur=CUR;
! 9743: if (cur != '.') {
! 9744: xmlFree(buf);
! 9745: return(NULL);
! 9746: }
! 9747: buf[len++] = cur;
! 9748: NEXT;
! 9749: cur=CUR;
! 9750: while ((cur >= '0') && (cur <= '9')) {
! 9751: if (len + 1 >= size) {
! 9752: xmlChar *tmp;
! 9753:
! 9754: size *= 2;
! 9755: tmp = (xmlChar *) xmlRealloc(buf, size * sizeof(xmlChar));
! 9756: if (tmp == NULL) {
! 9757: xmlFree(buf);
! 9758: xmlErrMemory(ctxt, NULL);
! 9759: return(NULL);
! 9760: }
! 9761: buf = tmp;
! 9762: }
! 9763: buf[len++] = cur;
! 9764: NEXT;
! 9765: cur=CUR;
! 9766: }
! 9767: buf[len] = 0;
! 9768: return(buf);
! 9769: }
! 9770:
! 9771: /**
! 9772: * xmlParseVersionInfo:
! 9773: * @ctxt: an XML parser context
! 9774: *
! 9775: * parse the XML version.
! 9776: *
! 9777: * [24] VersionInfo ::= S 'version' Eq (' VersionNum ' | " VersionNum ")
! 9778: *
! 9779: * [25] Eq ::= S? '=' S?
! 9780: *
! 9781: * Returns the version string, e.g. "1.0"
! 9782: */
! 9783:
! 9784: xmlChar *
! 9785: xmlParseVersionInfo(xmlParserCtxtPtr ctxt) {
! 9786: xmlChar *version = NULL;
! 9787:
! 9788: if (CMP7(CUR_PTR, 'v', 'e', 'r', 's', 'i', 'o', 'n')) {
! 9789: SKIP(7);
! 9790: SKIP_BLANKS;
! 9791: if (RAW != '=') {
! 9792: xmlFatalErr(ctxt, XML_ERR_EQUAL_REQUIRED, NULL);
! 9793: return(NULL);
! 9794: }
! 9795: NEXT;
! 9796: SKIP_BLANKS;
! 9797: if (RAW == '"') {
! 9798: NEXT;
! 9799: version = xmlParseVersionNum(ctxt);
! 9800: if (RAW != '"') {
! 9801: xmlFatalErr(ctxt, XML_ERR_STRING_NOT_CLOSED, NULL);
! 9802: } else
! 9803: NEXT;
! 9804: } else if (RAW == '\''){
! 9805: NEXT;
! 9806: version = xmlParseVersionNum(ctxt);
! 9807: if (RAW != '\'') {
! 9808: xmlFatalErr(ctxt, XML_ERR_STRING_NOT_CLOSED, NULL);
! 9809: } else
! 9810: NEXT;
! 9811: } else {
! 9812: xmlFatalErr(ctxt, XML_ERR_STRING_NOT_STARTED, NULL);
! 9813: }
! 9814: }
! 9815: return(version);
! 9816: }
! 9817:
! 9818: /**
! 9819: * xmlParseEncName:
! 9820: * @ctxt: an XML parser context
! 9821: *
! 9822: * parse the XML encoding name
! 9823: *
! 9824: * [81] EncName ::= [A-Za-z] ([A-Za-z0-9._] | '-')*
! 9825: *
! 9826: * Returns the encoding name value or NULL
! 9827: */
! 9828: xmlChar *
! 9829: xmlParseEncName(xmlParserCtxtPtr ctxt) {
! 9830: xmlChar *buf = NULL;
! 9831: int len = 0;
! 9832: int size = 10;
! 9833: xmlChar cur;
! 9834:
! 9835: cur = CUR;
! 9836: if (((cur >= 'a') && (cur <= 'z')) ||
! 9837: ((cur >= 'A') && (cur <= 'Z'))) {
! 9838: buf = (xmlChar *) xmlMallocAtomic(size * sizeof(xmlChar));
! 9839: if (buf == NULL) {
! 9840: xmlErrMemory(ctxt, NULL);
! 9841: return(NULL);
! 9842: }
! 9843:
! 9844: buf[len++] = cur;
! 9845: NEXT;
! 9846: cur = CUR;
! 9847: while (((cur >= 'a') && (cur <= 'z')) ||
! 9848: ((cur >= 'A') && (cur <= 'Z')) ||
! 9849: ((cur >= '0') && (cur <= '9')) ||
! 9850: (cur == '.') || (cur == '_') ||
! 9851: (cur == '-')) {
! 9852: if (len + 1 >= size) {
! 9853: xmlChar *tmp;
! 9854:
! 9855: size *= 2;
! 9856: tmp = (xmlChar *) xmlRealloc(buf, size * sizeof(xmlChar));
! 9857: if (tmp == NULL) {
! 9858: xmlErrMemory(ctxt, NULL);
! 9859: xmlFree(buf);
! 9860: return(NULL);
! 9861: }
! 9862: buf = tmp;
! 9863: }
! 9864: buf[len++] = cur;
! 9865: NEXT;
! 9866: cur = CUR;
! 9867: if (cur == 0) {
! 9868: SHRINK;
! 9869: GROW;
! 9870: cur = CUR;
! 9871: }
! 9872: }
! 9873: buf[len] = 0;
! 9874: } else {
! 9875: xmlFatalErr(ctxt, XML_ERR_ENCODING_NAME, NULL);
! 9876: }
! 9877: return(buf);
! 9878: }
! 9879:
! 9880: /**
! 9881: * xmlParseEncodingDecl:
! 9882: * @ctxt: an XML parser context
! 9883: *
! 9884: * parse the XML encoding declaration
! 9885: *
! 9886: * [80] EncodingDecl ::= S 'encoding' Eq ('"' EncName '"' | "'" EncName "'")
! 9887: *
! 9888: * this setups the conversion filters.
! 9889: *
! 9890: * Returns the encoding value or NULL
! 9891: */
! 9892:
! 9893: const xmlChar *
! 9894: xmlParseEncodingDecl(xmlParserCtxtPtr ctxt) {
! 9895: xmlChar *encoding = NULL;
! 9896:
! 9897: SKIP_BLANKS;
! 9898: if (CMP8(CUR_PTR, 'e', 'n', 'c', 'o', 'd', 'i', 'n', 'g')) {
! 9899: SKIP(8);
! 9900: SKIP_BLANKS;
! 9901: if (RAW != '=') {
! 9902: xmlFatalErr(ctxt, XML_ERR_EQUAL_REQUIRED, NULL);
! 9903: return(NULL);
! 9904: }
! 9905: NEXT;
! 9906: SKIP_BLANKS;
! 9907: if (RAW == '"') {
! 9908: NEXT;
! 9909: encoding = xmlParseEncName(ctxt);
! 9910: if (RAW != '"') {
! 9911: xmlFatalErr(ctxt, XML_ERR_STRING_NOT_CLOSED, NULL);
! 9912: } else
! 9913: NEXT;
! 9914: } else if (RAW == '\''){
! 9915: NEXT;
! 9916: encoding = xmlParseEncName(ctxt);
! 9917: if (RAW != '\'') {
! 9918: xmlFatalErr(ctxt, XML_ERR_STRING_NOT_CLOSED, NULL);
! 9919: } else
! 9920: NEXT;
! 9921: } else {
! 9922: xmlFatalErr(ctxt, XML_ERR_STRING_NOT_STARTED, NULL);
! 9923: }
! 9924: /*
! 9925: * UTF-16 encoding stwich has already taken place at this stage,
! 9926: * more over the little-endian/big-endian selection is already done
! 9927: */
! 9928: if ((encoding != NULL) &&
! 9929: ((!xmlStrcasecmp(encoding, BAD_CAST "UTF-16")) ||
! 9930: (!xmlStrcasecmp(encoding, BAD_CAST "UTF16")))) {
! 9931: /*
! 9932: * If no encoding was passed to the parser, that we are
! 9933: * using UTF-16 and no decoder is present i.e. the
! 9934: * document is apparently UTF-8 compatible, then raise an
! 9935: * encoding mismatch fatal error
! 9936: */
! 9937: if ((ctxt->encoding == NULL) &&
! 9938: (ctxt->input->buf != NULL) &&
! 9939: (ctxt->input->buf->encoder == NULL)) {
! 9940: xmlFatalErrMsg(ctxt, XML_ERR_INVALID_ENCODING,
! 9941: "Document labelled UTF-16 but has UTF-8 content\n");
! 9942: }
! 9943: if (ctxt->encoding != NULL)
! 9944: xmlFree((xmlChar *) ctxt->encoding);
! 9945: ctxt->encoding = encoding;
! 9946: }
! 9947: /*
! 9948: * UTF-8 encoding is handled natively
! 9949: */
! 9950: else if ((encoding != NULL) &&
! 9951: ((!xmlStrcasecmp(encoding, BAD_CAST "UTF-8")) ||
! 9952: (!xmlStrcasecmp(encoding, BAD_CAST "UTF8")))) {
! 9953: if (ctxt->encoding != NULL)
! 9954: xmlFree((xmlChar *) ctxt->encoding);
! 9955: ctxt->encoding = encoding;
! 9956: }
! 9957: else if (encoding != NULL) {
! 9958: xmlCharEncodingHandlerPtr handler;
! 9959:
! 9960: if (ctxt->input->encoding != NULL)
! 9961: xmlFree((xmlChar *) ctxt->input->encoding);
! 9962: ctxt->input->encoding = encoding;
! 9963:
! 9964: handler = xmlFindCharEncodingHandler((const char *) encoding);
! 9965: if (handler != NULL) {
! 9966: xmlSwitchToEncoding(ctxt, handler);
! 9967: } else {
! 9968: xmlFatalErrMsgStr(ctxt, XML_ERR_UNSUPPORTED_ENCODING,
! 9969: "Unsupported encoding %s\n", encoding);
! 9970: return(NULL);
! 9971: }
! 9972: }
! 9973: }
! 9974: return(encoding);
! 9975: }
! 9976:
! 9977: /**
! 9978: * xmlParseSDDecl:
! 9979: * @ctxt: an XML parser context
! 9980: *
! 9981: * parse the XML standalone declaration
! 9982: *
! 9983: * [32] SDDecl ::= S 'standalone' Eq
! 9984: * (("'" ('yes' | 'no') "'") | ('"' ('yes' | 'no')'"'))
! 9985: *
! 9986: * [ VC: Standalone Document Declaration ]
! 9987: * TODO The standalone document declaration must have the value "no"
! 9988: * if any external markup declarations contain declarations of:
! 9989: * - attributes with default values, if elements to which these
! 9990: * attributes apply appear in the document without specifications
! 9991: * of values for these attributes, or
! 9992: * - entities (other than amp, lt, gt, apos, quot), if references
! 9993: * to those entities appear in the document, or
! 9994: * - attributes with values subject to normalization, where the
! 9995: * attribute appears in the document with a value which will change
! 9996: * as a result of normalization, or
! 9997: * - element types with element content, if white space occurs directly
! 9998: * within any instance of those types.
! 9999: *
! 10000: * Returns:
! 10001: * 1 if standalone="yes"
! 10002: * 0 if standalone="no"
! 10003: * -2 if standalone attribute is missing or invalid
! 10004: * (A standalone value of -2 means that the XML declaration was found,
! 10005: * but no value was specified for the standalone attribute).
! 10006: */
! 10007:
! 10008: int
! 10009: xmlParseSDDecl(xmlParserCtxtPtr ctxt) {
! 10010: int standalone = -2;
! 10011:
! 10012: SKIP_BLANKS;
! 10013: if (CMP10(CUR_PTR, 's', 't', 'a', 'n', 'd', 'a', 'l', 'o', 'n', 'e')) {
! 10014: SKIP(10);
! 10015: SKIP_BLANKS;
! 10016: if (RAW != '=') {
! 10017: xmlFatalErr(ctxt, XML_ERR_EQUAL_REQUIRED, NULL);
! 10018: return(standalone);
! 10019: }
! 10020: NEXT;
! 10021: SKIP_BLANKS;
! 10022: if (RAW == '\''){
! 10023: NEXT;
! 10024: if ((RAW == 'n') && (NXT(1) == 'o')) {
! 10025: standalone = 0;
! 10026: SKIP(2);
! 10027: } else if ((RAW == 'y') && (NXT(1) == 'e') &&
! 10028: (NXT(2) == 's')) {
! 10029: standalone = 1;
! 10030: SKIP(3);
! 10031: } else {
! 10032: xmlFatalErr(ctxt, XML_ERR_STANDALONE_VALUE, NULL);
! 10033: }
! 10034: if (RAW != '\'') {
! 10035: xmlFatalErr(ctxt, XML_ERR_STRING_NOT_CLOSED, NULL);
! 10036: } else
! 10037: NEXT;
! 10038: } else if (RAW == '"'){
! 10039: NEXT;
! 10040: if ((RAW == 'n') && (NXT(1) == 'o')) {
! 10041: standalone = 0;
! 10042: SKIP(2);
! 10043: } else if ((RAW == 'y') && (NXT(1) == 'e') &&
! 10044: (NXT(2) == 's')) {
! 10045: standalone = 1;
! 10046: SKIP(3);
! 10047: } else {
! 10048: xmlFatalErr(ctxt, XML_ERR_STANDALONE_VALUE, NULL);
! 10049: }
! 10050: if (RAW != '"') {
! 10051: xmlFatalErr(ctxt, XML_ERR_STRING_NOT_CLOSED, NULL);
! 10052: } else
! 10053: NEXT;
! 10054: } else {
! 10055: xmlFatalErr(ctxt, XML_ERR_STRING_NOT_STARTED, NULL);
! 10056: }
! 10057: }
! 10058: return(standalone);
! 10059: }
! 10060:
! 10061: /**
! 10062: * xmlParseXMLDecl:
! 10063: * @ctxt: an XML parser context
! 10064: *
! 10065: * parse an XML declaration header
! 10066: *
! 10067: * [23] XMLDecl ::= '<?xml' VersionInfo EncodingDecl? SDDecl? S? '?>'
! 10068: */
! 10069:
! 10070: void
! 10071: xmlParseXMLDecl(xmlParserCtxtPtr ctxt) {
! 10072: xmlChar *version;
! 10073:
! 10074: /*
! 10075: * This value for standalone indicates that the document has an
! 10076: * XML declaration but it does not have a standalone attribute.
! 10077: * It will be overwritten later if a standalone attribute is found.
! 10078: */
! 10079: ctxt->input->standalone = -2;
! 10080:
! 10081: /*
! 10082: * We know that '<?xml' is here.
! 10083: */
! 10084: SKIP(5);
! 10085:
! 10086: if (!IS_BLANK_CH(RAW)) {
! 10087: xmlFatalErrMsg(ctxt, XML_ERR_SPACE_REQUIRED,
! 10088: "Blank needed after '<?xml'\n");
! 10089: }
! 10090: SKIP_BLANKS;
! 10091:
! 10092: /*
! 10093: * We must have the VersionInfo here.
! 10094: */
! 10095: version = xmlParseVersionInfo(ctxt);
! 10096: if (version == NULL) {
! 10097: xmlFatalErr(ctxt, XML_ERR_VERSION_MISSING, NULL);
! 10098: } else {
! 10099: if (!xmlStrEqual(version, (const xmlChar *) XML_DEFAULT_VERSION)) {
! 10100: /*
! 10101: * Changed here for XML-1.0 5th edition
! 10102: */
! 10103: if (ctxt->options & XML_PARSE_OLD10) {
! 10104: xmlFatalErrMsgStr(ctxt, XML_ERR_UNKNOWN_VERSION,
! 10105: "Unsupported version '%s'\n",
! 10106: version);
! 10107: } else {
! 10108: if ((version[0] == '1') && ((version[1] == '.'))) {
! 10109: xmlWarningMsg(ctxt, XML_WAR_UNKNOWN_VERSION,
! 10110: "Unsupported version '%s'\n",
! 10111: version, NULL);
! 10112: } else {
! 10113: xmlFatalErrMsgStr(ctxt, XML_ERR_UNKNOWN_VERSION,
! 10114: "Unsupported version '%s'\n",
! 10115: version);
! 10116: }
! 10117: }
! 10118: }
! 10119: if (ctxt->version != NULL)
! 10120: xmlFree((void *) ctxt->version);
! 10121: ctxt->version = version;
! 10122: }
! 10123:
! 10124: /*
! 10125: * We may have the encoding declaration
! 10126: */
! 10127: if (!IS_BLANK_CH(RAW)) {
! 10128: if ((RAW == '?') && (NXT(1) == '>')) {
! 10129: SKIP(2);
! 10130: return;
! 10131: }
! 10132: xmlFatalErrMsg(ctxt, XML_ERR_SPACE_REQUIRED, "Blank needed here\n");
! 10133: }
! 10134: xmlParseEncodingDecl(ctxt);
! 10135: if (ctxt->errNo == XML_ERR_UNSUPPORTED_ENCODING) {
! 10136: /*
! 10137: * The XML REC instructs us to stop parsing right here
! 10138: */
! 10139: return;
! 10140: }
! 10141:
! 10142: /*
! 10143: * We may have the standalone status.
! 10144: */
! 10145: if ((ctxt->input->encoding != NULL) && (!IS_BLANK_CH(RAW))) {
! 10146: if ((RAW == '?') && (NXT(1) == '>')) {
! 10147: SKIP(2);
! 10148: return;
! 10149: }
! 10150: xmlFatalErrMsg(ctxt, XML_ERR_SPACE_REQUIRED, "Blank needed here\n");
! 10151: }
! 10152:
! 10153: /*
! 10154: * We can grow the input buffer freely at that point
! 10155: */
! 10156: GROW;
! 10157:
! 10158: SKIP_BLANKS;
! 10159: ctxt->input->standalone = xmlParseSDDecl(ctxt);
! 10160:
! 10161: SKIP_BLANKS;
! 10162: if ((RAW == '?') && (NXT(1) == '>')) {
! 10163: SKIP(2);
! 10164: } else if (RAW == '>') {
! 10165: /* Deprecated old WD ... */
! 10166: xmlFatalErr(ctxt, XML_ERR_XMLDECL_NOT_FINISHED, NULL);
! 10167: NEXT;
! 10168: } else {
! 10169: xmlFatalErr(ctxt, XML_ERR_XMLDECL_NOT_FINISHED, NULL);
! 10170: MOVETO_ENDTAG(CUR_PTR);
! 10171: NEXT;
! 10172: }
! 10173: }
! 10174:
! 10175: /**
! 10176: * xmlParseMisc:
! 10177: * @ctxt: an XML parser context
! 10178: *
! 10179: * parse an XML Misc* optional field.
! 10180: *
! 10181: * [27] Misc ::= Comment | PI | S
! 10182: */
! 10183:
! 10184: void
! 10185: xmlParseMisc(xmlParserCtxtPtr ctxt) {
! 10186: while (((RAW == '<') && (NXT(1) == '?')) ||
! 10187: (CMP4(CUR_PTR, '<', '!', '-', '-')) ||
! 10188: IS_BLANK_CH(CUR)) {
! 10189: if ((RAW == '<') && (NXT(1) == '?')) {
! 10190: xmlParsePI(ctxt);
! 10191: } else if (IS_BLANK_CH(CUR)) {
! 10192: NEXT;
! 10193: } else
! 10194: xmlParseComment(ctxt);
! 10195: }
! 10196: }
! 10197:
! 10198: /**
! 10199: * xmlParseDocument:
! 10200: * @ctxt: an XML parser context
! 10201: *
! 10202: * parse an XML document (and build a tree if using the standard SAX
! 10203: * interface).
! 10204: *
! 10205: * [1] document ::= prolog element Misc*
! 10206: *
! 10207: * [22] prolog ::= XMLDecl? Misc* (doctypedecl Misc*)?
! 10208: *
! 10209: * Returns 0, -1 in case of error. the parser context is augmented
! 10210: * as a result of the parsing.
! 10211: */
! 10212:
! 10213: int
! 10214: xmlParseDocument(xmlParserCtxtPtr ctxt) {
! 10215: xmlChar start[4];
! 10216: xmlCharEncoding enc;
! 10217:
! 10218: xmlInitParser();
! 10219:
! 10220: if ((ctxt == NULL) || (ctxt->input == NULL))
! 10221: return(-1);
! 10222:
! 10223: GROW;
! 10224:
! 10225: /*
! 10226: * SAX: detecting the level.
! 10227: */
! 10228: xmlDetectSAX2(ctxt);
! 10229:
! 10230: /*
! 10231: * SAX: beginning of the document processing.
! 10232: */
! 10233: if ((ctxt->sax) && (ctxt->sax->setDocumentLocator))
! 10234: ctxt->sax->setDocumentLocator(ctxt->userData, &xmlDefaultSAXLocator);
! 10235:
! 10236: if ((ctxt->encoding == NULL) &&
! 10237: ((ctxt->input->end - ctxt->input->cur) >= 4)) {
! 10238: /*
! 10239: * Get the 4 first bytes and decode the charset
! 10240: * if enc != XML_CHAR_ENCODING_NONE
! 10241: * plug some encoding conversion routines.
! 10242: */
! 10243: start[0] = RAW;
! 10244: start[1] = NXT(1);
! 10245: start[2] = NXT(2);
! 10246: start[3] = NXT(3);
! 10247: enc = xmlDetectCharEncoding(&start[0], 4);
! 10248: if (enc != XML_CHAR_ENCODING_NONE) {
! 10249: xmlSwitchEncoding(ctxt, enc);
! 10250: }
! 10251: }
! 10252:
! 10253:
! 10254: if (CUR == 0) {
! 10255: xmlFatalErr(ctxt, XML_ERR_DOCUMENT_EMPTY, NULL);
! 10256: }
! 10257:
! 10258: /*
! 10259: * Check for the XMLDecl in the Prolog.
! 10260: * do not GROW here to avoid the detected encoder to decode more
! 10261: * than just the first line, unless the amount of data is really
! 10262: * too small to hold "<?xml version="1.0" encoding="foo"
! 10263: */
! 10264: if ((ctxt->input->end - ctxt->input->cur) < 35) {
! 10265: GROW;
! 10266: }
! 10267: if ((CMP5(CUR_PTR, '<', '?', 'x', 'm', 'l')) && (IS_BLANK_CH(NXT(5)))) {
! 10268:
! 10269: /*
! 10270: * Note that we will switch encoding on the fly.
! 10271: */
! 10272: xmlParseXMLDecl(ctxt);
! 10273: if (ctxt->errNo == XML_ERR_UNSUPPORTED_ENCODING) {
! 10274: /*
! 10275: * The XML REC instructs us to stop parsing right here
! 10276: */
! 10277: return(-1);
! 10278: }
! 10279: ctxt->standalone = ctxt->input->standalone;
! 10280: SKIP_BLANKS;
! 10281: } else {
! 10282: ctxt->version = xmlCharStrdup(XML_DEFAULT_VERSION);
! 10283: }
! 10284: if ((ctxt->sax) && (ctxt->sax->startDocument) && (!ctxt->disableSAX))
! 10285: ctxt->sax->startDocument(ctxt->userData);
! 10286:
! 10287: /*
! 10288: * The Misc part of the Prolog
! 10289: */
! 10290: GROW;
! 10291: xmlParseMisc(ctxt);
! 10292:
! 10293: /*
! 10294: * Then possibly doc type declaration(s) and more Misc
! 10295: * (doctypedecl Misc*)?
! 10296: */
! 10297: GROW;
! 10298: if (CMP9(CUR_PTR, '<', '!', 'D', 'O', 'C', 'T', 'Y', 'P', 'E')) {
! 10299:
! 10300: ctxt->inSubset = 1;
! 10301: xmlParseDocTypeDecl(ctxt);
! 10302: if (RAW == '[') {
! 10303: ctxt->instate = XML_PARSER_DTD;
! 10304: xmlParseInternalSubset(ctxt);
! 10305: }
! 10306:
! 10307: /*
! 10308: * Create and update the external subset.
! 10309: */
! 10310: ctxt->inSubset = 2;
! 10311: if ((ctxt->sax != NULL) && (ctxt->sax->externalSubset != NULL) &&
! 10312: (!ctxt->disableSAX))
! 10313: ctxt->sax->externalSubset(ctxt->userData, ctxt->intSubName,
! 10314: ctxt->extSubSystem, ctxt->extSubURI);
! 10315: ctxt->inSubset = 0;
! 10316:
! 10317: xmlCleanSpecialAttr(ctxt);
! 10318:
! 10319: ctxt->instate = XML_PARSER_PROLOG;
! 10320: xmlParseMisc(ctxt);
! 10321: }
! 10322:
! 10323: /*
! 10324: * Time to start parsing the tree itself
! 10325: */
! 10326: GROW;
! 10327: if (RAW != '<') {
! 10328: xmlFatalErrMsg(ctxt, XML_ERR_DOCUMENT_EMPTY,
! 10329: "Start tag expected, '<' not found\n");
! 10330: } else {
! 10331: ctxt->instate = XML_PARSER_CONTENT;
! 10332: xmlParseElement(ctxt);
! 10333: ctxt->instate = XML_PARSER_EPILOG;
! 10334:
! 10335:
! 10336: /*
! 10337: * The Misc part at the end
! 10338: */
! 10339: xmlParseMisc(ctxt);
! 10340:
! 10341: if (RAW != 0) {
! 10342: xmlFatalErr(ctxt, XML_ERR_DOCUMENT_END, NULL);
! 10343: }
! 10344: ctxt->instate = XML_PARSER_EOF;
! 10345: }
! 10346:
! 10347: /*
! 10348: * SAX: end of the document processing.
! 10349: */
! 10350: if ((ctxt->sax) && (ctxt->sax->endDocument != NULL))
! 10351: ctxt->sax->endDocument(ctxt->userData);
! 10352:
! 10353: /*
! 10354: * Remove locally kept entity definitions if the tree was not built
! 10355: */
! 10356: if ((ctxt->myDoc != NULL) &&
! 10357: (xmlStrEqual(ctxt->myDoc->version, SAX_COMPAT_MODE))) {
! 10358: xmlFreeDoc(ctxt->myDoc);
! 10359: ctxt->myDoc = NULL;
! 10360: }
! 10361:
! 10362: if ((ctxt->wellFormed) && (ctxt->myDoc != NULL)) {
! 10363: ctxt->myDoc->properties |= XML_DOC_WELLFORMED;
! 10364: if (ctxt->valid)
! 10365: ctxt->myDoc->properties |= XML_DOC_DTDVALID;
! 10366: if (ctxt->nsWellFormed)
! 10367: ctxt->myDoc->properties |= XML_DOC_NSVALID;
! 10368: if (ctxt->options & XML_PARSE_OLD10)
! 10369: ctxt->myDoc->properties |= XML_DOC_OLD10;
! 10370: }
! 10371: if (! ctxt->wellFormed) {
! 10372: ctxt->valid = 0;
! 10373: return(-1);
! 10374: }
! 10375: return(0);
! 10376: }
! 10377:
! 10378: /**
! 10379: * xmlParseExtParsedEnt:
! 10380: * @ctxt: an XML parser context
! 10381: *
! 10382: * parse a general parsed entity
! 10383: * An external general parsed entity is well-formed if it matches the
! 10384: * production labeled extParsedEnt.
! 10385: *
! 10386: * [78] extParsedEnt ::= TextDecl? content
! 10387: *
! 10388: * Returns 0, -1 in case of error. the parser context is augmented
! 10389: * as a result of the parsing.
! 10390: */
! 10391:
! 10392: int
! 10393: xmlParseExtParsedEnt(xmlParserCtxtPtr ctxt) {
! 10394: xmlChar start[4];
! 10395: xmlCharEncoding enc;
! 10396:
! 10397: if ((ctxt == NULL) || (ctxt->input == NULL))
! 10398: return(-1);
! 10399:
! 10400: xmlDefaultSAXHandlerInit();
! 10401:
! 10402: xmlDetectSAX2(ctxt);
! 10403:
! 10404: GROW;
! 10405:
! 10406: /*
! 10407: * SAX: beginning of the document processing.
! 10408: */
! 10409: if ((ctxt->sax) && (ctxt->sax->setDocumentLocator))
! 10410: ctxt->sax->setDocumentLocator(ctxt->userData, &xmlDefaultSAXLocator);
! 10411:
! 10412: /*
! 10413: * Get the 4 first bytes and decode the charset
! 10414: * if enc != XML_CHAR_ENCODING_NONE
! 10415: * plug some encoding conversion routines.
! 10416: */
! 10417: if ((ctxt->input->end - ctxt->input->cur) >= 4) {
! 10418: start[0] = RAW;
! 10419: start[1] = NXT(1);
! 10420: start[2] = NXT(2);
! 10421: start[3] = NXT(3);
! 10422: enc = xmlDetectCharEncoding(start, 4);
! 10423: if (enc != XML_CHAR_ENCODING_NONE) {
! 10424: xmlSwitchEncoding(ctxt, enc);
! 10425: }
! 10426: }
! 10427:
! 10428:
! 10429: if (CUR == 0) {
! 10430: xmlFatalErr(ctxt, XML_ERR_DOCUMENT_EMPTY, NULL);
! 10431: }
! 10432:
! 10433: /*
! 10434: * Check for the XMLDecl in the Prolog.
! 10435: */
! 10436: GROW;
! 10437: if ((CMP5(CUR_PTR, '<', '?', 'x', 'm', 'l')) && (IS_BLANK_CH(NXT(5)))) {
! 10438:
! 10439: /*
! 10440: * Note that we will switch encoding on the fly.
! 10441: */
! 10442: xmlParseXMLDecl(ctxt);
! 10443: if (ctxt->errNo == XML_ERR_UNSUPPORTED_ENCODING) {
! 10444: /*
! 10445: * The XML REC instructs us to stop parsing right here
! 10446: */
! 10447: return(-1);
! 10448: }
! 10449: SKIP_BLANKS;
! 10450: } else {
! 10451: ctxt->version = xmlCharStrdup(XML_DEFAULT_VERSION);
! 10452: }
! 10453: if ((ctxt->sax) && (ctxt->sax->startDocument) && (!ctxt->disableSAX))
! 10454: ctxt->sax->startDocument(ctxt->userData);
! 10455:
! 10456: /*
! 10457: * Doing validity checking on chunk doesn't make sense
! 10458: */
! 10459: ctxt->instate = XML_PARSER_CONTENT;
! 10460: ctxt->validate = 0;
! 10461: ctxt->loadsubset = 0;
! 10462: ctxt->depth = 0;
! 10463:
! 10464: xmlParseContent(ctxt);
! 10465:
! 10466: if ((RAW == '<') && (NXT(1) == '/')) {
! 10467: xmlFatalErr(ctxt, XML_ERR_NOT_WELL_BALANCED, NULL);
! 10468: } else if (RAW != 0) {
! 10469: xmlFatalErr(ctxt, XML_ERR_EXTRA_CONTENT, NULL);
! 10470: }
! 10471:
! 10472: /*
! 10473: * SAX: end of the document processing.
! 10474: */
! 10475: if ((ctxt->sax) && (ctxt->sax->endDocument != NULL))
! 10476: ctxt->sax->endDocument(ctxt->userData);
! 10477:
! 10478: if (! ctxt->wellFormed) return(-1);
! 10479: return(0);
! 10480: }
! 10481:
! 10482: #ifdef LIBXML_PUSH_ENABLED
! 10483: /************************************************************************
! 10484: * *
! 10485: * Progressive parsing interfaces *
! 10486: * *
! 10487: ************************************************************************/
! 10488:
! 10489: /**
! 10490: * xmlParseLookupSequence:
! 10491: * @ctxt: an XML parser context
! 10492: * @first: the first char to lookup
! 10493: * @next: the next char to lookup or zero
! 10494: * @third: the next char to lookup or zero
! 10495: *
! 10496: * Try to find if a sequence (first, next, third) or just (first next) or
! 10497: * (first) is available in the input stream.
! 10498: * This function has a side effect of (possibly) incrementing ctxt->checkIndex
! 10499: * to avoid rescanning sequences of bytes, it DOES change the state of the
! 10500: * parser, do not use liberally.
! 10501: *
! 10502: * Returns the index to the current parsing point if the full sequence
! 10503: * is available, -1 otherwise.
! 10504: */
! 10505: static int
! 10506: xmlParseLookupSequence(xmlParserCtxtPtr ctxt, xmlChar first,
! 10507: xmlChar next, xmlChar third) {
! 10508: int base, len;
! 10509: xmlParserInputPtr in;
! 10510: const xmlChar *buf;
! 10511:
! 10512: in = ctxt->input;
! 10513: if (in == NULL) return(-1);
! 10514: base = in->cur - in->base;
! 10515: if (base < 0) return(-1);
! 10516: if (ctxt->checkIndex > base)
! 10517: base = ctxt->checkIndex;
! 10518: if (in->buf == NULL) {
! 10519: buf = in->base;
! 10520: len = in->length;
! 10521: } else {
! 10522: buf = in->buf->buffer->content;
! 10523: len = in->buf->buffer->use;
! 10524: }
! 10525: /* take into account the sequence length */
! 10526: if (third) len -= 2;
! 10527: else if (next) len --;
! 10528: for (;base < len;base++) {
! 10529: if (buf[base] == first) {
! 10530: if (third != 0) {
! 10531: if ((buf[base + 1] != next) ||
! 10532: (buf[base + 2] != third)) continue;
! 10533: } else if (next != 0) {
! 10534: if (buf[base + 1] != next) continue;
! 10535: }
! 10536: ctxt->checkIndex = 0;
! 10537: #ifdef DEBUG_PUSH
! 10538: if (next == 0)
! 10539: xmlGenericError(xmlGenericErrorContext,
! 10540: "PP: lookup '%c' found at %d\n",
! 10541: first, base);
! 10542: else if (third == 0)
! 10543: xmlGenericError(xmlGenericErrorContext,
! 10544: "PP: lookup '%c%c' found at %d\n",
! 10545: first, next, base);
! 10546: else
! 10547: xmlGenericError(xmlGenericErrorContext,
! 10548: "PP: lookup '%c%c%c' found at %d\n",
! 10549: first, next, third, base);
! 10550: #endif
! 10551: return(base - (in->cur - in->base));
! 10552: }
! 10553: }
! 10554: ctxt->checkIndex = base;
! 10555: #ifdef DEBUG_PUSH
! 10556: if (next == 0)
! 10557: xmlGenericError(xmlGenericErrorContext,
! 10558: "PP: lookup '%c' failed\n", first);
! 10559: else if (third == 0)
! 10560: xmlGenericError(xmlGenericErrorContext,
! 10561: "PP: lookup '%c%c' failed\n", first, next);
! 10562: else
! 10563: xmlGenericError(xmlGenericErrorContext,
! 10564: "PP: lookup '%c%c%c' failed\n", first, next, third);
! 10565: #endif
! 10566: return(-1);
! 10567: }
! 10568:
! 10569: /**
! 10570: * xmlParseGetLasts:
! 10571: * @ctxt: an XML parser context
! 10572: * @lastlt: pointer to store the last '<' from the input
! 10573: * @lastgt: pointer to store the last '>' from the input
! 10574: *
! 10575: * Lookup the last < and > in the current chunk
! 10576: */
! 10577: static void
! 10578: xmlParseGetLasts(xmlParserCtxtPtr ctxt, const xmlChar **lastlt,
! 10579: const xmlChar **lastgt) {
! 10580: const xmlChar *tmp;
! 10581:
! 10582: if ((ctxt == NULL) || (lastlt == NULL) || (lastgt == NULL)) {
! 10583: xmlGenericError(xmlGenericErrorContext,
! 10584: "Internal error: xmlParseGetLasts\n");
! 10585: return;
! 10586: }
! 10587: if ((ctxt->progressive != 0) && (ctxt->inputNr == 1)) {
! 10588: tmp = ctxt->input->end;
! 10589: tmp--;
! 10590: while ((tmp >= ctxt->input->base) && (*tmp != '<')) tmp--;
! 10591: if (tmp < ctxt->input->base) {
! 10592: *lastlt = NULL;
! 10593: *lastgt = NULL;
! 10594: } else {
! 10595: *lastlt = tmp;
! 10596: tmp++;
! 10597: while ((tmp < ctxt->input->end) && (*tmp != '>')) {
! 10598: if (*tmp == '\'') {
! 10599: tmp++;
! 10600: while ((tmp < ctxt->input->end) && (*tmp != '\'')) tmp++;
! 10601: if (tmp < ctxt->input->end) tmp++;
! 10602: } else if (*tmp == '"') {
! 10603: tmp++;
! 10604: while ((tmp < ctxt->input->end) && (*tmp != '"')) tmp++;
! 10605: if (tmp < ctxt->input->end) tmp++;
! 10606: } else
! 10607: tmp++;
! 10608: }
! 10609: if (tmp < ctxt->input->end)
! 10610: *lastgt = tmp;
! 10611: else {
! 10612: tmp = *lastlt;
! 10613: tmp--;
! 10614: while ((tmp >= ctxt->input->base) && (*tmp != '>')) tmp--;
! 10615: if (tmp >= ctxt->input->base)
! 10616: *lastgt = tmp;
! 10617: else
! 10618: *lastgt = NULL;
! 10619: }
! 10620: }
! 10621: } else {
! 10622: *lastlt = NULL;
! 10623: *lastgt = NULL;
! 10624: }
! 10625: }
! 10626: /**
! 10627: * xmlCheckCdataPush:
! 10628: * @cur: pointer to the bock of characters
! 10629: * @len: length of the block in bytes
! 10630: *
! 10631: * Check that the block of characters is okay as SCdata content [20]
! 10632: *
! 10633: * Returns the number of bytes to pass if okay, a negative index where an
! 10634: * UTF-8 error occured otherwise
! 10635: */
! 10636: static int
! 10637: xmlCheckCdataPush(const xmlChar *utf, int len) {
! 10638: int ix;
! 10639: unsigned char c;
! 10640: int codepoint;
! 10641:
! 10642: if ((utf == NULL) || (len <= 0))
! 10643: return(0);
! 10644:
! 10645: for (ix = 0; ix < len;) { /* string is 0-terminated */
! 10646: c = utf[ix];
! 10647: if ((c & 0x80) == 0x00) { /* 1-byte code, starts with 10 */
! 10648: if (c >= 0x20)
! 10649: ix++;
! 10650: else if ((c == 0xA) || (c == 0xD) || (c == 0x9))
! 10651: ix++;
! 10652: else
! 10653: return(-ix);
! 10654: } else if ((c & 0xe0) == 0xc0) {/* 2-byte code, starts with 110 */
! 10655: if (ix + 2 > len) return(ix);
! 10656: if ((utf[ix+1] & 0xc0 ) != 0x80)
! 10657: return(-ix);
! 10658: codepoint = (utf[ix] & 0x1f) << 6;
! 10659: codepoint |= utf[ix+1] & 0x3f;
! 10660: if (!xmlIsCharQ(codepoint))
! 10661: return(-ix);
! 10662: ix += 2;
! 10663: } else if ((c & 0xf0) == 0xe0) {/* 3-byte code, starts with 1110 */
! 10664: if (ix + 3 > len) return(ix);
! 10665: if (((utf[ix+1] & 0xc0) != 0x80) ||
! 10666: ((utf[ix+2] & 0xc0) != 0x80))
! 10667: return(-ix);
! 10668: codepoint = (utf[ix] & 0xf) << 12;
! 10669: codepoint |= (utf[ix+1] & 0x3f) << 6;
! 10670: codepoint |= utf[ix+2] & 0x3f;
! 10671: if (!xmlIsCharQ(codepoint))
! 10672: return(-ix);
! 10673: ix += 3;
! 10674: } else if ((c & 0xf8) == 0xf0) {/* 4-byte code, starts with 11110 */
! 10675: if (ix + 4 > len) return(ix);
! 10676: if (((utf[ix+1] & 0xc0) != 0x80) ||
! 10677: ((utf[ix+2] & 0xc0) != 0x80) ||
! 10678: ((utf[ix+3] & 0xc0) != 0x80))
! 10679: return(-ix);
! 10680: codepoint = (utf[ix] & 0x7) << 18;
! 10681: codepoint |= (utf[ix+1] & 0x3f) << 12;
! 10682: codepoint |= (utf[ix+2] & 0x3f) << 6;
! 10683: codepoint |= utf[ix+3] & 0x3f;
! 10684: if (!xmlIsCharQ(codepoint))
! 10685: return(-ix);
! 10686: ix += 4;
! 10687: } else /* unknown encoding */
! 10688: return(-ix);
! 10689: }
! 10690: return(ix);
! 10691: }
! 10692:
! 10693: /**
! 10694: * xmlParseTryOrFinish:
! 10695: * @ctxt: an XML parser context
! 10696: * @terminate: last chunk indicator
! 10697: *
! 10698: * Try to progress on parsing
! 10699: *
! 10700: * Returns zero if no parsing was possible
! 10701: */
! 10702: static int
! 10703: xmlParseTryOrFinish(xmlParserCtxtPtr ctxt, int terminate) {
! 10704: int ret = 0;
! 10705: int avail, tlen;
! 10706: xmlChar cur, next;
! 10707: const xmlChar *lastlt, *lastgt;
! 10708:
! 10709: if (ctxt->input == NULL)
! 10710: return(0);
! 10711:
! 10712: #ifdef DEBUG_PUSH
! 10713: switch (ctxt->instate) {
! 10714: case XML_PARSER_EOF:
! 10715: xmlGenericError(xmlGenericErrorContext,
! 10716: "PP: try EOF\n"); break;
! 10717: case XML_PARSER_START:
! 10718: xmlGenericError(xmlGenericErrorContext,
! 10719: "PP: try START\n"); break;
! 10720: case XML_PARSER_MISC:
! 10721: xmlGenericError(xmlGenericErrorContext,
! 10722: "PP: try MISC\n");break;
! 10723: case XML_PARSER_COMMENT:
! 10724: xmlGenericError(xmlGenericErrorContext,
! 10725: "PP: try COMMENT\n");break;
! 10726: case XML_PARSER_PROLOG:
! 10727: xmlGenericError(xmlGenericErrorContext,
! 10728: "PP: try PROLOG\n");break;
! 10729: case XML_PARSER_START_TAG:
! 10730: xmlGenericError(xmlGenericErrorContext,
! 10731: "PP: try START_TAG\n");break;
! 10732: case XML_PARSER_CONTENT:
! 10733: xmlGenericError(xmlGenericErrorContext,
! 10734: "PP: try CONTENT\n");break;
! 10735: case XML_PARSER_CDATA_SECTION:
! 10736: xmlGenericError(xmlGenericErrorContext,
! 10737: "PP: try CDATA_SECTION\n");break;
! 10738: case XML_PARSER_END_TAG:
! 10739: xmlGenericError(xmlGenericErrorContext,
! 10740: "PP: try END_TAG\n");break;
! 10741: case XML_PARSER_ENTITY_DECL:
! 10742: xmlGenericError(xmlGenericErrorContext,
! 10743: "PP: try ENTITY_DECL\n");break;
! 10744: case XML_PARSER_ENTITY_VALUE:
! 10745: xmlGenericError(xmlGenericErrorContext,
! 10746: "PP: try ENTITY_VALUE\n");break;
! 10747: case XML_PARSER_ATTRIBUTE_VALUE:
! 10748: xmlGenericError(xmlGenericErrorContext,
! 10749: "PP: try ATTRIBUTE_VALUE\n");break;
! 10750: case XML_PARSER_DTD:
! 10751: xmlGenericError(xmlGenericErrorContext,
! 10752: "PP: try DTD\n");break;
! 10753: case XML_PARSER_EPILOG:
! 10754: xmlGenericError(xmlGenericErrorContext,
! 10755: "PP: try EPILOG\n");break;
! 10756: case XML_PARSER_PI:
! 10757: xmlGenericError(xmlGenericErrorContext,
! 10758: "PP: try PI\n");break;
! 10759: case XML_PARSER_IGNORE:
! 10760: xmlGenericError(xmlGenericErrorContext,
! 10761: "PP: try IGNORE\n");break;
! 10762: }
! 10763: #endif
! 10764:
! 10765: if ((ctxt->input != NULL) &&
! 10766: (ctxt->input->cur - ctxt->input->base > 4096)) {
! 10767: xmlSHRINK(ctxt);
! 10768: ctxt->checkIndex = 0;
! 10769: }
! 10770: xmlParseGetLasts(ctxt, &lastlt, &lastgt);
! 10771:
! 10772: while (1) {
! 10773: if ((ctxt->errNo != XML_ERR_OK) && (ctxt->disableSAX == 1))
! 10774: return(0);
! 10775:
! 10776:
! 10777: /*
! 10778: * Pop-up of finished entities.
! 10779: */
! 10780: while ((RAW == 0) && (ctxt->inputNr > 1))
! 10781: xmlPopInput(ctxt);
! 10782:
! 10783: if (ctxt->input == NULL) break;
! 10784: if (ctxt->input->buf == NULL)
! 10785: avail = ctxt->input->length -
! 10786: (ctxt->input->cur - ctxt->input->base);
! 10787: else {
! 10788: /*
! 10789: * If we are operating on converted input, try to flush
! 10790: * remainng chars to avoid them stalling in the non-converted
! 10791: * buffer.
! 10792: */
! 10793: if ((ctxt->input->buf->raw != NULL) &&
! 10794: (ctxt->input->buf->raw->use > 0)) {
! 10795: int base = ctxt->input->base -
! 10796: ctxt->input->buf->buffer->content;
! 10797: int current = ctxt->input->cur - ctxt->input->base;
! 10798:
! 10799: xmlParserInputBufferPush(ctxt->input->buf, 0, "");
! 10800: ctxt->input->base = ctxt->input->buf->buffer->content + base;
! 10801: ctxt->input->cur = ctxt->input->base + current;
! 10802: ctxt->input->end =
! 10803: &ctxt->input->buf->buffer->content[
! 10804: ctxt->input->buf->buffer->use];
! 10805: }
! 10806: avail = ctxt->input->buf->buffer->use -
! 10807: (ctxt->input->cur - ctxt->input->base);
! 10808: }
! 10809: if (avail < 1)
! 10810: goto done;
! 10811: switch (ctxt->instate) {
! 10812: case XML_PARSER_EOF:
! 10813: /*
! 10814: * Document parsing is done !
! 10815: */
! 10816: goto done;
! 10817: case XML_PARSER_START:
! 10818: if (ctxt->charset == XML_CHAR_ENCODING_NONE) {
! 10819: xmlChar start[4];
! 10820: xmlCharEncoding enc;
! 10821:
! 10822: /*
! 10823: * Very first chars read from the document flow.
! 10824: */
! 10825: if (avail < 4)
! 10826: goto done;
! 10827:
! 10828: /*
! 10829: * Get the 4 first bytes and decode the charset
! 10830: * if enc != XML_CHAR_ENCODING_NONE
! 10831: * plug some encoding conversion routines,
! 10832: * else xmlSwitchEncoding will set to (default)
! 10833: * UTF8.
! 10834: */
! 10835: start[0] = RAW;
! 10836: start[1] = NXT(1);
! 10837: start[2] = NXT(2);
! 10838: start[3] = NXT(3);
! 10839: enc = xmlDetectCharEncoding(start, 4);
! 10840: xmlSwitchEncoding(ctxt, enc);
! 10841: break;
! 10842: }
! 10843:
! 10844: if (avail < 2)
! 10845: goto done;
! 10846: cur = ctxt->input->cur[0];
! 10847: next = ctxt->input->cur[1];
! 10848: if (cur == 0) {
! 10849: if ((ctxt->sax) && (ctxt->sax->setDocumentLocator))
! 10850: ctxt->sax->setDocumentLocator(ctxt->userData,
! 10851: &xmlDefaultSAXLocator);
! 10852: xmlFatalErr(ctxt, XML_ERR_DOCUMENT_EMPTY, NULL);
! 10853: ctxt->instate = XML_PARSER_EOF;
! 10854: #ifdef DEBUG_PUSH
! 10855: xmlGenericError(xmlGenericErrorContext,
! 10856: "PP: entering EOF\n");
! 10857: #endif
! 10858: if ((ctxt->sax) && (ctxt->sax->endDocument != NULL))
! 10859: ctxt->sax->endDocument(ctxt->userData);
! 10860: goto done;
! 10861: }
! 10862: if ((cur == '<') && (next == '?')) {
! 10863: /* PI or XML decl */
! 10864: if (avail < 5) return(ret);
! 10865: if ((!terminate) &&
! 10866: (xmlParseLookupSequence(ctxt, '?', '>', 0) < 0))
! 10867: return(ret);
! 10868: if ((ctxt->sax) && (ctxt->sax->setDocumentLocator))
! 10869: ctxt->sax->setDocumentLocator(ctxt->userData,
! 10870: &xmlDefaultSAXLocator);
! 10871: if ((ctxt->input->cur[2] == 'x') &&
! 10872: (ctxt->input->cur[3] == 'm') &&
! 10873: (ctxt->input->cur[4] == 'l') &&
! 10874: (IS_BLANK_CH(ctxt->input->cur[5]))) {
! 10875: ret += 5;
! 10876: #ifdef DEBUG_PUSH
! 10877: xmlGenericError(xmlGenericErrorContext,
! 10878: "PP: Parsing XML Decl\n");
! 10879: #endif
! 10880: xmlParseXMLDecl(ctxt);
! 10881: if (ctxt->errNo == XML_ERR_UNSUPPORTED_ENCODING) {
! 10882: /*
! 10883: * The XML REC instructs us to stop parsing right
! 10884: * here
! 10885: */
! 10886: ctxt->instate = XML_PARSER_EOF;
! 10887: return(0);
! 10888: }
! 10889: ctxt->standalone = ctxt->input->standalone;
! 10890: if ((ctxt->encoding == NULL) &&
! 10891: (ctxt->input->encoding != NULL))
! 10892: ctxt->encoding = xmlStrdup(ctxt->input->encoding);
! 10893: if ((ctxt->sax) && (ctxt->sax->startDocument) &&
! 10894: (!ctxt->disableSAX))
! 10895: ctxt->sax->startDocument(ctxt->userData);
! 10896: ctxt->instate = XML_PARSER_MISC;
! 10897: #ifdef DEBUG_PUSH
! 10898: xmlGenericError(xmlGenericErrorContext,
! 10899: "PP: entering MISC\n");
! 10900: #endif
! 10901: } else {
! 10902: ctxt->version = xmlCharStrdup(XML_DEFAULT_VERSION);
! 10903: if ((ctxt->sax) && (ctxt->sax->startDocument) &&
! 10904: (!ctxt->disableSAX))
! 10905: ctxt->sax->startDocument(ctxt->userData);
! 10906: ctxt->instate = XML_PARSER_MISC;
! 10907: #ifdef DEBUG_PUSH
! 10908: xmlGenericError(xmlGenericErrorContext,
! 10909: "PP: entering MISC\n");
! 10910: #endif
! 10911: }
! 10912: } else {
! 10913: if ((ctxt->sax) && (ctxt->sax->setDocumentLocator))
! 10914: ctxt->sax->setDocumentLocator(ctxt->userData,
! 10915: &xmlDefaultSAXLocator);
! 10916: ctxt->version = xmlCharStrdup(XML_DEFAULT_VERSION);
! 10917: if (ctxt->version == NULL) {
! 10918: xmlErrMemory(ctxt, NULL);
! 10919: break;
! 10920: }
! 10921: if ((ctxt->sax) && (ctxt->sax->startDocument) &&
! 10922: (!ctxt->disableSAX))
! 10923: ctxt->sax->startDocument(ctxt->userData);
! 10924: ctxt->instate = XML_PARSER_MISC;
! 10925: #ifdef DEBUG_PUSH
! 10926: xmlGenericError(xmlGenericErrorContext,
! 10927: "PP: entering MISC\n");
! 10928: #endif
! 10929: }
! 10930: break;
! 10931: case XML_PARSER_START_TAG: {
! 10932: const xmlChar *name;
! 10933: const xmlChar *prefix = NULL;
! 10934: const xmlChar *URI = NULL;
! 10935: int nsNr = ctxt->nsNr;
! 10936:
! 10937: if ((avail < 2) && (ctxt->inputNr == 1))
! 10938: goto done;
! 10939: cur = ctxt->input->cur[0];
! 10940: if (cur != '<') {
! 10941: xmlFatalErr(ctxt, XML_ERR_DOCUMENT_EMPTY, NULL);
! 10942: ctxt->instate = XML_PARSER_EOF;
! 10943: if ((ctxt->sax) && (ctxt->sax->endDocument != NULL))
! 10944: ctxt->sax->endDocument(ctxt->userData);
! 10945: goto done;
! 10946: }
! 10947: if (!terminate) {
! 10948: if (ctxt->progressive) {
! 10949: /* > can be found unescaped in attribute values */
! 10950: if ((lastgt == NULL) || (ctxt->input->cur >= lastgt))
! 10951: goto done;
! 10952: } else if (xmlParseLookupSequence(ctxt, '>', 0, 0) < 0) {
! 10953: goto done;
! 10954: }
! 10955: }
! 10956: if (ctxt->spaceNr == 0)
! 10957: spacePush(ctxt, -1);
! 10958: else if (*ctxt->space == -2)
! 10959: spacePush(ctxt, -1);
! 10960: else
! 10961: spacePush(ctxt, *ctxt->space);
! 10962: #ifdef LIBXML_SAX1_ENABLED
! 10963: if (ctxt->sax2)
! 10964: #endif /* LIBXML_SAX1_ENABLED */
! 10965: name = xmlParseStartTag2(ctxt, &prefix, &URI, &tlen);
! 10966: #ifdef LIBXML_SAX1_ENABLED
! 10967: else
! 10968: name = xmlParseStartTag(ctxt);
! 10969: #endif /* LIBXML_SAX1_ENABLED */
! 10970: if (name == NULL) {
! 10971: spacePop(ctxt);
! 10972: ctxt->instate = XML_PARSER_EOF;
! 10973: if ((ctxt->sax) && (ctxt->sax->endDocument != NULL))
! 10974: ctxt->sax->endDocument(ctxt->userData);
! 10975: goto done;
! 10976: }
! 10977: #ifdef LIBXML_VALID_ENABLED
! 10978: /*
! 10979: * [ VC: Root Element Type ]
! 10980: * The Name in the document type declaration must match
! 10981: * the element type of the root element.
! 10982: */
! 10983: if (ctxt->validate && ctxt->wellFormed && ctxt->myDoc &&
! 10984: ctxt->node && (ctxt->node == ctxt->myDoc->children))
! 10985: ctxt->valid &= xmlValidateRoot(&ctxt->vctxt, ctxt->myDoc);
! 10986: #endif /* LIBXML_VALID_ENABLED */
! 10987:
! 10988: /*
! 10989: * Check for an Empty Element.
! 10990: */
! 10991: if ((RAW == '/') && (NXT(1) == '>')) {
! 10992: SKIP(2);
! 10993:
! 10994: if (ctxt->sax2) {
! 10995: if ((ctxt->sax != NULL) &&
! 10996: (ctxt->sax->endElementNs != NULL) &&
! 10997: (!ctxt->disableSAX))
! 10998: ctxt->sax->endElementNs(ctxt->userData, name,
! 10999: prefix, URI);
! 11000: if (ctxt->nsNr - nsNr > 0)
! 11001: nsPop(ctxt, ctxt->nsNr - nsNr);
! 11002: #ifdef LIBXML_SAX1_ENABLED
! 11003: } else {
! 11004: if ((ctxt->sax != NULL) &&
! 11005: (ctxt->sax->endElement != NULL) &&
! 11006: (!ctxt->disableSAX))
! 11007: ctxt->sax->endElement(ctxt->userData, name);
! 11008: #endif /* LIBXML_SAX1_ENABLED */
! 11009: }
! 11010: spacePop(ctxt);
! 11011: if (ctxt->nameNr == 0) {
! 11012: ctxt->instate = XML_PARSER_EPILOG;
! 11013: } else {
! 11014: ctxt->instate = XML_PARSER_CONTENT;
! 11015: }
! 11016: break;
! 11017: }
! 11018: if (RAW == '>') {
! 11019: NEXT;
! 11020: } else {
! 11021: xmlFatalErrMsgStr(ctxt, XML_ERR_GT_REQUIRED,
! 11022: "Couldn't find end of Start Tag %s\n",
! 11023: name);
! 11024: nodePop(ctxt);
! 11025: spacePop(ctxt);
! 11026: }
! 11027: if (ctxt->sax2)
! 11028: nameNsPush(ctxt, name, prefix, URI, ctxt->nsNr - nsNr);
! 11029: #ifdef LIBXML_SAX1_ENABLED
! 11030: else
! 11031: namePush(ctxt, name);
! 11032: #endif /* LIBXML_SAX1_ENABLED */
! 11033:
! 11034: ctxt->instate = XML_PARSER_CONTENT;
! 11035: break;
! 11036: }
! 11037: case XML_PARSER_CONTENT: {
! 11038: const xmlChar *test;
! 11039: unsigned int cons;
! 11040: if ((avail < 2) && (ctxt->inputNr == 1))
! 11041: goto done;
! 11042: cur = ctxt->input->cur[0];
! 11043: next = ctxt->input->cur[1];
! 11044:
! 11045: test = CUR_PTR;
! 11046: cons = ctxt->input->consumed;
! 11047: if ((cur == '<') && (next == '/')) {
! 11048: ctxt->instate = XML_PARSER_END_TAG;
! 11049: break;
! 11050: } else if ((cur == '<') && (next == '?')) {
! 11051: if ((!terminate) &&
! 11052: (xmlParseLookupSequence(ctxt, '?', '>', 0) < 0))
! 11053: goto done;
! 11054: xmlParsePI(ctxt);
! 11055: } else if ((cur == '<') && (next != '!')) {
! 11056: ctxt->instate = XML_PARSER_START_TAG;
! 11057: break;
! 11058: } else if ((cur == '<') && (next == '!') &&
! 11059: (ctxt->input->cur[2] == '-') &&
! 11060: (ctxt->input->cur[3] == '-')) {
! 11061: int term;
! 11062:
! 11063: if (avail < 4)
! 11064: goto done;
! 11065: ctxt->input->cur += 4;
! 11066: term = xmlParseLookupSequence(ctxt, '-', '-', '>');
! 11067: ctxt->input->cur -= 4;
! 11068: if ((!terminate) && (term < 0))
! 11069: goto done;
! 11070: xmlParseComment(ctxt);
! 11071: ctxt->instate = XML_PARSER_CONTENT;
! 11072: } else if ((cur == '<') && (ctxt->input->cur[1] == '!') &&
! 11073: (ctxt->input->cur[2] == '[') &&
! 11074: (ctxt->input->cur[3] == 'C') &&
! 11075: (ctxt->input->cur[4] == 'D') &&
! 11076: (ctxt->input->cur[5] == 'A') &&
! 11077: (ctxt->input->cur[6] == 'T') &&
! 11078: (ctxt->input->cur[7] == 'A') &&
! 11079: (ctxt->input->cur[8] == '[')) {
! 11080: SKIP(9);
! 11081: ctxt->instate = XML_PARSER_CDATA_SECTION;
! 11082: break;
! 11083: } else if ((cur == '<') && (next == '!') &&
! 11084: (avail < 9)) {
! 11085: goto done;
! 11086: } else if (cur == '&') {
! 11087: if ((!terminate) &&
! 11088: (xmlParseLookupSequence(ctxt, ';', 0, 0) < 0))
! 11089: goto done;
! 11090: xmlParseReference(ctxt);
! 11091: } else {
! 11092: /* TODO Avoid the extra copy, handle directly !!! */
! 11093: /*
! 11094: * Goal of the following test is:
! 11095: * - minimize calls to the SAX 'character' callback
! 11096: * when they are mergeable
! 11097: * - handle an problem for isBlank when we only parse
! 11098: * a sequence of blank chars and the next one is
! 11099: * not available to check against '<' presence.
! 11100: * - tries to homogenize the differences in SAX
! 11101: * callbacks between the push and pull versions
! 11102: * of the parser.
! 11103: */
! 11104: if ((ctxt->inputNr == 1) &&
! 11105: (avail < XML_PARSER_BIG_BUFFER_SIZE)) {
! 11106: if (!terminate) {
! 11107: if (ctxt->progressive) {
! 11108: if ((lastlt == NULL) ||
! 11109: (ctxt->input->cur > lastlt))
! 11110: goto done;
! 11111: } else if (xmlParseLookupSequence(ctxt,
! 11112: '<', 0, 0) < 0) {
! 11113: goto done;
! 11114: }
! 11115: }
! 11116: }
! 11117: ctxt->checkIndex = 0;
! 11118: xmlParseCharData(ctxt, 0);
! 11119: }
! 11120: /*
! 11121: * Pop-up of finished entities.
! 11122: */
! 11123: while ((RAW == 0) && (ctxt->inputNr > 1))
! 11124: xmlPopInput(ctxt);
! 11125: if ((cons == ctxt->input->consumed) && (test == CUR_PTR)) {
! 11126: xmlFatalErr(ctxt, XML_ERR_INTERNAL_ERROR,
! 11127: "detected an error in element content\n");
! 11128: ctxt->instate = XML_PARSER_EOF;
! 11129: break;
! 11130: }
! 11131: break;
! 11132: }
! 11133: case XML_PARSER_END_TAG:
! 11134: if (avail < 2)
! 11135: goto done;
! 11136: if (!terminate) {
! 11137: if (ctxt->progressive) {
! 11138: /* > can be found unescaped in attribute values */
! 11139: if ((lastgt == NULL) || (ctxt->input->cur >= lastgt))
! 11140: goto done;
! 11141: } else if (xmlParseLookupSequence(ctxt, '>', 0, 0) < 0) {
! 11142: goto done;
! 11143: }
! 11144: }
! 11145: if (ctxt->sax2) {
! 11146: xmlParseEndTag2(ctxt,
! 11147: (void *) ctxt->pushTab[ctxt->nameNr * 3 - 3],
! 11148: (void *) ctxt->pushTab[ctxt->nameNr * 3 - 2], 0,
! 11149: (int) (long) ctxt->pushTab[ctxt->nameNr * 3 - 1], 0);
! 11150: nameNsPop(ctxt);
! 11151: }
! 11152: #ifdef LIBXML_SAX1_ENABLED
! 11153: else
! 11154: xmlParseEndTag1(ctxt, 0);
! 11155: #endif /* LIBXML_SAX1_ENABLED */
! 11156: if (ctxt->nameNr == 0) {
! 11157: ctxt->instate = XML_PARSER_EPILOG;
! 11158: } else {
! 11159: ctxt->instate = XML_PARSER_CONTENT;
! 11160: }
! 11161: break;
! 11162: case XML_PARSER_CDATA_SECTION: {
! 11163: /*
! 11164: * The Push mode need to have the SAX callback for
! 11165: * cdataBlock merge back contiguous callbacks.
! 11166: */
! 11167: int base;
! 11168:
! 11169: base = xmlParseLookupSequence(ctxt, ']', ']', '>');
! 11170: if (base < 0) {
! 11171: if (avail >= XML_PARSER_BIG_BUFFER_SIZE + 2) {
! 11172: int tmp;
! 11173:
! 11174: tmp = xmlCheckCdataPush(ctxt->input->cur,
! 11175: XML_PARSER_BIG_BUFFER_SIZE);
! 11176: if (tmp < 0) {
! 11177: tmp = -tmp;
! 11178: ctxt->input->cur += tmp;
! 11179: goto encoding_error;
! 11180: }
! 11181: if ((ctxt->sax != NULL) && (!ctxt->disableSAX)) {
! 11182: if (ctxt->sax->cdataBlock != NULL)
! 11183: ctxt->sax->cdataBlock(ctxt->userData,
! 11184: ctxt->input->cur, tmp);
! 11185: else if (ctxt->sax->characters != NULL)
! 11186: ctxt->sax->characters(ctxt->userData,
! 11187: ctxt->input->cur, tmp);
! 11188: }
! 11189: SKIPL(tmp);
! 11190: ctxt->checkIndex = 0;
! 11191: }
! 11192: goto done;
! 11193: } else {
! 11194: int tmp;
! 11195:
! 11196: tmp = xmlCheckCdataPush(ctxt->input->cur, base);
! 11197: if ((tmp < 0) || (tmp != base)) {
! 11198: tmp = -tmp;
! 11199: ctxt->input->cur += tmp;
! 11200: goto encoding_error;
! 11201: }
! 11202: if ((ctxt->sax != NULL) && (base == 0) &&
! 11203: (ctxt->sax->cdataBlock != NULL) &&
! 11204: (!ctxt->disableSAX)) {
! 11205: /*
! 11206: * Special case to provide identical behaviour
! 11207: * between pull and push parsers on enpty CDATA
! 11208: * sections
! 11209: */
! 11210: if ((ctxt->input->cur - ctxt->input->base >= 9) &&
! 11211: (!strncmp((const char *)&ctxt->input->cur[-9],
! 11212: "<![CDATA[", 9)))
! 11213: ctxt->sax->cdataBlock(ctxt->userData,
! 11214: BAD_CAST "", 0);
! 11215: } else if ((ctxt->sax != NULL) && (base > 0) &&
! 11216: (!ctxt->disableSAX)) {
! 11217: if (ctxt->sax->cdataBlock != NULL)
! 11218: ctxt->sax->cdataBlock(ctxt->userData,
! 11219: ctxt->input->cur, base);
! 11220: else if (ctxt->sax->characters != NULL)
! 11221: ctxt->sax->characters(ctxt->userData,
! 11222: ctxt->input->cur, base);
! 11223: }
! 11224: SKIPL(base + 3);
! 11225: ctxt->checkIndex = 0;
! 11226: ctxt->instate = XML_PARSER_CONTENT;
! 11227: #ifdef DEBUG_PUSH
! 11228: xmlGenericError(xmlGenericErrorContext,
! 11229: "PP: entering CONTENT\n");
! 11230: #endif
! 11231: }
! 11232: break;
! 11233: }
! 11234: case XML_PARSER_MISC:
! 11235: SKIP_BLANKS;
! 11236: if (ctxt->input->buf == NULL)
! 11237: avail = ctxt->input->length -
! 11238: (ctxt->input->cur - ctxt->input->base);
! 11239: else
! 11240: avail = ctxt->input->buf->buffer->use -
! 11241: (ctxt->input->cur - ctxt->input->base);
! 11242: if (avail < 2)
! 11243: goto done;
! 11244: cur = ctxt->input->cur[0];
! 11245: next = ctxt->input->cur[1];
! 11246: if ((cur == '<') && (next == '?')) {
! 11247: if ((!terminate) &&
! 11248: (xmlParseLookupSequence(ctxt, '?', '>', 0) < 0))
! 11249: goto done;
! 11250: #ifdef DEBUG_PUSH
! 11251: xmlGenericError(xmlGenericErrorContext,
! 11252: "PP: Parsing PI\n");
! 11253: #endif
! 11254: xmlParsePI(ctxt);
! 11255: ctxt->checkIndex = 0;
! 11256: } else if ((cur == '<') && (next == '!') &&
! 11257: (ctxt->input->cur[2] == '-') &&
! 11258: (ctxt->input->cur[3] == '-')) {
! 11259: if ((!terminate) &&
! 11260: (xmlParseLookupSequence(ctxt, '-', '-', '>') < 0))
! 11261: goto done;
! 11262: #ifdef DEBUG_PUSH
! 11263: xmlGenericError(xmlGenericErrorContext,
! 11264: "PP: Parsing Comment\n");
! 11265: #endif
! 11266: xmlParseComment(ctxt);
! 11267: ctxt->instate = XML_PARSER_MISC;
! 11268: ctxt->checkIndex = 0;
! 11269: } else if ((cur == '<') && (next == '!') &&
! 11270: (ctxt->input->cur[2] == 'D') &&
! 11271: (ctxt->input->cur[3] == 'O') &&
! 11272: (ctxt->input->cur[4] == 'C') &&
! 11273: (ctxt->input->cur[5] == 'T') &&
! 11274: (ctxt->input->cur[6] == 'Y') &&
! 11275: (ctxt->input->cur[7] == 'P') &&
! 11276: (ctxt->input->cur[8] == 'E')) {
! 11277: if ((!terminate) &&
! 11278: (xmlParseLookupSequence(ctxt, '>', 0, 0) < 0))
! 11279: goto done;
! 11280: #ifdef DEBUG_PUSH
! 11281: xmlGenericError(xmlGenericErrorContext,
! 11282: "PP: Parsing internal subset\n");
! 11283: #endif
! 11284: ctxt->inSubset = 1;
! 11285: xmlParseDocTypeDecl(ctxt);
! 11286: if (RAW == '[') {
! 11287: ctxt->instate = XML_PARSER_DTD;
! 11288: #ifdef DEBUG_PUSH
! 11289: xmlGenericError(xmlGenericErrorContext,
! 11290: "PP: entering DTD\n");
! 11291: #endif
! 11292: } else {
! 11293: /*
! 11294: * Create and update the external subset.
! 11295: */
! 11296: ctxt->inSubset = 2;
! 11297: if ((ctxt->sax != NULL) && (!ctxt->disableSAX) &&
! 11298: (ctxt->sax->externalSubset != NULL))
! 11299: ctxt->sax->externalSubset(ctxt->userData,
! 11300: ctxt->intSubName, ctxt->extSubSystem,
! 11301: ctxt->extSubURI);
! 11302: ctxt->inSubset = 0;
! 11303: xmlCleanSpecialAttr(ctxt);
! 11304: ctxt->instate = XML_PARSER_PROLOG;
! 11305: #ifdef DEBUG_PUSH
! 11306: xmlGenericError(xmlGenericErrorContext,
! 11307: "PP: entering PROLOG\n");
! 11308: #endif
! 11309: }
! 11310: } else if ((cur == '<') && (next == '!') &&
! 11311: (avail < 9)) {
! 11312: goto done;
! 11313: } else {
! 11314: ctxt->instate = XML_PARSER_START_TAG;
! 11315: ctxt->progressive = 1;
! 11316: xmlParseGetLasts(ctxt, &lastlt, &lastgt);
! 11317: #ifdef DEBUG_PUSH
! 11318: xmlGenericError(xmlGenericErrorContext,
! 11319: "PP: entering START_TAG\n");
! 11320: #endif
! 11321: }
! 11322: break;
! 11323: case XML_PARSER_PROLOG:
! 11324: SKIP_BLANKS;
! 11325: if (ctxt->input->buf == NULL)
! 11326: avail = ctxt->input->length - (ctxt->input->cur - ctxt->input->base);
! 11327: else
! 11328: avail = ctxt->input->buf->buffer->use - (ctxt->input->cur - ctxt->input->base);
! 11329: if (avail < 2)
! 11330: goto done;
! 11331: cur = ctxt->input->cur[0];
! 11332: next = ctxt->input->cur[1];
! 11333: if ((cur == '<') && (next == '?')) {
! 11334: if ((!terminate) &&
! 11335: (xmlParseLookupSequence(ctxt, '?', '>', 0) < 0))
! 11336: goto done;
! 11337: #ifdef DEBUG_PUSH
! 11338: xmlGenericError(xmlGenericErrorContext,
! 11339: "PP: Parsing PI\n");
! 11340: #endif
! 11341: xmlParsePI(ctxt);
! 11342: } else if ((cur == '<') && (next == '!') &&
! 11343: (ctxt->input->cur[2] == '-') && (ctxt->input->cur[3] == '-')) {
! 11344: if ((!terminate) &&
! 11345: (xmlParseLookupSequence(ctxt, '-', '-', '>') < 0))
! 11346: goto done;
! 11347: #ifdef DEBUG_PUSH
! 11348: xmlGenericError(xmlGenericErrorContext,
! 11349: "PP: Parsing Comment\n");
! 11350: #endif
! 11351: xmlParseComment(ctxt);
! 11352: ctxt->instate = XML_PARSER_PROLOG;
! 11353: } else if ((cur == '<') && (next == '!') &&
! 11354: (avail < 4)) {
! 11355: goto done;
! 11356: } else {
! 11357: ctxt->instate = XML_PARSER_START_TAG;
! 11358: if (ctxt->progressive == 0)
! 11359: ctxt->progressive = 1;
! 11360: xmlParseGetLasts(ctxt, &lastlt, &lastgt);
! 11361: #ifdef DEBUG_PUSH
! 11362: xmlGenericError(xmlGenericErrorContext,
! 11363: "PP: entering START_TAG\n");
! 11364: #endif
! 11365: }
! 11366: break;
! 11367: case XML_PARSER_EPILOG:
! 11368: SKIP_BLANKS;
! 11369: if (ctxt->input->buf == NULL)
! 11370: avail = ctxt->input->length - (ctxt->input->cur - ctxt->input->base);
! 11371: else
! 11372: avail = ctxt->input->buf->buffer->use - (ctxt->input->cur - ctxt->input->base);
! 11373: if (avail < 2)
! 11374: goto done;
! 11375: cur = ctxt->input->cur[0];
! 11376: next = ctxt->input->cur[1];
! 11377: if ((cur == '<') && (next == '?')) {
! 11378: if ((!terminate) &&
! 11379: (xmlParseLookupSequence(ctxt, '?', '>', 0) < 0))
! 11380: goto done;
! 11381: #ifdef DEBUG_PUSH
! 11382: xmlGenericError(xmlGenericErrorContext,
! 11383: "PP: Parsing PI\n");
! 11384: #endif
! 11385: xmlParsePI(ctxt);
! 11386: ctxt->instate = XML_PARSER_EPILOG;
! 11387: } else if ((cur == '<') && (next == '!') &&
! 11388: (ctxt->input->cur[2] == '-') && (ctxt->input->cur[3] == '-')) {
! 11389: if ((!terminate) &&
! 11390: (xmlParseLookupSequence(ctxt, '-', '-', '>') < 0))
! 11391: goto done;
! 11392: #ifdef DEBUG_PUSH
! 11393: xmlGenericError(xmlGenericErrorContext,
! 11394: "PP: Parsing Comment\n");
! 11395: #endif
! 11396: xmlParseComment(ctxt);
! 11397: ctxt->instate = XML_PARSER_EPILOG;
! 11398: } else if ((cur == '<') && (next == '!') &&
! 11399: (avail < 4)) {
! 11400: goto done;
! 11401: } else {
! 11402: xmlFatalErr(ctxt, XML_ERR_DOCUMENT_END, NULL);
! 11403: ctxt->instate = XML_PARSER_EOF;
! 11404: #ifdef DEBUG_PUSH
! 11405: xmlGenericError(xmlGenericErrorContext,
! 11406: "PP: entering EOF\n");
! 11407: #endif
! 11408: if ((ctxt->sax) && (ctxt->sax->endDocument != NULL))
! 11409: ctxt->sax->endDocument(ctxt->userData);
! 11410: goto done;
! 11411: }
! 11412: break;
! 11413: case XML_PARSER_DTD: {
! 11414: /*
! 11415: * Sorry but progressive parsing of the internal subset
! 11416: * is not expected to be supported. We first check that
! 11417: * the full content of the internal subset is available and
! 11418: * the parsing is launched only at that point.
! 11419: * Internal subset ends up with "']' S? '>'" in an unescaped
! 11420: * section and not in a ']]>' sequence which are conditional
! 11421: * sections (whoever argued to keep that crap in XML deserve
! 11422: * a place in hell !).
! 11423: */
! 11424: int base, i;
! 11425: xmlChar *buf;
! 11426: xmlChar quote = 0;
! 11427:
! 11428: base = ctxt->input->cur - ctxt->input->base;
! 11429: if (base < 0) return(0);
! 11430: if (ctxt->checkIndex > base)
! 11431: base = ctxt->checkIndex;
! 11432: buf = ctxt->input->buf->buffer->content;
! 11433: for (;(unsigned int) base < ctxt->input->buf->buffer->use;
! 11434: base++) {
! 11435: if (quote != 0) {
! 11436: if (buf[base] == quote)
! 11437: quote = 0;
! 11438: continue;
! 11439: }
! 11440: if ((quote == 0) && (buf[base] == '<')) {
! 11441: int found = 0;
! 11442: /* special handling of comments */
! 11443: if (((unsigned int) base + 4 <
! 11444: ctxt->input->buf->buffer->use) &&
! 11445: (buf[base + 1] == '!') &&
! 11446: (buf[base + 2] == '-') &&
! 11447: (buf[base + 3] == '-')) {
! 11448: for (;(unsigned int) base + 3 <
! 11449: ctxt->input->buf->buffer->use; base++) {
! 11450: if ((buf[base] == '-') &&
! 11451: (buf[base + 1] == '-') &&
! 11452: (buf[base + 2] == '>')) {
! 11453: found = 1;
! 11454: base += 2;
! 11455: break;
! 11456: }
! 11457: }
! 11458: if (!found) {
! 11459: #if 0
! 11460: fprintf(stderr, "unfinished comment\n");
! 11461: #endif
! 11462: break; /* for */
! 11463: }
! 11464: continue;
! 11465: }
! 11466: }
! 11467: if (buf[base] == '"') {
! 11468: quote = '"';
! 11469: continue;
! 11470: }
! 11471: if (buf[base] == '\'') {
! 11472: quote = '\'';
! 11473: continue;
! 11474: }
! 11475: if (buf[base] == ']') {
! 11476: #if 0
! 11477: fprintf(stderr, "%c%c%c%c: ", buf[base],
! 11478: buf[base + 1], buf[base + 2], buf[base + 3]);
! 11479: #endif
! 11480: if ((unsigned int) base +1 >=
! 11481: ctxt->input->buf->buffer->use)
! 11482: break;
! 11483: if (buf[base + 1] == ']') {
! 11484: /* conditional crap, skip both ']' ! */
! 11485: base++;
! 11486: continue;
! 11487: }
! 11488: for (i = 1;
! 11489: (unsigned int) base + i < ctxt->input->buf->buffer->use;
! 11490: i++) {
! 11491: if (buf[base + i] == '>') {
! 11492: #if 0
! 11493: fprintf(stderr, "found\n");
! 11494: #endif
! 11495: goto found_end_int_subset;
! 11496: }
! 11497: if (!IS_BLANK_CH(buf[base + i])) {
! 11498: #if 0
! 11499: fprintf(stderr, "not found\n");
! 11500: #endif
! 11501: goto not_end_of_int_subset;
! 11502: }
! 11503: }
! 11504: #if 0
! 11505: fprintf(stderr, "end of stream\n");
! 11506: #endif
! 11507: break;
! 11508:
! 11509: }
! 11510: not_end_of_int_subset:
! 11511: continue; /* for */
! 11512: }
! 11513: /*
! 11514: * We didn't found the end of the Internal subset
! 11515: */
! 11516: #ifdef DEBUG_PUSH
! 11517: if (next == 0)
! 11518: xmlGenericError(xmlGenericErrorContext,
! 11519: "PP: lookup of int subset end filed\n");
! 11520: #endif
! 11521: goto done;
! 11522:
! 11523: found_end_int_subset:
! 11524: xmlParseInternalSubset(ctxt);
! 11525: ctxt->inSubset = 2;
! 11526: if ((ctxt->sax != NULL) && (!ctxt->disableSAX) &&
! 11527: (ctxt->sax->externalSubset != NULL))
! 11528: ctxt->sax->externalSubset(ctxt->userData, ctxt->intSubName,
! 11529: ctxt->extSubSystem, ctxt->extSubURI);
! 11530: ctxt->inSubset = 0;
! 11531: xmlCleanSpecialAttr(ctxt);
! 11532: ctxt->instate = XML_PARSER_PROLOG;
! 11533: ctxt->checkIndex = 0;
! 11534: #ifdef DEBUG_PUSH
! 11535: xmlGenericError(xmlGenericErrorContext,
! 11536: "PP: entering PROLOG\n");
! 11537: #endif
! 11538: break;
! 11539: }
! 11540: case XML_PARSER_COMMENT:
! 11541: xmlGenericError(xmlGenericErrorContext,
! 11542: "PP: internal error, state == COMMENT\n");
! 11543: ctxt->instate = XML_PARSER_CONTENT;
! 11544: #ifdef DEBUG_PUSH
! 11545: xmlGenericError(xmlGenericErrorContext,
! 11546: "PP: entering CONTENT\n");
! 11547: #endif
! 11548: break;
! 11549: case XML_PARSER_IGNORE:
! 11550: xmlGenericError(xmlGenericErrorContext,
! 11551: "PP: internal error, state == IGNORE");
! 11552: ctxt->instate = XML_PARSER_DTD;
! 11553: #ifdef DEBUG_PUSH
! 11554: xmlGenericError(xmlGenericErrorContext,
! 11555: "PP: entering DTD\n");
! 11556: #endif
! 11557: break;
! 11558: case XML_PARSER_PI:
! 11559: xmlGenericError(xmlGenericErrorContext,
! 11560: "PP: internal error, state == PI\n");
! 11561: ctxt->instate = XML_PARSER_CONTENT;
! 11562: #ifdef DEBUG_PUSH
! 11563: xmlGenericError(xmlGenericErrorContext,
! 11564: "PP: entering CONTENT\n");
! 11565: #endif
! 11566: break;
! 11567: case XML_PARSER_ENTITY_DECL:
! 11568: xmlGenericError(xmlGenericErrorContext,
! 11569: "PP: internal error, state == ENTITY_DECL\n");
! 11570: ctxt->instate = XML_PARSER_DTD;
! 11571: #ifdef DEBUG_PUSH
! 11572: xmlGenericError(xmlGenericErrorContext,
! 11573: "PP: entering DTD\n");
! 11574: #endif
! 11575: break;
! 11576: case XML_PARSER_ENTITY_VALUE:
! 11577: xmlGenericError(xmlGenericErrorContext,
! 11578: "PP: internal error, state == ENTITY_VALUE\n");
! 11579: ctxt->instate = XML_PARSER_CONTENT;
! 11580: #ifdef DEBUG_PUSH
! 11581: xmlGenericError(xmlGenericErrorContext,
! 11582: "PP: entering DTD\n");
! 11583: #endif
! 11584: break;
! 11585: case XML_PARSER_ATTRIBUTE_VALUE:
! 11586: xmlGenericError(xmlGenericErrorContext,
! 11587: "PP: internal error, state == ATTRIBUTE_VALUE\n");
! 11588: ctxt->instate = XML_PARSER_START_TAG;
! 11589: #ifdef DEBUG_PUSH
! 11590: xmlGenericError(xmlGenericErrorContext,
! 11591: "PP: entering START_TAG\n");
! 11592: #endif
! 11593: break;
! 11594: case XML_PARSER_SYSTEM_LITERAL:
! 11595: xmlGenericError(xmlGenericErrorContext,
! 11596: "PP: internal error, state == SYSTEM_LITERAL\n");
! 11597: ctxt->instate = XML_PARSER_START_TAG;
! 11598: #ifdef DEBUG_PUSH
! 11599: xmlGenericError(xmlGenericErrorContext,
! 11600: "PP: entering START_TAG\n");
! 11601: #endif
! 11602: break;
! 11603: case XML_PARSER_PUBLIC_LITERAL:
! 11604: xmlGenericError(xmlGenericErrorContext,
! 11605: "PP: internal error, state == PUBLIC_LITERAL\n");
! 11606: ctxt->instate = XML_PARSER_START_TAG;
! 11607: #ifdef DEBUG_PUSH
! 11608: xmlGenericError(xmlGenericErrorContext,
! 11609: "PP: entering START_TAG\n");
! 11610: #endif
! 11611: break;
! 11612: }
! 11613: }
! 11614: done:
! 11615: #ifdef DEBUG_PUSH
! 11616: xmlGenericError(xmlGenericErrorContext, "PP: done %d\n", ret);
! 11617: #endif
! 11618: return(ret);
! 11619: encoding_error:
! 11620: {
! 11621: char buffer[150];
! 11622:
! 11623: snprintf(buffer, 149, "Bytes: 0x%02X 0x%02X 0x%02X 0x%02X\n",
! 11624: ctxt->input->cur[0], ctxt->input->cur[1],
! 11625: ctxt->input->cur[2], ctxt->input->cur[3]);
! 11626: __xmlErrEncoding(ctxt, XML_ERR_INVALID_CHAR,
! 11627: "Input is not proper UTF-8, indicate encoding !\n%s",
! 11628: BAD_CAST buffer, NULL);
! 11629: }
! 11630: return(0);
! 11631: }
! 11632:
! 11633: /**
! 11634: * xmlParseChunk:
! 11635: * @ctxt: an XML parser context
! 11636: * @chunk: an char array
! 11637: * @size: the size in byte of the chunk
! 11638: * @terminate: last chunk indicator
! 11639: *
! 11640: * Parse a Chunk of memory
! 11641: *
! 11642: * Returns zero if no error, the xmlParserErrors otherwise.
! 11643: */
! 11644: int
! 11645: xmlParseChunk(xmlParserCtxtPtr ctxt, const char *chunk, int size,
! 11646: int terminate) {
! 11647: int end_in_lf = 0;
! 11648: int remain = 0;
! 11649:
! 11650: if (ctxt == NULL)
! 11651: return(XML_ERR_INTERNAL_ERROR);
! 11652: if ((ctxt->errNo != XML_ERR_OK) && (ctxt->disableSAX == 1))
! 11653: return(ctxt->errNo);
! 11654: if (ctxt->instate == XML_PARSER_START)
! 11655: xmlDetectSAX2(ctxt);
! 11656: if ((size > 0) && (chunk != NULL) && (!terminate) &&
! 11657: (chunk[size - 1] == '\r')) {
! 11658: end_in_lf = 1;
! 11659: size--;
! 11660: }
! 11661:
! 11662: xmldecl_done:
! 11663:
! 11664: if ((size > 0) && (chunk != NULL) && (ctxt->input != NULL) &&
! 11665: (ctxt->input->buf != NULL) && (ctxt->instate != XML_PARSER_EOF)) {
! 11666: int base = ctxt->input->base - ctxt->input->buf->buffer->content;
! 11667: int cur = ctxt->input->cur - ctxt->input->base;
! 11668: int res;
! 11669:
! 11670: /*
! 11671: * Specific handling if we autodetected an encoding, we should not
! 11672: * push more than the first line ... which depend on the encoding
! 11673: * And only push the rest once the final encoding was detected
! 11674: */
! 11675: if ((ctxt->instate == XML_PARSER_START) && (ctxt->input != NULL) &&
! 11676: (ctxt->input->buf != NULL) && (ctxt->input->buf->encoder != NULL)) {
! 11677: unsigned int len = 45;
! 11678:
! 11679: if ((xmlStrcasestr(BAD_CAST ctxt->input->buf->encoder->name,
! 11680: BAD_CAST "UTF-16")) ||
! 11681: (xmlStrcasestr(BAD_CAST ctxt->input->buf->encoder->name,
! 11682: BAD_CAST "UTF16")))
! 11683: len = 90;
! 11684: else if ((xmlStrcasestr(BAD_CAST ctxt->input->buf->encoder->name,
! 11685: BAD_CAST "UCS-4")) ||
! 11686: (xmlStrcasestr(BAD_CAST ctxt->input->buf->encoder->name,
! 11687: BAD_CAST "UCS4")))
! 11688: len = 180;
! 11689:
! 11690: if (ctxt->input->buf->rawconsumed < len)
! 11691: len -= ctxt->input->buf->rawconsumed;
! 11692:
! 11693: /*
! 11694: * Change size for reading the initial declaration only
! 11695: * if size is greater than len. Otherwise, memmove in xmlBufferAdd
! 11696: * will blindly copy extra bytes from memory.
! 11697: */
! 11698: if ((unsigned int) size > len) {
! 11699: remain = size - len;
! 11700: size = len;
! 11701: } else {
! 11702: remain = 0;
! 11703: }
! 11704: }
! 11705: res =xmlParserInputBufferPush(ctxt->input->buf, size, chunk);
! 11706: if (res < 0) {
! 11707: ctxt->errNo = XML_PARSER_EOF;
! 11708: ctxt->disableSAX = 1;
! 11709: return (XML_PARSER_EOF);
! 11710: }
! 11711: ctxt->input->base = ctxt->input->buf->buffer->content + base;
! 11712: ctxt->input->cur = ctxt->input->base + cur;
! 11713: ctxt->input->end =
! 11714: &ctxt->input->buf->buffer->content[ctxt->input->buf->buffer->use];
! 11715: #ifdef DEBUG_PUSH
! 11716: xmlGenericError(xmlGenericErrorContext, "PP: pushed %d\n", size);
! 11717: #endif
! 11718:
! 11719: } else if (ctxt->instate != XML_PARSER_EOF) {
! 11720: if ((ctxt->input != NULL) && ctxt->input->buf != NULL) {
! 11721: xmlParserInputBufferPtr in = ctxt->input->buf;
! 11722: if ((in->encoder != NULL) && (in->buffer != NULL) &&
! 11723: (in->raw != NULL)) {
! 11724: int nbchars;
! 11725:
! 11726: nbchars = xmlCharEncInFunc(in->encoder, in->buffer, in->raw);
! 11727: if (nbchars < 0) {
! 11728: /* TODO 2.6.0 */
! 11729: xmlGenericError(xmlGenericErrorContext,
! 11730: "xmlParseChunk: encoder error\n");
! 11731: return(XML_ERR_INVALID_ENCODING);
! 11732: }
! 11733: }
! 11734: }
! 11735: }
! 11736: if (remain != 0)
! 11737: xmlParseTryOrFinish(ctxt, 0);
! 11738: else
! 11739: xmlParseTryOrFinish(ctxt, terminate);
! 11740: if ((ctxt->errNo != XML_ERR_OK) && (ctxt->disableSAX == 1))
! 11741: return(ctxt->errNo);
! 11742:
! 11743: if (remain != 0) {
! 11744: chunk += size;
! 11745: size = remain;
! 11746: remain = 0;
! 11747: goto xmldecl_done;
! 11748: }
! 11749: if ((end_in_lf == 1) && (ctxt->input != NULL) &&
! 11750: (ctxt->input->buf != NULL)) {
! 11751: xmlParserInputBufferPush(ctxt->input->buf, 1, "\r");
! 11752: }
! 11753: if (terminate) {
! 11754: /*
! 11755: * Check for termination
! 11756: */
! 11757: int avail = 0;
! 11758:
! 11759: if (ctxt->input != NULL) {
! 11760: if (ctxt->input->buf == NULL)
! 11761: avail = ctxt->input->length -
! 11762: (ctxt->input->cur - ctxt->input->base);
! 11763: else
! 11764: avail = ctxt->input->buf->buffer->use -
! 11765: (ctxt->input->cur - ctxt->input->base);
! 11766: }
! 11767:
! 11768: if ((ctxt->instate != XML_PARSER_EOF) &&
! 11769: (ctxt->instate != XML_PARSER_EPILOG)) {
! 11770: xmlFatalErr(ctxt, XML_ERR_DOCUMENT_END, NULL);
! 11771: }
! 11772: if ((ctxt->instate == XML_PARSER_EPILOG) && (avail > 0)) {
! 11773: xmlFatalErr(ctxt, XML_ERR_DOCUMENT_END, NULL);
! 11774: }
! 11775: if (ctxt->instate != XML_PARSER_EOF) {
! 11776: if ((ctxt->sax) && (ctxt->sax->endDocument != NULL))
! 11777: ctxt->sax->endDocument(ctxt->userData);
! 11778: }
! 11779: ctxt->instate = XML_PARSER_EOF;
! 11780: }
! 11781: return((xmlParserErrors) ctxt->errNo);
! 11782: }
! 11783:
! 11784: /************************************************************************
! 11785: * *
! 11786: * I/O front end functions to the parser *
! 11787: * *
! 11788: ************************************************************************/
! 11789:
! 11790: /**
! 11791: * xmlCreatePushParserCtxt:
! 11792: * @sax: a SAX handler
! 11793: * @user_data: The user data returned on SAX callbacks
! 11794: * @chunk: a pointer to an array of chars
! 11795: * @size: number of chars in the array
! 11796: * @filename: an optional file name or URI
! 11797: *
! 11798: * Create a parser context for using the XML parser in push mode.
! 11799: * If @buffer and @size are non-NULL, the data is used to detect
! 11800: * the encoding. The remaining characters will be parsed so they
! 11801: * don't need to be fed in again through xmlParseChunk.
! 11802: * To allow content encoding detection, @size should be >= 4
! 11803: * The value of @filename is used for fetching external entities
! 11804: * and error/warning reports.
! 11805: *
! 11806: * Returns the new parser context or NULL
! 11807: */
! 11808:
! 11809: xmlParserCtxtPtr
! 11810: xmlCreatePushParserCtxt(xmlSAXHandlerPtr sax, void *user_data,
! 11811: const char *chunk, int size, const char *filename) {
! 11812: xmlParserCtxtPtr ctxt;
! 11813: xmlParserInputPtr inputStream;
! 11814: xmlParserInputBufferPtr buf;
! 11815: xmlCharEncoding enc = XML_CHAR_ENCODING_NONE;
! 11816:
! 11817: /*
! 11818: * plug some encoding conversion routines
! 11819: */
! 11820: if ((chunk != NULL) && (size >= 4))
! 11821: enc = xmlDetectCharEncoding((const xmlChar *) chunk, size);
! 11822:
! 11823: buf = xmlAllocParserInputBuffer(enc);
! 11824: if (buf == NULL) return(NULL);
! 11825:
! 11826: ctxt = xmlNewParserCtxt();
! 11827: if (ctxt == NULL) {
! 11828: xmlErrMemory(NULL, "creating parser: out of memory\n");
! 11829: xmlFreeParserInputBuffer(buf);
! 11830: return(NULL);
! 11831: }
! 11832: ctxt->dictNames = 1;
! 11833: ctxt->pushTab = (void **) xmlMalloc(ctxt->nameMax * 3 * sizeof(xmlChar *));
! 11834: if (ctxt->pushTab == NULL) {
! 11835: xmlErrMemory(ctxt, NULL);
! 11836: xmlFreeParserInputBuffer(buf);
! 11837: xmlFreeParserCtxt(ctxt);
! 11838: return(NULL);
! 11839: }
! 11840: if (sax != NULL) {
! 11841: #ifdef LIBXML_SAX1_ENABLED
! 11842: if (ctxt->sax != (xmlSAXHandlerPtr) &xmlDefaultSAXHandler)
! 11843: #endif /* LIBXML_SAX1_ENABLED */
! 11844: xmlFree(ctxt->sax);
! 11845: ctxt->sax = (xmlSAXHandlerPtr) xmlMalloc(sizeof(xmlSAXHandler));
! 11846: if (ctxt->sax == NULL) {
! 11847: xmlErrMemory(ctxt, NULL);
! 11848: xmlFreeParserInputBuffer(buf);
! 11849: xmlFreeParserCtxt(ctxt);
! 11850: return(NULL);
! 11851: }
! 11852: memset(ctxt->sax, 0, sizeof(xmlSAXHandler));
! 11853: if (sax->initialized == XML_SAX2_MAGIC)
! 11854: memcpy(ctxt->sax, sax, sizeof(xmlSAXHandler));
! 11855: else
! 11856: memcpy(ctxt->sax, sax, sizeof(xmlSAXHandlerV1));
! 11857: if (user_data != NULL)
! 11858: ctxt->userData = user_data;
! 11859: }
! 11860: if (filename == NULL) {
! 11861: ctxt->directory = NULL;
! 11862: } else {
! 11863: ctxt->directory = xmlParserGetDirectory(filename);
! 11864: }
! 11865:
! 11866: inputStream = xmlNewInputStream(ctxt);
! 11867: if (inputStream == NULL) {
! 11868: xmlFreeParserCtxt(ctxt);
! 11869: xmlFreeParserInputBuffer(buf);
! 11870: return(NULL);
! 11871: }
! 11872:
! 11873: if (filename == NULL)
! 11874: inputStream->filename = NULL;
! 11875: else {
! 11876: inputStream->filename = (char *)
! 11877: xmlCanonicPath((const xmlChar *) filename);
! 11878: if (inputStream->filename == NULL) {
! 11879: xmlFreeParserCtxt(ctxt);
! 11880: xmlFreeParserInputBuffer(buf);
! 11881: return(NULL);
! 11882: }
! 11883: }
! 11884: inputStream->buf = buf;
! 11885: inputStream->base = inputStream->buf->buffer->content;
! 11886: inputStream->cur = inputStream->buf->buffer->content;
! 11887: inputStream->end =
! 11888: &inputStream->buf->buffer->content[inputStream->buf->buffer->use];
! 11889:
! 11890: inputPush(ctxt, inputStream);
! 11891:
! 11892: /*
! 11893: * If the caller didn't provide an initial 'chunk' for determining
! 11894: * the encoding, we set the context to XML_CHAR_ENCODING_NONE so
! 11895: * that it can be automatically determined later
! 11896: */
! 11897: if ((size == 0) || (chunk == NULL)) {
! 11898: ctxt->charset = XML_CHAR_ENCODING_NONE;
! 11899: } else if ((ctxt->input != NULL) && (ctxt->input->buf != NULL)) {
! 11900: int base = ctxt->input->base - ctxt->input->buf->buffer->content;
! 11901: int cur = ctxt->input->cur - ctxt->input->base;
! 11902:
! 11903: xmlParserInputBufferPush(ctxt->input->buf, size, chunk);
! 11904:
! 11905: ctxt->input->base = ctxt->input->buf->buffer->content + base;
! 11906: ctxt->input->cur = ctxt->input->base + cur;
! 11907: ctxt->input->end =
! 11908: &ctxt->input->buf->buffer->content[ctxt->input->buf->buffer->use];
! 11909: #ifdef DEBUG_PUSH
! 11910: xmlGenericError(xmlGenericErrorContext, "PP: pushed %d\n", size);
! 11911: #endif
! 11912: }
! 11913:
! 11914: if (enc != XML_CHAR_ENCODING_NONE) {
! 11915: xmlSwitchEncoding(ctxt, enc);
! 11916: }
! 11917:
! 11918: return(ctxt);
! 11919: }
! 11920: #endif /* LIBXML_PUSH_ENABLED */
! 11921:
! 11922: /**
! 11923: * xmlStopParser:
! 11924: * @ctxt: an XML parser context
! 11925: *
! 11926: * Blocks further parser processing
! 11927: */
! 11928: void
! 11929: xmlStopParser(xmlParserCtxtPtr ctxt) {
! 11930: if (ctxt == NULL)
! 11931: return;
! 11932: ctxt->instate = XML_PARSER_EOF;
! 11933: ctxt->disableSAX = 1;
! 11934: if (ctxt->input != NULL) {
! 11935: ctxt->input->cur = BAD_CAST"";
! 11936: ctxt->input->base = ctxt->input->cur;
! 11937: }
! 11938: }
! 11939:
! 11940: /**
! 11941: * xmlCreateIOParserCtxt:
! 11942: * @sax: a SAX handler
! 11943: * @user_data: The user data returned on SAX callbacks
! 11944: * @ioread: an I/O read function
! 11945: * @ioclose: an I/O close function
! 11946: * @ioctx: an I/O handler
! 11947: * @enc: the charset encoding if known
! 11948: *
! 11949: * Create a parser context for using the XML parser with an existing
! 11950: * I/O stream
! 11951: *
! 11952: * Returns the new parser context or NULL
! 11953: */
! 11954: xmlParserCtxtPtr
! 11955: xmlCreateIOParserCtxt(xmlSAXHandlerPtr sax, void *user_data,
! 11956: xmlInputReadCallback ioread, xmlInputCloseCallback ioclose,
! 11957: void *ioctx, xmlCharEncoding enc) {
! 11958: xmlParserCtxtPtr ctxt;
! 11959: xmlParserInputPtr inputStream;
! 11960: xmlParserInputBufferPtr buf;
! 11961:
! 11962: if (ioread == NULL) return(NULL);
! 11963:
! 11964: buf = xmlParserInputBufferCreateIO(ioread, ioclose, ioctx, enc);
! 11965: if (buf == NULL) return(NULL);
! 11966:
! 11967: ctxt = xmlNewParserCtxt();
! 11968: if (ctxt == NULL) {
! 11969: xmlFreeParserInputBuffer(buf);
! 11970: return(NULL);
! 11971: }
! 11972: if (sax != NULL) {
! 11973: #ifdef LIBXML_SAX1_ENABLED
! 11974: if (ctxt->sax != (xmlSAXHandlerPtr) &xmlDefaultSAXHandler)
! 11975: #endif /* LIBXML_SAX1_ENABLED */
! 11976: xmlFree(ctxt->sax);
! 11977: ctxt->sax = (xmlSAXHandlerPtr) xmlMalloc(sizeof(xmlSAXHandler));
! 11978: if (ctxt->sax == NULL) {
! 11979: xmlErrMemory(ctxt, NULL);
! 11980: xmlFreeParserCtxt(ctxt);
! 11981: return(NULL);
! 11982: }
! 11983: memset(ctxt->sax, 0, sizeof(xmlSAXHandler));
! 11984: if (sax->initialized == XML_SAX2_MAGIC)
! 11985: memcpy(ctxt->sax, sax, sizeof(xmlSAXHandler));
! 11986: else
! 11987: memcpy(ctxt->sax, sax, sizeof(xmlSAXHandlerV1));
! 11988: if (user_data != NULL)
! 11989: ctxt->userData = user_data;
! 11990: }
! 11991:
! 11992: inputStream = xmlNewIOInputStream(ctxt, buf, enc);
! 11993: if (inputStream == NULL) {
! 11994: xmlFreeParserCtxt(ctxt);
! 11995: return(NULL);
! 11996: }
! 11997: inputPush(ctxt, inputStream);
! 11998:
! 11999: return(ctxt);
! 12000: }
! 12001:
! 12002: #ifdef LIBXML_VALID_ENABLED
! 12003: /************************************************************************
! 12004: * *
! 12005: * Front ends when parsing a DTD *
! 12006: * *
! 12007: ************************************************************************/
! 12008:
! 12009: /**
! 12010: * xmlIOParseDTD:
! 12011: * @sax: the SAX handler block or NULL
! 12012: * @input: an Input Buffer
! 12013: * @enc: the charset encoding if known
! 12014: *
! 12015: * Load and parse a DTD
! 12016: *
! 12017: * Returns the resulting xmlDtdPtr or NULL in case of error.
! 12018: * @input will be freed by the function in any case.
! 12019: */
! 12020:
! 12021: xmlDtdPtr
! 12022: xmlIOParseDTD(xmlSAXHandlerPtr sax, xmlParserInputBufferPtr input,
! 12023: xmlCharEncoding enc) {
! 12024: xmlDtdPtr ret = NULL;
! 12025: xmlParserCtxtPtr ctxt;
! 12026: xmlParserInputPtr pinput = NULL;
! 12027: xmlChar start[4];
! 12028:
! 12029: if (input == NULL)
! 12030: return(NULL);
! 12031:
! 12032: ctxt = xmlNewParserCtxt();
! 12033: if (ctxt == NULL) {
! 12034: xmlFreeParserInputBuffer(input);
! 12035: return(NULL);
! 12036: }
! 12037:
! 12038: /*
! 12039: * Set-up the SAX context
! 12040: */
! 12041: if (sax != NULL) {
! 12042: if (ctxt->sax != NULL)
! 12043: xmlFree(ctxt->sax);
! 12044: ctxt->sax = sax;
! 12045: ctxt->userData = ctxt;
! 12046: }
! 12047: xmlDetectSAX2(ctxt);
! 12048:
! 12049: /*
! 12050: * generate a parser input from the I/O handler
! 12051: */
! 12052:
! 12053: pinput = xmlNewIOInputStream(ctxt, input, XML_CHAR_ENCODING_NONE);
! 12054: if (pinput == NULL) {
! 12055: if (sax != NULL) ctxt->sax = NULL;
! 12056: xmlFreeParserInputBuffer(input);
! 12057: xmlFreeParserCtxt(ctxt);
! 12058: return(NULL);
! 12059: }
! 12060:
! 12061: /*
! 12062: * plug some encoding conversion routines here.
! 12063: */
! 12064: if (xmlPushInput(ctxt, pinput) < 0) {
! 12065: if (sax != NULL) ctxt->sax = NULL;
! 12066: xmlFreeParserCtxt(ctxt);
! 12067: return(NULL);
! 12068: }
! 12069: if (enc != XML_CHAR_ENCODING_NONE) {
! 12070: xmlSwitchEncoding(ctxt, enc);
! 12071: }
! 12072:
! 12073: pinput->filename = NULL;
! 12074: pinput->line = 1;
! 12075: pinput->col = 1;
! 12076: pinput->base = ctxt->input->cur;
! 12077: pinput->cur = ctxt->input->cur;
! 12078: pinput->free = NULL;
! 12079:
! 12080: /*
! 12081: * let's parse that entity knowing it's an external subset.
! 12082: */
! 12083: ctxt->inSubset = 2;
! 12084: ctxt->myDoc = xmlNewDoc(BAD_CAST "1.0");
! 12085: if (ctxt->myDoc == NULL) {
! 12086: xmlErrMemory(ctxt, "New Doc failed");
! 12087: return(NULL);
! 12088: }
! 12089: ctxt->myDoc->properties = XML_DOC_INTERNAL;
! 12090: ctxt->myDoc->extSubset = xmlNewDtd(ctxt->myDoc, BAD_CAST "none",
! 12091: BAD_CAST "none", BAD_CAST "none");
! 12092:
! 12093: if ((enc == XML_CHAR_ENCODING_NONE) &&
! 12094: ((ctxt->input->end - ctxt->input->cur) >= 4)) {
! 12095: /*
! 12096: * Get the 4 first bytes and decode the charset
! 12097: * if enc != XML_CHAR_ENCODING_NONE
! 12098: * plug some encoding conversion routines.
! 12099: */
! 12100: start[0] = RAW;
! 12101: start[1] = NXT(1);
! 12102: start[2] = NXT(2);
! 12103: start[3] = NXT(3);
! 12104: enc = xmlDetectCharEncoding(start, 4);
! 12105: if (enc != XML_CHAR_ENCODING_NONE) {
! 12106: xmlSwitchEncoding(ctxt, enc);
! 12107: }
! 12108: }
! 12109:
! 12110: xmlParseExternalSubset(ctxt, BAD_CAST "none", BAD_CAST "none");
! 12111:
! 12112: if (ctxt->myDoc != NULL) {
! 12113: if (ctxt->wellFormed) {
! 12114: ret = ctxt->myDoc->extSubset;
! 12115: ctxt->myDoc->extSubset = NULL;
! 12116: if (ret != NULL) {
! 12117: xmlNodePtr tmp;
! 12118:
! 12119: ret->doc = NULL;
! 12120: tmp = ret->children;
! 12121: while (tmp != NULL) {
! 12122: tmp->doc = NULL;
! 12123: tmp = tmp->next;
! 12124: }
! 12125: }
! 12126: } else {
! 12127: ret = NULL;
! 12128: }
! 12129: xmlFreeDoc(ctxt->myDoc);
! 12130: ctxt->myDoc = NULL;
! 12131: }
! 12132: if (sax != NULL) ctxt->sax = NULL;
! 12133: xmlFreeParserCtxt(ctxt);
! 12134:
! 12135: return(ret);
! 12136: }
! 12137:
! 12138: /**
! 12139: * xmlSAXParseDTD:
! 12140: * @sax: the SAX handler block
! 12141: * @ExternalID: a NAME* containing the External ID of the DTD
! 12142: * @SystemID: a NAME* containing the URL to the DTD
! 12143: *
! 12144: * Load and parse an external subset.
! 12145: *
! 12146: * Returns the resulting xmlDtdPtr or NULL in case of error.
! 12147: */
! 12148:
! 12149: xmlDtdPtr
! 12150: xmlSAXParseDTD(xmlSAXHandlerPtr sax, const xmlChar *ExternalID,
! 12151: const xmlChar *SystemID) {
! 12152: xmlDtdPtr ret = NULL;
! 12153: xmlParserCtxtPtr ctxt;
! 12154: xmlParserInputPtr input = NULL;
! 12155: xmlCharEncoding enc;
! 12156: xmlChar* systemIdCanonic;
! 12157:
! 12158: if ((ExternalID == NULL) && (SystemID == NULL)) return(NULL);
! 12159:
! 12160: ctxt = xmlNewParserCtxt();
! 12161: if (ctxt == NULL) {
! 12162: return(NULL);
! 12163: }
! 12164:
! 12165: /*
! 12166: * Set-up the SAX context
! 12167: */
! 12168: if (sax != NULL) {
! 12169: if (ctxt->sax != NULL)
! 12170: xmlFree(ctxt->sax);
! 12171: ctxt->sax = sax;
! 12172: ctxt->userData = ctxt;
! 12173: }
! 12174:
! 12175: /*
! 12176: * Canonicalise the system ID
! 12177: */
! 12178: systemIdCanonic = xmlCanonicPath(SystemID);
! 12179: if ((SystemID != NULL) && (systemIdCanonic == NULL)) {
! 12180: xmlFreeParserCtxt(ctxt);
! 12181: return(NULL);
! 12182: }
! 12183:
! 12184: /*
! 12185: * Ask the Entity resolver to load the damn thing
! 12186: */
! 12187:
! 12188: if ((ctxt->sax != NULL) && (ctxt->sax->resolveEntity != NULL))
! 12189: input = ctxt->sax->resolveEntity(ctxt->userData, ExternalID,
! 12190: systemIdCanonic);
! 12191: if (input == NULL) {
! 12192: if (sax != NULL) ctxt->sax = NULL;
! 12193: xmlFreeParserCtxt(ctxt);
! 12194: if (systemIdCanonic != NULL)
! 12195: xmlFree(systemIdCanonic);
! 12196: return(NULL);
! 12197: }
! 12198:
! 12199: /*
! 12200: * plug some encoding conversion routines here.
! 12201: */
! 12202: if (xmlPushInput(ctxt, input) < 0) {
! 12203: if (sax != NULL) ctxt->sax = NULL;
! 12204: xmlFreeParserCtxt(ctxt);
! 12205: if (systemIdCanonic != NULL)
! 12206: xmlFree(systemIdCanonic);
! 12207: return(NULL);
! 12208: }
! 12209: if ((ctxt->input->end - ctxt->input->cur) >= 4) {
! 12210: enc = xmlDetectCharEncoding(ctxt->input->cur, 4);
! 12211: xmlSwitchEncoding(ctxt, enc);
! 12212: }
! 12213:
! 12214: if (input->filename == NULL)
! 12215: input->filename = (char *) systemIdCanonic;
! 12216: else
! 12217: xmlFree(systemIdCanonic);
! 12218: input->line = 1;
! 12219: input->col = 1;
! 12220: input->base = ctxt->input->cur;
! 12221: input->cur = ctxt->input->cur;
! 12222: input->free = NULL;
! 12223:
! 12224: /*
! 12225: * let's parse that entity knowing it's an external subset.
! 12226: */
! 12227: ctxt->inSubset = 2;
! 12228: ctxt->myDoc = xmlNewDoc(BAD_CAST "1.0");
! 12229: if (ctxt->myDoc == NULL) {
! 12230: xmlErrMemory(ctxt, "New Doc failed");
! 12231: if (sax != NULL) ctxt->sax = NULL;
! 12232: xmlFreeParserCtxt(ctxt);
! 12233: return(NULL);
! 12234: }
! 12235: ctxt->myDoc->properties = XML_DOC_INTERNAL;
! 12236: ctxt->myDoc->extSubset = xmlNewDtd(ctxt->myDoc, BAD_CAST "none",
! 12237: ExternalID, SystemID);
! 12238: xmlParseExternalSubset(ctxt, ExternalID, SystemID);
! 12239:
! 12240: if (ctxt->myDoc != NULL) {
! 12241: if (ctxt->wellFormed) {
! 12242: ret = ctxt->myDoc->extSubset;
! 12243: ctxt->myDoc->extSubset = NULL;
! 12244: if (ret != NULL) {
! 12245: xmlNodePtr tmp;
! 12246:
! 12247: ret->doc = NULL;
! 12248: tmp = ret->children;
! 12249: while (tmp != NULL) {
! 12250: tmp->doc = NULL;
! 12251: tmp = tmp->next;
! 12252: }
! 12253: }
! 12254: } else {
! 12255: ret = NULL;
! 12256: }
! 12257: xmlFreeDoc(ctxt->myDoc);
! 12258: ctxt->myDoc = NULL;
! 12259: }
! 12260: if (sax != NULL) ctxt->sax = NULL;
! 12261: xmlFreeParserCtxt(ctxt);
! 12262:
! 12263: return(ret);
! 12264: }
! 12265:
! 12266:
! 12267: /**
! 12268: * xmlParseDTD:
! 12269: * @ExternalID: a NAME* containing the External ID of the DTD
! 12270: * @SystemID: a NAME* containing the URL to the DTD
! 12271: *
! 12272: * Load and parse an external subset.
! 12273: *
! 12274: * Returns the resulting xmlDtdPtr or NULL in case of error.
! 12275: */
! 12276:
! 12277: xmlDtdPtr
! 12278: xmlParseDTD(const xmlChar *ExternalID, const xmlChar *SystemID) {
! 12279: return(xmlSAXParseDTD(NULL, ExternalID, SystemID));
! 12280: }
! 12281: #endif /* LIBXML_VALID_ENABLED */
! 12282:
! 12283: /************************************************************************
! 12284: * *
! 12285: * Front ends when parsing an Entity *
! 12286: * *
! 12287: ************************************************************************/
! 12288:
! 12289: /**
! 12290: * xmlParseCtxtExternalEntity:
! 12291: * @ctx: the existing parsing context
! 12292: * @URL: the URL for the entity to load
! 12293: * @ID: the System ID for the entity to load
! 12294: * @lst: the return value for the set of parsed nodes
! 12295: *
! 12296: * Parse an external general entity within an existing parsing context
! 12297: * An external general parsed entity is well-formed if it matches the
! 12298: * production labeled extParsedEnt.
! 12299: *
! 12300: * [78] extParsedEnt ::= TextDecl? content
! 12301: *
! 12302: * Returns 0 if the entity is well formed, -1 in case of args problem and
! 12303: * the parser error code otherwise
! 12304: */
! 12305:
! 12306: int
! 12307: xmlParseCtxtExternalEntity(xmlParserCtxtPtr ctx, const xmlChar *URL,
! 12308: const xmlChar *ID, xmlNodePtr *lst) {
! 12309: xmlParserCtxtPtr ctxt;
! 12310: xmlDocPtr newDoc;
! 12311: xmlNodePtr newRoot;
! 12312: xmlSAXHandlerPtr oldsax = NULL;
! 12313: int ret = 0;
! 12314: xmlChar start[4];
! 12315: xmlCharEncoding enc;
! 12316:
! 12317: if (ctx == NULL) return(-1);
! 12318:
! 12319: if (((ctx->depth > 40) && ((ctx->options & XML_PARSE_HUGE) == 0)) ||
! 12320: (ctx->depth > 1024)) {
! 12321: return(XML_ERR_ENTITY_LOOP);
! 12322: }
! 12323:
! 12324: if (lst != NULL)
! 12325: *lst = NULL;
! 12326: if ((URL == NULL) && (ID == NULL))
! 12327: return(-1);
! 12328: if (ctx->myDoc == NULL) /* @@ relax but check for dereferences */
! 12329: return(-1);
! 12330:
! 12331: ctxt = xmlCreateEntityParserCtxtInternal(URL, ID, NULL, ctx);
! 12332: if (ctxt == NULL) {
! 12333: return(-1);
! 12334: }
! 12335:
! 12336: oldsax = ctxt->sax;
! 12337: ctxt->sax = ctx->sax;
! 12338: xmlDetectSAX2(ctxt);
! 12339: newDoc = xmlNewDoc(BAD_CAST "1.0");
! 12340: if (newDoc == NULL) {
! 12341: xmlFreeParserCtxt(ctxt);
! 12342: return(-1);
! 12343: }
! 12344: newDoc->properties = XML_DOC_INTERNAL;
! 12345: if (ctx->myDoc->dict) {
! 12346: newDoc->dict = ctx->myDoc->dict;
! 12347: xmlDictReference(newDoc->dict);
! 12348: }
! 12349: if (ctx->myDoc != NULL) {
! 12350: newDoc->intSubset = ctx->myDoc->intSubset;
! 12351: newDoc->extSubset = ctx->myDoc->extSubset;
! 12352: }
! 12353: if (ctx->myDoc->URL != NULL) {
! 12354: newDoc->URL = xmlStrdup(ctx->myDoc->URL);
! 12355: }
! 12356: newRoot = xmlNewDocNode(newDoc, NULL, BAD_CAST "pseudoroot", NULL);
! 12357: if (newRoot == NULL) {
! 12358: ctxt->sax = oldsax;
! 12359: xmlFreeParserCtxt(ctxt);
! 12360: newDoc->intSubset = NULL;
! 12361: newDoc->extSubset = NULL;
! 12362: xmlFreeDoc(newDoc);
! 12363: return(-1);
! 12364: }
! 12365: xmlAddChild((xmlNodePtr) newDoc, newRoot);
! 12366: nodePush(ctxt, newDoc->children);
! 12367: if (ctx->myDoc == NULL) {
! 12368: ctxt->myDoc = newDoc;
! 12369: } else {
! 12370: ctxt->myDoc = ctx->myDoc;
! 12371: newDoc->children->doc = ctx->myDoc;
! 12372: }
! 12373:
! 12374: /*
! 12375: * Get the 4 first bytes and decode the charset
! 12376: * if enc != XML_CHAR_ENCODING_NONE
! 12377: * plug some encoding conversion routines.
! 12378: */
! 12379: GROW
! 12380: if ((ctxt->input->end - ctxt->input->cur) >= 4) {
! 12381: start[0] = RAW;
! 12382: start[1] = NXT(1);
! 12383: start[2] = NXT(2);
! 12384: start[3] = NXT(3);
! 12385: enc = xmlDetectCharEncoding(start, 4);
! 12386: if (enc != XML_CHAR_ENCODING_NONE) {
! 12387: xmlSwitchEncoding(ctxt, enc);
! 12388: }
! 12389: }
! 12390:
! 12391: /*
! 12392: * Parse a possible text declaration first
! 12393: */
! 12394: if ((CMP5(CUR_PTR, '<', '?', 'x', 'm', 'l')) && (IS_BLANK_CH(NXT(5)))) {
! 12395: xmlParseTextDecl(ctxt);
! 12396: /*
! 12397: * An XML-1.0 document can't reference an entity not XML-1.0
! 12398: */
! 12399: if ((xmlStrEqual(ctx->version, BAD_CAST "1.0")) &&
! 12400: (!xmlStrEqual(ctxt->input->version, BAD_CAST "1.0"))) {
! 12401: xmlFatalErrMsg(ctxt, XML_ERR_VERSION_MISMATCH,
! 12402: "Version mismatch between document and entity\n");
! 12403: }
! 12404: }
! 12405:
! 12406: /*
! 12407: * Doing validity checking on chunk doesn't make sense
! 12408: */
! 12409: ctxt->instate = XML_PARSER_CONTENT;
! 12410: ctxt->validate = ctx->validate;
! 12411: ctxt->valid = ctx->valid;
! 12412: ctxt->loadsubset = ctx->loadsubset;
! 12413: ctxt->depth = ctx->depth + 1;
! 12414: ctxt->replaceEntities = ctx->replaceEntities;
! 12415: if (ctxt->validate) {
! 12416: ctxt->vctxt.error = ctx->vctxt.error;
! 12417: ctxt->vctxt.warning = ctx->vctxt.warning;
! 12418: } else {
! 12419: ctxt->vctxt.error = NULL;
! 12420: ctxt->vctxt.warning = NULL;
! 12421: }
! 12422: ctxt->vctxt.nodeTab = NULL;
! 12423: ctxt->vctxt.nodeNr = 0;
! 12424: ctxt->vctxt.nodeMax = 0;
! 12425: ctxt->vctxt.node = NULL;
! 12426: if (ctxt->dict != NULL) xmlDictFree(ctxt->dict);
! 12427: ctxt->dict = ctx->dict;
! 12428: ctxt->str_xml = xmlDictLookup(ctxt->dict, BAD_CAST "xml", 3);
! 12429: ctxt->str_xmlns = xmlDictLookup(ctxt->dict, BAD_CAST "xmlns", 5);
! 12430: ctxt->str_xml_ns = xmlDictLookup(ctxt->dict, XML_XML_NAMESPACE, 36);
! 12431: ctxt->dictNames = ctx->dictNames;
! 12432: ctxt->attsDefault = ctx->attsDefault;
! 12433: ctxt->attsSpecial = ctx->attsSpecial;
! 12434: ctxt->linenumbers = ctx->linenumbers;
! 12435:
! 12436: xmlParseContent(ctxt);
! 12437:
! 12438: ctx->validate = ctxt->validate;
! 12439: ctx->valid = ctxt->valid;
! 12440: if ((RAW == '<') && (NXT(1) == '/')) {
! 12441: xmlFatalErr(ctxt, XML_ERR_NOT_WELL_BALANCED, NULL);
! 12442: } else if (RAW != 0) {
! 12443: xmlFatalErr(ctxt, XML_ERR_EXTRA_CONTENT, NULL);
! 12444: }
! 12445: if (ctxt->node != newDoc->children) {
! 12446: xmlFatalErr(ctxt, XML_ERR_NOT_WELL_BALANCED, NULL);
! 12447: }
! 12448:
! 12449: if (!ctxt->wellFormed) {
! 12450: if (ctxt->errNo == 0)
! 12451: ret = 1;
! 12452: else
! 12453: ret = ctxt->errNo;
! 12454: } else {
! 12455: if (lst != NULL) {
! 12456: xmlNodePtr cur;
! 12457:
! 12458: /*
! 12459: * Return the newly created nodeset after unlinking it from
! 12460: * they pseudo parent.
! 12461: */
! 12462: cur = newDoc->children->children;
! 12463: *lst = cur;
! 12464: while (cur != NULL) {
! 12465: cur->parent = NULL;
! 12466: cur = cur->next;
! 12467: }
! 12468: newDoc->children->children = NULL;
! 12469: }
! 12470: ret = 0;
! 12471: }
! 12472: ctxt->sax = oldsax;
! 12473: ctxt->dict = NULL;
! 12474: ctxt->attsDefault = NULL;
! 12475: ctxt->attsSpecial = NULL;
! 12476: xmlFreeParserCtxt(ctxt);
! 12477: newDoc->intSubset = NULL;
! 12478: newDoc->extSubset = NULL;
! 12479: xmlFreeDoc(newDoc);
! 12480:
! 12481: return(ret);
! 12482: }
! 12483:
! 12484: /**
! 12485: * xmlParseExternalEntityPrivate:
! 12486: * @doc: the document the chunk pertains to
! 12487: * @oldctxt: the previous parser context if available
! 12488: * @sax: the SAX handler bloc (possibly NULL)
! 12489: * @user_data: The user data returned on SAX callbacks (possibly NULL)
! 12490: * @depth: Used for loop detection, use 0
! 12491: * @URL: the URL for the entity to load
! 12492: * @ID: the System ID for the entity to load
! 12493: * @list: the return value for the set of parsed nodes
! 12494: *
! 12495: * Private version of xmlParseExternalEntity()
! 12496: *
! 12497: * Returns 0 if the entity is well formed, -1 in case of args problem and
! 12498: * the parser error code otherwise
! 12499: */
! 12500:
! 12501: static xmlParserErrors
! 12502: xmlParseExternalEntityPrivate(xmlDocPtr doc, xmlParserCtxtPtr oldctxt,
! 12503: xmlSAXHandlerPtr sax,
! 12504: void *user_data, int depth, const xmlChar *URL,
! 12505: const xmlChar *ID, xmlNodePtr *list) {
! 12506: xmlParserCtxtPtr ctxt;
! 12507: xmlDocPtr newDoc;
! 12508: xmlNodePtr newRoot;
! 12509: xmlSAXHandlerPtr oldsax = NULL;
! 12510: xmlParserErrors ret = XML_ERR_OK;
! 12511: xmlChar start[4];
! 12512: xmlCharEncoding enc;
! 12513:
! 12514: if (((depth > 40) &&
! 12515: ((oldctxt == NULL) || (oldctxt->options & XML_PARSE_HUGE) == 0)) ||
! 12516: (depth > 1024)) {
! 12517: return(XML_ERR_ENTITY_LOOP);
! 12518: }
! 12519:
! 12520: if (list != NULL)
! 12521: *list = NULL;
! 12522: if ((URL == NULL) && (ID == NULL))
! 12523: return(XML_ERR_INTERNAL_ERROR);
! 12524: if (doc == NULL)
! 12525: return(XML_ERR_INTERNAL_ERROR);
! 12526:
! 12527:
! 12528: ctxt = xmlCreateEntityParserCtxtInternal(URL, ID, NULL, oldctxt);
! 12529: if (ctxt == NULL) return(XML_WAR_UNDECLARED_ENTITY);
! 12530: ctxt->userData = ctxt;
! 12531: if (oldctxt != NULL) {
! 12532: ctxt->_private = oldctxt->_private;
! 12533: ctxt->loadsubset = oldctxt->loadsubset;
! 12534: ctxt->validate = oldctxt->validate;
! 12535: ctxt->external = oldctxt->external;
! 12536: ctxt->record_info = oldctxt->record_info;
! 12537: ctxt->node_seq.maximum = oldctxt->node_seq.maximum;
! 12538: ctxt->node_seq.length = oldctxt->node_seq.length;
! 12539: ctxt->node_seq.buffer = oldctxt->node_seq.buffer;
! 12540: } else {
! 12541: /*
! 12542: * Doing validity checking on chunk without context
! 12543: * doesn't make sense
! 12544: */
! 12545: ctxt->_private = NULL;
! 12546: ctxt->validate = 0;
! 12547: ctxt->external = 2;
! 12548: ctxt->loadsubset = 0;
! 12549: }
! 12550: if (sax != NULL) {
! 12551: oldsax = ctxt->sax;
! 12552: ctxt->sax = sax;
! 12553: if (user_data != NULL)
! 12554: ctxt->userData = user_data;
! 12555: }
! 12556: xmlDetectSAX2(ctxt);
! 12557: newDoc = xmlNewDoc(BAD_CAST "1.0");
! 12558: if (newDoc == NULL) {
! 12559: ctxt->node_seq.maximum = 0;
! 12560: ctxt->node_seq.length = 0;
! 12561: ctxt->node_seq.buffer = NULL;
! 12562: xmlFreeParserCtxt(ctxt);
! 12563: return(XML_ERR_INTERNAL_ERROR);
! 12564: }
! 12565: newDoc->properties = XML_DOC_INTERNAL;
! 12566: newDoc->intSubset = doc->intSubset;
! 12567: newDoc->extSubset = doc->extSubset;
! 12568: newDoc->dict = doc->dict;
! 12569: xmlDictReference(newDoc->dict);
! 12570:
! 12571: if (doc->URL != NULL) {
! 12572: newDoc->URL = xmlStrdup(doc->URL);
! 12573: }
! 12574: newRoot = xmlNewDocNode(newDoc, NULL, BAD_CAST "pseudoroot", NULL);
! 12575: if (newRoot == NULL) {
! 12576: if (sax != NULL)
! 12577: ctxt->sax = oldsax;
! 12578: ctxt->node_seq.maximum = 0;
! 12579: ctxt->node_seq.length = 0;
! 12580: ctxt->node_seq.buffer = NULL;
! 12581: xmlFreeParserCtxt(ctxt);
! 12582: newDoc->intSubset = NULL;
! 12583: newDoc->extSubset = NULL;
! 12584: xmlFreeDoc(newDoc);
! 12585: return(XML_ERR_INTERNAL_ERROR);
! 12586: }
! 12587: xmlAddChild((xmlNodePtr) newDoc, newRoot);
! 12588: nodePush(ctxt, newDoc->children);
! 12589: ctxt->myDoc = doc;
! 12590: newRoot->doc = doc;
! 12591:
! 12592: /*
! 12593: * Get the 4 first bytes and decode the charset
! 12594: * if enc != XML_CHAR_ENCODING_NONE
! 12595: * plug some encoding conversion routines.
! 12596: */
! 12597: GROW;
! 12598: if ((ctxt->input->end - ctxt->input->cur) >= 4) {
! 12599: start[0] = RAW;
! 12600: start[1] = NXT(1);
! 12601: start[2] = NXT(2);
! 12602: start[3] = NXT(3);
! 12603: enc = xmlDetectCharEncoding(start, 4);
! 12604: if (enc != XML_CHAR_ENCODING_NONE) {
! 12605: xmlSwitchEncoding(ctxt, enc);
! 12606: }
! 12607: }
! 12608:
! 12609: /*
! 12610: * Parse a possible text declaration first
! 12611: */
! 12612: if ((CMP5(CUR_PTR, '<', '?', 'x', 'm', 'l')) && (IS_BLANK_CH(NXT(5)))) {
! 12613: xmlParseTextDecl(ctxt);
! 12614: }
! 12615:
! 12616: ctxt->instate = XML_PARSER_CONTENT;
! 12617: ctxt->depth = depth;
! 12618:
! 12619: xmlParseContent(ctxt);
! 12620:
! 12621: if ((RAW == '<') && (NXT(1) == '/')) {
! 12622: xmlFatalErr(ctxt, XML_ERR_NOT_WELL_BALANCED, NULL);
! 12623: } else if (RAW != 0) {
! 12624: xmlFatalErr(ctxt, XML_ERR_EXTRA_CONTENT, NULL);
! 12625: }
! 12626: if (ctxt->node != newDoc->children) {
! 12627: xmlFatalErr(ctxt, XML_ERR_NOT_WELL_BALANCED, NULL);
! 12628: }
! 12629:
! 12630: if (!ctxt->wellFormed) {
! 12631: if (ctxt->errNo == 0)
! 12632: ret = XML_ERR_INTERNAL_ERROR;
! 12633: else
! 12634: ret = (xmlParserErrors)ctxt->errNo;
! 12635: } else {
! 12636: if (list != NULL) {
! 12637: xmlNodePtr cur;
! 12638:
! 12639: /*
! 12640: * Return the newly created nodeset after unlinking it from
! 12641: * they pseudo parent.
! 12642: */
! 12643: cur = newDoc->children->children;
! 12644: *list = cur;
! 12645: while (cur != NULL) {
! 12646: cur->parent = NULL;
! 12647: cur = cur->next;
! 12648: }
! 12649: newDoc->children->children = NULL;
! 12650: }
! 12651: ret = XML_ERR_OK;
! 12652: }
! 12653:
! 12654: /*
! 12655: * Record in the parent context the number of entities replacement
! 12656: * done when parsing that reference.
! 12657: */
! 12658: if (oldctxt != NULL)
! 12659: oldctxt->nbentities += ctxt->nbentities;
! 12660:
! 12661: /*
! 12662: * Also record the size of the entity parsed
! 12663: */
! 12664: if (ctxt->input != NULL) {
! 12665: oldctxt->sizeentities += ctxt->input->consumed;
! 12666: oldctxt->sizeentities += (ctxt->input->cur - ctxt->input->base);
! 12667: }
! 12668: /*
! 12669: * And record the last error if any
! 12670: */
! 12671: if (ctxt->lastError.code != XML_ERR_OK)
! 12672: xmlCopyError(&ctxt->lastError, &oldctxt->lastError);
! 12673:
! 12674: if (sax != NULL)
! 12675: ctxt->sax = oldsax;
! 12676: oldctxt->node_seq.maximum = ctxt->node_seq.maximum;
! 12677: oldctxt->node_seq.length = ctxt->node_seq.length;
! 12678: oldctxt->node_seq.buffer = ctxt->node_seq.buffer;
! 12679: ctxt->node_seq.maximum = 0;
! 12680: ctxt->node_seq.length = 0;
! 12681: ctxt->node_seq.buffer = NULL;
! 12682: xmlFreeParserCtxt(ctxt);
! 12683: newDoc->intSubset = NULL;
! 12684: newDoc->extSubset = NULL;
! 12685: xmlFreeDoc(newDoc);
! 12686:
! 12687: return(ret);
! 12688: }
! 12689:
! 12690: #ifdef LIBXML_SAX1_ENABLED
! 12691: /**
! 12692: * xmlParseExternalEntity:
! 12693: * @doc: the document the chunk pertains to
! 12694: * @sax: the SAX handler bloc (possibly NULL)
! 12695: * @user_data: The user data returned on SAX callbacks (possibly NULL)
! 12696: * @depth: Used for loop detection, use 0
! 12697: * @URL: the URL for the entity to load
! 12698: * @ID: the System ID for the entity to load
! 12699: * @lst: the return value for the set of parsed nodes
! 12700: *
! 12701: * Parse an external general entity
! 12702: * An external general parsed entity is well-formed if it matches the
! 12703: * production labeled extParsedEnt.
! 12704: *
! 12705: * [78] extParsedEnt ::= TextDecl? content
! 12706: *
! 12707: * Returns 0 if the entity is well formed, -1 in case of args problem and
! 12708: * the parser error code otherwise
! 12709: */
! 12710:
! 12711: int
! 12712: xmlParseExternalEntity(xmlDocPtr doc, xmlSAXHandlerPtr sax, void *user_data,
! 12713: int depth, const xmlChar *URL, const xmlChar *ID, xmlNodePtr *lst) {
! 12714: return(xmlParseExternalEntityPrivate(doc, NULL, sax, user_data, depth, URL,
! 12715: ID, lst));
! 12716: }
! 12717:
! 12718: /**
! 12719: * xmlParseBalancedChunkMemory:
! 12720: * @doc: the document the chunk pertains to
! 12721: * @sax: the SAX handler bloc (possibly NULL)
! 12722: * @user_data: The user data returned on SAX callbacks (possibly NULL)
! 12723: * @depth: Used for loop detection, use 0
! 12724: * @string: the input string in UTF8 or ISO-Latin (zero terminated)
! 12725: * @lst: the return value for the set of parsed nodes
! 12726: *
! 12727: * Parse a well-balanced chunk of an XML document
! 12728: * called by the parser
! 12729: * The allowed sequence for the Well Balanced Chunk is the one defined by
! 12730: * the content production in the XML grammar:
! 12731: *
! 12732: * [43] content ::= (element | CharData | Reference | CDSect | PI | Comment)*
! 12733: *
! 12734: * Returns 0 if the chunk is well balanced, -1 in case of args problem and
! 12735: * the parser error code otherwise
! 12736: */
! 12737:
! 12738: int
! 12739: xmlParseBalancedChunkMemory(xmlDocPtr doc, xmlSAXHandlerPtr sax,
! 12740: void *user_data, int depth, const xmlChar *string, xmlNodePtr *lst) {
! 12741: return xmlParseBalancedChunkMemoryRecover( doc, sax, user_data,
! 12742: depth, string, lst, 0 );
! 12743: }
! 12744: #endif /* LIBXML_SAX1_ENABLED */
! 12745:
! 12746: /**
! 12747: * xmlParseBalancedChunkMemoryInternal:
! 12748: * @oldctxt: the existing parsing context
! 12749: * @string: the input string in UTF8 or ISO-Latin (zero terminated)
! 12750: * @user_data: the user data field for the parser context
! 12751: * @lst: the return value for the set of parsed nodes
! 12752: *
! 12753: *
! 12754: * Parse a well-balanced chunk of an XML document
! 12755: * called by the parser
! 12756: * The allowed sequence for the Well Balanced Chunk is the one defined by
! 12757: * the content production in the XML grammar:
! 12758: *
! 12759: * [43] content ::= (element | CharData | Reference | CDSect | PI | Comment)*
! 12760: *
! 12761: * Returns XML_ERR_OK if the chunk is well balanced, and the parser
! 12762: * error code otherwise
! 12763: *
! 12764: * In case recover is set to 1, the nodelist will not be empty even if
! 12765: * the parsed chunk is not well balanced.
! 12766: */
! 12767: static xmlParserErrors
! 12768: xmlParseBalancedChunkMemoryInternal(xmlParserCtxtPtr oldctxt,
! 12769: const xmlChar *string, void *user_data, xmlNodePtr *lst) {
! 12770: xmlParserCtxtPtr ctxt;
! 12771: xmlDocPtr newDoc = NULL;
! 12772: xmlNodePtr newRoot;
! 12773: xmlSAXHandlerPtr oldsax = NULL;
! 12774: xmlNodePtr content = NULL;
! 12775: xmlNodePtr last = NULL;
! 12776: int size;
! 12777: xmlParserErrors ret = XML_ERR_OK;
! 12778: #ifdef SAX2
! 12779: int i;
! 12780: #endif
! 12781:
! 12782: if (((oldctxt->depth > 40) && ((oldctxt->options & XML_PARSE_HUGE) == 0)) ||
! 12783: (oldctxt->depth > 1024)) {
! 12784: return(XML_ERR_ENTITY_LOOP);
! 12785: }
! 12786:
! 12787:
! 12788: if (lst != NULL)
! 12789: *lst = NULL;
! 12790: if (string == NULL)
! 12791: return(XML_ERR_INTERNAL_ERROR);
! 12792:
! 12793: size = xmlStrlen(string);
! 12794:
! 12795: ctxt = xmlCreateMemoryParserCtxt((char *) string, size);
! 12796: if (ctxt == NULL) return(XML_WAR_UNDECLARED_ENTITY);
! 12797: if (user_data != NULL)
! 12798: ctxt->userData = user_data;
! 12799: else
! 12800: ctxt->userData = ctxt;
! 12801: if (ctxt->dict != NULL) xmlDictFree(ctxt->dict);
! 12802: ctxt->dict = oldctxt->dict;
! 12803: ctxt->str_xml = xmlDictLookup(ctxt->dict, BAD_CAST "xml", 3);
! 12804: ctxt->str_xmlns = xmlDictLookup(ctxt->dict, BAD_CAST "xmlns", 5);
! 12805: ctxt->str_xml_ns = xmlDictLookup(ctxt->dict, XML_XML_NAMESPACE, 36);
! 12806:
! 12807: #ifdef SAX2
! 12808: /* propagate namespaces down the entity */
! 12809: for (i = 0;i < oldctxt->nsNr;i += 2) {
! 12810: nsPush(ctxt, oldctxt->nsTab[i], oldctxt->nsTab[i+1]);
! 12811: }
! 12812: #endif
! 12813:
! 12814: oldsax = ctxt->sax;
! 12815: ctxt->sax = oldctxt->sax;
! 12816: xmlDetectSAX2(ctxt);
! 12817: ctxt->replaceEntities = oldctxt->replaceEntities;
! 12818: ctxt->options = oldctxt->options;
! 12819:
! 12820: ctxt->_private = oldctxt->_private;
! 12821: if (oldctxt->myDoc == NULL) {
! 12822: newDoc = xmlNewDoc(BAD_CAST "1.0");
! 12823: if (newDoc == NULL) {
! 12824: ctxt->sax = oldsax;
! 12825: ctxt->dict = NULL;
! 12826: xmlFreeParserCtxt(ctxt);
! 12827: return(XML_ERR_INTERNAL_ERROR);
! 12828: }
! 12829: newDoc->properties = XML_DOC_INTERNAL;
! 12830: newDoc->dict = ctxt->dict;
! 12831: xmlDictReference(newDoc->dict);
! 12832: ctxt->myDoc = newDoc;
! 12833: } else {
! 12834: ctxt->myDoc = oldctxt->myDoc;
! 12835: content = ctxt->myDoc->children;
! 12836: last = ctxt->myDoc->last;
! 12837: }
! 12838: newRoot = xmlNewDocNode(ctxt->myDoc, NULL, BAD_CAST "pseudoroot", NULL);
! 12839: if (newRoot == NULL) {
! 12840: ctxt->sax = oldsax;
! 12841: ctxt->dict = NULL;
! 12842: xmlFreeParserCtxt(ctxt);
! 12843: if (newDoc != NULL) {
! 12844: xmlFreeDoc(newDoc);
! 12845: }
! 12846: return(XML_ERR_INTERNAL_ERROR);
! 12847: }
! 12848: ctxt->myDoc->children = NULL;
! 12849: ctxt->myDoc->last = NULL;
! 12850: xmlAddChild((xmlNodePtr) ctxt->myDoc, newRoot);
! 12851: nodePush(ctxt, ctxt->myDoc->children);
! 12852: ctxt->instate = XML_PARSER_CONTENT;
! 12853: ctxt->depth = oldctxt->depth + 1;
! 12854:
! 12855: ctxt->validate = 0;
! 12856: ctxt->loadsubset = oldctxt->loadsubset;
! 12857: if ((oldctxt->validate) || (oldctxt->replaceEntities != 0)) {
! 12858: /*
! 12859: * ID/IDREF registration will be done in xmlValidateElement below
! 12860: */
! 12861: ctxt->loadsubset |= XML_SKIP_IDS;
! 12862: }
! 12863: ctxt->dictNames = oldctxt->dictNames;
! 12864: ctxt->attsDefault = oldctxt->attsDefault;
! 12865: ctxt->attsSpecial = oldctxt->attsSpecial;
! 12866:
! 12867: xmlParseContent(ctxt);
! 12868: if ((RAW == '<') && (NXT(1) == '/')) {
! 12869: xmlFatalErr(ctxt, XML_ERR_NOT_WELL_BALANCED, NULL);
! 12870: } else if (RAW != 0) {
! 12871: xmlFatalErr(ctxt, XML_ERR_EXTRA_CONTENT, NULL);
! 12872: }
! 12873: if (ctxt->node != ctxt->myDoc->children) {
! 12874: xmlFatalErr(ctxt, XML_ERR_NOT_WELL_BALANCED, NULL);
! 12875: }
! 12876:
! 12877: if (!ctxt->wellFormed) {
! 12878: if (ctxt->errNo == 0)
! 12879: ret = XML_ERR_INTERNAL_ERROR;
! 12880: else
! 12881: ret = (xmlParserErrors)ctxt->errNo;
! 12882: } else {
! 12883: ret = XML_ERR_OK;
! 12884: }
! 12885:
! 12886: if ((lst != NULL) && (ret == XML_ERR_OK)) {
! 12887: xmlNodePtr cur;
! 12888:
! 12889: /*
! 12890: * Return the newly created nodeset after unlinking it from
! 12891: * they pseudo parent.
! 12892: */
! 12893: cur = ctxt->myDoc->children->children;
! 12894: *lst = cur;
! 12895: while (cur != NULL) {
! 12896: #ifdef LIBXML_VALID_ENABLED
! 12897: if ((oldctxt->validate) && (oldctxt->wellFormed) &&
! 12898: (oldctxt->myDoc) && (oldctxt->myDoc->intSubset) &&
! 12899: (cur->type == XML_ELEMENT_NODE)) {
! 12900: oldctxt->valid &= xmlValidateElement(&oldctxt->vctxt,
! 12901: oldctxt->myDoc, cur);
! 12902: }
! 12903: #endif /* LIBXML_VALID_ENABLED */
! 12904: cur->parent = NULL;
! 12905: cur = cur->next;
! 12906: }
! 12907: ctxt->myDoc->children->children = NULL;
! 12908: }
! 12909: if (ctxt->myDoc != NULL) {
! 12910: xmlFreeNode(ctxt->myDoc->children);
! 12911: ctxt->myDoc->children = content;
! 12912: ctxt->myDoc->last = last;
! 12913: }
! 12914:
! 12915: /*
! 12916: * Record in the parent context the number of entities replacement
! 12917: * done when parsing that reference.
! 12918: */
! 12919: if (oldctxt != NULL)
! 12920: oldctxt->nbentities += ctxt->nbentities;
! 12921:
! 12922: /*
! 12923: * Also record the last error if any
! 12924: */
! 12925: if (ctxt->lastError.code != XML_ERR_OK)
! 12926: xmlCopyError(&ctxt->lastError, &oldctxt->lastError);
! 12927:
! 12928: ctxt->sax = oldsax;
! 12929: ctxt->dict = NULL;
! 12930: ctxt->attsDefault = NULL;
! 12931: ctxt->attsSpecial = NULL;
! 12932: xmlFreeParserCtxt(ctxt);
! 12933: if (newDoc != NULL) {
! 12934: xmlFreeDoc(newDoc);
! 12935: }
! 12936:
! 12937: return(ret);
! 12938: }
! 12939:
! 12940: /**
! 12941: * xmlParseInNodeContext:
! 12942: * @node: the context node
! 12943: * @data: the input string
! 12944: * @datalen: the input string length in bytes
! 12945: * @options: a combination of xmlParserOption
! 12946: * @lst: the return value for the set of parsed nodes
! 12947: *
! 12948: * Parse a well-balanced chunk of an XML document
! 12949: * within the context (DTD, namespaces, etc ...) of the given node.
! 12950: *
! 12951: * The allowed sequence for the data is a Well Balanced Chunk defined by
! 12952: * the content production in the XML grammar:
! 12953: *
! 12954: * [43] content ::= (element | CharData | Reference | CDSect | PI | Comment)*
! 12955: *
! 12956: * Returns XML_ERR_OK if the chunk is well balanced, and the parser
! 12957: * error code otherwise
! 12958: */
! 12959: xmlParserErrors
! 12960: xmlParseInNodeContext(xmlNodePtr node, const char *data, int datalen,
! 12961: int options, xmlNodePtr *lst) {
! 12962: #ifdef SAX2
! 12963: xmlParserCtxtPtr ctxt;
! 12964: xmlDocPtr doc = NULL;
! 12965: xmlNodePtr fake, cur;
! 12966: int nsnr = 0;
! 12967:
! 12968: xmlParserErrors ret = XML_ERR_OK;
! 12969:
! 12970: /*
! 12971: * check all input parameters, grab the document
! 12972: */
! 12973: if ((lst == NULL) || (node == NULL) || (data == NULL) || (datalen < 0))
! 12974: return(XML_ERR_INTERNAL_ERROR);
! 12975: switch (node->type) {
! 12976: case XML_ELEMENT_NODE:
! 12977: case XML_ATTRIBUTE_NODE:
! 12978: case XML_TEXT_NODE:
! 12979: case XML_CDATA_SECTION_NODE:
! 12980: case XML_ENTITY_REF_NODE:
! 12981: case XML_PI_NODE:
! 12982: case XML_COMMENT_NODE:
! 12983: case XML_DOCUMENT_NODE:
! 12984: case XML_HTML_DOCUMENT_NODE:
! 12985: break;
! 12986: default:
! 12987: return(XML_ERR_INTERNAL_ERROR);
! 12988:
! 12989: }
! 12990: while ((node != NULL) && (node->type != XML_ELEMENT_NODE) &&
! 12991: (node->type != XML_DOCUMENT_NODE) &&
! 12992: (node->type != XML_HTML_DOCUMENT_NODE))
! 12993: node = node->parent;
! 12994: if (node == NULL)
! 12995: return(XML_ERR_INTERNAL_ERROR);
! 12996: if (node->type == XML_ELEMENT_NODE)
! 12997: doc = node->doc;
! 12998: else
! 12999: doc = (xmlDocPtr) node;
! 13000: if (doc == NULL)
! 13001: return(XML_ERR_INTERNAL_ERROR);
! 13002:
! 13003: /*
! 13004: * allocate a context and set-up everything not related to the
! 13005: * node position in the tree
! 13006: */
! 13007: if (doc->type == XML_DOCUMENT_NODE)
! 13008: ctxt = xmlCreateMemoryParserCtxt((char *) data, datalen);
! 13009: #ifdef LIBXML_HTML_ENABLED
! 13010: else if (doc->type == XML_HTML_DOCUMENT_NODE) {
! 13011: ctxt = htmlCreateMemoryParserCtxt((char *) data, datalen);
! 13012: /*
! 13013: * When parsing in context, it makes no sense to add implied
! 13014: * elements like html/body/etc...
! 13015: */
! 13016: options |= HTML_PARSE_NOIMPLIED;
! 13017: }
! 13018: #endif
! 13019: else
! 13020: return(XML_ERR_INTERNAL_ERROR);
! 13021:
! 13022: if (ctxt == NULL)
! 13023: return(XML_ERR_NO_MEMORY);
! 13024:
! 13025: /*
! 13026: * Use input doc's dict if present, else assure XML_PARSE_NODICT is set.
! 13027: * We need a dictionary for xmlDetectSAX2, so if there's no doc dict
! 13028: * we must wait until the last moment to free the original one.
! 13029: */
! 13030: if (doc->dict != NULL) {
! 13031: if (ctxt->dict != NULL)
! 13032: xmlDictFree(ctxt->dict);
! 13033: ctxt->dict = doc->dict;
! 13034: } else
! 13035: options |= XML_PARSE_NODICT;
! 13036:
! 13037: if (doc->encoding != NULL) {
! 13038: xmlCharEncodingHandlerPtr hdlr;
! 13039:
! 13040: if (ctxt->encoding != NULL)
! 13041: xmlFree((xmlChar *) ctxt->encoding);
! 13042: ctxt->encoding = xmlStrdup((const xmlChar *) doc->encoding);
! 13043:
! 13044: hdlr = xmlFindCharEncodingHandler(doc->encoding);
! 13045: if (hdlr != NULL) {
! 13046: xmlSwitchToEncoding(ctxt, hdlr);
! 13047: } else {
! 13048: return(XML_ERR_UNSUPPORTED_ENCODING);
! 13049: }
! 13050: }
! 13051:
! 13052: xmlCtxtUseOptionsInternal(ctxt, options, NULL);
! 13053: xmlDetectSAX2(ctxt);
! 13054: ctxt->myDoc = doc;
! 13055:
! 13056: fake = xmlNewComment(NULL);
! 13057: if (fake == NULL) {
! 13058: xmlFreeParserCtxt(ctxt);
! 13059: return(XML_ERR_NO_MEMORY);
! 13060: }
! 13061: xmlAddChild(node, fake);
! 13062:
! 13063: if (node->type == XML_ELEMENT_NODE) {
! 13064: nodePush(ctxt, node);
! 13065: /*
! 13066: * initialize the SAX2 namespaces stack
! 13067: */
! 13068: cur = node;
! 13069: while ((cur != NULL) && (cur->type == XML_ELEMENT_NODE)) {
! 13070: xmlNsPtr ns = cur->nsDef;
! 13071: const xmlChar *iprefix, *ihref;
! 13072:
! 13073: while (ns != NULL) {
! 13074: if (ctxt->dict) {
! 13075: iprefix = xmlDictLookup(ctxt->dict, ns->prefix, -1);
! 13076: ihref = xmlDictLookup(ctxt->dict, ns->href, -1);
! 13077: } else {
! 13078: iprefix = ns->prefix;
! 13079: ihref = ns->href;
! 13080: }
! 13081:
! 13082: if (xmlGetNamespace(ctxt, iprefix) == NULL) {
! 13083: nsPush(ctxt, iprefix, ihref);
! 13084: nsnr++;
! 13085: }
! 13086: ns = ns->next;
! 13087: }
! 13088: cur = cur->parent;
! 13089: }
! 13090: ctxt->instate = XML_PARSER_CONTENT;
! 13091: }
! 13092:
! 13093: if ((ctxt->validate) || (ctxt->replaceEntities != 0)) {
! 13094: /*
! 13095: * ID/IDREF registration will be done in xmlValidateElement below
! 13096: */
! 13097: ctxt->loadsubset |= XML_SKIP_IDS;
! 13098: }
! 13099:
! 13100: #ifdef LIBXML_HTML_ENABLED
! 13101: if (doc->type == XML_HTML_DOCUMENT_NODE)
! 13102: __htmlParseContent(ctxt);
! 13103: else
! 13104: #endif
! 13105: xmlParseContent(ctxt);
! 13106:
! 13107: nsPop(ctxt, nsnr);
! 13108: if ((RAW == '<') && (NXT(1) == '/')) {
! 13109: xmlFatalErr(ctxt, XML_ERR_NOT_WELL_BALANCED, NULL);
! 13110: } else if (RAW != 0) {
! 13111: xmlFatalErr(ctxt, XML_ERR_EXTRA_CONTENT, NULL);
! 13112: }
! 13113: if ((ctxt->node != NULL) && (ctxt->node != node)) {
! 13114: xmlFatalErr(ctxt, XML_ERR_NOT_WELL_BALANCED, NULL);
! 13115: ctxt->wellFormed = 0;
! 13116: }
! 13117:
! 13118: if (!ctxt->wellFormed) {
! 13119: if (ctxt->errNo == 0)
! 13120: ret = XML_ERR_INTERNAL_ERROR;
! 13121: else
! 13122: ret = (xmlParserErrors)ctxt->errNo;
! 13123: } else {
! 13124: ret = XML_ERR_OK;
! 13125: }
! 13126:
! 13127: /*
! 13128: * Return the newly created nodeset after unlinking it from
! 13129: * the pseudo sibling.
! 13130: */
! 13131:
! 13132: cur = fake->next;
! 13133: fake->next = NULL;
! 13134: node->last = fake;
! 13135:
! 13136: if (cur != NULL) {
! 13137: cur->prev = NULL;
! 13138: }
! 13139:
! 13140: *lst = cur;
! 13141:
! 13142: while (cur != NULL) {
! 13143: cur->parent = NULL;
! 13144: cur = cur->next;
! 13145: }
! 13146:
! 13147: xmlUnlinkNode(fake);
! 13148: xmlFreeNode(fake);
! 13149:
! 13150:
! 13151: if (ret != XML_ERR_OK) {
! 13152: xmlFreeNodeList(*lst);
! 13153: *lst = NULL;
! 13154: }
! 13155:
! 13156: if (doc->dict != NULL)
! 13157: ctxt->dict = NULL;
! 13158: xmlFreeParserCtxt(ctxt);
! 13159:
! 13160: return(ret);
! 13161: #else /* !SAX2 */
! 13162: return(XML_ERR_INTERNAL_ERROR);
! 13163: #endif
! 13164: }
! 13165:
! 13166: #ifdef LIBXML_SAX1_ENABLED
! 13167: /**
! 13168: * xmlParseBalancedChunkMemoryRecover:
! 13169: * @doc: the document the chunk pertains to
! 13170: * @sax: the SAX handler bloc (possibly NULL)
! 13171: * @user_data: The user data returned on SAX callbacks (possibly NULL)
! 13172: * @depth: Used for loop detection, use 0
! 13173: * @string: the input string in UTF8 or ISO-Latin (zero terminated)
! 13174: * @lst: the return value for the set of parsed nodes
! 13175: * @recover: return nodes even if the data is broken (use 0)
! 13176: *
! 13177: *
! 13178: * Parse a well-balanced chunk of an XML document
! 13179: * called by the parser
! 13180: * The allowed sequence for the Well Balanced Chunk is the one defined by
! 13181: * the content production in the XML grammar:
! 13182: *
! 13183: * [43] content ::= (element | CharData | Reference | CDSect | PI | Comment)*
! 13184: *
! 13185: * Returns 0 if the chunk is well balanced, -1 in case of args problem and
! 13186: * the parser error code otherwise
! 13187: *
! 13188: * In case recover is set to 1, the nodelist will not be empty even if
! 13189: * the parsed chunk is not well balanced, assuming the parsing succeeded to
! 13190: * some extent.
! 13191: */
! 13192: int
! 13193: xmlParseBalancedChunkMemoryRecover(xmlDocPtr doc, xmlSAXHandlerPtr sax,
! 13194: void *user_data, int depth, const xmlChar *string, xmlNodePtr *lst,
! 13195: int recover) {
! 13196: xmlParserCtxtPtr ctxt;
! 13197: xmlDocPtr newDoc;
! 13198: xmlSAXHandlerPtr oldsax = NULL;
! 13199: xmlNodePtr content, newRoot;
! 13200: int size;
! 13201: int ret = 0;
! 13202:
! 13203: if (depth > 40) {
! 13204: return(XML_ERR_ENTITY_LOOP);
! 13205: }
! 13206:
! 13207:
! 13208: if (lst != NULL)
! 13209: *lst = NULL;
! 13210: if (string == NULL)
! 13211: return(-1);
! 13212:
! 13213: size = xmlStrlen(string);
! 13214:
! 13215: ctxt = xmlCreateMemoryParserCtxt((char *) string, size);
! 13216: if (ctxt == NULL) return(-1);
! 13217: ctxt->userData = ctxt;
! 13218: if (sax != NULL) {
! 13219: oldsax = ctxt->sax;
! 13220: ctxt->sax = sax;
! 13221: if (user_data != NULL)
! 13222: ctxt->userData = user_data;
! 13223: }
! 13224: newDoc = xmlNewDoc(BAD_CAST "1.0");
! 13225: if (newDoc == NULL) {
! 13226: xmlFreeParserCtxt(ctxt);
! 13227: return(-1);
! 13228: }
! 13229: newDoc->properties = XML_DOC_INTERNAL;
! 13230: if ((doc != NULL) && (doc->dict != NULL)) {
! 13231: xmlDictFree(ctxt->dict);
! 13232: ctxt->dict = doc->dict;
! 13233: xmlDictReference(ctxt->dict);
! 13234: ctxt->str_xml = xmlDictLookup(ctxt->dict, BAD_CAST "xml", 3);
! 13235: ctxt->str_xmlns = xmlDictLookup(ctxt->dict, BAD_CAST "xmlns", 5);
! 13236: ctxt->str_xml_ns = xmlDictLookup(ctxt->dict, XML_XML_NAMESPACE, 36);
! 13237: ctxt->dictNames = 1;
! 13238: } else {
! 13239: xmlCtxtUseOptionsInternal(ctxt, XML_PARSE_NODICT, NULL);
! 13240: }
! 13241: if (doc != NULL) {
! 13242: newDoc->intSubset = doc->intSubset;
! 13243: newDoc->extSubset = doc->extSubset;
! 13244: }
! 13245: newRoot = xmlNewDocNode(newDoc, NULL, BAD_CAST "pseudoroot", NULL);
! 13246: if (newRoot == NULL) {
! 13247: if (sax != NULL)
! 13248: ctxt->sax = oldsax;
! 13249: xmlFreeParserCtxt(ctxt);
! 13250: newDoc->intSubset = NULL;
! 13251: newDoc->extSubset = NULL;
! 13252: xmlFreeDoc(newDoc);
! 13253: return(-1);
! 13254: }
! 13255: xmlAddChild((xmlNodePtr) newDoc, newRoot);
! 13256: nodePush(ctxt, newRoot);
! 13257: if (doc == NULL) {
! 13258: ctxt->myDoc = newDoc;
! 13259: } else {
! 13260: ctxt->myDoc = newDoc;
! 13261: newDoc->children->doc = doc;
! 13262: /* Ensure that doc has XML spec namespace */
! 13263: xmlSearchNsByHref(doc, (xmlNodePtr)doc, XML_XML_NAMESPACE);
! 13264: newDoc->oldNs = doc->oldNs;
! 13265: }
! 13266: ctxt->instate = XML_PARSER_CONTENT;
! 13267: ctxt->depth = depth;
! 13268:
! 13269: /*
! 13270: * Doing validity checking on chunk doesn't make sense
! 13271: */
! 13272: ctxt->validate = 0;
! 13273: ctxt->loadsubset = 0;
! 13274: xmlDetectSAX2(ctxt);
! 13275:
! 13276: if ( doc != NULL ){
! 13277: content = doc->children;
! 13278: doc->children = NULL;
! 13279: xmlParseContent(ctxt);
! 13280: doc->children = content;
! 13281: }
! 13282: else {
! 13283: xmlParseContent(ctxt);
! 13284: }
! 13285: if ((RAW == '<') && (NXT(1) == '/')) {
! 13286: xmlFatalErr(ctxt, XML_ERR_NOT_WELL_BALANCED, NULL);
! 13287: } else if (RAW != 0) {
! 13288: xmlFatalErr(ctxt, XML_ERR_EXTRA_CONTENT, NULL);
! 13289: }
! 13290: if (ctxt->node != newDoc->children) {
! 13291: xmlFatalErr(ctxt, XML_ERR_NOT_WELL_BALANCED, NULL);
! 13292: }
! 13293:
! 13294: if (!ctxt->wellFormed) {
! 13295: if (ctxt->errNo == 0)
! 13296: ret = 1;
! 13297: else
! 13298: ret = ctxt->errNo;
! 13299: } else {
! 13300: ret = 0;
! 13301: }
! 13302:
! 13303: if ((lst != NULL) && ((ret == 0) || (recover == 1))) {
! 13304: xmlNodePtr cur;
! 13305:
! 13306: /*
! 13307: * Return the newly created nodeset after unlinking it from
! 13308: * they pseudo parent.
! 13309: */
! 13310: cur = newDoc->children->children;
! 13311: *lst = cur;
! 13312: while (cur != NULL) {
! 13313: xmlSetTreeDoc(cur, doc);
! 13314: cur->parent = NULL;
! 13315: cur = cur->next;
! 13316: }
! 13317: newDoc->children->children = NULL;
! 13318: }
! 13319:
! 13320: if (sax != NULL)
! 13321: ctxt->sax = oldsax;
! 13322: xmlFreeParserCtxt(ctxt);
! 13323: newDoc->intSubset = NULL;
! 13324: newDoc->extSubset = NULL;
! 13325: newDoc->oldNs = NULL;
! 13326: xmlFreeDoc(newDoc);
! 13327:
! 13328: return(ret);
! 13329: }
! 13330:
! 13331: /**
! 13332: * xmlSAXParseEntity:
! 13333: * @sax: the SAX handler block
! 13334: * @filename: the filename
! 13335: *
! 13336: * parse an XML external entity out of context and build a tree.
! 13337: * It use the given SAX function block to handle the parsing callback.
! 13338: * If sax is NULL, fallback to the default DOM tree building routines.
! 13339: *
! 13340: * [78] extParsedEnt ::= TextDecl? content
! 13341: *
! 13342: * This correspond to a "Well Balanced" chunk
! 13343: *
! 13344: * Returns the resulting document tree
! 13345: */
! 13346:
! 13347: xmlDocPtr
! 13348: xmlSAXParseEntity(xmlSAXHandlerPtr sax, const char *filename) {
! 13349: xmlDocPtr ret;
! 13350: xmlParserCtxtPtr ctxt;
! 13351:
! 13352: ctxt = xmlCreateFileParserCtxt(filename);
! 13353: if (ctxt == NULL) {
! 13354: return(NULL);
! 13355: }
! 13356: if (sax != NULL) {
! 13357: if (ctxt->sax != NULL)
! 13358: xmlFree(ctxt->sax);
! 13359: ctxt->sax = sax;
! 13360: ctxt->userData = NULL;
! 13361: }
! 13362:
! 13363: xmlParseExtParsedEnt(ctxt);
! 13364:
! 13365: if (ctxt->wellFormed)
! 13366: ret = ctxt->myDoc;
! 13367: else {
! 13368: ret = NULL;
! 13369: xmlFreeDoc(ctxt->myDoc);
! 13370: ctxt->myDoc = NULL;
! 13371: }
! 13372: if (sax != NULL)
! 13373: ctxt->sax = NULL;
! 13374: xmlFreeParserCtxt(ctxt);
! 13375:
! 13376: return(ret);
! 13377: }
! 13378:
! 13379: /**
! 13380: * xmlParseEntity:
! 13381: * @filename: the filename
! 13382: *
! 13383: * parse an XML external entity out of context and build a tree.
! 13384: *
! 13385: * [78] extParsedEnt ::= TextDecl? content
! 13386: *
! 13387: * This correspond to a "Well Balanced" chunk
! 13388: *
! 13389: * Returns the resulting document tree
! 13390: */
! 13391:
! 13392: xmlDocPtr
! 13393: xmlParseEntity(const char *filename) {
! 13394: return(xmlSAXParseEntity(NULL, filename));
! 13395: }
! 13396: #endif /* LIBXML_SAX1_ENABLED */
! 13397:
! 13398: /**
! 13399: * xmlCreateEntityParserCtxtInternal:
! 13400: * @URL: the entity URL
! 13401: * @ID: the entity PUBLIC ID
! 13402: * @base: a possible base for the target URI
! 13403: * @pctx: parser context used to set options on new context
! 13404: *
! 13405: * Create a parser context for an external entity
! 13406: * Automatic support for ZLIB/Compress compressed document is provided
! 13407: * by default if found at compile-time.
! 13408: *
! 13409: * Returns the new parser context or NULL
! 13410: */
! 13411: static xmlParserCtxtPtr
! 13412: xmlCreateEntityParserCtxtInternal(const xmlChar *URL, const xmlChar *ID,
! 13413: const xmlChar *base, xmlParserCtxtPtr pctx) {
! 13414: xmlParserCtxtPtr ctxt;
! 13415: xmlParserInputPtr inputStream;
! 13416: char *directory = NULL;
! 13417: xmlChar *uri;
! 13418:
! 13419: ctxt = xmlNewParserCtxt();
! 13420: if (ctxt == NULL) {
! 13421: return(NULL);
! 13422: }
! 13423:
! 13424: if (pctx != NULL) {
! 13425: ctxt->options = pctx->options;
! 13426: ctxt->_private = pctx->_private;
! 13427: }
! 13428:
! 13429: uri = xmlBuildURI(URL, base);
! 13430:
! 13431: if (uri == NULL) {
! 13432: inputStream = xmlLoadExternalEntity((char *)URL, (char *)ID, ctxt);
! 13433: if (inputStream == NULL) {
! 13434: xmlFreeParserCtxt(ctxt);
! 13435: return(NULL);
! 13436: }
! 13437:
! 13438: inputPush(ctxt, inputStream);
! 13439:
! 13440: if ((ctxt->directory == NULL) && (directory == NULL))
! 13441: directory = xmlParserGetDirectory((char *)URL);
! 13442: if ((ctxt->directory == NULL) && (directory != NULL))
! 13443: ctxt->directory = directory;
! 13444: } else {
! 13445: inputStream = xmlLoadExternalEntity((char *)uri, (char *)ID, ctxt);
! 13446: if (inputStream == NULL) {
! 13447: xmlFree(uri);
! 13448: xmlFreeParserCtxt(ctxt);
! 13449: return(NULL);
! 13450: }
! 13451:
! 13452: inputPush(ctxt, inputStream);
! 13453:
! 13454: if ((ctxt->directory == NULL) && (directory == NULL))
! 13455: directory = xmlParserGetDirectory((char *)uri);
! 13456: if ((ctxt->directory == NULL) && (directory != NULL))
! 13457: ctxt->directory = directory;
! 13458: xmlFree(uri);
! 13459: }
! 13460: return(ctxt);
! 13461: }
! 13462:
! 13463: /**
! 13464: * xmlCreateEntityParserCtxt:
! 13465: * @URL: the entity URL
! 13466: * @ID: the entity PUBLIC ID
! 13467: * @base: a possible base for the target URI
! 13468: *
! 13469: * Create a parser context for an external entity
! 13470: * Automatic support for ZLIB/Compress compressed document is provided
! 13471: * by default if found at compile-time.
! 13472: *
! 13473: * Returns the new parser context or NULL
! 13474: */
! 13475: xmlParserCtxtPtr
! 13476: xmlCreateEntityParserCtxt(const xmlChar *URL, const xmlChar *ID,
! 13477: const xmlChar *base) {
! 13478: return xmlCreateEntityParserCtxtInternal(URL, ID, base, NULL);
! 13479:
! 13480: }
! 13481:
! 13482: /************************************************************************
! 13483: * *
! 13484: * Front ends when parsing from a file *
! 13485: * *
! 13486: ************************************************************************/
! 13487:
! 13488: /**
! 13489: * xmlCreateURLParserCtxt:
! 13490: * @filename: the filename or URL
! 13491: * @options: a combination of xmlParserOption
! 13492: *
! 13493: * Create a parser context for a file or URL content.
! 13494: * Automatic support for ZLIB/Compress compressed document is provided
! 13495: * by default if found at compile-time and for file accesses
! 13496: *
! 13497: * Returns the new parser context or NULL
! 13498: */
! 13499: xmlParserCtxtPtr
! 13500: xmlCreateURLParserCtxt(const char *filename, int options)
! 13501: {
! 13502: xmlParserCtxtPtr ctxt;
! 13503: xmlParserInputPtr inputStream;
! 13504: char *directory = NULL;
! 13505:
! 13506: ctxt = xmlNewParserCtxt();
! 13507: if (ctxt == NULL) {
! 13508: xmlErrMemory(NULL, "cannot allocate parser context");
! 13509: return(NULL);
! 13510: }
! 13511:
! 13512: if (options)
! 13513: xmlCtxtUseOptionsInternal(ctxt, options, NULL);
! 13514: ctxt->linenumbers = 1;
! 13515:
! 13516: inputStream = xmlLoadExternalEntity(filename, NULL, ctxt);
! 13517: if (inputStream == NULL) {
! 13518: xmlFreeParserCtxt(ctxt);
! 13519: return(NULL);
! 13520: }
! 13521:
! 13522: inputPush(ctxt, inputStream);
! 13523: if ((ctxt->directory == NULL) && (directory == NULL))
! 13524: directory = xmlParserGetDirectory(filename);
! 13525: if ((ctxt->directory == NULL) && (directory != NULL))
! 13526: ctxt->directory = directory;
! 13527:
! 13528: return(ctxt);
! 13529: }
! 13530:
! 13531: /**
! 13532: * xmlCreateFileParserCtxt:
! 13533: * @filename: the filename
! 13534: *
! 13535: * Create a parser context for a file content.
! 13536: * Automatic support for ZLIB/Compress compressed document is provided
! 13537: * by default if found at compile-time.
! 13538: *
! 13539: * Returns the new parser context or NULL
! 13540: */
! 13541: xmlParserCtxtPtr
! 13542: xmlCreateFileParserCtxt(const char *filename)
! 13543: {
! 13544: return(xmlCreateURLParserCtxt(filename, 0));
! 13545: }
! 13546:
! 13547: #ifdef LIBXML_SAX1_ENABLED
! 13548: /**
! 13549: * xmlSAXParseFileWithData:
! 13550: * @sax: the SAX handler block
! 13551: * @filename: the filename
! 13552: * @recovery: work in recovery mode, i.e. tries to read no Well Formed
! 13553: * documents
! 13554: * @data: the userdata
! 13555: *
! 13556: * parse an XML file and build a tree. Automatic support for ZLIB/Compress
! 13557: * compressed document is provided by default if found at compile-time.
! 13558: * It use the given SAX function block to handle the parsing callback.
! 13559: * If sax is NULL, fallback to the default DOM tree building routines.
! 13560: *
! 13561: * User data (void *) is stored within the parser context in the
! 13562: * context's _private member, so it is available nearly everywhere in libxml
! 13563: *
! 13564: * Returns the resulting document tree
! 13565: */
! 13566:
! 13567: xmlDocPtr
! 13568: xmlSAXParseFileWithData(xmlSAXHandlerPtr sax, const char *filename,
! 13569: int recovery, void *data) {
! 13570: xmlDocPtr ret;
! 13571: xmlParserCtxtPtr ctxt;
! 13572:
! 13573: xmlInitParser();
! 13574:
! 13575: ctxt = xmlCreateFileParserCtxt(filename);
! 13576: if (ctxt == NULL) {
! 13577: return(NULL);
! 13578: }
! 13579: if (sax != NULL) {
! 13580: if (ctxt->sax != NULL)
! 13581: xmlFree(ctxt->sax);
! 13582: ctxt->sax = sax;
! 13583: }
! 13584: xmlDetectSAX2(ctxt);
! 13585: if (data!=NULL) {
! 13586: ctxt->_private = data;
! 13587: }
! 13588:
! 13589: if (ctxt->directory == NULL)
! 13590: ctxt->directory = xmlParserGetDirectory(filename);
! 13591:
! 13592: ctxt->recovery = recovery;
! 13593:
! 13594: xmlParseDocument(ctxt);
! 13595:
! 13596: if ((ctxt->wellFormed) || recovery) {
! 13597: ret = ctxt->myDoc;
! 13598: if (ret != NULL) {
! 13599: if (ctxt->input->buf->compressed > 0)
! 13600: ret->compression = 9;
! 13601: else
! 13602: ret->compression = ctxt->input->buf->compressed;
! 13603: }
! 13604: }
! 13605: else {
! 13606: ret = NULL;
! 13607: xmlFreeDoc(ctxt->myDoc);
! 13608: ctxt->myDoc = NULL;
! 13609: }
! 13610: if (sax != NULL)
! 13611: ctxt->sax = NULL;
! 13612: xmlFreeParserCtxt(ctxt);
! 13613:
! 13614: return(ret);
! 13615: }
! 13616:
! 13617: /**
! 13618: * xmlSAXParseFile:
! 13619: * @sax: the SAX handler block
! 13620: * @filename: the filename
! 13621: * @recovery: work in recovery mode, i.e. tries to read no Well Formed
! 13622: * documents
! 13623: *
! 13624: * parse an XML file and build a tree. Automatic support for ZLIB/Compress
! 13625: * compressed document is provided by default if found at compile-time.
! 13626: * It use the given SAX function block to handle the parsing callback.
! 13627: * If sax is NULL, fallback to the default DOM tree building routines.
! 13628: *
! 13629: * Returns the resulting document tree
! 13630: */
! 13631:
! 13632: xmlDocPtr
! 13633: xmlSAXParseFile(xmlSAXHandlerPtr sax, const char *filename,
! 13634: int recovery) {
! 13635: return(xmlSAXParseFileWithData(sax,filename,recovery,NULL));
! 13636: }
! 13637:
! 13638: /**
! 13639: * xmlRecoverDoc:
! 13640: * @cur: a pointer to an array of xmlChar
! 13641: *
! 13642: * parse an XML in-memory document and build a tree.
! 13643: * In the case the document is not Well Formed, a attempt to build a
! 13644: * tree is tried anyway
! 13645: *
! 13646: * Returns the resulting document tree or NULL in case of failure
! 13647: */
! 13648:
! 13649: xmlDocPtr
! 13650: xmlRecoverDoc(const xmlChar *cur) {
! 13651: return(xmlSAXParseDoc(NULL, cur, 1));
! 13652: }
! 13653:
! 13654: /**
! 13655: * xmlParseFile:
! 13656: * @filename: the filename
! 13657: *
! 13658: * parse an XML file and build a tree. Automatic support for ZLIB/Compress
! 13659: * compressed document is provided by default if found at compile-time.
! 13660: *
! 13661: * Returns the resulting document tree if the file was wellformed,
! 13662: * NULL otherwise.
! 13663: */
! 13664:
! 13665: xmlDocPtr
! 13666: xmlParseFile(const char *filename) {
! 13667: return(xmlSAXParseFile(NULL, filename, 0));
! 13668: }
! 13669:
! 13670: /**
! 13671: * xmlRecoverFile:
! 13672: * @filename: the filename
! 13673: *
! 13674: * parse an XML file and build a tree. Automatic support for ZLIB/Compress
! 13675: * compressed document is provided by default if found at compile-time.
! 13676: * In the case the document is not Well Formed, it attempts to build
! 13677: * a tree anyway
! 13678: *
! 13679: * Returns the resulting document tree or NULL in case of failure
! 13680: */
! 13681:
! 13682: xmlDocPtr
! 13683: xmlRecoverFile(const char *filename) {
! 13684: return(xmlSAXParseFile(NULL, filename, 1));
! 13685: }
! 13686:
! 13687:
! 13688: /**
! 13689: * xmlSetupParserForBuffer:
! 13690: * @ctxt: an XML parser context
! 13691: * @buffer: a xmlChar * buffer
! 13692: * @filename: a file name
! 13693: *
! 13694: * Setup the parser context to parse a new buffer; Clears any prior
! 13695: * contents from the parser context. The buffer parameter must not be
! 13696: * NULL, but the filename parameter can be
! 13697: */
! 13698: void
! 13699: xmlSetupParserForBuffer(xmlParserCtxtPtr ctxt, const xmlChar* buffer,
! 13700: const char* filename)
! 13701: {
! 13702: xmlParserInputPtr input;
! 13703:
! 13704: if ((ctxt == NULL) || (buffer == NULL))
! 13705: return;
! 13706:
! 13707: input = xmlNewInputStream(ctxt);
! 13708: if (input == NULL) {
! 13709: xmlErrMemory(NULL, "parsing new buffer: out of memory\n");
! 13710: xmlClearParserCtxt(ctxt);
! 13711: return;
! 13712: }
! 13713:
! 13714: xmlClearParserCtxt(ctxt);
! 13715: if (filename != NULL)
! 13716: input->filename = (char *) xmlCanonicPath((const xmlChar *)filename);
! 13717: input->base = buffer;
! 13718: input->cur = buffer;
! 13719: input->end = &buffer[xmlStrlen(buffer)];
! 13720: inputPush(ctxt, input);
! 13721: }
! 13722:
! 13723: /**
! 13724: * xmlSAXUserParseFile:
! 13725: * @sax: a SAX handler
! 13726: * @user_data: The user data returned on SAX callbacks
! 13727: * @filename: a file name
! 13728: *
! 13729: * parse an XML file and call the given SAX handler routines.
! 13730: * Automatic support for ZLIB/Compress compressed document is provided
! 13731: *
! 13732: * Returns 0 in case of success or a error number otherwise
! 13733: */
! 13734: int
! 13735: xmlSAXUserParseFile(xmlSAXHandlerPtr sax, void *user_data,
! 13736: const char *filename) {
! 13737: int ret = 0;
! 13738: xmlParserCtxtPtr ctxt;
! 13739:
! 13740: ctxt = xmlCreateFileParserCtxt(filename);
! 13741: if (ctxt == NULL) return -1;
! 13742: if (ctxt->sax != (xmlSAXHandlerPtr) &xmlDefaultSAXHandler)
! 13743: xmlFree(ctxt->sax);
! 13744: ctxt->sax = sax;
! 13745: xmlDetectSAX2(ctxt);
! 13746:
! 13747: if (user_data != NULL)
! 13748: ctxt->userData = user_data;
! 13749:
! 13750: xmlParseDocument(ctxt);
! 13751:
! 13752: if (ctxt->wellFormed)
! 13753: ret = 0;
! 13754: else {
! 13755: if (ctxt->errNo != 0)
! 13756: ret = ctxt->errNo;
! 13757: else
! 13758: ret = -1;
! 13759: }
! 13760: if (sax != NULL)
! 13761: ctxt->sax = NULL;
! 13762: if (ctxt->myDoc != NULL) {
! 13763: xmlFreeDoc(ctxt->myDoc);
! 13764: ctxt->myDoc = NULL;
! 13765: }
! 13766: xmlFreeParserCtxt(ctxt);
! 13767:
! 13768: return ret;
! 13769: }
! 13770: #endif /* LIBXML_SAX1_ENABLED */
! 13771:
! 13772: /************************************************************************
! 13773: * *
! 13774: * Front ends when parsing from memory *
! 13775: * *
! 13776: ************************************************************************/
! 13777:
! 13778: /**
! 13779: * xmlCreateMemoryParserCtxt:
! 13780: * @buffer: a pointer to a char array
! 13781: * @size: the size of the array
! 13782: *
! 13783: * Create a parser context for an XML in-memory document.
! 13784: *
! 13785: * Returns the new parser context or NULL
! 13786: */
! 13787: xmlParserCtxtPtr
! 13788: xmlCreateMemoryParserCtxt(const char *buffer, int size) {
! 13789: xmlParserCtxtPtr ctxt;
! 13790: xmlParserInputPtr input;
! 13791: xmlParserInputBufferPtr buf;
! 13792:
! 13793: if (buffer == NULL)
! 13794: return(NULL);
! 13795: if (size <= 0)
! 13796: return(NULL);
! 13797:
! 13798: ctxt = xmlNewParserCtxt();
! 13799: if (ctxt == NULL)
! 13800: return(NULL);
! 13801:
! 13802: /* TODO: xmlParserInputBufferCreateStatic, requires some serious changes */
! 13803: buf = xmlParserInputBufferCreateMem(buffer, size, XML_CHAR_ENCODING_NONE);
! 13804: if (buf == NULL) {
! 13805: xmlFreeParserCtxt(ctxt);
! 13806: return(NULL);
! 13807: }
! 13808:
! 13809: input = xmlNewInputStream(ctxt);
! 13810: if (input == NULL) {
! 13811: xmlFreeParserInputBuffer(buf);
! 13812: xmlFreeParserCtxt(ctxt);
! 13813: return(NULL);
! 13814: }
! 13815:
! 13816: input->filename = NULL;
! 13817: input->buf = buf;
! 13818: input->base = input->buf->buffer->content;
! 13819: input->cur = input->buf->buffer->content;
! 13820: input->end = &input->buf->buffer->content[input->buf->buffer->use];
! 13821:
! 13822: inputPush(ctxt, input);
! 13823: return(ctxt);
! 13824: }
! 13825:
! 13826: #ifdef LIBXML_SAX1_ENABLED
! 13827: /**
! 13828: * xmlSAXParseMemoryWithData:
! 13829: * @sax: the SAX handler block
! 13830: * @buffer: an pointer to a char array
! 13831: * @size: the size of the array
! 13832: * @recovery: work in recovery mode, i.e. tries to read no Well Formed
! 13833: * documents
! 13834: * @data: the userdata
! 13835: *
! 13836: * parse an XML in-memory block and use the given SAX function block
! 13837: * to handle the parsing callback. If sax is NULL, fallback to the default
! 13838: * DOM tree building routines.
! 13839: *
! 13840: * User data (void *) is stored within the parser context in the
! 13841: * context's _private member, so it is available nearly everywhere in libxml
! 13842: *
! 13843: * Returns the resulting document tree
! 13844: */
! 13845:
! 13846: xmlDocPtr
! 13847: xmlSAXParseMemoryWithData(xmlSAXHandlerPtr sax, const char *buffer,
! 13848: int size, int recovery, void *data) {
! 13849: xmlDocPtr ret;
! 13850: xmlParserCtxtPtr ctxt;
! 13851:
! 13852: xmlInitParser();
! 13853:
! 13854: ctxt = xmlCreateMemoryParserCtxt(buffer, size);
! 13855: if (ctxt == NULL) return(NULL);
! 13856: if (sax != NULL) {
! 13857: if (ctxt->sax != NULL)
! 13858: xmlFree(ctxt->sax);
! 13859: ctxt->sax = sax;
! 13860: }
! 13861: xmlDetectSAX2(ctxt);
! 13862: if (data!=NULL) {
! 13863: ctxt->_private=data;
! 13864: }
! 13865:
! 13866: ctxt->recovery = recovery;
! 13867:
! 13868: xmlParseDocument(ctxt);
! 13869:
! 13870: if ((ctxt->wellFormed) || recovery) ret = ctxt->myDoc;
! 13871: else {
! 13872: ret = NULL;
! 13873: xmlFreeDoc(ctxt->myDoc);
! 13874: ctxt->myDoc = NULL;
! 13875: }
! 13876: if (sax != NULL)
! 13877: ctxt->sax = NULL;
! 13878: xmlFreeParserCtxt(ctxt);
! 13879:
! 13880: return(ret);
! 13881: }
! 13882:
! 13883: /**
! 13884: * xmlSAXParseMemory:
! 13885: * @sax: the SAX handler block
! 13886: * @buffer: an pointer to a char array
! 13887: * @size: the size of the array
! 13888: * @recovery: work in recovery mode, i.e. tries to read not Well Formed
! 13889: * documents
! 13890: *
! 13891: * parse an XML in-memory block and use the given SAX function block
! 13892: * to handle the parsing callback. If sax is NULL, fallback to the default
! 13893: * DOM tree building routines.
! 13894: *
! 13895: * Returns the resulting document tree
! 13896: */
! 13897: xmlDocPtr
! 13898: xmlSAXParseMemory(xmlSAXHandlerPtr sax, const char *buffer,
! 13899: int size, int recovery) {
! 13900: return xmlSAXParseMemoryWithData(sax, buffer, size, recovery, NULL);
! 13901: }
! 13902:
! 13903: /**
! 13904: * xmlParseMemory:
! 13905: * @buffer: an pointer to a char array
! 13906: * @size: the size of the array
! 13907: *
! 13908: * parse an XML in-memory block and build a tree.
! 13909: *
! 13910: * Returns the resulting document tree
! 13911: */
! 13912:
! 13913: xmlDocPtr xmlParseMemory(const char *buffer, int size) {
! 13914: return(xmlSAXParseMemory(NULL, buffer, size, 0));
! 13915: }
! 13916:
! 13917: /**
! 13918: * xmlRecoverMemory:
! 13919: * @buffer: an pointer to a char array
! 13920: * @size: the size of the array
! 13921: *
! 13922: * parse an XML in-memory block and build a tree.
! 13923: * In the case the document is not Well Formed, an attempt to
! 13924: * build a tree is tried anyway
! 13925: *
! 13926: * Returns the resulting document tree or NULL in case of error
! 13927: */
! 13928:
! 13929: xmlDocPtr xmlRecoverMemory(const char *buffer, int size) {
! 13930: return(xmlSAXParseMemory(NULL, buffer, size, 1));
! 13931: }
! 13932:
! 13933: /**
! 13934: * xmlSAXUserParseMemory:
! 13935: * @sax: a SAX handler
! 13936: * @user_data: The user data returned on SAX callbacks
! 13937: * @buffer: an in-memory XML document input
! 13938: * @size: the length of the XML document in bytes
! 13939: *
! 13940: * A better SAX parsing routine.
! 13941: * parse an XML in-memory buffer and call the given SAX handler routines.
! 13942: *
! 13943: * Returns 0 in case of success or a error number otherwise
! 13944: */
! 13945: int xmlSAXUserParseMemory(xmlSAXHandlerPtr sax, void *user_data,
! 13946: const char *buffer, int size) {
! 13947: int ret = 0;
! 13948: xmlParserCtxtPtr ctxt;
! 13949:
! 13950: xmlInitParser();
! 13951:
! 13952: ctxt = xmlCreateMemoryParserCtxt(buffer, size);
! 13953: if (ctxt == NULL) return -1;
! 13954: if (ctxt->sax != (xmlSAXHandlerPtr) &xmlDefaultSAXHandler)
! 13955: xmlFree(ctxt->sax);
! 13956: ctxt->sax = sax;
! 13957: xmlDetectSAX2(ctxt);
! 13958:
! 13959: if (user_data != NULL)
! 13960: ctxt->userData = user_data;
! 13961:
! 13962: xmlParseDocument(ctxt);
! 13963:
! 13964: if (ctxt->wellFormed)
! 13965: ret = 0;
! 13966: else {
! 13967: if (ctxt->errNo != 0)
! 13968: ret = ctxt->errNo;
! 13969: else
! 13970: ret = -1;
! 13971: }
! 13972: if (sax != NULL)
! 13973: ctxt->sax = NULL;
! 13974: if (ctxt->myDoc != NULL) {
! 13975: xmlFreeDoc(ctxt->myDoc);
! 13976: ctxt->myDoc = NULL;
! 13977: }
! 13978: xmlFreeParserCtxt(ctxt);
! 13979:
! 13980: return ret;
! 13981: }
! 13982: #endif /* LIBXML_SAX1_ENABLED */
! 13983:
! 13984: /**
! 13985: * xmlCreateDocParserCtxt:
! 13986: * @cur: a pointer to an array of xmlChar
! 13987: *
! 13988: * Creates a parser context for an XML in-memory document.
! 13989: *
! 13990: * Returns the new parser context or NULL
! 13991: */
! 13992: xmlParserCtxtPtr
! 13993: xmlCreateDocParserCtxt(const xmlChar *cur) {
! 13994: int len;
! 13995:
! 13996: if (cur == NULL)
! 13997: return(NULL);
! 13998: len = xmlStrlen(cur);
! 13999: return(xmlCreateMemoryParserCtxt((const char *)cur, len));
! 14000: }
! 14001:
! 14002: #ifdef LIBXML_SAX1_ENABLED
! 14003: /**
! 14004: * xmlSAXParseDoc:
! 14005: * @sax: the SAX handler block
! 14006: * @cur: a pointer to an array of xmlChar
! 14007: * @recovery: work in recovery mode, i.e. tries to read no Well Formed
! 14008: * documents
! 14009: *
! 14010: * parse an XML in-memory document and build a tree.
! 14011: * It use the given SAX function block to handle the parsing callback.
! 14012: * If sax is NULL, fallback to the default DOM tree building routines.
! 14013: *
! 14014: * Returns the resulting document tree
! 14015: */
! 14016:
! 14017: xmlDocPtr
! 14018: xmlSAXParseDoc(xmlSAXHandlerPtr sax, const xmlChar *cur, int recovery) {
! 14019: xmlDocPtr ret;
! 14020: xmlParserCtxtPtr ctxt;
! 14021: xmlSAXHandlerPtr oldsax = NULL;
! 14022:
! 14023: if (cur == NULL) return(NULL);
! 14024:
! 14025:
! 14026: ctxt = xmlCreateDocParserCtxt(cur);
! 14027: if (ctxt == NULL) return(NULL);
! 14028: if (sax != NULL) {
! 14029: oldsax = ctxt->sax;
! 14030: ctxt->sax = sax;
! 14031: ctxt->userData = NULL;
! 14032: }
! 14033: xmlDetectSAX2(ctxt);
! 14034:
! 14035: xmlParseDocument(ctxt);
! 14036: if ((ctxt->wellFormed) || recovery) ret = ctxt->myDoc;
! 14037: else {
! 14038: ret = NULL;
! 14039: xmlFreeDoc(ctxt->myDoc);
! 14040: ctxt->myDoc = NULL;
! 14041: }
! 14042: if (sax != NULL)
! 14043: ctxt->sax = oldsax;
! 14044: xmlFreeParserCtxt(ctxt);
! 14045:
! 14046: return(ret);
! 14047: }
! 14048:
! 14049: /**
! 14050: * xmlParseDoc:
! 14051: * @cur: a pointer to an array of xmlChar
! 14052: *
! 14053: * parse an XML in-memory document and build a tree.
! 14054: *
! 14055: * Returns the resulting document tree
! 14056: */
! 14057:
! 14058: xmlDocPtr
! 14059: xmlParseDoc(const xmlChar *cur) {
! 14060: return(xmlSAXParseDoc(NULL, cur, 0));
! 14061: }
! 14062: #endif /* LIBXML_SAX1_ENABLED */
! 14063:
! 14064: #ifdef LIBXML_LEGACY_ENABLED
! 14065: /************************************************************************
! 14066: * *
! 14067: * Specific function to keep track of entities references *
! 14068: * and used by the XSLT debugger *
! 14069: * *
! 14070: ************************************************************************/
! 14071:
! 14072: static xmlEntityReferenceFunc xmlEntityRefFunc = NULL;
! 14073:
! 14074: /**
! 14075: * xmlAddEntityReference:
! 14076: * @ent : A valid entity
! 14077: * @firstNode : A valid first node for children of entity
! 14078: * @lastNode : A valid last node of children entity
! 14079: *
! 14080: * Notify of a reference to an entity of type XML_EXTERNAL_GENERAL_PARSED_ENTITY
! 14081: */
! 14082: static void
! 14083: xmlAddEntityReference(xmlEntityPtr ent, xmlNodePtr firstNode,
! 14084: xmlNodePtr lastNode)
! 14085: {
! 14086: if (xmlEntityRefFunc != NULL) {
! 14087: (*xmlEntityRefFunc) (ent, firstNode, lastNode);
! 14088: }
! 14089: }
! 14090:
! 14091:
! 14092: /**
! 14093: * xmlSetEntityReferenceFunc:
! 14094: * @func: A valid function
! 14095: *
! 14096: * Set the function to call call back when a xml reference has been made
! 14097: */
! 14098: void
! 14099: xmlSetEntityReferenceFunc(xmlEntityReferenceFunc func)
! 14100: {
! 14101: xmlEntityRefFunc = func;
! 14102: }
! 14103: #endif /* LIBXML_LEGACY_ENABLED */
! 14104:
! 14105: /************************************************************************
! 14106: * *
! 14107: * Miscellaneous *
! 14108: * *
! 14109: ************************************************************************/
! 14110:
! 14111: #ifdef LIBXML_XPATH_ENABLED
! 14112: #include <libxml/xpath.h>
! 14113: #endif
! 14114:
! 14115: extern void XMLCDECL xmlGenericErrorDefaultFunc(void *ctx, const char *msg, ...);
! 14116: static int xmlParserInitialized = 0;
! 14117:
! 14118: /**
! 14119: * xmlInitParser:
! 14120: *
! 14121: * Initialization function for the XML parser.
! 14122: * This is not reentrant. Call once before processing in case of
! 14123: * use in multithreaded programs.
! 14124: */
! 14125:
! 14126: void
! 14127: xmlInitParser(void) {
! 14128: if (xmlParserInitialized != 0)
! 14129: return;
! 14130:
! 14131: #ifdef LIBXML_THREAD_ENABLED
! 14132: __xmlGlobalInitMutexLock();
! 14133: if (xmlParserInitialized == 0) {
! 14134: #endif
! 14135: xmlInitThreads();
! 14136: xmlInitGlobals();
! 14137: if ((xmlGenericError == xmlGenericErrorDefaultFunc) ||
! 14138: (xmlGenericError == NULL))
! 14139: initGenericErrorDefaultFunc(NULL);
! 14140: xmlInitMemory();
! 14141: xmlInitCharEncodingHandlers();
! 14142: xmlDefaultSAXHandlerInit();
! 14143: xmlRegisterDefaultInputCallbacks();
! 14144: #ifdef LIBXML_OUTPUT_ENABLED
! 14145: xmlRegisterDefaultOutputCallbacks();
! 14146: #endif /* LIBXML_OUTPUT_ENABLED */
! 14147: #ifdef LIBXML_HTML_ENABLED
! 14148: htmlInitAutoClose();
! 14149: htmlDefaultSAXHandlerInit();
! 14150: #endif
! 14151: #ifdef LIBXML_XPATH_ENABLED
! 14152: xmlXPathInit();
! 14153: #endif
! 14154: xmlParserInitialized = 1;
! 14155: #ifdef LIBXML_THREAD_ENABLED
! 14156: }
! 14157: __xmlGlobalInitMutexUnlock();
! 14158: #endif
! 14159: }
! 14160:
! 14161: /**
! 14162: * xmlCleanupParser:
! 14163: *
! 14164: * This function name is somewhat misleading. It does not clean up
! 14165: * parser state, it cleans up memory allocated by the library itself.
! 14166: * It is a cleanup function for the XML library. It tries to reclaim all
! 14167: * related global memory allocated for the library processing.
! 14168: * It doesn't deallocate any document related memory. One should
! 14169: * call xmlCleanupParser() only when the process has finished using
! 14170: * the library and all XML/HTML documents built with it.
! 14171: * See also xmlInitParser() which has the opposite function of preparing
! 14172: * the library for operations.
! 14173: *
! 14174: * WARNING: if your application is multithreaded or has plugin support
! 14175: * calling this may crash the application if another thread or
! 14176: * a plugin is still using libxml2. It's sometimes very hard to
! 14177: * guess if libxml2 is in use in the application, some libraries
! 14178: * or plugins may use it without notice. In case of doubt abstain
! 14179: * from calling this function or do it just before calling exit()
! 14180: * to avoid leak reports from valgrind !
! 14181: */
! 14182:
! 14183: void
! 14184: xmlCleanupParser(void) {
! 14185: if (!xmlParserInitialized)
! 14186: return;
! 14187:
! 14188: xmlCleanupCharEncodingHandlers();
! 14189: #ifdef LIBXML_CATALOG_ENABLED
! 14190: xmlCatalogCleanup();
! 14191: #endif
! 14192: xmlDictCleanup();
! 14193: xmlCleanupInputCallbacks();
! 14194: #ifdef LIBXML_OUTPUT_ENABLED
! 14195: xmlCleanupOutputCallbacks();
! 14196: #endif
! 14197: #ifdef LIBXML_SCHEMAS_ENABLED
! 14198: xmlSchemaCleanupTypes();
! 14199: xmlRelaxNGCleanupTypes();
! 14200: #endif
! 14201: xmlCleanupGlobals();
! 14202: xmlResetLastError();
! 14203: xmlCleanupThreads(); /* must be last if called not from the main thread */
! 14204: xmlCleanupMemory();
! 14205: xmlParserInitialized = 0;
! 14206: }
! 14207:
! 14208: /************************************************************************
! 14209: * *
! 14210: * New set (2.6.0) of simpler and more flexible APIs *
! 14211: * *
! 14212: ************************************************************************/
! 14213:
! 14214: /**
! 14215: * DICT_FREE:
! 14216: * @str: a string
! 14217: *
! 14218: * Free a string if it is not owned by the "dict" dictionnary in the
! 14219: * current scope
! 14220: */
! 14221: #define DICT_FREE(str) \
! 14222: if ((str) && ((!dict) || \
! 14223: (xmlDictOwns(dict, (const xmlChar *)(str)) == 0))) \
! 14224: xmlFree((char *)(str));
! 14225:
! 14226: /**
! 14227: * xmlCtxtReset:
! 14228: * @ctxt: an XML parser context
! 14229: *
! 14230: * Reset a parser context
! 14231: */
! 14232: void
! 14233: xmlCtxtReset(xmlParserCtxtPtr ctxt)
! 14234: {
! 14235: xmlParserInputPtr input;
! 14236: xmlDictPtr dict;
! 14237:
! 14238: if (ctxt == NULL)
! 14239: return;
! 14240:
! 14241: dict = ctxt->dict;
! 14242:
! 14243: while ((input = inputPop(ctxt)) != NULL) { /* Non consuming */
! 14244: xmlFreeInputStream(input);
! 14245: }
! 14246: ctxt->inputNr = 0;
! 14247: ctxt->input = NULL;
! 14248:
! 14249: ctxt->spaceNr = 0;
! 14250: if (ctxt->spaceTab != NULL) {
! 14251: ctxt->spaceTab[0] = -1;
! 14252: ctxt->space = &ctxt->spaceTab[0];
! 14253: } else {
! 14254: ctxt->space = NULL;
! 14255: }
! 14256:
! 14257:
! 14258: ctxt->nodeNr = 0;
! 14259: ctxt->node = NULL;
! 14260:
! 14261: ctxt->nameNr = 0;
! 14262: ctxt->name = NULL;
! 14263:
! 14264: DICT_FREE(ctxt->version);
! 14265: ctxt->version = NULL;
! 14266: DICT_FREE(ctxt->encoding);
! 14267: ctxt->encoding = NULL;
! 14268: DICT_FREE(ctxt->directory);
! 14269: ctxt->directory = NULL;
! 14270: DICT_FREE(ctxt->extSubURI);
! 14271: ctxt->extSubURI = NULL;
! 14272: DICT_FREE(ctxt->extSubSystem);
! 14273: ctxt->extSubSystem = NULL;
! 14274: if (ctxt->myDoc != NULL)
! 14275: xmlFreeDoc(ctxt->myDoc);
! 14276: ctxt->myDoc = NULL;
! 14277:
! 14278: ctxt->standalone = -1;
! 14279: ctxt->hasExternalSubset = 0;
! 14280: ctxt->hasPErefs = 0;
! 14281: ctxt->html = 0;
! 14282: ctxt->external = 0;
! 14283: ctxt->instate = XML_PARSER_START;
! 14284: ctxt->token = 0;
! 14285:
! 14286: ctxt->wellFormed = 1;
! 14287: ctxt->nsWellFormed = 1;
! 14288: ctxt->disableSAX = 0;
! 14289: ctxt->valid = 1;
! 14290: #if 0
! 14291: ctxt->vctxt.userData = ctxt;
! 14292: ctxt->vctxt.error = xmlParserValidityError;
! 14293: ctxt->vctxt.warning = xmlParserValidityWarning;
! 14294: #endif
! 14295: ctxt->record_info = 0;
! 14296: ctxt->nbChars = 0;
! 14297: ctxt->checkIndex = 0;
! 14298: ctxt->inSubset = 0;
! 14299: ctxt->errNo = XML_ERR_OK;
! 14300: ctxt->depth = 0;
! 14301: ctxt->charset = XML_CHAR_ENCODING_UTF8;
! 14302: ctxt->catalogs = NULL;
! 14303: ctxt->nbentities = 0;
! 14304: ctxt->sizeentities = 0;
! 14305: xmlInitNodeInfoSeq(&ctxt->node_seq);
! 14306:
! 14307: if (ctxt->attsDefault != NULL) {
! 14308: xmlHashFree(ctxt->attsDefault, (xmlHashDeallocator) xmlFree);
! 14309: ctxt->attsDefault = NULL;
! 14310: }
! 14311: if (ctxt->attsSpecial != NULL) {
! 14312: xmlHashFree(ctxt->attsSpecial, NULL);
! 14313: ctxt->attsSpecial = NULL;
! 14314: }
! 14315:
! 14316: #ifdef LIBXML_CATALOG_ENABLED
! 14317: if (ctxt->catalogs != NULL)
! 14318: xmlCatalogFreeLocal(ctxt->catalogs);
! 14319: #endif
! 14320: if (ctxt->lastError.code != XML_ERR_OK)
! 14321: xmlResetError(&ctxt->lastError);
! 14322: }
! 14323:
! 14324: /**
! 14325: * xmlCtxtResetPush:
! 14326: * @ctxt: an XML parser context
! 14327: * @chunk: a pointer to an array of chars
! 14328: * @size: number of chars in the array
! 14329: * @filename: an optional file name or URI
! 14330: * @encoding: the document encoding, or NULL
! 14331: *
! 14332: * Reset a push parser context
! 14333: *
! 14334: * Returns 0 in case of success and 1 in case of error
! 14335: */
! 14336: int
! 14337: xmlCtxtResetPush(xmlParserCtxtPtr ctxt, const char *chunk,
! 14338: int size, const char *filename, const char *encoding)
! 14339: {
! 14340: xmlParserInputPtr inputStream;
! 14341: xmlParserInputBufferPtr buf;
! 14342: xmlCharEncoding enc = XML_CHAR_ENCODING_NONE;
! 14343:
! 14344: if (ctxt == NULL)
! 14345: return(1);
! 14346:
! 14347: if ((encoding == NULL) && (chunk != NULL) && (size >= 4))
! 14348: enc = xmlDetectCharEncoding((const xmlChar *) chunk, size);
! 14349:
! 14350: buf = xmlAllocParserInputBuffer(enc);
! 14351: if (buf == NULL)
! 14352: return(1);
! 14353:
! 14354: if (ctxt == NULL) {
! 14355: xmlFreeParserInputBuffer(buf);
! 14356: return(1);
! 14357: }
! 14358:
! 14359: xmlCtxtReset(ctxt);
! 14360:
! 14361: if (ctxt->pushTab == NULL) {
! 14362: ctxt->pushTab = (void **) xmlMalloc(ctxt->nameMax * 3 *
! 14363: sizeof(xmlChar *));
! 14364: if (ctxt->pushTab == NULL) {
! 14365: xmlErrMemory(ctxt, NULL);
! 14366: xmlFreeParserInputBuffer(buf);
! 14367: return(1);
! 14368: }
! 14369: }
! 14370:
! 14371: if (filename == NULL) {
! 14372: ctxt->directory = NULL;
! 14373: } else {
! 14374: ctxt->directory = xmlParserGetDirectory(filename);
! 14375: }
! 14376:
! 14377: inputStream = xmlNewInputStream(ctxt);
! 14378: if (inputStream == NULL) {
! 14379: xmlFreeParserInputBuffer(buf);
! 14380: return(1);
! 14381: }
! 14382:
! 14383: if (filename == NULL)
! 14384: inputStream->filename = NULL;
! 14385: else
! 14386: inputStream->filename = (char *)
! 14387: xmlCanonicPath((const xmlChar *) filename);
! 14388: inputStream->buf = buf;
! 14389: inputStream->base = inputStream->buf->buffer->content;
! 14390: inputStream->cur = inputStream->buf->buffer->content;
! 14391: inputStream->end =
! 14392: &inputStream->buf->buffer->content[inputStream->buf->buffer->use];
! 14393:
! 14394: inputPush(ctxt, inputStream);
! 14395:
! 14396: if ((size > 0) && (chunk != NULL) && (ctxt->input != NULL) &&
! 14397: (ctxt->input->buf != NULL)) {
! 14398: int base = ctxt->input->base - ctxt->input->buf->buffer->content;
! 14399: int cur = ctxt->input->cur - ctxt->input->base;
! 14400:
! 14401: xmlParserInputBufferPush(ctxt->input->buf, size, chunk);
! 14402:
! 14403: ctxt->input->base = ctxt->input->buf->buffer->content + base;
! 14404: ctxt->input->cur = ctxt->input->base + cur;
! 14405: ctxt->input->end =
! 14406: &ctxt->input->buf->buffer->content[ctxt->input->buf->buffer->
! 14407: use];
! 14408: #ifdef DEBUG_PUSH
! 14409: xmlGenericError(xmlGenericErrorContext, "PP: pushed %d\n", size);
! 14410: #endif
! 14411: }
! 14412:
! 14413: if (encoding != NULL) {
! 14414: xmlCharEncodingHandlerPtr hdlr;
! 14415:
! 14416: if (ctxt->encoding != NULL)
! 14417: xmlFree((xmlChar *) ctxt->encoding);
! 14418: ctxt->encoding = xmlStrdup((const xmlChar *) encoding);
! 14419:
! 14420: hdlr = xmlFindCharEncodingHandler(encoding);
! 14421: if (hdlr != NULL) {
! 14422: xmlSwitchToEncoding(ctxt, hdlr);
! 14423: } else {
! 14424: xmlFatalErrMsgStr(ctxt, XML_ERR_UNSUPPORTED_ENCODING,
! 14425: "Unsupported encoding %s\n", BAD_CAST encoding);
! 14426: }
! 14427: } else if (enc != XML_CHAR_ENCODING_NONE) {
! 14428: xmlSwitchEncoding(ctxt, enc);
! 14429: }
! 14430:
! 14431: return(0);
! 14432: }
! 14433:
! 14434:
! 14435: /**
! 14436: * xmlCtxtUseOptionsInternal:
! 14437: * @ctxt: an XML parser context
! 14438: * @options: a combination of xmlParserOption
! 14439: * @encoding: the user provided encoding to use
! 14440: *
! 14441: * Applies the options to the parser context
! 14442: *
! 14443: * Returns 0 in case of success, the set of unknown or unimplemented options
! 14444: * in case of error.
! 14445: */
! 14446: static int
! 14447: xmlCtxtUseOptionsInternal(xmlParserCtxtPtr ctxt, int options, const char *encoding)
! 14448: {
! 14449: if (ctxt == NULL)
! 14450: return(-1);
! 14451: if (encoding != NULL) {
! 14452: if (ctxt->encoding != NULL)
! 14453: xmlFree((xmlChar *) ctxt->encoding);
! 14454: ctxt->encoding = xmlStrdup((const xmlChar *) encoding);
! 14455: }
! 14456: if (options & XML_PARSE_RECOVER) {
! 14457: ctxt->recovery = 1;
! 14458: options -= XML_PARSE_RECOVER;
! 14459: ctxt->options |= XML_PARSE_RECOVER;
! 14460: } else
! 14461: ctxt->recovery = 0;
! 14462: if (options & XML_PARSE_DTDLOAD) {
! 14463: ctxt->loadsubset = XML_DETECT_IDS;
! 14464: options -= XML_PARSE_DTDLOAD;
! 14465: ctxt->options |= XML_PARSE_DTDLOAD;
! 14466: } else
! 14467: ctxt->loadsubset = 0;
! 14468: if (options & XML_PARSE_DTDATTR) {
! 14469: ctxt->loadsubset |= XML_COMPLETE_ATTRS;
! 14470: options -= XML_PARSE_DTDATTR;
! 14471: ctxt->options |= XML_PARSE_DTDATTR;
! 14472: }
! 14473: if (options & XML_PARSE_NOENT) {
! 14474: ctxt->replaceEntities = 1;
! 14475: /* ctxt->loadsubset |= XML_DETECT_IDS; */
! 14476: options -= XML_PARSE_NOENT;
! 14477: ctxt->options |= XML_PARSE_NOENT;
! 14478: } else
! 14479: ctxt->replaceEntities = 0;
! 14480: if (options & XML_PARSE_PEDANTIC) {
! 14481: ctxt->pedantic = 1;
! 14482: options -= XML_PARSE_PEDANTIC;
! 14483: ctxt->options |= XML_PARSE_PEDANTIC;
! 14484: } else
! 14485: ctxt->pedantic = 0;
! 14486: if (options & XML_PARSE_NOBLANKS) {
! 14487: ctxt->keepBlanks = 0;
! 14488: ctxt->sax->ignorableWhitespace = xmlSAX2IgnorableWhitespace;
! 14489: options -= XML_PARSE_NOBLANKS;
! 14490: ctxt->options |= XML_PARSE_NOBLANKS;
! 14491: } else
! 14492: ctxt->keepBlanks = 1;
! 14493: if (options & XML_PARSE_DTDVALID) {
! 14494: ctxt->validate = 1;
! 14495: if (options & XML_PARSE_NOWARNING)
! 14496: ctxt->vctxt.warning = NULL;
! 14497: if (options & XML_PARSE_NOERROR)
! 14498: ctxt->vctxt.error = NULL;
! 14499: options -= XML_PARSE_DTDVALID;
! 14500: ctxt->options |= XML_PARSE_DTDVALID;
! 14501: } else
! 14502: ctxt->validate = 0;
! 14503: if (options & XML_PARSE_NOWARNING) {
! 14504: ctxt->sax->warning = NULL;
! 14505: options -= XML_PARSE_NOWARNING;
! 14506: }
! 14507: if (options & XML_PARSE_NOERROR) {
! 14508: ctxt->sax->error = NULL;
! 14509: ctxt->sax->fatalError = NULL;
! 14510: options -= XML_PARSE_NOERROR;
! 14511: }
! 14512: #ifdef LIBXML_SAX1_ENABLED
! 14513: if (options & XML_PARSE_SAX1) {
! 14514: ctxt->sax->startElement = xmlSAX2StartElement;
! 14515: ctxt->sax->endElement = xmlSAX2EndElement;
! 14516: ctxt->sax->startElementNs = NULL;
! 14517: ctxt->sax->endElementNs = NULL;
! 14518: ctxt->sax->initialized = 1;
! 14519: options -= XML_PARSE_SAX1;
! 14520: ctxt->options |= XML_PARSE_SAX1;
! 14521: }
! 14522: #endif /* LIBXML_SAX1_ENABLED */
! 14523: if (options & XML_PARSE_NODICT) {
! 14524: ctxt->dictNames = 0;
! 14525: options -= XML_PARSE_NODICT;
! 14526: ctxt->options |= XML_PARSE_NODICT;
! 14527: } else {
! 14528: ctxt->dictNames = 1;
! 14529: }
! 14530: if (options & XML_PARSE_NOCDATA) {
! 14531: ctxt->sax->cdataBlock = NULL;
! 14532: options -= XML_PARSE_NOCDATA;
! 14533: ctxt->options |= XML_PARSE_NOCDATA;
! 14534: }
! 14535: if (options & XML_PARSE_NSCLEAN) {
! 14536: ctxt->options |= XML_PARSE_NSCLEAN;
! 14537: options -= XML_PARSE_NSCLEAN;
! 14538: }
! 14539: if (options & XML_PARSE_NONET) {
! 14540: ctxt->options |= XML_PARSE_NONET;
! 14541: options -= XML_PARSE_NONET;
! 14542: }
! 14543: if (options & XML_PARSE_COMPACT) {
! 14544: ctxt->options |= XML_PARSE_COMPACT;
! 14545: options -= XML_PARSE_COMPACT;
! 14546: }
! 14547: if (options & XML_PARSE_OLD10) {
! 14548: ctxt->options |= XML_PARSE_OLD10;
! 14549: options -= XML_PARSE_OLD10;
! 14550: }
! 14551: if (options & XML_PARSE_NOBASEFIX) {
! 14552: ctxt->options |= XML_PARSE_NOBASEFIX;
! 14553: options -= XML_PARSE_NOBASEFIX;
! 14554: }
! 14555: if (options & XML_PARSE_HUGE) {
! 14556: ctxt->options |= XML_PARSE_HUGE;
! 14557: options -= XML_PARSE_HUGE;
! 14558: }
! 14559: if (options & XML_PARSE_OLDSAX) {
! 14560: ctxt->options |= XML_PARSE_OLDSAX;
! 14561: options -= XML_PARSE_OLDSAX;
! 14562: }
! 14563: ctxt->linenumbers = 1;
! 14564: return (options);
! 14565: }
! 14566:
! 14567: /**
! 14568: * xmlCtxtUseOptions:
! 14569: * @ctxt: an XML parser context
! 14570: * @options: a combination of xmlParserOption
! 14571: *
! 14572: * Applies the options to the parser context
! 14573: *
! 14574: * Returns 0 in case of success, the set of unknown or unimplemented options
! 14575: * in case of error.
! 14576: */
! 14577: int
! 14578: xmlCtxtUseOptions(xmlParserCtxtPtr ctxt, int options)
! 14579: {
! 14580: return(xmlCtxtUseOptionsInternal(ctxt, options, NULL));
! 14581: }
! 14582:
! 14583: /**
! 14584: * xmlDoRead:
! 14585: * @ctxt: an XML parser context
! 14586: * @URL: the base URL to use for the document
! 14587: * @encoding: the document encoding, or NULL
! 14588: * @options: a combination of xmlParserOption
! 14589: * @reuse: keep the context for reuse
! 14590: *
! 14591: * Common front-end for the xmlRead functions
! 14592: *
! 14593: * Returns the resulting document tree or NULL
! 14594: */
! 14595: static xmlDocPtr
! 14596: xmlDoRead(xmlParserCtxtPtr ctxt, const char *URL, const char *encoding,
! 14597: int options, int reuse)
! 14598: {
! 14599: xmlDocPtr ret;
! 14600:
! 14601: xmlCtxtUseOptionsInternal(ctxt, options, encoding);
! 14602: if (encoding != NULL) {
! 14603: xmlCharEncodingHandlerPtr hdlr;
! 14604:
! 14605: hdlr = xmlFindCharEncodingHandler(encoding);
! 14606: if (hdlr != NULL)
! 14607: xmlSwitchToEncoding(ctxt, hdlr);
! 14608: }
! 14609: if ((URL != NULL) && (ctxt->input != NULL) &&
! 14610: (ctxt->input->filename == NULL))
! 14611: ctxt->input->filename = (char *) xmlStrdup((const xmlChar *) URL);
! 14612: xmlParseDocument(ctxt);
! 14613: if ((ctxt->wellFormed) || ctxt->recovery)
! 14614: ret = ctxt->myDoc;
! 14615: else {
! 14616: ret = NULL;
! 14617: if (ctxt->myDoc != NULL) {
! 14618: xmlFreeDoc(ctxt->myDoc);
! 14619: }
! 14620: }
! 14621: ctxt->myDoc = NULL;
! 14622: if (!reuse) {
! 14623: xmlFreeParserCtxt(ctxt);
! 14624: }
! 14625:
! 14626: return (ret);
! 14627: }
! 14628:
! 14629: /**
! 14630: * xmlReadDoc:
! 14631: * @cur: a pointer to a zero terminated string
! 14632: * @URL: the base URL to use for the document
! 14633: * @encoding: the document encoding, or NULL
! 14634: * @options: a combination of xmlParserOption
! 14635: *
! 14636: * parse an XML in-memory document and build a tree.
! 14637: *
! 14638: * Returns the resulting document tree
! 14639: */
! 14640: xmlDocPtr
! 14641: xmlReadDoc(const xmlChar * cur, const char *URL, const char *encoding, int options)
! 14642: {
! 14643: xmlParserCtxtPtr ctxt;
! 14644:
! 14645: if (cur == NULL)
! 14646: return (NULL);
! 14647:
! 14648: ctxt = xmlCreateDocParserCtxt(cur);
! 14649: if (ctxt == NULL)
! 14650: return (NULL);
! 14651: return (xmlDoRead(ctxt, URL, encoding, options, 0));
! 14652: }
! 14653:
! 14654: /**
! 14655: * xmlReadFile:
! 14656: * @filename: a file or URL
! 14657: * @encoding: the document encoding, or NULL
! 14658: * @options: a combination of xmlParserOption
! 14659: *
! 14660: * parse an XML file from the filesystem or the network.
! 14661: *
! 14662: * Returns the resulting document tree
! 14663: */
! 14664: xmlDocPtr
! 14665: xmlReadFile(const char *filename, const char *encoding, int options)
! 14666: {
! 14667: xmlParserCtxtPtr ctxt;
! 14668:
! 14669: ctxt = xmlCreateURLParserCtxt(filename, options);
! 14670: if (ctxt == NULL)
! 14671: return (NULL);
! 14672: return (xmlDoRead(ctxt, NULL, encoding, options, 0));
! 14673: }
! 14674:
! 14675: /**
! 14676: * xmlReadMemory:
! 14677: * @buffer: a pointer to a char array
! 14678: * @size: the size of the array
! 14679: * @URL: the base URL to use for the document
! 14680: * @encoding: the document encoding, or NULL
! 14681: * @options: a combination of xmlParserOption
! 14682: *
! 14683: * parse an XML in-memory document and build a tree.
! 14684: *
! 14685: * Returns the resulting document tree
! 14686: */
! 14687: xmlDocPtr
! 14688: xmlReadMemory(const char *buffer, int size, const char *URL, const char *encoding, int options)
! 14689: {
! 14690: xmlParserCtxtPtr ctxt;
! 14691:
! 14692: ctxt = xmlCreateMemoryParserCtxt(buffer, size);
! 14693: if (ctxt == NULL)
! 14694: return (NULL);
! 14695: return (xmlDoRead(ctxt, URL, encoding, options, 0));
! 14696: }
! 14697:
! 14698: /**
! 14699: * xmlReadFd:
! 14700: * @fd: an open file descriptor
! 14701: * @URL: the base URL to use for the document
! 14702: * @encoding: the document encoding, or NULL
! 14703: * @options: a combination of xmlParserOption
! 14704: *
! 14705: * parse an XML from a file descriptor and build a tree.
! 14706: * NOTE that the file descriptor will not be closed when the
! 14707: * reader is closed or reset.
! 14708: *
! 14709: * Returns the resulting document tree
! 14710: */
! 14711: xmlDocPtr
! 14712: xmlReadFd(int fd, const char *URL, const char *encoding, int options)
! 14713: {
! 14714: xmlParserCtxtPtr ctxt;
! 14715: xmlParserInputBufferPtr input;
! 14716: xmlParserInputPtr stream;
! 14717:
! 14718: if (fd < 0)
! 14719: return (NULL);
! 14720:
! 14721: input = xmlParserInputBufferCreateFd(fd, XML_CHAR_ENCODING_NONE);
! 14722: if (input == NULL)
! 14723: return (NULL);
! 14724: input->closecallback = NULL;
! 14725: ctxt = xmlNewParserCtxt();
! 14726: if (ctxt == NULL) {
! 14727: xmlFreeParserInputBuffer(input);
! 14728: return (NULL);
! 14729: }
! 14730: stream = xmlNewIOInputStream(ctxt, input, XML_CHAR_ENCODING_NONE);
! 14731: if (stream == NULL) {
! 14732: xmlFreeParserInputBuffer(input);
! 14733: xmlFreeParserCtxt(ctxt);
! 14734: return (NULL);
! 14735: }
! 14736: inputPush(ctxt, stream);
! 14737: return (xmlDoRead(ctxt, URL, encoding, options, 0));
! 14738: }
! 14739:
! 14740: /**
! 14741: * xmlReadIO:
! 14742: * @ioread: an I/O read function
! 14743: * @ioclose: an I/O close function
! 14744: * @ioctx: an I/O handler
! 14745: * @URL: the base URL to use for the document
! 14746: * @encoding: the document encoding, or NULL
! 14747: * @options: a combination of xmlParserOption
! 14748: *
! 14749: * parse an XML document from I/O functions and source and build a tree.
! 14750: *
! 14751: * Returns the resulting document tree
! 14752: */
! 14753: xmlDocPtr
! 14754: xmlReadIO(xmlInputReadCallback ioread, xmlInputCloseCallback ioclose,
! 14755: void *ioctx, const char *URL, const char *encoding, int options)
! 14756: {
! 14757: xmlParserCtxtPtr ctxt;
! 14758: xmlParserInputBufferPtr input;
! 14759: xmlParserInputPtr stream;
! 14760:
! 14761: if (ioread == NULL)
! 14762: return (NULL);
! 14763:
! 14764: input = xmlParserInputBufferCreateIO(ioread, ioclose, ioctx,
! 14765: XML_CHAR_ENCODING_NONE);
! 14766: if (input == NULL)
! 14767: return (NULL);
! 14768: ctxt = xmlNewParserCtxt();
! 14769: if (ctxt == NULL) {
! 14770: xmlFreeParserInputBuffer(input);
! 14771: return (NULL);
! 14772: }
! 14773: stream = xmlNewIOInputStream(ctxt, input, XML_CHAR_ENCODING_NONE);
! 14774: if (stream == NULL) {
! 14775: xmlFreeParserInputBuffer(input);
! 14776: xmlFreeParserCtxt(ctxt);
! 14777: return (NULL);
! 14778: }
! 14779: inputPush(ctxt, stream);
! 14780: return (xmlDoRead(ctxt, URL, encoding, options, 0));
! 14781: }
! 14782:
! 14783: /**
! 14784: * xmlCtxtReadDoc:
! 14785: * @ctxt: an XML parser context
! 14786: * @cur: a pointer to a zero terminated string
! 14787: * @URL: the base URL to use for the document
! 14788: * @encoding: the document encoding, or NULL
! 14789: * @options: a combination of xmlParserOption
! 14790: *
! 14791: * parse an XML in-memory document and build a tree.
! 14792: * This reuses the existing @ctxt parser context
! 14793: *
! 14794: * Returns the resulting document tree
! 14795: */
! 14796: xmlDocPtr
! 14797: xmlCtxtReadDoc(xmlParserCtxtPtr ctxt, const xmlChar * cur,
! 14798: const char *URL, const char *encoding, int options)
! 14799: {
! 14800: xmlParserInputPtr stream;
! 14801:
! 14802: if (cur == NULL)
! 14803: return (NULL);
! 14804: if (ctxt == NULL)
! 14805: return (NULL);
! 14806:
! 14807: xmlCtxtReset(ctxt);
! 14808:
! 14809: stream = xmlNewStringInputStream(ctxt, cur);
! 14810: if (stream == NULL) {
! 14811: return (NULL);
! 14812: }
! 14813: inputPush(ctxt, stream);
! 14814: return (xmlDoRead(ctxt, URL, encoding, options, 1));
! 14815: }
! 14816:
! 14817: /**
! 14818: * xmlCtxtReadFile:
! 14819: * @ctxt: an XML parser context
! 14820: * @filename: a file or URL
! 14821: * @encoding: the document encoding, or NULL
! 14822: * @options: a combination of xmlParserOption
! 14823: *
! 14824: * parse an XML file from the filesystem or the network.
! 14825: * This reuses the existing @ctxt parser context
! 14826: *
! 14827: * Returns the resulting document tree
! 14828: */
! 14829: xmlDocPtr
! 14830: xmlCtxtReadFile(xmlParserCtxtPtr ctxt, const char *filename,
! 14831: const char *encoding, int options)
! 14832: {
! 14833: xmlParserInputPtr stream;
! 14834:
! 14835: if (filename == NULL)
! 14836: return (NULL);
! 14837: if (ctxt == NULL)
! 14838: return (NULL);
! 14839:
! 14840: xmlCtxtReset(ctxt);
! 14841:
! 14842: stream = xmlLoadExternalEntity(filename, NULL, ctxt);
! 14843: if (stream == NULL) {
! 14844: return (NULL);
! 14845: }
! 14846: inputPush(ctxt, stream);
! 14847: return (xmlDoRead(ctxt, NULL, encoding, options, 1));
! 14848: }
! 14849:
! 14850: /**
! 14851: * xmlCtxtReadMemory:
! 14852: * @ctxt: an XML parser context
! 14853: * @buffer: a pointer to a char array
! 14854: * @size: the size of the array
! 14855: * @URL: the base URL to use for the document
! 14856: * @encoding: the document encoding, or NULL
! 14857: * @options: a combination of xmlParserOption
! 14858: *
! 14859: * parse an XML in-memory document and build a tree.
! 14860: * This reuses the existing @ctxt parser context
! 14861: *
! 14862: * Returns the resulting document tree
! 14863: */
! 14864: xmlDocPtr
! 14865: xmlCtxtReadMemory(xmlParserCtxtPtr ctxt, const char *buffer, int size,
! 14866: const char *URL, const char *encoding, int options)
! 14867: {
! 14868: xmlParserInputBufferPtr input;
! 14869: xmlParserInputPtr stream;
! 14870:
! 14871: if (ctxt == NULL)
! 14872: return (NULL);
! 14873: if (buffer == NULL)
! 14874: return (NULL);
! 14875:
! 14876: xmlCtxtReset(ctxt);
! 14877:
! 14878: input = xmlParserInputBufferCreateMem(buffer, size, XML_CHAR_ENCODING_NONE);
! 14879: if (input == NULL) {
! 14880: return(NULL);
! 14881: }
! 14882:
! 14883: stream = xmlNewIOInputStream(ctxt, input, XML_CHAR_ENCODING_NONE);
! 14884: if (stream == NULL) {
! 14885: xmlFreeParserInputBuffer(input);
! 14886: return(NULL);
! 14887: }
! 14888:
! 14889: inputPush(ctxt, stream);
! 14890: return (xmlDoRead(ctxt, URL, encoding, options, 1));
! 14891: }
! 14892:
! 14893: /**
! 14894: * xmlCtxtReadFd:
! 14895: * @ctxt: an XML parser context
! 14896: * @fd: an open file descriptor
! 14897: * @URL: the base URL to use for the document
! 14898: * @encoding: the document encoding, or NULL
! 14899: * @options: a combination of xmlParserOption
! 14900: *
! 14901: * parse an XML from a file descriptor and build a tree.
! 14902: * This reuses the existing @ctxt parser context
! 14903: * NOTE that the file descriptor will not be closed when the
! 14904: * reader is closed or reset.
! 14905: *
! 14906: * Returns the resulting document tree
! 14907: */
! 14908: xmlDocPtr
! 14909: xmlCtxtReadFd(xmlParserCtxtPtr ctxt, int fd,
! 14910: const char *URL, const char *encoding, int options)
! 14911: {
! 14912: xmlParserInputBufferPtr input;
! 14913: xmlParserInputPtr stream;
! 14914:
! 14915: if (fd < 0)
! 14916: return (NULL);
! 14917: if (ctxt == NULL)
! 14918: return (NULL);
! 14919:
! 14920: xmlCtxtReset(ctxt);
! 14921:
! 14922:
! 14923: input = xmlParserInputBufferCreateFd(fd, XML_CHAR_ENCODING_NONE);
! 14924: if (input == NULL)
! 14925: return (NULL);
! 14926: input->closecallback = NULL;
! 14927: stream = xmlNewIOInputStream(ctxt, input, XML_CHAR_ENCODING_NONE);
! 14928: if (stream == NULL) {
! 14929: xmlFreeParserInputBuffer(input);
! 14930: return (NULL);
! 14931: }
! 14932: inputPush(ctxt, stream);
! 14933: return (xmlDoRead(ctxt, URL, encoding, options, 1));
! 14934: }
! 14935:
! 14936: /**
! 14937: * xmlCtxtReadIO:
! 14938: * @ctxt: an XML parser context
! 14939: * @ioread: an I/O read function
! 14940: * @ioclose: an I/O close function
! 14941: * @ioctx: an I/O handler
! 14942: * @URL: the base URL to use for the document
! 14943: * @encoding: the document encoding, or NULL
! 14944: * @options: a combination of xmlParserOption
! 14945: *
! 14946: * parse an XML document from I/O functions and source and build a tree.
! 14947: * This reuses the existing @ctxt parser context
! 14948: *
! 14949: * Returns the resulting document tree
! 14950: */
! 14951: xmlDocPtr
! 14952: xmlCtxtReadIO(xmlParserCtxtPtr ctxt, xmlInputReadCallback ioread,
! 14953: xmlInputCloseCallback ioclose, void *ioctx,
! 14954: const char *URL,
! 14955: const char *encoding, int options)
! 14956: {
! 14957: xmlParserInputBufferPtr input;
! 14958: xmlParserInputPtr stream;
! 14959:
! 14960: if (ioread == NULL)
! 14961: return (NULL);
! 14962: if (ctxt == NULL)
! 14963: return (NULL);
! 14964:
! 14965: xmlCtxtReset(ctxt);
! 14966:
! 14967: input = xmlParserInputBufferCreateIO(ioread, ioclose, ioctx,
! 14968: XML_CHAR_ENCODING_NONE);
! 14969: if (input == NULL)
! 14970: return (NULL);
! 14971: stream = xmlNewIOInputStream(ctxt, input, XML_CHAR_ENCODING_NONE);
! 14972: if (stream == NULL) {
! 14973: xmlFreeParserInputBuffer(input);
! 14974: return (NULL);
! 14975: }
! 14976: inputPush(ctxt, stream);
! 14977: return (xmlDoRead(ctxt, URL, encoding, options, 1));
! 14978: }
! 14979:
! 14980: #define bottom_parser
! 14981: #include "elfgcchack.h"
FreeBSD-CVSweb <freebsd-cvsweb@FreeBSD.org>
![[BACK]](/icons/cvsweb/back.gif){kind=icon}
Return to parser.c CVS log ![[TXT]](/icons/cvsweb/text.gif){kind=icon}
![[DIR]](/icons/cvsweb/dir.gif){kind=icon}
Up to [ELWIX - Embedded LightWeight unIX -] / embedaddon / libxml2