SAX2.h File Reference

#include <libxml/xmlversion.h>
#include <libxml/parser.h>

Include dependency graph for SAX2.h:

This graph shows which files directly or indirectly include this file:

Go to the source code of this file.

Functions
XMLPUBFUN const xmlChar *	xmlSAX2GetPublicId (void *ctx)
XMLPUBFUN const xmlChar *	xmlSAX2GetSystemId (void *ctx)
XMLPUBFUN void	xmlSAX2SetDocumentLocator (void *ctx, xmlSAXLocatorPtr loc)
XMLPUBFUN int	xmlSAX2GetLineNumber (void *ctx)
XMLPUBFUN int	xmlSAX2GetColumnNumber (void *ctx)
XMLPUBFUN int	xmlSAX2IsStandalone (void *ctx)
XMLPUBFUN int	xmlSAX2HasInternalSubset (void *ctx)
XMLPUBFUN int	xmlSAX2HasExternalSubset (void *ctx)
XMLPUBFUN void	xmlSAX2InternalSubset (void *ctx, const xmlChar *name, const xmlChar *ExternalID, const xmlChar *SystemID)
XMLPUBFUN void	xmlSAX2ExternalSubset (void *ctx, const xmlChar *name, const xmlChar *ExternalID, const xmlChar *SystemID)
XMLPUBFUN xmlEntityPtr	xmlSAX2GetEntity (void *ctx, const xmlChar *name)
XMLPUBFUN xmlEntityPtr	xmlSAX2GetParameterEntity (void *ctx, const xmlChar *name)
XMLPUBFUN xmlParserInputPtr	xmlSAX2ResolveEntity (void *ctx, const xmlChar *publicId, const xmlChar *systemId)
XMLPUBFUN void	xmlSAX2EntityDecl (void *ctx, const xmlChar *name, int type, const xmlChar *publicId, const xmlChar *systemId, xmlChar *content)
XMLPUBFUN void	xmlSAX2AttributeDecl (void *ctx, const xmlChar *elem, const xmlChar *fullname, int type, int def, const xmlChar *defaultValue, xmlEnumerationPtr tree)
XMLPUBFUN void	xmlSAX2ElementDecl (void *ctx, const xmlChar *name, int type, xmlElementContentPtr content)
XMLPUBFUN void	xmlSAX2NotationDecl (void *ctx, const xmlChar *name, const xmlChar *publicId, const xmlChar *systemId)
XMLPUBFUN void	xmlSAX2UnparsedEntityDecl (void *ctx, const xmlChar *name, const xmlChar *publicId, const xmlChar *systemId, const xmlChar *notationName)
XMLPUBFUN void	xmlSAX2StartDocument (void *ctx)
XMLPUBFUN void	xmlSAX2EndDocument (void *ctx)
XMLPUBFUN 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)
XMLPUBFUN void	xmlSAX2EndElementNs (void *ctx, const xmlChar *localname, const xmlChar *prefix, const xmlChar *URI)
XMLPUBFUN void	xmlSAX2Reference (void *ctx, const xmlChar *name)
XMLPUBFUN void	xmlSAX2Characters (void *ctx, const xmlChar *ch, int len)
XMLPUBFUN void	xmlSAX2IgnorableWhitespace (void *ctx, const xmlChar *ch, int len)
XMLPUBFUN void	xmlSAX2ProcessingInstruction (void *ctx, const xmlChar *target, const xmlChar *data)
XMLPUBFUN void	xmlSAX2Comment (void *ctx, const xmlChar *value)
XMLPUBFUN void	xmlSAX2CDataBlock (void *ctx, const xmlChar *value, int len)
XMLPUBFUN int	xmlSAXVersion (xmlSAXHandler *hdlr, int version)
XMLPUBFUN void	xmlSAX2InitDefaultSAXHandler (xmlSAXHandler *hdlr, int warning)
XML_DEPRECATED XMLPUBFUN void	xmlDefaultSAXHandlerInit (void)

Function Documentation

xmlDefaultSAXHandlerInit()

XML_DEPRECATED XMLPUBFUN void xmlDefaultSAXHandlerInit

(

void

)

xmlDefaultSAXHandlerInit:

DEPRECATED: This function is a no-op. Call xmlInitParser to initialize the library.

Initialize the default SAX2 handler

Definition at line 2783 of file SAX2.c.

{
}

xmlSAX2AttributeDecl()

XMLPUBFUN void xmlSAX2AttributeDecl	(	void *	ctx,
		const xmlChar *	elem,
		const xmlChar *	fullname,
		int	type,
		int	def,
		const xmlChar *	defaultValue,
		xmlEnumerationPtr	tree
	)

Definition at line 653 of file SAX2.c.

