## SAX2

SAX2 - SAX2 parser interface used to build the DOM tree

those are the default SAX2 interfaces used by the library when building DOM tree.

Author(s): Daniel Veillard

## Synopsis

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

## Description

## Details

### htmlDefaultSAXHandlerInit ()

    void	htmlDefaultSAXHandlerInit	(void)

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

### xmlDefaultSAXHandlerInit ()

    void	xmlDefaultSAXHandlerInit	(void)

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

### xmlSAX2AttributeDecl ()

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

An attribute definition has been parsed

`ctx`: | the user data (XML parser context)
`elem`: | the name of the element
`fullname`: | the attribute name
`type`: | the attribute type
`def`: | the type of default value
`defaultValue`: | the attribute default value
`tree`: | the tree of enumerated value set

### xmlSAX2CDataBlock ()

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

called when a pcdata block has been parsed

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

### xmlSAX2Characters ()

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

receiving some chars from the parser.

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

### xmlSAX2Comment ()

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

A xmlSAX2Comment has been parsed.

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

### xmlSAX2ElementDecl ()

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

An element definition has been parsed

`ctx`: | the user data (XML parser context)
`name`: | the element name
`type`: | the element type
`content`: | the element value tree

### xmlSAX2EndDocument ()

    void	xmlSAX2EndDocument		(void * ctx)

called when the document end has been detected.

`ctx`: | the user data (XML parser context)

### xmlSAX2EndElement ()

    void	xmlSAX2EndElement		(void * ctx,
    					 const xmlChar * name)

called when the end of an element has been detected.

`ctx`: | the user data (XML parser context)
`name`: | The element name

### xmlSAX2EndElementNs ()

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

SAX2 callback when an element end has been detected by the parser. It provides the namespace information for the element.

