--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/xml/libxml2libs/src/libxml2/libxml2_sax2.c Thu Dec 17 09:29:21 2009 +0200
@@ -0,0 +1,2905 @@
+/*
+ * libxml2_sax2.c : Default SAX2 handler to build a tree.
+ *
+ * See Copyright for the status of this software.
+ *
+ * Daniel Veillard <daniel@veillard.com>
+ * Portion Copyright © 2009 Nokia Corporation and/or its subsidiary(-ies). All rights reserved.
+ */
+
+#define IN_LIBXML
+
+#include "xmlenglibxml.h"
+
+#include <stdlib.h>
+#include <string.h>
+#include <stdapis/libxml2/libxml2_parserinternals.h>
+#include "libxml2_xmlerror2.h"
+
+#ifdef LIBXML_DEBUG_ENABLED
+#include "libxml2_debugxml.h"
+#endif
+
+#include <stdapis/libxml2/libxml2_uri.h>
+#include <stdapis/libxml2/libxml2_globals.h>
+
+#ifdef LIBXML_HTML_ENABLED
+#include "libxml2_htmltree.h"
+#endif
+
+/* #define DEBUG_SAX2 */
+/* #define DEBUG_SAX2_TREE */
+
+/**
+ *
+ *
+ * macro to flag unimplemented blocks
+ * XML_CATALOG_PREFER user env to select between system/public prefered
+ * option. C.f. Richard Tobin <richard@cogsci.ed.ac.uk>
+ *> Just FYI, I am using an environment variable XML_CATALOG_PREFER with
+ *> values "system" and "public". I have made the default be "system" to
+ *> match yours.
+ */
+#define _TODO_ \
+ xmlGenericError(xmlGenericErrorContext, \
+ EMBED_ERRTXT("Unimplemented block at %s:%d\n"), \
+ __FILE__, __LINE__);
+
+/**
+ * xmlValidError:
+ * @param ctxt an XML validation parser context
+ * @param error the error number
+ * @param msg the error message
+ * @param str1 extra data
+ * @param str2 extra data
+ *
+ * Handle a validation error
+ */
+static void
+xmlErrValid(xmlParserCtxtPtr ctxt, xmlParserErrors error,
+ const char *msg, const char *str1, const char *str2)
+{
+ xmlStructuredErrorFunc schannel = NULL;
+
+ if ((ctxt != NULL) && (ctxt->disableSAX != 0) &&
+ (ctxt->instate == XML_PARSER_EOF))
+ return;
+ ctxt->errNo = error;
+ if ((ctxt->sax != NULL) && (ctxt->sax->initialized == XML_SAX2_MAGIC))
+ schannel = ctxt->sax->serror;
+ __xmlRaiseError(schannel,
+ ctxt->vctxt.error, ctxt->vctxt.userData,
+ ctxt, NULL, XML_FROM_DTD, error,
+ XML_ERR_ERROR, NULL, 0, (const char *) str1,
+ (const char *) str2, NULL, 0, 0,
+ msg, (const char *) str1, (const char *) str2);
+ ctxt->valid = 0;
+}
+
+/**
+ * xmlSAX2GetPublicId:
+ * @param ctx the user data (XML parser context)
+ *
+ * Provides the public ID e.g. "-//SGMLSOURCE//DTD DEMO//EN"
+ *
+ * Returns a xmlChar *
+ */
+XMLPUBFUNEXPORT const xmlChar *
+xmlSAX2GetPublicId(void *ctx ATTRIBUTE_UNUSED)
+{
+ /* xmlParserCtxtPtr ctxt = (xmlParserCtxtPtr) ctx; */
+ if(ctx)
+ return NULL; // just to use ctx
+ return(NULL);
+}
+
+/**
+ * xmlSAX2GetSystemId:
+ * @param ctx the user data (XML parser context)
+ *
+ * Provides the system ID, basically URL or filename e.g.
+ * http://www.sgmlsource.com/dtds/memo.dtd
+ *
+ * Returns a xmlChar *
+ */
+XMLPUBFUNEXPORT const xmlChar *
+xmlSAX2GetSystemId(void *ctx)
+{
+ xmlParserCtxtPtr ctxt = (xmlParserCtxtPtr) ctx;
+ return((const xmlChar *) ctxt->input->filename);
+}
+
+/**
+ * xmlSAX2GetLineNumber:
+ * @param ctx the user data (XML parser context)
+ *
+ * Provide the line number of the current parsing point.
+ *
+ * Returns an int
+ */
+XMLPUBFUNEXPORT int
+xmlSAX2GetLineNumber(void *ctx)
+{
+ xmlParserCtxtPtr ctxt = (xmlParserCtxtPtr) ctx;
+ return(ctxt->input->line);
+}
+
+/**
+ * xmlSAX2GetColumnNumber:
+ * @param ctx the user data (XML parser context)
+ *
+ * Provide the column number of the current parsing point.
+ *
+ * Returns an int
+ */
+XMLPUBFUNEXPORT int
+xmlSAX2GetColumnNumber(void *ctx)
+{
+ xmlParserCtxtPtr ctxt = (xmlParserCtxtPtr) ctx;
+ return(ctxt->input->col);
+}
+
+/**
+ * xmlSAX2IsStandalone:
+ * @param ctx the user data (XML parser context)
+ *
+ * Is this document tagged standalone ?
+ *
+ * Returns 1 if true
+ */
+XMLPUBFUNEXPORT int
+xmlSAX2IsStandalone(void *ctx)
+{
+ xmlParserCtxtPtr ctxt = (xmlParserCtxtPtr) ctx;
+ return(ctxt->myDoc->standalone == 1);
+}
+
+/**
+ * xmlSAX2HasInternalSubset:
+ * @param ctx the user data (XML parser context)
+ *
+ * Does this document has an internal subset
+ *
+ * Returns 1 if true
+ */
+XMLPUBFUNEXPORT int
+xmlSAX2HasInternalSubset(void *ctx)
+{
+ xmlParserCtxtPtr ctxt = (xmlParserCtxtPtr) ctx;
+ return(ctxt->myDoc->intSubset != NULL);
+}
+
+/**
+ * xmlSAX2HasExternalSubset:
+ * @param ctx the user data (XML parser context)
+ *
+ * Does this document has an external subset
+ *
+ * Returns 1 if true
+ */
+XMLPUBFUNEXPORT int
+xmlSAX2HasExternalSubset(void *ctx)
+{
+ xmlParserCtxtPtr ctxt = (xmlParserCtxtPtr) ctx;
+ return(ctxt->myDoc->extSubset != NULL);
+}
+
+/**
+ * xmlSAX2InternalSubset:
+ * @param ctx the user data (XML parser context)
+ * @param name the root element name
+ * @param ExternalID the external ID
+ * @param SystemID the SYSTEM ID (e.g. filename or URL)
+ *
+ * Callback on internal subset declaration.
+ */
+XMLPUBFUNEXPORT void
+xmlSAX2InternalSubset(void *ctx, const xmlChar *name,
+ const xmlChar *ExternalID, const xmlChar *SystemID)
+{
+ xmlParserCtxtPtr ctxt = (xmlParserCtxtPtr) ctx;
+ xmlDtdPtr dtd;
+#ifdef DEBUG_SAX
+ xmlGenericError(xmlGenericErrorContext,
+ "SAX.xmlSAX2InternalSubset(%s, %s, %s)\n",
+ name, ExternalID, SystemID);
+#endif
+
+ if (ctxt->myDoc == NULL)
+ return;
+ dtd = xmlGetIntSubset(ctxt->myDoc);
+ if (dtd != NULL) {
+ if (ctxt->html)
+ return;
+ xmlUnlinkNode((xmlNodePtr) dtd);
+ xmlFreeDtd(dtd);
+ ctxt->myDoc->intSubset = NULL;
+ }
+ ctxt->myDoc->intSubset = xmlCreateIntSubset(ctxt->myDoc, name, ExternalID, SystemID);
+}
+
+/**
+ * xmlSAX2ExternalSubset:
+ * @param ctx the user data (XML parser context)
+ * @param name the root element name
+ * @param ExternalID the external ID
+ * @param SystemID the SYSTEM ID (e.g. filename or URL)
+ *
+ * Callback on external subset declaration.
+ */
+XMLPUBFUNEXPORT void
+xmlSAX2ExternalSubset(void *ctx, const xmlChar *name,
+ const xmlChar *ExternalID, const xmlChar *SystemID)
+{
+ xmlParserCtxtPtr ctxt = (xmlParserCtxtPtr) ctx;
+#ifdef DEBUG_SAX
+ xmlGenericError(xmlGenericErrorContext,
+ "SAX.xmlSAX2ExternalSubset(%s, %s, %s)\n",
+ name, ExternalID, SystemID);
+#endif
+ if (((ExternalID != NULL) || (SystemID != NULL)) &&
+ (((ctxt->validate) || (ctxt->loadsubset != 0)) &&
+ (ctxt->wellFormed && ctxt->myDoc))) {
+ /*
+ * Try to fetch and parse the external subset.
+ */
+ xmlParserInputPtr oldinput;
+ int oldinputNr;
+ int oldinputMax;
+ xmlParserInputPtr *oldinputTab;
+ xmlParserInputPtr input = NULL;
+ xmlCharEncoding enc;
+ int oldcharset;
+
+ /*
+ * Ask the Entity resolver to load the damn thing
+ */
+ if ((ctxt->sax != NULL) && (ctxt->sax->resolveEntity != NULL))
+ input = ctxt->sax->resolveEntity(ctxt->userData, ExternalID,
+ SystemID);
+ if (input == NULL) {
+ return;
+ }
+
+ xmlNewDtd(ctxt->myDoc, name, ExternalID, SystemID);
+
+ /*
+ * make sure we won't destroy the main document context
+ */
+
+ oldinput = ctxt->input;
+ oldinputNr = ctxt->inputNr;
+ oldinputMax = ctxt->inputMax;
+ oldinputTab = ctxt->inputTab;
+ oldcharset = ctxt->charset;
+
+ ctxt->inputTab = (xmlParserInputPtr *)
+ xmlMalloc(5 * sizeof(xmlParserInputPtr));
+ if (ctxt->inputTab == NULL) {
+ ctxt->errNo = XML_ERR_NO_MEMORY;
+ if ((ctxt->sax != NULL) && (ctxt->sax->error != NULL))
+ ctxt->sax->error(ctxt->userData,
+ EMBED_ERRTXT("xmlSAX2ExternalSubset: out of memory\n"));
+ ctxt->errNo = XML_ERR_NO_MEMORY;
+ ctxt->instate = XML_PARSER_EOF;
+ ctxt->disableSAX = 1;
+ ctxt->input = oldinput;
+ ctxt->inputNr = oldinputNr;
+ ctxt->inputMax = oldinputMax;
+ ctxt->inputTab = oldinputTab;
+ ctxt->charset = oldcharset;
+ return;
+ }
+ ctxt->inputNr = 0;
+ ctxt->inputMax = 5;
+ ctxt->input = NULL;
+ xmlPushInput(ctxt, input);
+
+ /*
+ * On the fly encoding conversion if needed
+ */
+ if (ctxt->input->length >= 4) {
+ enc = xmlDetectCharEncoding(ctxt->input->cur, 4);
+ xmlSwitchEncoding(ctxt, enc);
+ }
+
+ if (input->filename == NULL)
+ input->filename = (char *) xmlCanonicPath(SystemID);
+ input->line = 1;
+ input->col = 1;
+ input->base = ctxt->input->cur;
+ input->cur = ctxt->input->cur;
+ input->free = NULL;
+
+ /*
+ * let's parse that entity knowing it's an external subset.
+ */
+ xmlParseExternalSubset(ctxt, ExternalID, SystemID);
+
+ /*
+ * Free up the external entities
+ */
+
+ while (ctxt->inputNr > 1)
+ xmlPopInput(ctxt);
+ xmlFreeInputStream(ctxt->input);
+ xmlFree(ctxt->inputTab);
+
+ /*
+ * Restore the parsing context of the main entity
+ */
+ ctxt->input = oldinput;
+ ctxt->inputNr = oldinputNr;
+ ctxt->inputMax = oldinputMax;
+ ctxt->inputTab = oldinputTab;
+ ctxt->charset = oldcharset;
+ /* ctxt->wellFormed = oldwellFormed; */
+ }
+}
+
+/**
+ * xmlSAX2ResolveEntity:
+ * @param ctx the user data (XML parser context)
+ * @param publicId The public ID of the entity
+ * @param systemId The system ID of the entity
+ *
+ * The entity loader, to control the loading of external entities,
+ * the application can either:
+ * - override this xmlSAX2ResolveEntity() callback in the SAX block
+ * - or better use the xmlSetExternalEntityLoader() function to
+ * set up it's own entity resolution routine
+ *
+ * Returns the xmlParserInputPtr if inlined or NULL for DOM behaviour.
+ */
+XMLPUBFUNEXPORT xmlParserInputPtr
+xmlSAX2ResolveEntity(void *ctx, const xmlChar *publicId, const xmlChar *systemId)
+{
+ xmlParserCtxtPtr ctxt = (xmlParserCtxtPtr) ctx;
+ xmlParserInputPtr ret;
+ xmlChar* URI;
+ const char* base = NULL;
+
+ if (ctxt->input)
+ base = ctxt->input->filename;
+ if (!base)
+ base = ctxt->directory;
+
+ URI = xmlBuildURI(systemId, (const xmlChar *) base);
+
+#ifdef DEBUG_SAX
+ xmlGenericError(xmlGenericErrorContext,
+ "SAX.xmlSAX2ResolveEntity(%s, %s)\n", publicId, systemId);
+#endif
+
+ ret = xmlLoadExternalEntity((const char *) URI,
+ (const char *) publicId, ctxt);
+ if (URI)
+ xmlFree(URI);
+ return(ret);
+}
+
+/**
+ * xmlSAX2GetEntity:
+ * @param ctx the user data (XML parser context)
+ * @param name The entity name
+ *
+ * Get an entity by name
+ *
+ * Returns the xmlEntityPtr if found.
+ */
+XMLPUBFUNEXPORT xmlEntityPtr
+xmlSAX2GetEntity(void *ctx, const xmlChar *name)
+{
+ xmlParserCtxtPtr ctxt = (xmlParserCtxtPtr) ctx;
+ xmlEntityPtr ret = NULL;
+
+#ifdef DEBUG_SAX
+ xmlGenericError(xmlGenericErrorContext, "SAX.xmlSAX2GetEntity(%s)\n", name);
+#endif
+
+ if (ctxt->inSubset == 0) {
+ ret = xmlGetPredefinedEntity(name);
+ if (ret != NULL)
+ return(ret);
+ }
+ if ((ctxt->myDoc != NULL) && (ctxt->myDoc->standalone == 1))
+ {
+ if (ctxt->inSubset == 2) {
+ ctxt->myDoc->standalone = 0;
+ ret = xmlGetDocEntity(ctxt->myDoc, name);
+ ctxt->myDoc->standalone = 1;
+ } else {
+ ret = xmlGetDocEntity(ctxt->myDoc, name);
+ if (ret == NULL) {
+ ctxt->myDoc->standalone = 0;
+ ret = xmlGetDocEntity(ctxt->myDoc, name);
+ if (ret != NULL) {
+ if ((ctxt->sax != NULL) && (ctxt->sax->error != NULL))
+ ctxt->sax->error(ctxt->userData,
+ EMBED_ERRTXT("Entity(%s) document marked standalone but requires external subset\n"),
+ name);
+ ctxt->valid = 0;
+ ctxt->wellFormed = 0;
+ }
+ ctxt->myDoc->standalone = 1;
+ }
+ }
+ } else {
+ ret = xmlGetDocEntity(ctxt->myDoc, name);
+ }
+ if (ret &&
+ ((ctxt->validate) || (ctxt->replaceEntities)) &&
+ !ret->children &&
+ (ret->etype == XML_EXTERNAL_GENERAL_PARSED_ENTITY))
+ {
+ int val;
+
+ /*
+ * for validation purposes we really need to fetch and
+ * parse the external entity
+ */
+ xmlNodePtr children;
+
+ val = xmlParseCtxtExternalEntity(ctxt, ret->URI, ret->ExternalID, &children);
+
+ if (val == 0) {
+ xmlAddChildList((xmlNodePtr) ret, children);
+ } else {
+ if ((ctxt->sax != NULL) && (ctxt->sax->error != NULL))
+ ctxt->sax->error(ctxt->userData,
+ EMBED_ERRTXT("Failure to process entity %s\n"), name);
+ ctxt->wellFormed = 0;
+ ctxt->valid = 0;
+ ctxt->validate = 0;
+ return(NULL);
+ }
+ ret->owner = 1;
+ }
+ return(ret);
+}
+
+/**
+ * xmlSAX2GetParameterEntity:
+ * @param ctx the user data (XML parser context)
+ * @param name The entity name
+ *
+ * Get a parameter entity by name
+ *
+ * Returns the xmlEntityPtr if found.
+ */
+XMLPUBFUNEXPORT xmlEntityPtr
+xmlSAX2GetParameterEntity(void *ctx, const xmlChar *name)
+{
+ xmlParserCtxtPtr ctxt = (xmlParserCtxtPtr) ctx;
+ xmlEntityPtr ret;
+
+#ifdef DEBUG_SAX
+ xmlGenericError(xmlGenericErrorContext,
+ "SAX.xmlSAX2GetParameterEntity(%s)\n", name);
+#endif
+
+ ret = xmlGetParameterEntity(ctxt->myDoc, name);
+ return(ret);
+}
+
+
+/**
+ * xmlSAX2EntityDecl:
+ * @param ctx the user data (XML parser context)
+ * @param name the entity name
+ * @param type the entity type
+ * @param publicId The public ID of the entity
+ * @param systemId The system ID of the entity
+ * @param content the entity value (without processing).
+ *
+ * An entity definition has been parsed
+ */
+XMLPUBFUNEXPORT void
+xmlSAX2EntityDecl(void *ctx, const xmlChar *name, int type,
+ const xmlChar *publicId, const xmlChar *systemId, xmlChar *content)
+{
+ xmlEntityPtr ent;
+ xmlParserCtxtPtr ctxt = (xmlParserCtxtPtr) ctx;
+
+#ifdef DEBUG_SAX
+ xmlGenericError(xmlGenericErrorContext,
+ "SAX.xmlSAX2EntityDecl(%s, %d, %s, %s, %s)\n",
+ name, type, publicId, systemId, content);
+#endif
+ if (ctxt->inSubset == 1)
+ {
+ ent = xmlAddDocEntity(ctxt->myDoc, name, type, publicId,
+ systemId, content);
+ if (!ent &&
+ ctxt->pedantic &&
+ ctxt->sax && ctxt->sax->warning)
+ {
+ ctxt->sax->warning(ctxt->userData,
+ EMBED_ERRTXT("Entity(%s) already defined in the internal subset\n"), name);
+ }
+ if (ent && !ent->URI && systemId)
+ {
+ xmlChar *URI;
+ const char *base = NULL;
+
+ if (ctxt->input)
+ base = ctxt->input->filename;
+ if (!base)
+ base = ctxt->directory;
+
+ URI = xmlBuildURI(systemId, (const xmlChar *) base);
+ ent->URI = URI;
+ }
+ }
+ else if (ctxt->inSubset == 2)
+ {
+ ent = xmlAddDtdEntity(ctxt->myDoc, name, type, publicId,
+ systemId, content);
+ if (!ent &&
+ ctxt->pedantic &&
+ ctxt->sax &&
+ ctxt->sax->warning)
+ {
+ ctxt->sax->warning(ctxt->userData,
+ EMBED_ERRTXT("Entity(%s) already defined in the external subset\n"), name);
+ }
+ if (ent && !ent->URI && systemId)
+ {
+ xmlChar *URI;
+ const char* base = NULL;
+
+ if (ctxt->input != NULL)
+ base = ctxt->input->filename;
+ if (!base)
+ base = ctxt->directory;
+
+ URI = xmlBuildURI(systemId, (const xmlChar*) base);
+ ent->URI = URI;
+ }
+ }
+ else if (ctxt->sax && ctxt->sax->error)
+ {
+ ctxt->sax->error(ctxt->userData,
+ EMBED_ERRTXT("SAX.xmlSAX2EntityDecl(%s) called while not in subset\n"),
+ name);
+ }
+}
+
+/**
+ * xmlSAX2AttributeDecl:
+ * @param ctx the user data (XML parser context)
+ * @param elem the name of the element
+ * @param fullname the attribute name
+ * @param type the attribute type
+ * @param def the type of default value
+ * @param defaultValue the attribute default value
+ * @param tree the tree of enumerated value set
+ *
+ * An attribute definition has been parsed
+ */
+XMLPUBFUNEXPORT void
+xmlSAX2AttributeDecl(void *ctx, const xmlChar *elem, const xmlChar *fullname,
+ int type, int def, const xmlChar *defaultValue,
+ xmlEnumerationPtr tree)
+{
+ xmlParserCtxtPtr ctxt = (xmlParserCtxtPtr) ctx;
+#ifdef LIBXML_VALID_ENABLED
+ xmlAttributePtr attr;
+#endif
+ xmlChar *name = NULL, *prefix = NULL;
+
+#ifdef DEBUG_SAX
+ xmlGenericError(xmlGenericErrorContext,
+ "SAX.xmlSAX2AttributeDecl(%s, %s, %d, %d, %s, ...)\n",
+ elem, fullname, type, def, defaultValue);
+#endif
+ if ((xmlStrEqual(fullname, BAD_CAST "xml:id")) &&
+ (type != XML_ATTRIBUTE_ID)) {
+ /*
+ * Raise the error but keep the validity flag
+ */
+ int tmp = ctxt->valid;
+ xmlErrValid(ctxt, XML_DTD_XMLID_TYPE,
+ EMBED_ERRTXT("xml:id : attribute type should be ID\n"), NULL, NULL);
+ ctxt->valid = tmp;
+ }
+
+ name = xmlSplitQName(ctxt, fullname, &prefix);
+ ctxt->vctxt.valid = 1;
+ if (ctxt->inSubset == 1)
+ {
+#ifdef LIBXML_VALID_ENABLED
+ attr =
+#endif
+ xmlAddAttributeDecl(&ctxt->vctxt, ctxt->myDoc->intSubset, elem,
+ name, prefix, (xmlAttributeType) type,
+ (xmlAttributeDefault) def, defaultValue, tree);
+ }
+ else if (ctxt->inSubset == 2)
+ {
+#ifdef LIBXML_VALID_ENABLED
+ attr =
+#endif
+ xmlAddAttributeDecl(&ctxt->vctxt, ctxt->myDoc->extSubset, elem,
+ name, prefix, (xmlAttributeType) type,
+ (xmlAttributeDefault) def, defaultValue, tree);
+ }
+ else
+ {
+ if ((ctxt->sax != NULL) && (ctxt->sax->error != NULL))
+ ctxt->sax->error(ctxt->userData,
+ EMBED_ERRTXT("SAX.xmlSAX2AttributeDecl(%s) called while not in subset\n"), name);
+ xmlFreeEnumeration(tree);
+ return;
+ }
+#ifdef LIBXML_VALID_ENABLED
+ if (ctxt->vctxt.valid == 0)
+ ctxt->valid = 0;
+ if ((attr != NULL) && (ctxt->validate) && (ctxt->wellFormed) &&
+ (ctxt->myDoc != NULL) && (ctxt->myDoc->intSubset != NULL))
+ ctxt->valid &= xmlValidateAttributeDecl(&ctxt->vctxt, ctxt->myDoc,
+ attr);
+#endif /* LIBXML_VALID_ENABLED */
+ if (prefix != NULL)
+ xmlFree(prefix);
+ if (name != NULL)
+ xmlFree(name);
+}
+
+/**
+ * xmlSAX2ElementDecl:
+ * @param ctx the user data (XML parser context)
+ * @param name the element name
+ * @param type the element type
+ * @param content the element value tree
+ *
+ * An element definition has been parsed
+ */
+XMLPUBFUNEXPORT void
+xmlSAX2ElementDecl(void *ctx, const xmlChar * name, int type,
+ xmlElementContentPtr content)
+{
+ xmlParserCtxtPtr ctxt = (xmlParserCtxtPtr) ctx;
+#ifdef LIBXML_VALID_ENABLED
+ xmlElementPtr elem = NULL;
+#endif
+
+#ifdef DEBUG_SAX
+ xmlGenericError(xmlGenericErrorContext,
+ "SAX.xmlSAX2ElementDecl(%s, %d, ...)\n", name, type);
+#endif
+
+ if (ctxt->inSubset == 1){
+#ifdef LIBXML_VALID_ENABLED
+ elem =
+#endif
+ xmlAddElementDecl(&ctxt->vctxt, ctxt->myDoc->intSubset,
+ name, (xmlElementTypeVal) type, content);
+ }
+ else if (ctxt->inSubset == 2)
+ {
+#ifdef LIBXML_VALID_ENABLED
+ elem =
+#endif
+ xmlAddElementDecl(&ctxt->vctxt, ctxt->myDoc->extSubset,
+ name, (xmlElementTypeVal) type, content);
+ }
+ else
+ {
+ if ((ctxt->sax != NULL) && (ctxt->sax->error != NULL))
+ ctxt->sax->error(ctxt->userData,
+ EMBED_ERRTXT("SAX.xmlSAX2ElementDecl(%s) called while not in subset\n"),
+ name);
+ return;
+ }
+#ifdef LIBXML_VALID_ENABLED
+ if (elem == NULL)
+ ctxt->valid = 0;
+ if (ctxt->validate && ctxt->wellFormed &&
+ ctxt->myDoc && ctxt->myDoc->intSubset)
+ ctxt->valid &=
+ xmlValidateElementDecl(&ctxt->vctxt, ctxt->myDoc, elem);
+#endif /* LIBXML_VALID_ENABLED */
+}
+
+/**
+ * xmlSAX2NotationDecl:
+ * @param ctx the user data (XML parser context)
+ * @param name The name of the notation
+ * @param publicId The public ID of the entity
+ * @param systemId The system ID of the entity
+ *
+ * What to do when a notation declaration has been parsed.
+ */
+XMLPUBFUNEXPORT void
+xmlSAX2NotationDecl(void *ctx, const xmlChar *name,
+ const xmlChar *publicId, const xmlChar *systemId)
+{
+ xmlParserCtxtPtr ctxt = (xmlParserCtxtPtr) ctx;
+#ifdef LIBXML_VALID_ENABLED
+ xmlNotationPtr nota = NULL;
+#endif
+
+#ifdef DEBUG_SAX
+ xmlGenericError(xmlGenericErrorContext,
+ "SAX.xmlSAX2NotationDecl(%s, %s, %s)\n", name, publicId, systemId);
+#endif
+
+ if ((publicId == NULL) && (systemId == NULL)) {
+ if ((ctxt->sax != NULL) && (ctxt->sax->error != NULL))
+ ctxt->sax->error(ctxt->userData,
+ EMBED_ERRTXT("SAX.xmlSAX2NotationDecl(%s) externalID or PublicID missing\n"), name);
+ ctxt->valid = 0;
+ ctxt->wellFormed = 0;
+ return;
+ }
+ else if (ctxt->inSubset == 1)
+ {
+#ifdef LIBXML_VALID_ENABLED
+ nota =
+#endif
+ xmlAddNotationDecl(&ctxt->vctxt, ctxt->myDoc->intSubset, name,
+ publicId, systemId);
+ }
+ else if (ctxt->inSubset == 2)
+ {
+#ifdef LIBXML_VALID_ENABLED
+ nota =
+#endif
+ xmlAddNotationDecl(&ctxt->vctxt, ctxt->myDoc->extSubset, name,
+ publicId, systemId);
+ }
+ else
+ {
+ if ((ctxt->sax != NULL) && (ctxt->sax->error != NULL))
+ ctxt->sax->error(ctxt->userData,
+ EMBED_ERRTXT("SAX.xmlSAX2NotationDecl(%s) called while not in subset\n"), name);
+ return;
+ }
+#ifdef LIBXML_VALID_ENABLED
+ if (nota == NULL)
+ ctxt->valid = 0;
+ if (ctxt->validate && ctxt->wellFormed &&
+ ctxt->myDoc && ctxt->myDoc->intSubset)
+ ctxt->valid &= xmlValidateNotationDecl(&ctxt->vctxt, ctxt->myDoc,
+ nota);
+#endif /* LIBXML_VALID_ENABLED */
+}
+
+/**
+ * xmlSAX2UnparsedEntityDecl:
+ * @param ctx the user data (XML parser context)
+ * @param name The name of the entity
+ * @param publicId The public ID of the entity
+ * @param systemId The system ID of the entity
+ * @param notationName the name of the notation
+ *
+ * What to do when an unparsed entity declaration is parsed
+ */
+XMLPUBFUNEXPORT void
+xmlSAX2UnparsedEntityDecl(void *ctx, const xmlChar *name,
+ const xmlChar *publicId, const xmlChar *systemId,
+ const xmlChar *notationName)
+{
+ xmlEntityPtr ent;
+ xmlParserCtxtPtr ctxt = (xmlParserCtxtPtr) ctx;
+#ifdef DEBUG_SAX
+ xmlGenericError(xmlGenericErrorContext,
+ "SAX.xmlSAX2UnparsedEntityDecl(%s, %s, %s, %s)\n",
+ name, publicId, systemId, notationName);
+#endif
+ if (ctxt->inSubset == 1)
+ {
+ ent = xmlAddDocEntity(ctxt->myDoc, name,
+ XML_EXTERNAL_GENERAL_UNPARSED_ENTITY,
+ publicId, systemId, notationName);
+ if (!ent && ctxt->pedantic &&
+ ctxt->sax && ctxt->sax->warning)
+ {
+ ctxt->sax->warning(ctxt->userData,
+ EMBED_ERRTXT("Entity(%s) already defined in the internal subset\n"), name);
+ }
+ if (ent && !ent->URI && systemId)
+ {
+ xmlChar *URI;
+ const char* base = NULL;
+
+ if (ctxt->input)
+ base = ctxt->input->filename;
+ if (!base)
+ base = ctxt->directory;
+
+ URI = xmlBuildURI(systemId, (const xmlChar *) base);
+ ent->URI = URI;
+ }
+ }
+ else if (ctxt->inSubset == 2)
+ {
+ ent = xmlAddDtdEntity(ctxt->myDoc, name,
+ XML_EXTERNAL_GENERAL_UNPARSED_ENTITY,
+ publicId, systemId, notationName);
+ if (!ent && ctxt->pedantic &&
+ ctxt->sax && ctxt->sax->warning)
+ {
+ ctxt->sax->warning(ctxt->userData,
+ EMBED_ERRTXT("Entity(%s) already defined in the external subset\n"), name);
+ }
+ if (ent && !ent->URI && systemId)
+ {
+ xmlChar *URI;
+ const char* base = NULL;
+
+ if (ctxt->input)
+ base = ctxt->input->filename;
+ if (!base)
+ base = ctxt->directory;
+
+ URI = xmlBuildURI(systemId, (const xmlChar*) base);
+ ent->URI = URI;
+ }
+ }
+ else if (ctxt->sax && ctxt->sax->error)
+ {
+ ctxt->sax->error(ctxt->userData,
+ EMBED_ERRTXT("SAX.xmlSAX2UnparsedEntityDecl(%s) called while not in subset\n"), name);
+ }
+}
+
+/**
+ * xmlSAX2SetDocumentLocator:
+ * @param ctx the user data (XML parser context)
+ * @param loc A SAX Locator
+ *
+ * Receive the document locator at startup, actually xmlDefaultSAXLocator
+ * Everything is available on the context, so this is useless in our case.
+ */
+XMLPUBFUNEXPORT void
+xmlSAX2SetDocumentLocator(void *ctx ATTRIBUTE_UNUSED, xmlSAXLocatorPtr loc ATTRIBUTE_UNUSED)
+{
+ /* xmlParserCtxtPtr ctxt = (xmlParserCtxtPtr) ctx; */
+#ifdef DEBUG_SAX
+ xmlGenericError(xmlGenericErrorContext, "SAX.xmlSAX2SetDocumentLocator()\n");
+#endif
+ if(ctx) return; // just to use ctx
+}
+
+/**
+ * xmlSAX2StartDocument:
+ * @param ctx the user data (XML parser context)
+ *
+ * called when the document start being processed.
+ *
+ * OOM: possible --> check OOM flag
+ */
+XMLPUBFUNEXPORT void xmlSAX2StartDocument(void *ctx)
+{
+ xmlParserCtxtPtr ctxt = (xmlParserCtxtPtr) ctx;
+ xmlDocPtr doc = NULL;
+
+#ifdef DEBUG_SAX
+ xmlGenericError(xmlGenericErrorContext, "SAX.xmlSAX2StartDocument()\n");
+#endif
+ if (ctxt->html) {
+
+#ifdef LIBXML_HTML_ENABLED
+ if (ctxt->myDoc == NULL)
+ doc = ctxt->myDoc = htmlNewDocNoDtD(NULL, NULL);
+ if (!ctxt->myDoc)
+ goto OOM;
+#else
+ xmlGenericError(xmlGenericErrorContext, EMBED_ERRTXT("libxml2 built without HTML support\n"));
+ ctxt->errNo = XML_ERR_INTERNAL_ERROR;
+ goto ERR;
+#endif
+ } else { // not HTML
+ doc = ctxt->myDoc = xmlNewDoc(ctxt->version);
+ if (!doc)
+ goto OOM;
+
+ if (ctxt->encoding != NULL){
+ doc->encoding = xmlStrdup(ctxt->encoding);
+ if(! doc->encoding)
+ goto OOM;
+ }
+ //else
+ // doc->encoding = NULL; // it is NULL after xmlNewDoc
+ doc->standalone = ctxt->standalone;
+ if (ctxt->dictNames && doc) {
+ doc->dict = ctxt->dict;
+ xmlDictReference(doc->dict);
+ }
+ }
+ if ( /* (ctxt->myDoc != NULL) && : it's NOT NULL here */
+ !doc->URL &&
+ ctxt->input &&
+ ctxt->input->filename)
+ {
+ doc->URL = xmlCanonicPath((const xmlChar *) ctxt->input->filename);
+ if (!doc->URL)
+ doc->URL = xmlStrdup((const xmlChar *) ctxt->input->filename);
+ }
+ return;
+//----------------------------
+OOM:
+ if ((ctxt->sax != NULL) && (ctxt->sax->error != NULL))
+ ctxt->sax->error(ctxt->userData, EMBED_ERRTXT("SAX.xmlSAX2StartDocument(): out of memory\n"));
+ ctxt->errNo = XML_ERR_NO_MEMORY;
+ERR:
+ ctxt->instate = XML_PARSER_EOF;
+ ctxt->disableSAX = 1;
+ return;
+}
+
+/**
+ * xmlSAX2EndDocument:
+ * @param ctx the user data (XML parser context)
+ *
+ * called when the document end has been detected.
+ */
+XMLPUBFUNEXPORT void
+xmlSAX2EndDocument(void *ctx)
+{
+ xmlParserCtxtPtr ctxt = (xmlParserCtxtPtr) ctx;
+#ifdef DEBUG_SAX
+ xmlGenericError(xmlGenericErrorContext, "SAX.xmlSAX2EndDocument()\n");
+#endif
+#ifdef LIBXML_VALID_ENABLED
+ if (ctxt->validate && ctxt->wellFormed && ctxt->myDoc && ctxt->myDoc->intSubset)
+ ctxt->valid &= xmlValidateDocumentFinal(&ctxt->vctxt, ctxt->myDoc);
+#endif /* LIBXML_VALID_ENABLED */
+
+ /*
+ * Grab the encoding if it was added on-the-fly
+ */
+ if (ctxt->encoding &&
+ ctxt->myDoc &&
+ !ctxt->myDoc->encoding)
+ {
+ ctxt->myDoc->encoding = ctxt->encoding;
+ ctxt->encoding = NULL;
+ }
+ if (ctxt->inputTab[0]->encoding &&
+ ctxt->myDoc &&
+ !ctxt->myDoc->encoding)
+ {
+ ctxt->myDoc->encoding = xmlStrdup(ctxt->inputTab[0]->encoding);
+ }
+ if ((ctxt->charset != XML_CHAR_ENCODING_NONE) &&
+ ctxt->myDoc &&
+ (ctxt->myDoc->charset == XML_CHAR_ENCODING_NONE))
+ {
+ ctxt->myDoc->charset = ctxt->charset;
+ }
+}
+
+// Note: old (SAX1) handlers -- name is misleading
+#if defined(LIBXML_SAX1_ENABLED) || defined(LIBXML_HTML_ENABLED)
+/**
+ * xmlSAX2AttributeInternal:
+ * @param ctx the user data (XML parser context)
+ * @param fullname The attribute name, including namespace prefix
+ * @param value The attribute value
+ * @param prefix the prefix on the element node
+ *
+ * Handle an attribute that has been read by the parser.
+ * The default handling is to convert the attribute into an
+ * DOM subtree and past it in a new xmlAttr element added to
+ * the element.
+ */
+static void
+xmlSAX2AttributeInternal(void *ctx, const xmlChar *fullname,
+ const xmlChar *value, const xmlChar *prefix ATTRIBUTE_UNUSED)
+{
+ // DONE: Find and refactor all "namespace" variables to not match C++ keyword
+ xmlParserCtxtPtr ctxt = (xmlParserCtxtPtr) ctx;
+ xmlAttrPtr ret;
+ xmlChar *name;
+ xmlChar *ns;
+ xmlChar *nval;
+ xmlNsPtr nameSpace;
+
+ /*
+ * Split the full name into a namespace prefix and the tag name
+ */
+ name = xmlSplitQName(ctxt, fullname, &ns);
+ if ((name != NULL) && (name[0] == 0)) {
+ if (xmlStrEqual(ns, BAD_CAST "xmlns")) {
+ if ((ctxt->sax != NULL) && (ctxt->sax->error != NULL))
+ ctxt->sax->error(ctxt->userData,
+ EMBED_ERRTXT("invalid namespace declaration '%s'\n"), fullname);
+ } else {
+ if ((ctxt->sax != NULL) && (ctxt->sax->warning != NULL))
+ ctxt->sax->warning(ctxt->userData,
+ EMBED_ERRTXT("Avoid attribute ending with ':' like '%s'\n"), fullname);
+ }
+ if (ns != NULL)
+ xmlFree(ns);
+ ns = NULL;
+ xmlFree(name);
+ name = xmlStrdup(fullname);
+ }
+ if (name == NULL) {
+ if ((ctxt->sax != NULL) && (ctxt->sax->error != NULL))
+ ctxt->sax->error(ctxt->userData,EMBED_ERRTXT("SAX.xmlSAX2StartElement(): out of memory\n"));
+ ctxt->errNo = XML_ERR_NO_MEMORY;
+ ctxt->instate = XML_PARSER_EOF;
+ ctxt->disableSAX = 1;
+ if (ns != NULL)
+ xmlFree(ns);
+ return;
+ }
+
+#ifdef LIBXML_VALID_ENABLED
+ /*
+ * Do the last stage of the attribute normalization
+ * Needed for HTML too:
+ * http://www.w3.org/TR/html4/types.html#h-6.2
+ */
+ ctxt->vctxt.valid = 1;
+ nval = xmlValidCtxtNormalizeAttributeValue(&ctxt->vctxt,
+ ctxt->myDoc, ctxt->node,
+ fullname, value);
+ if (ctxt->vctxt.valid != 1) {
+ ctxt->valid = 0;
+ }
+ if (nval != NULL)
+ value = nval;
+#else
+ nval = NULL;
+#endif /* LIBXML_VALID_ENABLED */
+
+ /*
+ * Check whether it's a namespace definition
+ */
+ if ((!ctxt->html) && (ns == NULL) &&
+ (name[0] == 'x') && (name[1] == 'm') && (name[2] == 'l') &&
+ (name[3] == 'n') && (name[4] == 's') && (name[5] == 0))
+ {
+ xmlNsPtr nsret;
+ xmlChar *val;
+
+ if (!ctxt->replaceEntities) {
+ ctxt->depth++;
+ val = xmlStringDecodeEntities(ctxt, value, XML_SUBSTITUTE_REF,0,0,0);
+ ctxt->depth--;
+ } else {
+ val = (xmlChar *) value;
+ }
+
+ if (val[0] != 0) {
+ xmlURIPtr uri;
+
+ uri = xmlParseURI((const char *)val);
+ if (uri == NULL) {
+ if ((ctxt->sax != NULL) && (ctxt->sax->warning != NULL))
+ ctxt->sax->warning(ctxt->userData,
+ EMBED_ERRTXT("xmlns: %s not a valid URI\n"), val);
+ } else {
+ if (uri->scheme == NULL) {
+ if ((ctxt->sax != NULL) && (ctxt->sax->warning != NULL))
+ ctxt->sax->warning(ctxt->userData,
+ EMBED_ERRTXT("xmlns: URI %s is not absolute\n"), val);
+ }
+ xmlFreeURI(uri);
+ }
+ }
+
+ /* a default namespace definition */
+ nsret = xmlNewNs(ctxt->node, val, NULL);
+
+#ifdef LIBXML_VALID_ENABLED
+ /*
+ * Validate also for namespace decls, they are attributes from
+ * an XML-1.0 perspective
+ */
+ if (nsret != NULL &&
+ ctxt->validate &&
+ ctxt->wellFormed &&
+ ctxt->myDoc && ctxt->myDoc->intSubset)
+ {
+ ctxt->valid &= xmlValidateOneNamespace(&ctxt->vctxt, ctxt->myDoc,
+ ctxt->node, prefix, nsret, val);
+ }
+#endif /* LIBXML_VALID_ENABLED */
+ if (name != NULL)
+ xmlFree(name);
+ if (nval != NULL)
+ xmlFree(nval);
+ if (val != value)
+ xmlFree(val);
+ return;
+ }
+
+ if ((!ctxt->html) &&
+ (ns != NULL) &&
+ (ns[0] == 'x') && (ns[1] == 'm') && (ns[2] == 'l') &&
+ (ns[3] == 'n') && (ns[4] == 's') && (ns[5] == 0))
+ {
+ xmlNsPtr nsret;
+ xmlChar *val;
+
+ if (!ctxt->replaceEntities) {
+ ctxt->depth++;
+ val = xmlStringDecodeEntities(ctxt, value, XML_SUBSTITUTE_REF,
+ 0,0,0);
+ ctxt->depth--;
+ if (val == NULL) {
+ if ((ctxt->sax != NULL) && (ctxt->sax->error != NULL))
+ ctxt->sax->error(ctxt->userData, EMBED_ERRTXT("SAX.xmlSAX2StartElement(): out of memory\n"));
+ ctxt->errNo = XML_ERR_NO_MEMORY;
+ ctxt->instate = XML_PARSER_EOF;
+ ctxt->disableSAX = 1;
+ xmlFree(ns);
+ if (name != NULL)
+ xmlFree(name);
+ return;
+ }
+ } else {
+ val = (xmlChar *) value;
+ }
+
+ if (val[0] == 0) {
+ if ((ctxt->sax != NULL) && (ctxt->sax->error != NULL))
+ ctxt->sax->error(ctxt->userData, EMBED_ERRTXT("Empty namespace name for prefix %s\n"), name);
+ }
+ if ((ctxt->pedantic != 0) && (val[0] != 0)) {
+ xmlURIPtr uri;
+
+ uri = xmlParseURI((const char *)val);
+ if (uri == NULL) {
+ if ((ctxt->sax != NULL) && (ctxt->sax->warning != NULL))
+ ctxt->sax->warning(ctxt->userData,
+ EMBED_ERRTXT("xmlns:%s: %s not a valid URI\n"), name, value);
+ } else {
+ if (uri->scheme == NULL) {
+ if ((ctxt->sax != NULL) && (ctxt->sax->warning != NULL))
+ ctxt->sax->warning(ctxt->userData,
+ EMBED_ERRTXT("xmlns:%s: URI %s is not absolute\n"), name, value);
+ }
+ xmlFreeURI(uri);
+ }
+ }
+
+ /* a standard namespace definition */
+ nsret = xmlNewNs(ctxt->node, val, name);
+ xmlFree(ns);
+#ifdef LIBXML_VALID_ENABLED
+ /*
+ * Validate also for namespace decls, they are attributes from
+ * an XML-1.0 perspective
+ */
+ if (nsret != NULL && ctxt->validate && ctxt->wellFormed &&
+ ctxt->myDoc && ctxt->myDoc->intSubset)
+ ctxt->valid &= xmlValidateOneNamespace(&ctxt->vctxt, ctxt->myDoc,
+ ctxt->node, prefix, nsret, value);
+#endif /* LIBXML_VALID_ENABLED */
+ if (name != NULL)
+ xmlFree(name);
+ if (nval != NULL)
+ xmlFree(nval);
+ if (val != value)
+ xmlFree(val);
+ return;
+ }
+
+ if (ns != NULL) {
+ xmlAttrPtr prop;
+ nameSpace = xmlSearchNs(ctxt->myDoc, ctxt->node, ns);
+ if (nameSpace == NULL) {
+ if ((ctxt->sax != NULL) && (ctxt->sax->error != NULL))
+ ctxt->sax->error(ctxt->userData,
+ EMBED_ERRTXT("Namespace prefix %s of attribute %s is not defined\n"),
+ ns, name);
+ }
+
+ prop = ctxt->node->properties;
+ while (prop != NULL) {
+ if (prop->ns != NULL) {
+ if ((xmlStrEqual(name, prop->name)) &&
+ ((nameSpace == prop->ns) ||
+ (xmlStrEqual(nameSpace->href, prop->ns->href)))) {
+ ctxt->errNo = XML_ERR_ATTRIBUTE_REDEFINED;
+ if ((ctxt->sax != NULL) && (ctxt->sax->error != NULL))
+ ctxt->sax->error(ctxt->userData,
+ EMBED_ERRTXT("Attribute %s in %s redefined\n"),
+ name, nameSpace->href);
+ ctxt->wellFormed = 0;
+ if (ctxt->recovery == 0) ctxt->disableSAX = 1;
+ goto error;
+ }
+ }
+ prop = prop->next;
+ }
+ } else {
+ nameSpace = NULL;
+ }
+
+ /* !!!!!! <a toto:arg="" xmlns:toto="http://toto.com"> */
+ ret = xmlNewNsPropEatName(ctxt->node, nameSpace, name, NULL);
+
+ if (ret != NULL) {
+ if ((ctxt->replaceEntities == 0) && (!ctxt->html)) {
+ xmlNodePtr tmp;
+
+ ret->children = xmlStringGetNodeList(ctxt->myDoc, value);
+ tmp = ret->children;
+ while (tmp != NULL) {
+ tmp->parent = (xmlNodePtr) ret;
+ if (tmp->next == NULL)
+ ret->last = tmp;
+ tmp = tmp->next;
+ }
+ } else if (value != NULL) {
+ ret->children = xmlNewDocText(ctxt->myDoc, value);
+ ret->last = ret->children;
+ if (ret->children != NULL)
+ ret->children->parent = (xmlNodePtr) ret;
+ }
+ }
+
+#ifdef LIBXML_VALID_ENABLED
+ if ((!ctxt->html) && ctxt->validate && ctxt->wellFormed &&
+ ctxt->myDoc && ctxt->myDoc->intSubset)
+ {
+ /*
+ * If we don't substitute entities, the validation should be
+ * done on a value with replaced entities anyway.
+ */
+ if (!ctxt->replaceEntities) {
+ xmlChar *val;
+
+ ctxt->depth++;
+ val = xmlStringDecodeEntities(ctxt, value, XML_SUBSTITUTE_REF,0,0,0);
+ ctxt->depth--;
+
+ if (val == NULL)
+ ctxt->valid &= xmlValidateOneAttribute(&ctxt->vctxt, ctxt->myDoc, ctxt->node, ret, value);
+ else {
+ xmlChar *nvalnorm;
+
+ /*
+ * Do the last stage of the attribute normalization
+ * It need to be done twice ... it's an extra burden related
+ * to the ability to keep xmlSAX2References in attributes
+ */
+ nvalnorm = xmlValidNormalizeAttributeValue(ctxt->myDoc, ctxt->node, fullname, val);
+ if (nvalnorm != NULL) {
+ xmlFree(val);
+ val = nvalnorm;
+ }
+
+ ctxt->valid &= xmlValidateOneAttribute(&ctxt->vctxt, ctxt->myDoc, ctxt->node, ret, val);
+ xmlFree(val);
+ }
+ } else {
+ ctxt->valid &= xmlValidateOneAttribute(&ctxt->vctxt, ctxt->myDoc, ctxt->node, ret, value);
+ }
+ } else
+#endif /* LIBXML_VALID_ENABLED */
+ if (((ctxt->loadsubset & XML_SKIP_IDS) == 0) &&
+ (((ctxt->replaceEntities == 0) && (ctxt->external != 2)) ||
+ ((ctxt->replaceEntities != 0) && (ctxt->inSubset == 0)))) {
+ /*
+ * when validating, the ID registration is done at the attribute
+ * validation level. Otherwise we have to do specific handling here.
+ */
+ if (xmlIsID(ctxt->myDoc, ctxt->node, ret))
+ xmlAddID(&ctxt->vctxt, ctxt->myDoc, value, ret);
+ else if (xmlIsRef(ctxt->myDoc, ctxt->node, ret))
+ xmlAddRef(&ctxt->vctxt, ctxt->myDoc, value, ret);
+ else if (xmlStrEqual(fullname, BAD_CAST "xml:id")) {
+ /*
+ * Add the xml:id value
+ *
+ * Open issue: normalization of the value.
+ */
+ if (xmlValidateNCName(value, 1) != 0) {
+ xmlErrValid(ctxt, XML_DTD_XMLID_VALUE,
+ EMBED_ERRTXT("xml:id : attribute value %s is not an NCName\n"),
+ (const char *) value, NULL);
+ }
+ xmlAddID(&ctxt->vctxt, ctxt->myDoc, value, ret);
+ }
+ }
+
+error:
+ if (nval != NULL)
+ xmlFree(nval);
+ if (ns != NULL)
+ xmlFree(ns);
+}
+
+/*
+ * xmlCheckDefaultedAttributes:
+ *
+ * Check defaulted attributes from the DTD
+ */
+static void
+xmlCheckDefaultedAttributes(xmlParserCtxtPtr ctxt, const xmlChar *name,
+ const xmlChar *prefix, const xmlChar **atts) {
+ xmlElementPtr elemDecl;
+ const xmlChar *att;
+ int internal = 1;
+ int i;
+
+ elemDecl = xmlGetDtdQElementDesc(ctxt->myDoc->intSubset, name, prefix);
+ if (elemDecl == NULL) {
+ elemDecl = xmlGetDtdQElementDesc(ctxt->myDoc->extSubset, name, prefix);
+ internal = 0;
+ }
+
+process_external_subset:
+
+ if (elemDecl != NULL) {
+ xmlAttributePtr attr = elemDecl->attributes;
+ /*
+ * Check against defaulted attributes from the external subset
+ * if the document is stamped as standalone
+ */
+ if ((ctxt->myDoc->standalone == 1) &&
+ (ctxt->myDoc->extSubset != NULL) &&
+ (ctxt->validate)) {
+ while (attr != NULL) {
+ if ((attr->defaultValue != NULL) &&
+ (xmlGetDtdQAttrDesc(ctxt->myDoc->extSubset,
+ attr->elem, attr->name,
+ attr->prefix) == attr) &&
+ (xmlGetDtdQAttrDesc(ctxt->myDoc->intSubset,
+ attr->elem, attr->name,
+ attr->prefix) == NULL)) {
+ xmlChar *fulln;
+
+ if (attr->prefix != NULL) {
+ fulln = xmlStrdup(attr->prefix);
+ fulln = xmlStrcat(fulln, BAD_CAST ":");
+ fulln = xmlStrcat(fulln, attr->name);
+ } else {
+ fulln = xmlStrdup(attr->name);
+ }
+
+ /*
+ * Check that the attribute is not declared in the
+ * serialization
+ */
+ att = NULL;
+ if (atts != NULL) {
+ i = 0;
+ att = atts[i];
+ while (att != NULL) {
+ if (xmlStrEqual(att, fulln))
+ break;
+ i += 2;
+ att = atts[i];
+ }
+ }
+ if (att == NULL) {
+ xmlErrValid(ctxt, XML_DTD_STANDALONE_DEFAULTED,
+ EMBED_ERRTXT("standalone: attribute %s on %s defaulted from external subset\n"),
+ (const char *)fulln,
+ (const char *)attr->elem);
+ }
+ }
+ attr = attr->nexth;
+ }
+ }
+
+ /*
+ * Actually insert defaulted values when needed
+ */
+ attr = elemDecl->attributes;
+ while (attr != NULL) {
+ /*
+ * Make sure that attributes redefinition occuring in the
+ * internal subset are not overriden by definitions in the
+ * external subset.
+ */
+ if (attr->defaultValue != NULL) {
+ /*
+ * the element should be instantiated in the tree if:
+ * - this is a namespace prefix
+ * - the user required for completion in the tree
+ * like XSLT
+ * - there isn't already an attribute definition
+ * in the internal subset overriding it.
+ */
+ if (((attr->prefix != NULL) &&
+ (xmlStrEqual(attr->prefix, BAD_CAST "xmlns"))) ||
+ ((attr->prefix == NULL) &&
+ (xmlStrEqual(attr->name, BAD_CAST "xmlns"))) ||
+ (ctxt->loadsubset & XML_COMPLETE_ATTRS)) {
+ xmlAttributePtr tst;
+
+ tst = xmlGetDtdQAttrDesc(ctxt->myDoc->intSubset,
+ attr->elem, attr->name,
+ attr->prefix);
+ if ((tst == attr) || (tst == NULL)) {
+ xmlChar fn[50];
+ xmlChar *fulln;
+
+ fulln = xmlBuildQName(attr->name, attr->prefix, fn, 50);
+ if (fulln == NULL) {
+ if ((ctxt->sax != NULL) &&
+ (ctxt->sax->error != NULL))
+ ctxt->sax->error(ctxt->userData,
+ EMBED_ERRTXT("SAX.xmlSAX2StartElement(): out of memory\n"));
+ ctxt->errNo = XML_ERR_NO_MEMORY;
+ ctxt->instate = XML_PARSER_EOF;
+ ctxt->disableSAX = 1;
+ return;
+ }
+
+ /*
+ * Check that the attribute is not declared in the
+ * serialization
+ */
+ att = NULL;
+ if (atts != NULL) {
+ i = 0;
+ att = atts[i];
+ while (att != NULL) {
+ if (xmlStrEqual(att, fulln))
+ break;
+ i += 2;
+ att = atts[i];
+ }
+ }
+ if (att == NULL) {
+ xmlSAX2AttributeInternal(ctxt, fulln,
+ attr->defaultValue, prefix);
+ }
+ if ((fulln != fn) && (fulln != attr->name))
+ xmlFree(fulln);
+ }
+ }
+ }
+ attr = attr->nexth;
+ }
+ if (internal == 1) {
+ elemDecl = xmlGetDtdQElementDesc(ctxt->myDoc->extSubset,
+ name, prefix);
+ internal = 0;
+ goto process_external_subset;
+ }
+ }
+}
+
+/**
+ * xmlSAX2StartElement:
+ * @param ctx the user data (XML parser context)
+ * @param fullname The element name, including namespace prefix
+ * @param atts An array of name/value attributes pairs, NULL terminated
+ *
+ * called when an opening tag has been processed.
+ */
+XMLPUBFUNEXPORT void
+xmlSAX2StartElement(void *ctx, const xmlChar *fullname, const xmlChar **atts)
+{
+ xmlParserCtxtPtr ctxt = (xmlParserCtxtPtr) ctx;
+ xmlNodePtr ret;
+ xmlNodePtr parent = ctxt->node;
+ xmlNsPtr ns;
+ xmlChar *name;
+ xmlChar *prefix;
+ const xmlChar *att;
+ const xmlChar *value;
+ int i;
+
+#ifdef DEBUG_SAX
+ xmlGenericError(xmlGenericErrorContext,
+ "SAX.xmlSAX2StartElement(%s)\n", fullname);
+#endif
+
+ /*
+ * First check on validity:
+ */
+ if (ctxt->validate && (ctxt->myDoc->extSubset == NULL) &&
+ ((ctxt->myDoc->intSubset == NULL) ||
+ ((ctxt->myDoc->intSubset->notations == NULL) &&
+ (ctxt->myDoc->intSubset->elements == NULL) &&
+ (ctxt->myDoc->intSubset->attributes == NULL) &&
+ (ctxt->myDoc->intSubset->entities == NULL)))) {
+ xmlErrValid(ctxt, XML_ERR_NO_DTD,
+ EMBED_ERRTXT("Validation failed: no DTD found !"), NULL, NULL);
+ ctxt->validate = 0;
+ }
+
+
+ /*
+ * Split the full name into a namespace prefix and the tag name
+ */
+ name = xmlSplitQName(ctxt, fullname, &prefix);
+
+
+ /*
+ * Note : the namespace resolution is deferred until the end of the
+ * attributes parsing, since local namespace can be defined as
+ * an attribute at this level.
+ */
+ ret = xmlNewDocNodeEatName(ctxt->myDoc, NULL, name, NULL);
+ if (ret == NULL) {
+ if (prefix != NULL)
+ xmlFree(prefix);
+ ctxt->errNo = XML_ERR_NO_MEMORY;
+ ctxt->instate = XML_PARSER_EOF;
+ ctxt->disableSAX = 1;
+ return;
+ }
+ if (ctxt->myDoc->children == NULL) {
+#ifdef DEBUG_SAX_TREE
+ xmlGenericError(xmlGenericErrorContext, "Setting %s as root\n", name);
+#endif
+ xmlAddChild((xmlNodePtr) ctxt->myDoc, (xmlNodePtr) ret);
+ } else if (parent == NULL) {
+ parent = ctxt->myDoc->children;
+ }
+ ctxt->nodemem = -1;
+
+#ifdef LIBXML_ENABLE_NODE_LINEINFO
+ if (ctxt->linenumbers) {
+ if (ctxt->input != NULL) {
+ if (ctxt->input->line < 65535)
+ ret->line = (short) ctxt->input->line;
+ else
+ ret->line = 65535;
+ }
+ }
+#endif
+ /*
+ * We are parsing a new node.
+ */
+#ifdef DEBUG_SAX_TREE
+ xmlGenericError(xmlGenericErrorContext, "pushing(%s)\n", name);
+#endif
+ nodePush(ctxt, ret);
+
+ /*
+ * Link the child element
+ */
+ if (parent != NULL) {
+ if (parent->type == XML_ELEMENT_NODE) {
+#ifdef DEBUG_SAX_TREE
+ xmlGenericError(xmlGenericErrorContext,"adding child %s to %s\n", name, parent->name);
+#endif
+ xmlAddChild(parent, ret);
+ } else {
+#ifdef DEBUG_SAX_TREE
+ xmlGenericError(xmlGenericErrorContext,"adding sibling %s to ", name);
+ xmlDebugDumpOneNode(stderr, parent, 0);
+#endif
+ xmlAddSibling(parent, ret);
+ }
+ }
+
+ /*
+ * Insert all the defaulted attributes from the DTD especially namespaces
+ */
+
+ if ((!ctxt->html) &&
+ ((ctxt->myDoc->intSubset != NULL) || (ctxt->myDoc->extSubset != NULL)))
+ {
+ xmlCheckDefaultedAttributes(ctxt, name, prefix, atts);
+ }
+
+ /*
+ * process all the attributes whose name start with "xmlns"
+ */
+ if (atts != NULL) {
+ i = 0;
+ att = atts[i++];
+ value = atts[i++];
+ if (!ctxt->html) {
+ while ((att != NULL) && (value != NULL)) {
+ if ((att[0] == 'x') && (att[1] == 'm') && (att[2] == 'l') &&
+ (att[3] == 'n') && (att[4] == 's'))
+ xmlSAX2AttributeInternal(ctxt, att, value, prefix);
+
+ att = atts[i++];
+ value = atts[i++];
+ }
+ }
+ }
+
+ /*
+ * Search the namespace, note that since the attributes have been
+ * processed, the local namespaces are available.
+ */
+ ns = xmlSearchNs(ctxt->myDoc, ret, prefix);
+ if ((ns == NULL) && (parent != NULL))
+ ns = xmlSearchNs(ctxt->myDoc, parent, prefix);
+
+ if ((prefix != NULL) && (ns == NULL)) {
+ ns = xmlNewNs(ret, NULL, prefix);
+ if ((ctxt->sax != NULL) && (ctxt->sax->warning != NULL))
+ ctxt->sax->warning(ctxt->userData,EMBED_ERRTXT("Namespace prefix %s is not defined\n"), prefix);
+ }
+
+ /*
+ * set the namespace node, making sure that if the default namspace
+ * is unbound on a parent we simply kee it NULL
+ */
+ if ((ns != NULL) && (ns->href != NULL) &&
+ ((ns->href[0] != 0) || (ns->prefix != NULL)))
+ xmlSetNs(ret, ns);
+
+ /*
+ * process all the other attributes
+ */
+ if (atts != NULL) {
+ i = 0;
+ att = atts[i++];
+ value = atts[i++];
+ if (ctxt->html) {
+ while (att != NULL) {
+ xmlSAX2AttributeInternal(ctxt, att, value, NULL);
+ att = atts[i++];
+ value = atts[i++];
+ }
+ } else {
+ while ((att != NULL) && (value != NULL)) {
+ if ((att[0] != 'x') || (att[1] != 'm') || (att[2] != 'l') ||
+ (att[3] != 'n') || (att[4] != 's'))
+ xmlSAX2AttributeInternal(ctxt, att, value, NULL);
+
+ /*
+ * Next ones
+ */
+ att = atts[i++];
+ value = atts[i++];
+ }
+ }
+ }
+
+#ifdef LIBXML_VALID_ENABLED
+ /*
+ * If it's the Document root, finish the DTD validation and
+ * check the document root element for validity
+ */
+ if ((ctxt->validate) && (ctxt->vctxt.finishDtd == 0)) {
+ int chk;
+
+ chk = xmlValidateDtdFinal(&ctxt->vctxt, ctxt->myDoc);
+ if (chk <= 0)
+ ctxt->valid = 0;
+ if (chk < 0)
+ ctxt->wellFormed = 0;
+ ctxt->valid &= xmlValidateRoot(&ctxt->vctxt, ctxt->myDoc);
+ ctxt->vctxt.finishDtd = 1;
+ }
+#endif /* LIBXML_VALID_ENABLED */
+
+ if (prefix != NULL)
+ xmlFree(prefix);
+
+}
+
+/**
+ * xmlSAX2EndElement:
+ * @param ctx the user data (XML parser context)
+ * @param name The element name
+ *
+ * called when the end of an element has been detected.
+ */
+XMLPUBFUNEXPORT void
+xmlSAX2EndElement(void *ctx, const xmlChar *name ATTRIBUTE_UNUSED)
+{
+ xmlParserCtxtPtr ctxt = (xmlParserCtxtPtr) ctx;
+ //xmlParserNodeInfo node_info;
+ xmlNodePtr cur = ctxt->node;
+
+#ifdef DEBUG_SAX
+ if (name == NULL)
+ xmlGenericError(xmlGenericErrorContext, "SAX.xmlSAX2EndElement(NULL)\n");
+ else
+ xmlGenericError(xmlGenericErrorContext, "SAX.xmlSAX2EndElement(%s)\n", name);
+#endif
+
+#ifdef XMLENGINE_ENABLE_PARSER_RECORD_INFO
+ /* Capture end position and add node */
+ if (cur != NULL && ctxt->record_info) {
+ node_info.end_pos = ctxt->input->cur - ctxt->input->base;
+ node_info.end_line = ctxt->input->line;
+ node_info.node = cur;
+ xmlParserAddNodeInfo(ctxt, &node_info);
+ }
+#endif // XMLENGINE_ENABLE_PARSER_RECORD_INFO
+
+ ctxt->nodemem = -1;
+
+#ifdef LIBXML_VALID_ENABLED
+ if (ctxt->validate && ctxt->wellFormed &&
+ ctxt->myDoc && ctxt->myDoc->intSubset)
+ ctxt->valid &= xmlValidateOneElement(&ctxt->vctxt, ctxt->myDoc,
+ cur);
+#endif /* LIBXML_VALID_ENABLED */
+
+
+ /*
+ * end of parsing of this node.
+ */
+#ifdef DEBUG_SAX_TREE
+ xmlGenericError(xmlGenericErrorContext, "popping(%s)\n", cur->name);
+#endif
+ nodePop(ctxt);
+}
+#endif /* LIBXML_SAX1_ENABLED || LIBXML_HTML_ENABLE */
+
+/*
+ * xmlSAX2TextNode:
+ * @param ctxt the parser context
+ * @param str the input string
+ * @param len the string length
+ *
+ * Remove the entities from an attribute value
+ *
+ * Returns the newly allocated string or NULL if not needed or error
+ */
+static xmlNodePtr
+xmlSAX2TextNode(xmlParserCtxtPtr ctxt, const xmlChar *str, int len) {
+ LOAD_GS(ctxt)
+ xmlNodePtr ret;
+ const xmlChar *intern = NULL;
+
+ /*
+ * Allocate
+ */
+ if (ctxt->freeElems != NULL) {
+ ret = ctxt->freeElems;
+ ctxt->freeElems = ret->next;
+ ctxt->freeElemsNr--;
+ } else {
+ ret = (xmlNodePtr) xmlMalloc(sizeof(xmlNode));
+ }
+ if (ret == NULL) {
+OOM:
+ if ((ctxt->sax != NULL) && (ctxt->sax->error != NULL))
+ ctxt->sax->error(ctxt->userData, EMBED_ERRTXT("SAX.xmlSAX2Characters(): out of memory\n"));
+ ctxt->errNo = XML_ERR_NO_MEMORY;
+ ctxt->instate = XML_PARSER_EOF;
+ ctxt->disableSAX = 1;
+ return(NULL);
+ }
+ /*
+ * intern the formatting blanks found between tags, or the
+ * very short strings
+ */
+ if (ctxt->dictNames) {
+ xmlChar cur = str[len];
+
+ if ((len <= 3) && ((cur == '"') || (cur == '\'') ||
+ ((cur == '<') && (str[len + 1] != '!'))))
+ {
+ intern = xmlDictLookup(ctxt->dict, str, len);
+ }
+ else if (IS_BLANK_CH(*str) && (len < 60) && (cur == '<') &&
+ (str[len + 1] != '!'))
+ {
+ int i;
+
+ for (i = 1;i < len;i++) {
+ if (!IS_BLANK_CH(str[i])) goto skip;
+ }
+ intern = xmlDictLookup(ctxt->dict, str, len);
+ }
+ }
+skip:
+ memset(ret, 0, sizeof(xmlNode));
+ ret->type = XML_TEXT_NODE;
+
+ ret->name = xmlStringText;
+ if (intern == NULL)
+ {
+ ret->content = xmlStrndup(str, len);
+ {
+ if(OOM_FLAG)
+ {
+ if (ctxt->freeElems != NULL)
+ {
+ ctxt->freeElemsNr++;
+ ret->next = ctxt->freeElems;
+ ctxt->freeElems = ret;
+ }
+ else
+ {
+ xmlFreeNode(ret);
+ }
+ goto OOM;
+ }
+ }
+ }
+ else
+ ret->content = (xmlChar *) intern;
+
+ if ((__xmlRegisterCallbacks) && (xmlRegisterNodeDefaultValue))
+ xmlRegisterNodeDefaultValue(ret);
+ return(ret);
+}
+
+#ifdef LIBXML_VALID_ENABLED
+/*
+ * xmlSAX2DecodeAttrEntities:
+ * @param ctxt the parser context
+ * @param str the input string
+ * @param len the string length
+ *
+ * Remove the entities from an attribute value
+ *
+ * Returns the newly allocated string or NULL if not needed or error
+ */
+static xmlChar *
+xmlSAX2DecodeAttrEntities(xmlParserCtxtPtr ctxt, const xmlChar *str,
+ const xmlChar *end) {
+ const xmlChar *in;
+ xmlChar *ret;
+
+ in = str;
+ while (in < end)
+ if (*in++ == '&')
+ goto decode;
+ return(NULL);
+decode:
+ ctxt->depth++;
+ ret = xmlStringLenDecodeEntities(ctxt, str, end - str,
+ XML_SUBSTITUTE_REF, 0,0,0);
+ ctxt->depth--;
+ return(ret);
+}
+#endif /* LIBXML_VALID_ENABLED */
+
+
+/**
+ * xmlSAX2AttributeNs:
+ * @param ctx the user data (XML parser context)
+ * @param localname the local name of the attribute
+ * @param prefix the attribute namespace prefix if available
+ * @param URI the attribute namespace name if available
+ * @param value Start of the attribute value
+ * @param valueend end of the attribute value
+ *
+ * Handle an attribute that has been read by the parser.
+ * The default handling is to convert the attribute into an
+ * DOM subtree and past it in a new xmlAttr element added to
+ * the element.
+ */
+static void
+xmlSAX2AttributeNs(xmlParserCtxtPtr ctxt,
+ const xmlChar* localname,
+ const xmlChar* prefix,
+ const xmlChar* value,
+ const xmlChar* valueend)
+{
+ LOAD_GS(ctxt)
+ xmlAttrPtr ret;
+ xmlNsPtr nameSpace = NULL;
+ xmlChar *dup = NULL;
+
+ /*
+ * Note: if prefix == NULL, the attribute is not in the default namespace
+ */
+ if (prefix != NULL)
+ nameSpace = xmlSearchNs(ctxt->myDoc, ctxt->node, prefix);
+
+ /*
+ * allocate the node
+ */
+ if (ctxt->freeAttrs != NULL)
+ {
+ ret = ctxt->freeAttrs;
+ ctxt->freeAttrs = ret->next;
+ ctxt->freeAttrsNr--;
+ memset(ret, 0, sizeof(xmlAttr));
+ ret->type = XML_ATTRIBUTE_NODE;
+
+ ret->parent = ctxt->node;
+ ret->doc = ctxt->myDoc;
+ ret->ns = nameSpace;
+
+ if (ctxt->dictNames)
+ ret->name = localname;
+ else
+ ret->name = xmlStrdup(localname);
+
+
+ if (ctxt->node->properties == NULL) {
+ ctxt->node->properties = ret;
+ } else {
+ xmlAttrPtr prev = ctxt->node->properties;
+
+ while (prev->next != NULL) prev = prev->next;
+ prev->next = ret;
+ ret->prev = prev;
+ }
+
+ if ((__xmlRegisterCallbacks) && (xmlRegisterNodeDefaultValue))
+ xmlRegisterNodeDefaultValue((xmlNodePtr)ret);
+ } else {
+ if (ctxt->dictNames)
+ ret = xmlNewNsPropEatName(ctxt->node, nameSpace,
+ (xmlChar *) localname, NULL);
+ else
+ ret = xmlNewNsProp(ctxt->node, nameSpace, localname, NULL);
+ if (ret == NULL) {
+ ctxt->errNo = XML_ERR_NO_MEMORY;
+ ctxt->instate = XML_PARSER_EOF;
+ ctxt->disableSAX = 1;
+ return;
+ }
+ }
+
+ if ((ctxt->replaceEntities == 0) && (!ctxt->html))
+ {
+ xmlNodePtr tmp;
+
+ /*
+ * We know that if there is an entity reference, then
+ * the string has been dup'ed and terminates with 0
+ * otherwise with ' or "
+ */
+ if (*valueend != 0) {
+ tmp = xmlSAX2TextNode(ctxt, value, valueend - value);
+ if(OOM_FLAG)
+ {
+ xmlFree(dup);
+ return;
+ }
+ ret->children = tmp;
+ ret->last = tmp;
+ if (tmp != NULL) {
+ tmp->doc = ret->doc;
+ tmp->parent = (xmlNodePtr) ret;
+ }
+ } else {
+ ret->children = xmlStringLenGetNodeList(ctxt->myDoc, value, valueend - value);
+
+ tmp = ret->children;
+ while (tmp != NULL) {
+ tmp->parent = (xmlNodePtr) ret;
+ if (tmp->next == NULL)
+ ret->last = tmp;
+ tmp = tmp->next;
+ }
+ }
+ } else if (value != NULL) {
+ xmlNodePtr tmp;
+
+ tmp = xmlSAX2TextNode(ctxt, value, valueend - value);
+ ret->children = tmp;
+ ret->last = tmp;
+ if (tmp != NULL) {
+ tmp->doc = ret->doc;
+ tmp->parent = (xmlNodePtr) ret;
+ }
+ }
+
+#ifdef LIBXML_VALID_ENABLED
+ if ((!ctxt->html) && ctxt->validate && ctxt->wellFormed &&
+ ctxt->myDoc && ctxt->myDoc->intSubset) {
+ /*
+ * If we don't substitute entities, the validation should be
+ * done on a value with replaced entities anyway.
+ */
+ if (!ctxt->replaceEntities) {
+ dup = xmlSAX2DecodeAttrEntities(ctxt, value, valueend);
+ if (dup == NULL) {
+ if (*valueend == 0) {
+ ctxt->valid &= xmlValidateOneAttribute(&ctxt->vctxt,
+ ctxt->myDoc, ctxt->node, ret, value);
+ } else {
+ /*
+ * That should already be normalized.
+ * cheaper to finally allocate here than duplicate
+ * entry points in the full validation code
+ */
+ dup = xmlStrndup(value, valueend - value);
+
+ ctxt->valid &= xmlValidateOneAttribute(&ctxt->vctxt,
+ ctxt->myDoc, ctxt->node, ret, dup);
+ }
+ } else {
+ /*
+ * dup now contains a string of the flattened attribute
+ * content with entities substitued. Check if we need to
+ * apply an extra layer of normalization.
+ * It need to be done twice ... it's an extra burden related
+ * to the ability to keep references in attributes
+ */
+ if (ctxt->attsSpecial != NULL) {
+ xmlChar *nvalnorm;
+ xmlChar fn[50];
+ xmlChar *fullname;
+
+ fullname = xmlBuildQName(localname, prefix, fn, 50);
+ if (fullname != NULL) {
+ ctxt->vctxt.valid = 1;
+ nvalnorm = xmlValidCtxtNormalizeAttributeValue(
+ &ctxt->vctxt, ctxt->myDoc,
+ ctxt->node, fullname, dup);
+ if (ctxt->vctxt.valid != 1)
+ ctxt->valid = 0;
+
+ if ((fullname != fn) && (fullname != localname))
+ xmlFree(fullname);
+ if (nvalnorm != NULL) {
+ xmlFree(dup);
+ dup = nvalnorm;
+ }
+ }
+ }
+
+ ctxt->valid &= xmlValidateOneAttribute(&ctxt->vctxt,
+ ctxt->myDoc, ctxt->node, ret, dup);
+ }
+ } else {
+ /*
+ * if entities already have been substitued, then
+ * the attribute as passed is already normalized
+ */
+ dup = xmlStrndup(value, valueend - value);
+
+ ctxt->valid &= xmlValidateOneAttribute(&ctxt->vctxt,
+ ctxt->myDoc, ctxt->node, ret, dup);
+ }
+ } else
+#endif /* LIBXML_VALID_ENABLED */
+ if (((ctxt->loadsubset & XML_SKIP_IDS) == 0) &&
+ (((ctxt->replaceEntities == 0) && (ctxt->external != 2)) ||
+ ((ctxt->replaceEntities != 0) && (ctxt->inSubset == 0)))) {
+ /*
+ * when validating, the ID registration is done at the attribute
+ * validation level. Otherwise we have to do specific handling here.
+ */
+ if (xmlIsID(ctxt->myDoc, ctxt->node, ret)) {
+ /* might be worth duplicate entry points and not copy */
+ if (dup == NULL)
+ dup = xmlStrndup(value, valueend - value);
+ xmlAddID(&ctxt->vctxt, ctxt->myDoc, dup, ret);
+ } else if (xmlIsRef(ctxt->myDoc, ctxt->node, ret)) {
+ if (dup == NULL)
+ dup = xmlStrndup(value, valueend - value);
+ xmlAddRef(&ctxt->vctxt, ctxt->myDoc, dup, ret);
+ } else if ((prefix == ctxt->str_xml) &&
+ (localname[0] == 'i') && (localname[1] == 'd') &&
+ (localname[2] == 0)) {
+ /*
+ * Add the xml:id value
+ *
+ * Open issue: normalization of the value.
+ */
+ if (dup == NULL)
+ dup = xmlStrndup(value, valueend - value);
+ if (xmlValidateNCName(dup, 1) != 0) {
+ xmlErrValid(ctxt, XML_DTD_XMLID_VALUE,
+ EMBED_ERRTXT("xml:id : attribute value %s is not an NCName\n"),
+ (const char *) dup, NULL);
+ }
+ xmlAddID(&ctxt->vctxt, ctxt->myDoc, dup, ret);
+ }
+ }
+ if (dup != NULL)
+ xmlFree(dup);
+}
+
+/**
+ * xmlSAX2StartElementNs:
+ * @param ctx the user data (XML parser context)
+ * @param localname the local name of the element
+ * @param prefix the element namespace prefix if available
+ * @param URI the element namespace name if available
+ * @param nb_namespaces number of namespace definitions on that node
+ * @param namespaces pointer to the array of prefix/URI pairs namespace definitions
+ * @param nb_attributes the number of attributes on that node
+ * @param nb_defaulted the number of defaulted attributes.
+ * @param attributes pointer to the array of (localname/prefix/URI/value/end)
+ * attribute values.
+ *
+ * SAX2 callback when an element start has been detected by the parser.
+ * It provides the namespace informations for the element, as well as
+ * the new namespace declarations on the element.
+ */
+XMLPUBFUNEXPORT void
+xmlSAX2StartElementNs(void* ctx,
+ const xmlChar *localname,
+ const xmlChar *prefix,
+ const xmlChar *URI,
+ int nb_namespaces,
+ const xmlChar **namespaces,
+ int nb_attributes,
+ int nb_defaulted,
+ const xmlChar **attributes)
+{
+ xmlParserCtxtPtr ctxt = (xmlParserCtxtPtr) ctx;
+ xmlNodePtr ret;
+ xmlNodePtr parent = ctxt->node;
+ xmlNsPtr last = NULL, ns;
+ const xmlChar *uri, *pref;
+ int i, j;
+ LOAD_GS_SAFE_CTXT(ctxt)
+
+
+ /*
+ * First check on validity:
+ */
+ if (ctxt->validate &&
+ (ctxt->myDoc->extSubset == NULL) &&
+ ((ctxt->myDoc->intSubset == NULL)
+ ||
+ ((ctxt->myDoc->intSubset->notations == NULL) &&
+ (ctxt->myDoc->intSubset->elements == NULL) &&
+ (ctxt->myDoc->intSubset->attributes == NULL)&&
+ (ctxt->myDoc->intSubset->entities == NULL)
+ )
+ )
+ )
+ {
+ xmlErrValid(ctxt, XML_ERR_NO_DTD, EMBED_ERRTXT("Validation failed: no DTD found !"), NULL, NULL);
+ ctxt->validate = 0;
+ }
+
+ /*
+ * allocate the node
+ */
+ if (ctxt->freeElems != NULL) {
+ ret = ctxt->freeElems;
+ ctxt->freeElems = ret->next;
+ ctxt->freeElemsNr--;
+ memset(ret, 0, sizeof(xmlNode));
+ ret->type = XML_ELEMENT_NODE;
+
+ if (ctxt->dictNames)
+ ret->name = localname;
+ else
+ ret->name = xmlStrdup(localname);
+
+ if ((__xmlRegisterCallbacks) && (xmlRegisterNodeDefaultValue))
+ xmlRegisterNodeDefaultValue(ret);
+ } else {
+ if (ctxt->dictNames)
+ ret = xmlNewDocNodeEatName(ctxt->myDoc, NULL,
+ (xmlChar *) localname, NULL);
+ else
+ ret = xmlNewDocNode(ctxt->myDoc, NULL, localname, NULL);
+
+ if (ret == NULL) {
+ ctxt->errNo = XML_ERR_NO_MEMORY;
+ ctxt->instate = XML_PARSER_EOF;
+ ctxt->disableSAX = 1;
+ return;
+ }
+ }
+#ifdef LIBXML_ENABLE_NODE_LINEINFO
+ if (ctxt->linenumbers) {
+ if (ctxt->input != NULL) {
+ if (ctxt->input->line < 65535)
+ ret->line = (short) ctxt->input->line;
+ else
+ ret->line = 65535;
+ }
+ }
+#endif
+
+ if (ctxt->myDoc->children == NULL) {
+ xmlAddChild((xmlNodePtr) ctxt->myDoc, (xmlNodePtr) ret);
+ } else if (parent == NULL) {
+ parent = ctxt->myDoc->children;
+ }
+ /*
+ * Build the namespace list
+ */
+ for (i = 0,j = 0;j < nb_namespaces;j++)
+ {
+ pref = namespaces[i++];
+ uri = namespaces[i++];
+ // NULL passed in order to avoid uniqueness check in xmlNewNs(),
+ ns = xmlNewNs(NULL, uri, pref);
+ // ... but then we need to link new Ns node manually
+ if (ns != NULL) {
+ if (last == NULL) {
+ ret->nsDef = last = ns;
+ } else {
+ last->next = ns;
+ last = ns;
+ }
+ if ((URI != NULL) && (prefix == pref))
+ ret->ns = ns;
+ } else {
+ ctxt->errNo = XML_ERR_NO_MEMORY;
+ ctxt->instate = XML_PARSER_EOF;
+ ctxt->disableSAX = 1;
+ //DONE: OOM: cleanup:
+ if(ctxt->myDoc->children != ret)
+ xmlFreeNode(ret); // it was not yet inserted in myDoc
+ return;
+ }
+#ifdef LIBXML_VALID_ENABLED
+ if (ctxt->validate && (!ctxt->html) && ctxt->wellFormed &&
+ ctxt->myDoc && ctxt->myDoc->intSubset)
+ {
+ ctxt->valid &= xmlValidateOneNamespace(&ctxt->vctxt, ctxt->myDoc,
+ ret, prefix, ns, uri);
+ }
+#endif /* LIBXML_VALID_ENABLED */
+ } // for (i = 0,j = 0;j < nb_namespaces;j++)
+
+ ctxt->nodemem = -1;
+
+ /*
+ * We are parsing a new node.
+ */
+ nodePush(ctxt, ret);
+
+ /*
+ * Link the child element
+ */
+ if (parent != NULL) {
+ if (parent->type == XML_ELEMENT_NODE) {
+ xmlAddChild(parent, ret);
+ } else {
+ xmlAddSibling(parent, ret);
+ }
+ }
+
+ /*
+ * Insert the defaulted attributes from the DTD only if requested:
+ */
+ if ((nb_defaulted != 0) &&
+ ((ctxt->loadsubset & XML_COMPLETE_ATTRS) == 0))
+ {
+ nb_attributes -= nb_defaulted;
+ }
+
+ /*
+ * Search the namespace if it wasn't already found
+ */
+ if ((URI != NULL) && (ret->ns == NULL)) {
+ ret->ns = xmlSearchNs(ctxt->myDoc, parent, prefix);
+ if (ret->ns == NULL) {
+ ns = xmlNewNs(ret, NULL, prefix);
+ if ((ctxt->sax != NULL) && (ctxt->sax->warning != NULL))
+ ctxt->sax->warning(ctxt->userData,
+ EMBED_ERRTXT("Namespace prefix %s was not found\n"), prefix);
+ }
+ }
+
+ /*
+ * process all the other attributes
+ */
+ if (nb_attributes > 0) {
+ for (j = 0,i = 0;i < nb_attributes;i++,j+=5) {
+
+ xmlSAX2AttributeNs(ctxt, attributes[j], attributes[j+1],
+ attributes[j+3], attributes[j+4]);
+ if(OOM_FLAG)
+ {
+ return;
+ }
+ }
+ }
+
+#ifdef LIBXML_VALID_ENABLED
+ /*
+ * If it's the Document root, finish the DTD validation and
+ * check the document root element for validity
+ */
+ if ((ctxt->validate) && (ctxt->vctxt.finishDtd == 0)) {
+ int chk;
+
+ chk = xmlValidateDtdFinal(&ctxt->vctxt, ctxt->myDoc);
+ if (chk <= 0)
+ ctxt->valid = 0;
+ if (chk < 0)
+ ctxt->wellFormed = 0;
+ ctxt->valid &= xmlValidateRoot(&ctxt->vctxt, ctxt->myDoc);
+ ctxt->vctxt.finishDtd = 1;
+ }
+#endif /* LIBXML_VALID_ENABLED */
+}
+
+/**
+ * xmlSAX2EndElementNs:
+ * @param ctx the user data (XML parser context)
+ * @param localname the local name of the element
+ * @param prefix the element namespace prefix if available
+ * @param URI the element namespace name if available
+ *
+ * SAX2 callback when an element end has been detected by the parser.
+ * It provides the namespace informations for the element.
+ */
+
+XMLPUBFUNEXPORT void
+xmlSAX2EndElementNs(void *ctx,
+ const xmlChar * localname ATTRIBUTE_UNUSED,
+ const xmlChar * prefix ATTRIBUTE_UNUSED,
+ const xmlChar * URI ATTRIBUTE_UNUSED)
+{
+ xmlParserCtxtPtr ctxt = (xmlParserCtxtPtr) ctx;
+#if defined(LIBXML_VALID_ENABLED) || defined(XMLENGINE_ENABLE_PARSER_RECORD_INFO)
+ xmlNodePtr cur = ctxt->node;
+#endif
+
+#ifdef XMLENGINE_ENABLE_PARSER_RECORD_INFO
+ {
+ xmlParserNodeInfo node_info;
+
+ /* Capture end position and add node */
+ if ((ctxt->record_info) && (cur != NULL)) {
+ node_info.end_pos = ctxt->input->cur - ctxt->input->base;
+ node_info.end_line = ctxt->input->line;
+ node_info.node = cur;
+ xmlParserAddNodeInfo(ctxt, &node_info);
+ }
+ }
+#endif
+
+ ctxt->nodemem = -1;
+
+#ifdef LIBXML_VALID_ENABLED
+ if (ctxt->validate && ctxt->wellFormed &&
+ ctxt->myDoc && ctxt->myDoc->intSubset)
+ ctxt->valid &= xmlValidateOneElement(&ctxt->vctxt, ctxt->myDoc, cur);
+#endif /* LIBXML_VALID_ENABLED */
+
+ /*
+ * end of parsing of this node.
+ */
+ nodePop(ctxt);
+}
+
+/**
+ * xmlSAX2Reference:
+ * @param ctx the user data (XML parser context)
+ * @param name The entity name
+ *
+ * called when an entity xmlSAX2Reference is detected.
+ */
+XMLPUBFUNEXPORT void
+xmlSAX2Reference(void *ctx, const xmlChar *name)
+{
+ xmlParserCtxtPtr ctxt = (xmlParserCtxtPtr) ctx;
+ xmlNodePtr ret;
+
+#ifdef DEBUG_SAX
+ xmlGenericError(xmlGenericErrorContext,
+ "SAX.xmlSAX2Reference(%s)\n", name);
+#endif
+ if (name[0] == '#')
+ ret = xmlNewCharRef(ctxt->myDoc, name);
+ else
+ ret = xmlNewReference(ctxt->myDoc, name);
+#ifdef DEBUG_SAX_TREE
+ xmlGenericError(xmlGenericErrorContext,
+ "add xmlSAX2Reference %s to %s \n", name, ctxt->node->name);
+#endif
+ xmlAddChild(ctxt->node, ret);
+}
+
+/**
+ * xmlSAX2Characters:
+ * @param ctx the user data (XML parser context)
+ * @param ch a xmlChar string
+ * @param len the number of xmlChar
+ *
+ * receiving some chars from the parser.
+ */
+XMLPUBFUNEXPORT void
+xmlSAX2Characters(void *ctx, const xmlChar *ch, int len)
+{
+ xmlParserCtxtPtr ctxt = (xmlParserCtxtPtr) ctx;
+ xmlNodePtr lastChild;
+
+ /*
+ * SYMBIAN DEF130695 FIX : Ensuring that CTX(xml buffer context) is valid or not. The CTX is being considered
+ * here while receiving parsed characters using SAX parsing mechanism.
+ */
+ if(ctx == NULL)
+ return;
+
+
+#ifdef DEBUG_SAX
+ xmlGenericError(xmlGenericErrorContext, "SAX.xmlSAX2Characters(%.30s, %d)\n", ch, len);
+#endif
+ /*
+ * Handle the data if any. If there is no child
+ * add it as content, otherwise if the last child is text,
+ * concatenate it, else create a new node of type text.
+ */
+
+ if (ctxt->node == NULL) {
+#ifdef DEBUG_SAX_TREE
+ xmlGenericError(xmlGenericErrorContext, "add chars: ctxt->node == NULL !\n");
+#endif
+ return;
+ }
+ lastChild = ctxt->node->last;
+#ifdef DEBUG_SAX_TREE
+ xmlGenericError(xmlGenericErrorContext, "add chars to %s \n", ctxt->node->name);
+#endif
+
+ /*
+ * Here we needed an accelerator mechanism in case of very large
+ * elements. Use an attribute in the structure !!!
+ */
+ if (lastChild == NULL) {
+ lastChild = xmlSAX2TextNode(ctxt, ch, len);
+
+ if (lastChild != NULL) {
+ ctxt->node->children = lastChild;
+ ctxt->node->last = lastChild;
+ lastChild->parent = ctxt->node;
+ lastChild->doc = ctxt->node->doc;
+ ctxt->nodelen = len;
+ ctxt->nodemem = len + 1;
+ }
+ } else {
+ int coalesceText = (lastChild != NULL) &&
+ (lastChild->type == XML_TEXT_NODE) &&
+ (lastChild->name == xmlStringText);
+ if ((coalesceText) && (ctxt->nodemem != 0)) {
+ /*
+ * The whole point of maintaining nodelen and nodemem,
+ * xmlTextConcat is too costly, i.e. compute length,
+ * reallocate a new buffer, move data, append ch. Here
+ * We try to minimaze realloc() uses and avoid copying
+ * and recomputing length over and over.
+ */
+ if ((ctxt->nodemem == ctxt->nodelen + 1) &&
+ (xmlDictOwns(ctxt->dict, lastChild->content)))
+ {
+ lastChild->content = xmlStrdup(lastChild->content);
+ }
+ if (ctxt->nodelen + len >= ctxt->nodemem) {
+ xmlChar *newbuf;
+ int size;
+
+ size = ctxt->nodemem + len;
+ size *= 2;
+ newbuf = (xmlChar *) xmlRealloc(lastChild->content,size);
+ if (newbuf == NULL) {
+ if ((ctxt->sax != NULL) && (ctxt->sax->error != NULL))
+ ctxt->sax->error(ctxt->userData, EMBED_ERRTXT("SAX.xmlSAX2Characters(): out of memory\n"));
+ ctxt->errNo = XML_ERR_NO_MEMORY;
+ ctxt->instate = XML_PARSER_EOF;
+ ctxt->disableSAX = 1;
+ return;
+ }
+ ctxt->nodemem = size;
+ lastChild->content = newbuf;
+ }
+ memcpy(&lastChild->content[ctxt->nodelen], ch, len);
+ ctxt->nodelen += len;
+ lastChild->content[ctxt->nodelen] = 0;
+ } else if (coalesceText) {
+ if (xmlTextConcat(lastChild, ch, len)) {
+ if ((ctxt->sax != NULL) && (ctxt->sax->error != NULL))
+ ctxt->sax->error(ctxt->userData, EMBED_ERRTXT("SAX.xmlSAX2Characters(): out of memory\n"));
+ ctxt->errNo = XML_ERR_NO_MEMORY;
+ ctxt->instate = XML_PARSER_EOF;
+ ctxt->disableSAX = 1;
+ }
+ if (ctxt->node->children != NULL) {
+ ctxt->nodelen = xmlStrlen(lastChild->content);
+ ctxt->nodemem = ctxt->nodelen + 1;
+ }
+ } else {
+ /* Mixed content, first time */
+ lastChild = xmlSAX2TextNode(ctxt, ch, len);
+ if (lastChild != NULL) {
+ xmlAddChild(ctxt->node, lastChild);
+ if (ctxt->node->children != NULL) {
+ ctxt->nodelen = len;
+ ctxt->nodemem = len + 1;
+ }
+ }
+ }
+ }
+}
+
+/**
+ * xmlSAX2IgnorableWhitespace:
+ * @param ctx the user data (XML parser context)
+ * @param ch a xmlChar string
+ * @param len the number of xmlChar
+ *
+ * receiving some ignorable whitespaces from the parser.
+ * UNUSED: by default the DOM building will use xmlSAX2Characters
+ */
+XMLPUBFUNEXPORT void
+xmlSAX2IgnorableWhitespace(void *ctx ATTRIBUTE_UNUSED, const xmlChar *ch ATTRIBUTE_UNUSED, int len ATTRIBUTE_UNUSED)
+{
+ /* xmlParserCtxtPtr ctxt = (xmlParserCtxtPtr) ctx; */
+#ifdef DEBUG_SAX
+ xmlGenericError(xmlGenericErrorContext, "SAX.xmlSAX2IgnorableWhitespace(%.30s, %d)\n", ch, len);
+#endif
+ if(ctx) return; // just to use ctx
+}
+
+/**
+ * xmlSAX2ProcessingInstruction:
+ * @param ctx the user data (XML parser context)
+ * @param target the target name
+ * @param data the PI data's
+ *
+ * A processing instruction has been parsed.
+ */
+XMLPUBFUNEXPORT void
+xmlSAX2ProcessingInstruction(void *ctx,
+ const xmlChar *target,
+ const xmlChar *data)
+{
+ xmlParserCtxtPtr ctxt = (xmlParserCtxtPtr) ctx;
+ xmlNodePtr ret;
+ xmlNodePtr parent = ctxt->node;
+
+#ifdef DEBUG_SAX
+ xmlGenericError(xmlGenericErrorContext,
+ "SAX.xmlSAX2ProcessingInstruction(%s, %s)\n", target, data);
+#endif
+
+ ret = xmlNewPI(target, data);
+ if (!ret)
+ return;
+ parent = ctxt->node;
+
+ if (ctxt->inSubset == 1) {
+ xmlAddChild((xmlNodePtr) ctxt->myDoc->intSubset, ret);
+ return;
+ } else
+ if (ctxt->inSubset == 2) {
+ xmlAddChild((xmlNodePtr) ctxt->myDoc->extSubset, ret);
+ return;
+ }
+ if ((ctxt->myDoc->children == NULL) || (parent == NULL)) {
+#ifdef DEBUG_SAX_TREE
+ xmlGenericError(xmlGenericErrorContext,"Setting PI %s as root\n", target);
+#endif
+ xmlAddChild((xmlNodePtr) ctxt->myDoc, (xmlNodePtr) ret);
+ return;
+ }
+ if (parent->type == XML_ELEMENT_NODE) {
+#ifdef DEBUG_SAX_TREE
+ xmlGenericError(xmlGenericErrorContext,
+ "adding PI %s child to %s\n", target, parent->name);
+#endif
+ xmlAddChild(parent, ret);
+ } else {
+#ifdef DEBUG_SAX_TREE
+ xmlGenericError(xmlGenericErrorContext, "adding PI %s sibling to ", target);
+ xmlDebugDumpOneNode(stderr, parent, 0);
+#endif
+ xmlAddSibling(parent, ret);
+ }
+}
+
+/**
+ * xmlSAX2Comment:
+ * @param ctx the user data (XML parser context)
+ * @param value the xmlSAX2Comment content
+ *
+ * A xmlSAX2Comment has been parsed.
+ */
+XMLPUBFUNEXPORT void
+xmlSAX2Comment(void *ctx, const xmlChar *value)
+{
+ xmlParserCtxtPtr ctxt = (xmlParserCtxtPtr) ctx;
+ xmlNodePtr ret;
+ xmlNodePtr parent = ctxt->node;
+
+#ifdef DEBUG_SAX
+ xmlGenericError(xmlGenericErrorContext, "SAX.xmlSAX2Comment(%s)\n", value);
+#endif
+ ret = xmlNewDocComment(ctxt->myDoc, value);
+ if (ret == NULL) return;
+
+
+ if (ctxt->inSubset == 1) {
+ xmlAddChild((xmlNodePtr) ctxt->myDoc->intSubset, ret);
+ return;
+ } else if (ctxt->inSubset == 2) {
+ xmlAddChild((xmlNodePtr) ctxt->myDoc->extSubset, ret);
+ return;
+ }
+ if ((ctxt->myDoc->children == NULL) || (parent == NULL)) {
+#ifdef DEBUG_SAX_TREE
+ xmlGenericError(xmlGenericErrorContext,
+ "Setting xmlSAX2Comment as root\n");
+#endif
+ xmlAddChild((xmlNodePtr) ctxt->myDoc, (xmlNodePtr) ret);
+ return;
+ }
+ if (parent->type == XML_ELEMENT_NODE) {
+#ifdef DEBUG_SAX_TREE
+ xmlGenericError(xmlGenericErrorContext,
+ "adding xmlSAX2Comment child to %s\n", parent->name);
+#endif
+ xmlAddChild(parent, ret);
+ } else {
+#ifdef DEBUG_SAX_TREE
+ xmlGenericError(xmlGenericErrorContext,
+ "adding xmlSAX2Comment sibling to ");
+ xmlDebugDumpOneNode(stderr, parent, 0);
+#endif
+ xmlAddSibling(parent, ret);
+ }
+}
+
+/**
+ * xmlSAX2CDataBlock:
+ * @param ctx the user data (XML parser context)
+ * @param value The pcdata content
+ * @param len the block length
+ *
+ * called when a pcdata block has been parsed
+ */
+XMLPUBFUNEXPORT void
+xmlSAX2CDataBlock(void *ctx, const xmlChar *value, int len)
+{
+ xmlParserCtxtPtr ctxt = (xmlParserCtxtPtr) ctx;
+ xmlNodePtr ret, lastChild;
+
+#ifdef DEBUG_SAX
+ xmlGenericError(xmlGenericErrorContext,"SAX.pcdata(%.10s, %d)\n", value, len);
+#endif
+ lastChild = xmlGetLastChild(ctxt->node);
+#ifdef DEBUG_SAX_TREE
+ xmlGenericError(xmlGenericErrorContext,"add chars to %s \n", ctxt->node->name);
+#endif
+ if ((lastChild != NULL) &&
+ (lastChild->type == XML_CDATA_SECTION_NODE))
+ {
+ xmlTextConcat(lastChild, value, len);
+ } else {
+ ret = xmlNewCDataBlock(ctxt->myDoc, value, len);
+ xmlAddChild(ctxt->node, ret);
+ }
+}
+
+#ifdef LIBXML_SAX1_ENABLED
+/**
+ * xmlSAXDefaultVersion:
+ * @param version the version, 1 or 2
+ *
+ * Set the default version of SAX used globally by the library.
+ * Note that this may not be a good thing to do from a library
+ * it is better to use xmlSAXVersion() to set up specifically the
+ * version for a given parsing context.
+ *
+ * Returns the previous value in case of success and -1 in case of error.
+ */
+XMLPUBFUNEXPORT int
+xmlSAXDefaultVersion(int version)
+{
+ LOAD_GS_DIRECT
+ int ret = xmlSAX2DefaultVersionValue;
+
+ if ((version != 1) && (version != 2))
+ return(-1);
+ xmlSAX2DefaultVersionValue = version;
+ return(ret);
+}
+#endif /* LIBXML_SAX1_ENABLED */
+
+/**
+ * xmlSAXVersion:
+ * @param hdlr the SAX handler
+ * @param version the version, 1 or 2
+ *
+ * Initialize the default XML SAX handler according to the version
+ *
+ * Returns 0 in case of success and -1 in case of error.
+ *
+ * OOM: never
+ */
+XMLPUBFUNEXPORT int
+xmlSAXVersion(xmlSAXHandler *hdlr, int version)
+{
+ if (hdlr == NULL) return(-1);
+ if (version == 2) {
+ hdlr->startElement = NULL;
+ hdlr->endElement = NULL;
+ hdlr->startElementNs = xmlSAX2StartElementNs;
+ hdlr->endElementNs = xmlSAX2EndElementNs;
+ hdlr->serror = NULL;
+ hdlr->initialized = XML_SAX2_MAGIC;
+#ifdef LIBXML_SAX1_ENABLED
+ } else if (version == 1) {
+ hdlr->startElement = xmlSAX2StartElement;
+ hdlr->endElement = xmlSAX2EndElement;
+ hdlr->initialized = 1;
+#endif /* LIBXML_SAX1_ENABLED */
+ } else
+ return(-1);
+ hdlr->internalSubset = xmlSAX2InternalSubset;
+ hdlr->externalSubset = xmlSAX2ExternalSubset;
+ hdlr->isStandalone = xmlSAX2IsStandalone;
+ hdlr->hasInternalSubset = xmlSAX2HasInternalSubset;
+ hdlr->hasExternalSubset = xmlSAX2HasExternalSubset;
+ hdlr->resolveEntity = xmlSAX2ResolveEntity;
+ hdlr->getEntity = xmlSAX2GetEntity;
+ hdlr->getParameterEntity = xmlSAX2GetParameterEntity;
+ hdlr->entityDecl = xmlSAX2EntityDecl;
+ hdlr->attributeDecl = xmlSAX2AttributeDecl;
+ hdlr->elementDecl = xmlSAX2ElementDecl;
+ hdlr->notationDecl = xmlSAX2NotationDecl;
+ hdlr->unparsedEntityDecl = xmlSAX2UnparsedEntityDecl;
+ hdlr->setDocumentLocator = xmlSAX2SetDocumentLocator;
+ hdlr->startDocument = xmlSAX2StartDocument;
+ hdlr->endDocument = xmlSAX2EndDocument;
+ hdlr->reference = xmlSAX2Reference;
+ hdlr->characters = xmlSAX2Characters;
+ hdlr->cdataBlock = xmlSAX2CDataBlock;
+ hdlr->ignorableWhitespace = xmlSAX2Characters;
+ hdlr->processingInstruction = xmlSAX2ProcessingInstruction;
+ hdlr->comment = xmlSAX2Comment;
+// XMLENGINE: MODIFIED CODE
+// preprocessor directive is used for managing error callbacks
+#ifdef _DEBUG_LIBXML
+ hdlr->warning = xmlParserWarning;
+ hdlr->error = xmlParserError;
+ hdlr->fatalError = xmlParserError;
+#else
+ hdlr->warning = NULL;
+ hdlr->error = NULL;
+ hdlr->fatalError = NULL;
+#endif
+// XMLENGINE: BEGINE NEW CODE
+ // These should be nullified for DOMParser
+ hdlr->startPrefixMapping = NULL;
+ hdlr->endPrefixMapping = NULL;
+// XMLENGINE: END NEW CODE
+
+ return(0);
+}
+
+#ifdef LIBXML_HTML_ENABLED
+/**
+ * xmlSAX2InitHtmlDefaultSAXHandler:
+ * @param hdlr the SAX handler
+ *
+ * Initialize the default HTML SAX2 handler
+ */
+void
+xmlSAX2InitHtmlDefaultSAXHandler(xmlSAXHandler *hdlr)
+{
+ if(hdlr->initialized != 0)
+ return;
+
+ hdlr->internalSubset = xmlSAX2InternalSubset;
+ hdlr->externalSubset = NULL;
+ hdlr->isStandalone = NULL;
+ hdlr->hasInternalSubset = NULL;
+ hdlr->hasExternalSubset = NULL;
+ hdlr->resolveEntity = NULL;
+ hdlr->getEntity = xmlSAX2GetEntity;
+ hdlr->getParameterEntity = NULL;
+ hdlr->entityDecl = NULL;
+ hdlr->attributeDecl = NULL;
+ hdlr->elementDecl = NULL;
+ hdlr->notationDecl = NULL;
+ hdlr->unparsedEntityDecl = NULL;
+ hdlr->setDocumentLocator = xmlSAX2SetDocumentLocator;
+ hdlr->startDocument = xmlSAX2StartDocument;
+ hdlr->endDocument = xmlSAX2EndDocument;
+ hdlr->startElement = xmlSAX2StartElement;
+ hdlr->endElement = xmlSAX2EndElement;
+ hdlr->reference = NULL;
+ hdlr->characters = xmlSAX2Characters;
+ hdlr->cdataBlock = xmlSAX2CDataBlock;
+ hdlr->ignorableWhitespace = xmlSAX2IgnorableWhitespace;
+ hdlr->processingInstruction = NULL;
+ hdlr->comment = xmlSAX2Comment;
+ hdlr->warning = xmlParserWarning;
+ hdlr->error = xmlParserError;
+ hdlr->fatalError = xmlParserError;
+
+ hdlr->initialized = 1;
+}
+
+
+/**
+ * htmlDefaultSAXHandlerInit:
+ *
+ * Initialize the default SAX handler
+ */
+void
+htmlDefaultSAXHandlerInit(void)
+{
+// XMLENGINE: disabled: HTML is never parsed
+// xmlSAX2InitHtmlDefaultSAXHandler((xmlSAXHandlerPtr) &htmlDefaultSAXHandler);
+}
+#endif
+
+
+/**
+ * xmlSAX2InitDefaultSAXHandler:
+ * @param hdlr the SAX handler
+ * @param warning flag if non-zero sets the handler warning procedure
+ *
+ * Initialize the default XML SAX2 handler
+ */
+XMLPUBFUNEXPORT void
+xmlSAX2InitDefaultSAXHandler(xmlSAXHandler* hdlr, int warning)
+{
+ LOAD_GS_DIRECT
+ if ((hdlr == NULL) || (hdlr->initialized != 0))
+ return;
+
+ xmlSAXVersion(hdlr, xmlSAX2DefaultVersionValue);
+ // Note: hdlr->warning is NULL after previous line
+ if(warning)
+ hdlr->warning = xmlParserWarning;
+}
+
+/**
+ * xmlDefaultSAXHandlerInit:
+ *
+ * Initialize the default SAX2 handler
+ *
+ * OOM: never
+ */
+XMLPUBFUNEXPORT void
+xmlDefaultSAXHandlerInit(void)
+{
+#ifdef XMLENGINE_SAX1
+#ifdef LIBXML_SAX1_ENABLED
+ xmlSAXVersion((xmlSAXHandlerPtr) &xmlDefaultSAXHandler, 1);
+#endif /* LIBXML_SAX1_ENABLED */
+#endif
+}
+
+
+#ifdef LIBXML_DOCB_ENABLED
+
+/**
+ * xmlSAX2InitDocbDefaultSAXHandler:
+ * @param hdlr the SAX handler
+ *
+ * Initialize the default DocBook SAX2 handler
+ */
+void
+xmlSAX2InitDocbDefaultSAXHandler(xmlSAXHandler *hdlr)
+{
+ if(hdlr->initialized != 0)
+ return;
+
+ hdlr->internalSubset = xmlSAX2InternalSubset;
+ hdlr->externalSubset = NULL;
+ hdlr->isStandalone = xmlSAX2IsStandalone;
+ hdlr->hasInternalSubset = xmlSAX2HasInternalSubset;
+ hdlr->hasExternalSubset = xmlSAX2HasExternalSubset;
+ hdlr->resolveEntity = xmlSAX2ResolveEntity;
+ hdlr->getEntity = xmlSAX2GetEntity;
+ hdlr->getParameterEntity = NULL;
+ hdlr->entityDecl = xmlSAX2EntityDecl;
+ hdlr->attributeDecl = NULL;
+ hdlr->elementDecl = NULL;
+ hdlr->notationDecl = NULL;
+ hdlr->unparsedEntityDecl = NULL;
+ hdlr->setDocumentLocator = xmlSAX2SetDocumentLocator;
+ hdlr->startDocument = xmlSAX2StartDocument;
+ hdlr->endDocument = xmlSAX2EndDocument;
+ hdlr->startElement = xmlSAX2StartElement;
+ hdlr->endElement = xmlSAX2EndElement;
+ hdlr->reference = xmlSAX2Reference;
+ hdlr->characters = xmlSAX2Characters;
+ hdlr->cdataBlock = NULL;
+ hdlr->ignorableWhitespace = xmlSAX2IgnorableWhitespace;
+ hdlr->processingInstruction = NULL;
+ hdlr->comment = xmlSAX2Comment;
+ hdlr->warning = xmlParserWarning;
+ hdlr->error = xmlParserError;
+ hdlr->fatalError = xmlParserError;
+
+ hdlr->initialized = 1;
+}
+
+/**
+ * docbDefaultSAXHandlerInit:
+ *
+ * Initialize the default SAX handler
+ */
+void
+docbDefaultSAXHandlerInit(void)
+{
+ xmlSAX2InitDocbDefaultSAXHandler((xmlSAXHandlerPtr) &docbDefaultSAXHandler);
+}
+
+#endif /* LIBXML_DOCB_ENABLED */
+