{
    xmlParserCtxtPtr ctxt = (xmlParserCtxtPtr) ctx;
    xmlAttributePtr attr;
    xmlChar *name = NULL, *prefix = NULL;
 
    /* Avoid unused variable warning if features are disabled. */
    (void) attr;
 
    if ((ctxt == NULL) || (ctxt->myDoc == NULL))
        return;
 
    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,
          "xml:id : attribute type should be ID\n", NULL, NULL);
    ctxt->valid = tmp;
    }
    /* TODO: optimize name/prefix allocation */
    name = xmlSplitQName(ctxt, fullname, &prefix);
    ctxt->vctxt.valid = 1;
    if (ctxt->inSubset == 1)
    attr = xmlAddAttributeDecl(&ctxt->vctxt, ctxt->myDoc->intSubset, elem,
           name, prefix, (xmlAttributeType) type,
           (xmlAttributeDefault) def, defaultValue, tree);
    else if (ctxt->inSubset == 2)
    attr = xmlAddAttributeDecl(&ctxt->vctxt, ctxt->myDoc->extSubset, elem,
       name, prefix, (xmlAttributeType) type,
       (xmlAttributeDefault) def, defaultValue, tree);
    else {
        xmlFatalErrMsg(ctxt, XML_ERR_INTERNAL_ERROR,
         "SAX.xmlSAX2AttributeDecl(%s) called while not in subset\n",
                   name, NULL);
    xmlFree(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->intSubset != NULL))
    ctxt->valid &= xmlValidateAttributeDecl(&ctxt->vctxt, ctxt->myDoc,
                                            attr);
#endif /* LIBXML_VALID_ENABLED */
    if (prefix != NULL)
    xmlFree(prefix);
    if (name != NULL)
    xmlFree(name);
}

Referenced by doparse(), and xmlSAXVersion().

xmlSAX2CDataBlock()

XMLPUBFUN void xmlSAX2CDataBlock	(	void *	ctx,
		const xmlChar *	value,
		int	len
	)

xmlSAX2CDataBlock: @ctx: the user data (XML parser context) @value: The pcdata content @len: the block length

called when a pcdata block has been parsed

Definition at line 2660 of file SAX2.c.

{
    xmlSAX2Text((xmlParserCtxtPtr) ctx, value, len, XML_CDATA_SECTION_NODE);
}

Referenced by doparse(), and xmlSAXVersion().

xmlSAX2Characters()

XMLPUBFUN void xmlSAX2Characters	(	void *	ctx,
		const xmlChar *	ch,
		int	len
	)

xmlSAX2Characters: @ctx: the user data (XML parser context) @ch: a xmlChar string @len: the number of xmlChar

receiving some chars from the parser.

Definition at line 2539 of file SAX2.c.

{
    xmlSAX2Text((xmlParserCtxtPtr) ctx, ch, len, XML_TEXT_NODE);
}

Referenced by sax_characters(), and xmlSAXVersion().

xmlSAX2Comment()

XMLPUBFUN void xmlSAX2Comment	(	void *	ctx,
		const xmlChar *	value
	)

xmlSAX2Comment: @ctx: the user data (XML parser context) @value: the xmlSAX2Comment content

A xmlSAX2Comment has been parsed.

Definition at line 2614 of file SAX2.c.

{
    xmlParserCtxtPtr ctxt = (xmlParserCtxtPtr) ctx;
    xmlNodePtr ret;
    xmlNodePtr parent;
 
    if (ctx == NULL) return;
    parent = ctxt->node;
    ret = xmlNewDocComment(ctxt->myDoc, value);
    if (ret == NULL) return;
    if (ctxt->linenumbers) {
    if (ctxt->input != NULL) {
        if ((unsigned) ctxt->input->line < (unsigned) USHRT_MAX)
        ret->line = ctxt->input->line;
        else
            ret->line = USHRT_MAX;
    }
    }
 
    if (ctxt->inSubset == 1) {
    xmlAddChild((xmlNodePtr) ctxt->myDoc->intSubset, ret);
    return;
    } else if (ctxt->inSubset == 2) {
    xmlAddChild((xmlNodePtr) ctxt->myDoc->extSubset, ret);
    return;
    }
    if (parent == NULL) {
        xmlAddChild((xmlNodePtr) ctxt->myDoc, (xmlNodePtr) ret);
    return;
    }
    if (parent->type == XML_ELEMENT_NODE) {
    xmlAddChild(parent, ret);
    } else {
    xmlAddSibling(parent, ret);
    }
}

Referenced by doparse(), and xmlSAXVersion().

xmlSAX2ElementDecl()

XMLPUBFUN void xmlSAX2ElementDecl	(	void *	ctx,
		const xmlChar *	name,
		int	type,
		xmlElementContentPtr	content
	)

Definition at line 720 of file SAX2.c.