`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

### xmlSAX2EntityDecl ()

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

An entity definition has been parsed

`ctx`: | the user data (XML parser context)
`name`: | the entity name
`type`: | the entity type
`publicId`: | The public ID of the entity
`systemId`: | The system ID of the entity
`content`: | the entity value (without processing).

### xmlSAX2ExternalSubset ()

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

Callback on external subset declaration.

`ctx`: | the user data (XML parser context)
`name`: | the root element name
`ExternalID`: | the external ID
`SystemID`: | the SYSTEM ID (e.g. filename or URL)

### xmlSAX2GetColumnNumber ()

    int	xmlSAX2GetColumnNumber		(void * ctx)

Provide the column number of the current parsing point.

`ctx`: | the user data (XML parser context)
`Returns`: | an int

### xmlSAX2GetEntity ()

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

Get an entity by name

`ctx`: | the user data (XML parser context)
`name`: | The entity name
`Returns`: | the xmlEntityPtr if found.

### xmlSAX2GetLineNumber ()

    int	xmlSAX2GetLineNumber		(void * ctx)

Provide the line number of the current parsing point.

`ctx`: | the user data (XML parser context)
`Returns`: | an int

### xmlSAX2GetParameterEntity ()

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

Get a parameter entity by name

`ctx`: | the user data (XML parser context)
`name`: | The entity name
`Returns`: | the xmlEntityPtr if found.

### xmlSAX2GetPublicId ()

    const xmlChar *	xmlSAX2GetPublicId	(void * ctx)

Provides the public ID e.g. "-//SGMLSOURCE//DTD DEMO//EN"

`ctx`: | the user data (XML parser context)
`Returns`: | a xmlChar *

### xmlSAX2GetSystemId ()

    const xmlChar *	xmlSAX2GetSystemId	(void * ctx)

Provides the system ID, basically URL or filename e.g. http://www.sgmlsource.com/dtds/memo.dtd

`ctx`: | the user data (XML parser context)
`Returns`: | a xmlChar *

### xmlSAX2HasExternalSubset ()

    int	xmlSAX2HasExternalSubset	(void * ctx)

Does this document has an external subset

`ctx`: | the user data (XML parser context)
`Returns`: | 1 if true

### xmlSAX2HasInternalSubset ()

    int	xmlSAX2HasInternalSubset	(void * ctx)

Does this document has an internal subset

`ctx`: | the user data (XML parser context)
`Returns`: | 1 if true

### xmlSAX2IgnorableWhitespace ()

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

receiving some ignorable whitespaces from the parser. UNUSED: by default the DOM building will use xmlSAX2Characters

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

### xmlSAX2InitDefaultSAXHandler ()

    void	xmlSAX2InitDefaultSAXHandler	(xmlSAXHandler * hdlr,
    					 int warning)

Initialize the default XML SAX2 handler

`hdlr`: | the SAX handler
`warning`: | flag if non-zero sets the handler warning procedure

### xmlSAX2InitHtmlDefaultSAXHandler ()

    void	xmlSAX2InitHtmlDefaultSAXHandler	(xmlSAXHandler * hdlr)

Initialize the default HTML SAX2 handler

`hdlr`: | the SAX handler

### xmlSAX2InternalSubset ()

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

Callback on internal subset declaration.

`ctx`: | the user data (XML parser context)
`name`: | the root element name
`ExternalID`: | the external ID
`SystemID`: | the SYSTEM ID (e.g. filename or URL)

### xmlSAX2IsStandalone ()

    int	xmlSAX2IsStandalone		(void * ctx)

Is this document tagged standalone ?

`ctx`: | the user data (XML parser context)
`Returns`: | 1 if true

### xmlSAX2NotationDecl ()

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

What to do when a notation declaration has been parsed.

`ctx`: | the user data (XML parser context)
`name`: | The name of the notation
`publicId`: | The public ID of the entity
`systemId`: | The system ID of the entity

### xmlSAX2ProcessingInstruction ()

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

A processing instruction has been parsed.

`ctx`: | the user data (XML parser context)
`target`: | the target name
`data`: | the PI data's

### xmlSAX2Reference ()

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

called when an entity xmlSAX2Reference is detected.

`ctx`: | the user data (XML parser context)
`name`: | The entity name

### xmlSAX2ResolveEntity ()

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

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

`ctx`: | the user data (XML parser context)
`publicId`: | The public ID of the entity
`systemId`: | The system ID of the entity
`Returns`: | the xmlParserInputPtr if inlined or NULL for DOM behaviour.

### xmlSAX2SetDocumentLocator ()

    void	xmlSAX2SetDocumentLocator	(void * ctx,
    					 xmlSAXLocatorPtr loc)

Receive the document locator at startup, actually xmlDefaultSAXLocator Everything is available on the context, so this is useless in our case.

`ctx`: | the user data (XML parser context)
`loc`: | A SAX Locator

### xmlSAX2StartDocument ()

    void	xmlSAX2StartDocument		(void * ctx)

called when the document start being processed.

`ctx`: | the user data (XML parser context)

### xmlSAX2StartElement ()

    void	xmlSAX2StartElement		(void * ctx,
    					 const xmlChar * fullname,
    					 const xmlChar ** atts)

called when an opening tag has been processed.

`ctx`: | the user data (XML parser context)
`fullname`: | The element name, including namespace prefix
`atts`: | An array of name/value attributes pairs, NULL terminated

### xmlSAX2StartElementNs ()

    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)

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.

`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.

### xmlSAX2UnparsedEntityDecl ()

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

What to do when an unparsed entity declaration is parsed

`ctx`: | the user data (XML parser context)
`name`: | The name of the entity
`publicId`: | The public ID of the entity
`systemId`: | The system ID of the entity
`notationName`: | the name of the notation

### xmlSAXDefaultVersion ()

    int	xmlSAXDefaultVersion		(int version)

DEPRECATED: Use parser option XML_PARSE_SAX1. Set the default version of SAX used globally by the library. By default, during initialization the default is set to 2. Note that it is generally a better coding style to use xmlSAXVersion() to set up the version explicitly for a given parsing context.

`version`: | the version, 1 or 2
`Returns`: | the previous value in case of success and -1 in case of error.

### xmlSAXVersion ()

    int	xmlSAXVersion			(xmlSAXHandler * hdlr,
    					 int version)

Initialize the default XML SAX handler according to the version

`hdlr`: | the SAX handler
`version`: | the version, 1 or 2
`Returns`: | 0 in case of success and -1 in case of error.