{
    xmlParserCtxtPtr ctxt = (xmlParserCtxtPtr) ctx;
    xmlElementPtr elem = NULL;
 
    /* Avoid unused variable warning if features are disabled. */
    (void) elem;
 
    if ((ctxt == NULL) || (ctxt->myDoc == NULL))
        return;
 
    if (ctxt->inSubset == 1)
        elem = xmlAddElementDecl(&ctxt->vctxt, ctxt->myDoc->intSubset,
                                 name, (xmlElementTypeVal) type, content);
    else if (ctxt->inSubset == 2)
        elem = xmlAddElementDecl(&ctxt->vctxt, ctxt->myDoc->extSubset,
                                 name, (xmlElementTypeVal) type, content);
    else {
        xmlFatalErrMsg(ctxt, XML_ERR_INTERNAL_ERROR,
         "SAX.xmlSAX2ElementDecl(%s) called while not in subset\n",
                   name, NULL);
        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 */
}

Referenced by doparse(), and xmlSAXVersion().

xmlSAX2EndDocument()

XMLPUBFUN void xmlSAX2EndDocument

(

void *

ctx

)

xmlSAX2EndDocument: @ctx: the user data (XML parser context)

called when the document end has been detected.

Definition at line 944 of file SAX2.c.

{
    xmlParserCtxtPtr ctxt = (xmlParserCtxtPtr) ctx;
    xmlDocPtr doc;
 
    if (ctx == NULL) return;
#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 */
 
    doc = ctxt->myDoc;
    if ((doc != NULL) && (doc->encoding == NULL)) {
        const xmlChar *encoding = xmlGetActualEncoding(ctxt);
 
        if (encoding != NULL) {
            doc->encoding = xmlStrdup(encoding);
            if (doc->encoding == NULL)
                xmlSAX2ErrMemory(ctxt, "xmlSAX2EndDocument");
        }
    }
}

Referenced by doparse(), and xmlSAXVersion().

xmlSAX2EndElementNs()

XMLPUBFUN void xmlSAX2EndElementNs	(	void *	ctx,
		const xmlChar *	localname,
		const xmlChar *	prefix,
		const xmlChar *	URI
	)

Referenced by doparse().

xmlSAX2EntityDecl()

XMLPUBFUN void xmlSAX2EntityDecl	(	void *	ctx,
		const xmlChar *	name,
		int	type,
		const xmlChar *	publicId,
		const xmlChar *	systemId,
		xmlChar *	content
	)

Definition at line 588 of file SAX2.c.

{
    xmlEntityPtr ent;
    xmlParserCtxtPtr ctxt = (xmlParserCtxtPtr) ctx;
 
    if (ctx == NULL) return;
    if (ctxt->inSubset == 1) {
    ent = xmlAddDocEntity(ctxt->myDoc, name, type, publicId,
                      systemId, content);
    if ((ent == NULL) && (ctxt->pedantic))
        xmlWarnMsg(ctxt, XML_WAR_ENTITY_REDEFINED,
         "Entity(%s) already defined in the internal subset\n",
                   name);
    if ((ent != NULL) && (ent->URI == NULL) && (systemId != NULL)) {
        xmlChar *URI;
        const char *base = NULL;
 
        if (ctxt->input != NULL)
        base = ctxt->input->filename;
        if (base == NULL)
        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 == NULL) && (ctxt->pedantic) &&
        (ctxt->sax != NULL) && (ctxt->sax->warning != NULL))
        ctxt->sax->warning(ctxt->userData,
         "Entity(%s) already defined in the external subset\n", name);
    if ((ent != NULL) && (ent->URI == NULL) && (systemId != NULL)) {
        xmlChar *URI;
        const char *base = NULL;
 
        if (ctxt->input != NULL)
        base = ctxt->input->filename;
        if (base == NULL)
        base = ctxt->directory;
 
        URI = xmlBuildURI(systemId, (const xmlChar *) base);
        ent->URI = URI;
    }
    } else {
    xmlFatalErrMsg(ctxt, XML_ERR_ENTITY_PROCESSING,
                   "SAX.xmlSAX2EntityDecl(%s) called while not in subset\n",
               name, NULL);
    }
}

Referenced by doparse(), xmlParseEntityDecl(), and xmlSAXVersion().

xmlSAX2ExternalSubset()

XMLPUBFUN void xmlSAX2ExternalSubset	(	void *	ctx,
		const xmlChar *	name,
		const xmlChar *	ExternalID,
		const xmlChar *	SystemID
	)

Definition at line 357 of file SAX2.c.

{
    xmlParserCtxtPtr ctxt = (xmlParserCtxtPtr) ctx;
    if (ctx == NULL) return;
    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;
    const xmlChar *oldencoding;
    int oldprogressive;
        unsigned long consumed;
        size_t buffered;
 
    /*
     * 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;
    oldencoding = ctxt->encoding;
        oldprogressive = ctxt->progressive;
    ctxt->encoding = NULL;
        ctxt->progressive = 0;
 
    ctxt->inputTab = (xmlParserInputPtr *)
                     xmlMalloc(5 * sizeof(xmlParserInputPtr));
    if (ctxt->inputTab == NULL) {
        xmlSAX2ErrMemory(ctxt, "xmlSAX2ExternalSubset");
            xmlFreeInputStream(input);
        ctxt->input = oldinput;
        ctxt->inputNr = oldinputNr;
        ctxt->inputMax = oldinputMax;
        ctxt->inputTab = oldinputTab;
        ctxt->encoding = oldencoding;
            ctxt->progressive = oldprogressive;
        return;
    }
    ctxt->inputNr = 0;
    ctxt->inputMax = 5;
    ctxt->input = NULL;
    xmlPushInput(ctxt, input);
 
    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);
 
        consumed = ctxt->input->consumed;
        buffered = ctxt->input->cur - ctxt->input->base;
        if (buffered > ULONG_MAX - consumed)
            consumed = ULONG_MAX;
        else
            consumed += buffered;
        if (consumed > ULONG_MAX - ctxt->sizeentities)
            ctxt->sizeentities = ULONG_MAX;
        else
            ctxt->sizeentities += consumed;
 
    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;
    if ((ctxt->encoding != NULL) &&
        ((ctxt->dict == NULL) ||
         (!xmlDictOwns(ctxt->dict, ctxt->encoding))))
        xmlFree((xmlChar *) ctxt->encoding);
    ctxt->encoding = oldencoding;
        ctxt->progressive = oldprogressive;
    /* ctxt->wellFormed = oldwellFormed; */
    }
}

Referenced by doparse(), and xmlSAXVersion().

xmlSAX2GetColumnNumber()

XMLPUBFUN int xmlSAX2GetColumnNumber

(

void *

ctx

)

xmlSAX2GetColumnNumber: @ctx: the user data (XML parser context)

Provide the column number of the current parsing point.

Returns an int

Definition at line 259 of file SAX2.c.

{
    xmlParserCtxtPtr ctxt = (xmlParserCtxtPtr) ctx;
    if ((ctx == NULL) || (ctxt->input == NULL)) return(0);
    return(ctxt->input->col);
}

Referenced by update_position().

xmlSAX2GetEntity()

XMLPUBFUN xmlEntityPtr xmlSAX2GetEntity	(	void *	ctx,
		const xmlChar *	name
	)

Definition at line 518 of file SAX2.c.

{
    xmlParserCtxtPtr ctxt = (xmlParserCtxtPtr) ctx;
    xmlEntityPtr ret = NULL;
 
    if (ctx == NULL) return(NULL);
 
    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) {
            xmlFatalErrMsg(ctxt, XML_ERR_NOT_STANDALONE,
     "Entity(%s) document marked standalone but requires external subset\n",
                   name, NULL);
        }
        ctxt->myDoc->standalone = 1;
        }
    }
    } else {
    ret = xmlGetDocEntity(ctxt->myDoc, name);
    }
    return(ret);
}

Referenced by doparse(), xmlParseEntityDecl(), xmlParseEntityRef(), xmlParseStringEntityRef(), and xmlSAXVersion().

xmlSAX2GetLineNumber()

XMLPUBFUN int xmlSAX2GetLineNumber

(

void *

ctx

)

xmlSAX2GetLineNumber: @ctx: the user data (XML parser context)

Provide the line number of the current parsing point.

Returns an int

Definition at line 243 of file SAX2.c.

{
    xmlParserCtxtPtr ctxt = (xmlParserCtxtPtr) ctx;
    if ((ctx == NULL) || (ctxt->input == NULL)) return(0);
    return(ctxt->input->line);
}

Referenced by update_position().

xmlSAX2GetParameterEntity()

XMLPUBFUN xmlEntityPtr xmlSAX2GetParameterEntity	(	void *	ctx,
		const xmlChar *	name
	)

Definition at line 564 of file SAX2.c.

{
    xmlParserCtxtPtr ctxt = (xmlParserCtxtPtr) ctx;
    xmlEntityPtr ret;
 
    if (ctx == NULL) return(NULL);
 
    ret = xmlGetParameterEntity(ctxt->myDoc, name);
    return(ret);
}

Referenced by doparse(), and xmlSAXVersion().

xmlSAX2GetPublicId()

XMLPUBFUN const xmlChar * xmlSAX2GetPublicId

(

void *

ctx

)

Referenced by isaxlocator_getPublicId().

xmlSAX2GetSystemId()

XMLPUBFUN const xmlChar * xmlSAX2GetSystemId

(

void *

ctx

)

xmlSAX2GetSystemId: @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 *

Definition at line 227 of file SAX2.c.

{
    xmlParserCtxtPtr ctxt = (xmlParserCtxtPtr) ctx;
    if ((ctx == NULL) || (ctxt->input == NULL)) return(NULL);
    return((const xmlChar *) ctxt->input->filename);
}

Referenced by isaxlocator_getSystemId().

xmlSAX2HasExternalSubset()

XMLPUBFUN int xmlSAX2HasExternalSubset

(

void *

ctx

)

xmlSAX2HasExternalSubset: @ctx: the user data (XML parser context)

Does this document has an external subset

Returns 1 if true

Definition at line 307 of file SAX2.c.

{
    xmlParserCtxtPtr ctxt = (xmlParserCtxtPtr) ctx;
    if ((ctxt == NULL) || (ctxt->myDoc == NULL)) return(0);
    return(ctxt->myDoc->extSubset != NULL);
}

Referenced by doparse(), and xmlSAXVersion().

xmlSAX2HasInternalSubset()

XMLPUBFUN int xmlSAX2HasInternalSubset

(

void *

ctx

)

xmlSAX2HasInternalSubset: @ctx: the user data (XML parser context)

Does this document has an internal subset

Returns 1 if true

Definition at line 291 of file SAX2.c.

{
    xmlParserCtxtPtr ctxt = (xmlParserCtxtPtr) ctx;
    if ((ctxt == NULL) || (ctxt->myDoc == NULL)) return(0);
    return(ctxt->myDoc->intSubset != NULL);
}

Referenced by doparse(), and xmlSAXVersion().

xmlSAX2IgnorableWhitespace()

XMLPUBFUN void xmlSAX2IgnorableWhitespace	(	void *	ctx,
		const xmlChar *	ch,
		int	len
	)

Referenced by xmlCtxtUseOptionsInternal(), and xmlInitSAXParserCtxt().

xmlSAX2InitDefaultSAXHandler()

XMLPUBFUN void xmlSAX2InitDefaultSAXHandler	(	xmlSAXHandler *	hdlr,
		int	warning
	)

xmlSAX2InitDefaultSAXHandler: @hdlr: the SAX handler

Warning

: flag if non-zero sets the handler warning procedure

Initialize the default XML SAX2 handler

Definition at line 2762 of file SAX2.c.

{
    if ((hdlr == NULL) || (hdlr->initialized != 0))
    return;
 
    xmlSAXVersion(hdlr, xmlSAX2DefaultVersionValue);
    if (warning == 0)
    hdlr->warning = NULL;
    else
    hdlr->warning = xmlParserWarning;
}

xmlSAX2InternalSubset()

XMLPUBFUN void xmlSAX2InternalSubset	(	void *	ctx,
		const xmlChar *	name,
		const xmlChar *	ExternalID,
		const xmlChar *	SystemID
	)

Definition at line 324 of file SAX2.c.

{
    xmlParserCtxtPtr ctxt = (xmlParserCtxtPtr) ctx;
    xmlDtdPtr dtd;
    if (ctx == NULL) return;
 
    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);
    if (ctxt->myDoc->intSubset == NULL)
        xmlSAX2ErrMemory(ctxt, "xmlSAX2InternalSubset");
}

Referenced by doparse(), and xmlSAXVersion().

xmlSAX2IsStandalone()

XMLPUBFUN int xmlSAX2IsStandalone

(

void *

ctx

)

xmlSAX2IsStandalone: @ctx: the user data (XML parser context)

Is this document tagged standalone ?

Returns 1 if true

Definition at line 275 of file SAX2.c.

{
    xmlParserCtxtPtr ctxt = (xmlParserCtxtPtr) ctx;
    if ((ctx == NULL) || (ctxt->myDoc == NULL)) return(0);
    return(ctxt->myDoc->standalone == 1);
}

Referenced by doparse(), and xmlSAXVersion().

xmlSAX2NotationDecl()

XMLPUBFUN void xmlSAX2NotationDecl	(	void *	ctx,
		const xmlChar *	name,
		const xmlChar *	publicId,
		const xmlChar *	systemId
	)

Definition at line 764 of file SAX2.c.

{
    xmlParserCtxtPtr ctxt = (xmlParserCtxtPtr) ctx;
    xmlNotationPtr nota = NULL;
 
    /* Avoid unused variable warning if features are disabled. */
    (void) nota;
 
    if ((ctxt == NULL) || (ctxt->myDoc == NULL))
        return;
 
    if ((publicId == NULL) && (systemId == NULL)) {
    xmlFatalErrMsg(ctxt, XML_ERR_NOTATION_PROCESSING,
         "SAX.xmlSAX2NotationDecl(%s) externalID or PublicID missing\n",
                   name, NULL);
    return;
    } else if (ctxt->inSubset == 1)
    nota = xmlAddNotationDecl(&ctxt->vctxt, ctxt->myDoc->intSubset, name,
                              publicId, systemId);
    else if (ctxt->inSubset == 2)
    nota = xmlAddNotationDecl(&ctxt->vctxt, ctxt->myDoc->extSubset, name,
                              publicId, systemId);
    else {
    xmlFatalErrMsg(ctxt, XML_ERR_NOTATION_PROCESSING,
         "SAX.xmlSAX2NotationDecl(%s) called while not in subset\n",
                   name, NULL);
    return;
    }
#ifdef LIBXML_VALID_ENABLED
    if (nota == NULL) ctxt->valid = 0;
    if ((ctxt->validate) && (ctxt->wellFormed) &&
        (ctxt->myDoc->intSubset != NULL))
    ctxt->valid &= xmlValidateNotationDecl(&ctxt->vctxt, ctxt->myDoc,
                                           nota);
#endif /* LIBXML_VALID_ENABLED */
}

Referenced by doparse(), and xmlSAXVersion().

xmlSAX2ProcessingInstruction()

XMLPUBFUN void xmlSAX2ProcessingInstruction	(	void *	ctx,
		const xmlChar *	target,
		const xmlChar *	data
	)

xmlSAX2ProcessingInstruction: @ctx: the user data (XML parser context) @target: the target name @data: the PI data's

A processing instruction has been parsed.

Definition at line 2567 of file SAX2.c.

{
    xmlParserCtxtPtr ctxt = (xmlParserCtxtPtr) ctx;
    xmlNodePtr ret;
    xmlNodePtr parent;
 
    if (ctx == NULL) return;
    parent = ctxt->node;
 
    ret = xmlNewDocPI(ctxt->myDoc, target, data);
    if (ret == NULL) return;
 
    if (ctxt->linenumbers) {
    if (ctxt->input != NULL) {
        if ((unsigned) ctxt->input->line < (unsigned) USHRT_MAX)
        ret->line = ctxt->input->line;
        else
            ret->line = USHRT_MAX;
    }
    }
    if (ctxt->inSubset == 1) {
    xmlAddChild((xmlNodePtr) ctxt->myDoc->intSubset, ret);
    return;
    } else if (ctxt->inSubset == 2) {
    xmlAddChild((xmlNodePtr) ctxt->myDoc->extSubset, ret);
    return;
    }
    if (parent == NULL) {
        xmlAddChild((xmlNodePtr) ctxt->myDoc, (xmlNodePtr) ret);
    return;
    }
    if (parent->type == XML_ELEMENT_NODE) {
    xmlAddChild(parent, ret);
    } else {
    xmlAddSibling(parent, ret);
    }
}

Referenced by doparse(), and xmlSAXVersion().

xmlSAX2Reference()

XMLPUBFUN void xmlSAX2Reference	(	void *	ctx,
		const xmlChar *	name
	)

Definition at line 2379 of file SAX2.c.

{
    xmlParserCtxtPtr ctxt = (xmlParserCtxtPtr) ctx;
    xmlNodePtr ret;
 
    if (ctx == NULL) return;
    ret = xmlNewReference(ctxt->myDoc, name);
    if (xmlAddChild(ctxt->node, ret) == NULL) {
        xmlFreeNode(ret);
    }
}

Referenced by doparse(), and xmlSAXVersion().

xmlSAX2ResolveEntity()

XMLPUBFUN xmlParserInputPtr xmlSAX2ResolveEntity	(	void *	ctx,
		const xmlChar *	publicId,
		const xmlChar *	systemId
	)

xmlSAX2ResolveEntity: @ctx: the user data (XML parser context) @publicId: The public ID of the entity @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.

Definition at line 486 of file SAX2.c.

{
    xmlParserCtxtPtr ctxt = (xmlParserCtxtPtr) ctx;
    xmlParserInputPtr ret;
    xmlChar *URI;
    const char *base = NULL;
 
    if (ctx == NULL) return(NULL);
    if (ctxt->input != NULL)
    base = ctxt->input->filename;
    if (base == NULL)
    base = ctxt->directory;
 
    URI = xmlBuildURI(systemId, (const xmlChar *) base);
 
    ret = xmlLoadExternalEntity((const char *) URI,
                (const char *) publicId, ctxt);
    if (URI != NULL)
    xmlFree(URI);
    return(ret);
}

Referenced by doparse(), libxmlresolveentity(), and xmlSAXVersion().

xmlSAX2SetDocumentLocator()

XMLPUBFUN void xmlSAX2SetDocumentLocator	(	void *	ctx,
		xmlSAXLocatorPtr	loc
	)

Referenced by doparse().

xmlSAX2StartDocument()

XMLPUBFUN void xmlSAX2StartDocument

(

void *

ctx

)

xmlSAX2StartDocument: @ctx: the user data (XML parser context)

called when the document start being processed.

Definition at line 887 of file SAX2.c.

{
    xmlParserCtxtPtr ctxt = (xmlParserCtxtPtr) ctx;
    xmlDocPtr doc;
 
    if (ctx == NULL) return;
 
    if (ctxt->html) {
#ifdef LIBXML_HTML_ENABLED
    if (ctxt->myDoc == NULL)
        ctxt->myDoc = htmlNewDocNoDtD(NULL, NULL);
    if (ctxt->myDoc == NULL) {
        xmlSAX2ErrMemory(ctxt, "xmlSAX2StartDocument");
        return;
    }
    ctxt->myDoc->properties = XML_DOC_HTML;
    ctxt->myDoc->parseFlags = ctxt->options;
#else
        xmlGenericError(xmlGenericErrorContext,
        "libxml2 built without HTML support\n");
    ctxt->errNo = XML_ERR_INTERNAL_ERROR;
    ctxt->instate = XML_PARSER_EOF;
    ctxt->disableSAX = 1;
    return;
#endif
    } else {
    doc = ctxt->myDoc = xmlNewDoc(ctxt->version);
    if (doc != NULL) {
        doc->properties = 0;
        if (ctxt->options & XML_PARSE_OLD10)
            doc->properties |= XML_DOC_OLD10;
        doc->parseFlags = ctxt->options;
        doc->standalone = ctxt->standalone;
    } else {
        xmlSAX2ErrMemory(ctxt, "xmlSAX2StartDocument");
        return;
    }
    if ((ctxt->dictNames) && (doc != NULL)) {
        doc->dict = ctxt->dict;
        xmlDictReference(doc->dict);
    }
    }
    if ((ctxt->myDoc != NULL) && (ctxt->myDoc->URL == NULL) &&
    (ctxt->input != NULL) && (ctxt->input->filename != NULL)) {
    ctxt->myDoc->URL = xmlPathToURI((const xmlChar *)ctxt->input->filename);
    if (ctxt->myDoc->URL == NULL)
        xmlSAX2ErrMemory(ctxt, "xmlSAX2StartDocument");
    }
}

Referenced by doparse(), and xmlSAXVersion().

xmlSAX2StartElementNs()

XMLPUBFUN 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
	)

xmlSAX2StartElementNs: @ctx: the user data (XML parser context) @localname: the local name of the element @prefix: the element namespace prefix if available @URI: the element namespace name if available @nb_namespaces: number of namespace definitions on that node @namespaces: pointer to the array of prefix/URI pairs namespace definitions @nb_attributes: the number of attributes on that node @nb_defaulted: the number of defaulted attributes. @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 information for the element, as well as the new namespace declarations on the element.

Definition at line 2077 of file SAX2.c.

{
    xmlParserCtxtPtr ctxt = (xmlParserCtxtPtr) ctx;
    xmlNodePtr ret;
    xmlNodePtr parent;
    xmlNsPtr last = NULL, ns;
    const xmlChar *uri, *pref;
    xmlChar *lname = NULL;
    int i, j;
 
    if (ctx == NULL) return;
    /*
     * 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_DTD_NO_DTD,
      "Validation failed: no DTD found !", NULL, NULL);
    ctxt->validate = 0;
    }
 
    /*
     * Take care of the rare case of an undefined namespace prefix
     */
    if ((prefix != NULL) && (URI == NULL)) {
        if (ctxt->dictNames) {
        const xmlChar *fullname;
 
        fullname = xmlDictQLookup(ctxt->dict, prefix, localname);
        if (fullname != NULL)
            localname = fullname;
    } else {
        lname = xmlBuildQName(localname, prefix, NULL, 0);
    }
    }
    /*
     * allocate the node
     */
    if (ctxt->freeElems != NULL) {
        ret = ctxt->freeElems;
    ctxt->freeElems = ret->next;
    ctxt->freeElemsNr--;
    memset(ret, 0, sizeof(xmlNode));
        ret->doc = ctxt->myDoc;
    ret->type = XML_ELEMENT_NODE;
 
    if (ctxt->dictNames)
        ret->name = localname;
    else {
        if (lname == NULL)
        ret->name = xmlStrdup(localname);
        else
            ret->name = lname;
        if (ret->name == NULL) {
            xmlSAX2ErrMemory(ctxt, "xmlSAX2StartElementNs");
                xmlFree(ret);
        return;
        }
    }
    if ((__xmlRegisterCallbacks) && (xmlRegisterNodeDefaultValue))
        xmlRegisterNodeDefaultValue(ret);
    } else {
    if (ctxt->dictNames)
        ret = xmlNewDocNodeEatName(ctxt->myDoc, NULL,
                                   (xmlChar *) localname, NULL);
    else if (lname == NULL)
        ret = xmlNewDocNode(ctxt->myDoc, NULL, localname, NULL);
    else
        ret = xmlNewDocNodeEatName(ctxt->myDoc, NULL,
                                   (xmlChar *) lname, NULL);
    if (ret == NULL) {
        xmlSAX2ErrMemory(ctxt, "xmlSAX2StartElementNs");
        return;
    }
    }
    if (ctxt->linenumbers) {
    if (ctxt->input != NULL) {
        if ((unsigned) ctxt->input->line < (unsigned) USHRT_MAX)
        ret->line = ctxt->input->line;
        else
            ret->line = USHRT_MAX;
    }
    }
 
    /*
     * Build the namespace list
     */
    for (i = 0,j = 0;j < nb_namespaces;j++) {
        pref = namespaces[i++];
    uri = namespaces[i++];
    ns = xmlNewNs(NULL, uri, pref);
    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 {
            /*
             * any out of memory error would already have been raised
             * but we can't be guaranteed it's the actual error due to the
             * API, best is to skip in this case
             */
        continue;
    }
 
        xmlParserNsUpdateSax(ctxt, pref, ns);
 
#ifdef LIBXML_VALID_ENABLED
    if ((!ctxt->html) && ctxt->validate && ctxt->wellFormed &&
        ctxt->myDoc && ctxt->myDoc->intSubset) {
        ctxt->valid &= xmlValidateOneNamespace(&ctxt->vctxt, ctxt->myDoc,
                                               ret, prefix, ns, uri);
    }
#endif /* LIBXML_VALID_ENABLED */
    }
    ctxt->nodemem = -1;
 
    /* Initialize parent before pushing node */
    parent = ctxt->node;
    if (parent == NULL)
        parent = (xmlNodePtr) ctxt->myDoc;
 
    /*
     * We are parsing a new node.
     */
    if (nodePush(ctxt, ret) < 0) {
        xmlUnlinkNode(ret);
        xmlFreeNode(ret);
        return;
    }
 
    /*
     * Link the child element
     */
    xmlAddChild(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
     * Note that, if prefix is NULL, this searches for the default Ns
     */
    if ((URI != NULL) && (ret->ns == NULL)) {
        ret->ns = xmlParserNsLookupSax(ctxt, prefix);
    if ((ret->ns == NULL) && (xmlStrEqual(prefix, BAD_CAST "xml"))) {
        ret->ns = xmlSearchNs(ctxt->myDoc, ret, prefix);
    }
    if (ret->ns == NULL) {
        ns = xmlNewNs(ret, NULL, prefix);
        if (ns == NULL) {
 
            xmlSAX2ErrMemory(ctxt, "xmlSAX2StartElementNs");
        return;
        }
            if (prefix != NULL)
                xmlNsWarnMsg(ctxt, XML_NS_ERR_UNDEFINED_NAMESPACE,
                             "Namespace prefix %s was not found\n",
                             prefix, NULL);
            else
                xmlNsWarnMsg(ctxt, XML_NS_ERR_UNDEFINED_NAMESPACE,
                             "Namespace default prefix was not found\n",
                             NULL, NULL);
    }
    }
 
    /*
     * process all the other attributes
     */
    if (nb_attributes > 0) {
        xmlAttrPtr prev = NULL;
 
        for (j = 0,i = 0;i < nb_attributes;i++,j+=5) {
            xmlAttrPtr attr = NULL;
 
        /*
         * Handle the rare case of an undefined attribute prefix
         */
        if ((attributes[j+1] != NULL) && (attributes[j+2] == NULL)) {
        if (ctxt->dictNames) {
            const xmlChar *fullname;
 
            fullname = xmlDictQLookup(ctxt->dict, attributes[j+1],
                                      attributes[j]);
            if (fullname != NULL) {
                        attr = xmlSAX2AttributeNs(ctxt, fullname, NULL,
                                                  attributes[j+3],
                                                  attributes[j+4]);
                        goto have_attr;
            }
        } else {
            lname = xmlBuildQName(attributes[j], attributes[j+1],
                                  NULL, 0);
            if (lname != NULL) {
                        attr = xmlSAX2AttributeNs(ctxt, lname, NULL,
                                                  attributes[j+3],
                                                  attributes[j+4]);
            xmlFree(lname);
                        goto have_attr;
            }
        }
        }
            attr = xmlSAX2AttributeNs(ctxt, attributes[j], attributes[j+1],
                                      attributes[j+3], attributes[j+4]);
have_attr:
            if (attr == NULL)
                continue;
 
            /* link at the end to preserve order */
            if (prev == NULL) {
                ctxt->node->properties = attr;
            } else {
                prev->next = attr;
                attr->prev = prev;
            }
 
            prev = attr;
    }
    }
 
#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.flags & XML_VCTXT_DTD_VALIDATED) == 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.flags |= XML_VCTXT_DTD_VALIDATED;
    }
#endif /* LIBXML_VALID_ENABLED */
}

Referenced by doparse(), and xmlSAXVersion().

xmlSAX2UnparsedEntityDecl()

XMLPUBFUN void xmlSAX2UnparsedEntityDecl	(	void *	ctx,
		const xmlChar *	name,
		const xmlChar *	publicId,
		const xmlChar *	systemId,
		const xmlChar *	notationName
	)

Definition at line 813 of file SAX2.c.

{
    xmlEntityPtr ent;
    xmlParserCtxtPtr ctxt = (xmlParserCtxtPtr) ctx;
    if (ctx == NULL) return;
    if (ctxt->inSubset == 1) {
    ent = xmlAddDocEntity(ctxt->myDoc, name,
            XML_EXTERNAL_GENERAL_UNPARSED_ENTITY,
            publicId, systemId, notationName);
    if ((ent == NULL) && (ctxt->pedantic) &&
        (ctxt->sax != NULL) && (ctxt->sax->warning != NULL))
        ctxt->sax->warning(ctxt->userData,
         "Entity(%s) already defined in the internal subset\n", name);
    if ((ent != NULL) && (ent->URI == NULL) && (systemId != NULL)) {
        xmlChar *URI;
        const char *base = NULL;
 
        if (ctxt->input != NULL)
        base = ctxt->input->filename;
        if (base == NULL)
        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 == NULL) && (ctxt->pedantic) &&
        (ctxt->sax != NULL) && (ctxt->sax->warning != NULL))
        ctxt->sax->warning(ctxt->userData,
         "Entity(%s) already defined in the external subset\n", name);
    if ((ent != NULL) && (ent->URI == NULL) && (systemId != NULL)) {
        xmlChar *URI;
        const char *base = NULL;
 
        if (ctxt->input != NULL)
        base = ctxt->input->filename;
        if (base == NULL)
        base = ctxt->directory;
 
        URI = xmlBuildURI(systemId, (const xmlChar *) base);
        ent->URI = URI;
    }
    } else {
        xmlFatalErrMsg(ctxt, XML_ERR_INTERNAL_ERROR,
         "SAX.xmlSAX2UnparsedEntityDecl(%s) called while not in subset\n",
                   name, NULL);
    }
}

Referenced by doparse(), and xmlSAXVersion().

xmlSAXVersion()

XMLPUBFUN int xmlSAXVersion	(	xmlSAXHandler *	hdlr,
		int	version
	)

xmlSAXVersion: @hdlr: the SAX handler

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.

Definition at line 2704 of file SAX2.c.

{
    if (hdlr == NULL) return(-1);
    if (version == 2) {
    hdlr->startElementNs = xmlSAX2StartElementNs;
    hdlr->endElementNs = xmlSAX2EndElementNs;
    hdlr->serror = NULL;
    hdlr->initialized = XML_SAX2_MAGIC;
#ifdef LIBXML_SAX1_ENABLED
    } else if (version == 1) {
    hdlr->initialized = 1;
#endif /* LIBXML_SAX1_ENABLED */
    } else
        return(-1);
#ifdef LIBXML_SAX1_ENABLED
    hdlr->startElement = xmlSAX2StartElement;
    hdlr->endElement = xmlSAX2EndElement;
#else
    hdlr->startElement = NULL;
    hdlr->endElement = NULL;
#endif /* LIBXML_SAX1_ENABLED */
    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;
    hdlr->warning = xmlParserWarning;
    hdlr->error = xmlParserError;
    hdlr->fatalError = xmlParserError;
 
    return(0);
}

Referenced by xmlInitSAXParserCtxt(), and xmlSAX2InitDefaultSAXHandler().