/*
 * Summary: the core parser module
 * Description: Interfaces, constants and types related to the XML parser
 *
 * Copy: See Copyright for the status of this software.
 *
 * Author: Daniel Veillard
 * Portion Copyright © 2009 Nokia Corporation and/or its subsidiary(-ies). All rights reserved. 
 */

/** @file
@publishedAll
@released
*/

#ifndef XML_PARSER_H
#define XML_PARSER_H

#include <stdapis/libxml2/libxml2_dict.h>
#include <stdapis/libxml2/libxml2_hash.h>
#include <stdapis/libxml2/libxml2_valid.h>
#include <stdapis/libxml2/libxml2_entities.h>
#include <stdapis/libxml2/libxml2_encoding.h>

//typedef struct _xmlParserInput xmlParserInput;
//typedef xmlParserInput *xmlParserInputPtr;

#include <stdapis/libxml2/libxml2_xmlio.h>

#ifdef __cplusplus
extern "C" {
#endif

/**
 * XML_DEFAULT_VERSION:
 *
 * The default version of XML used: 1.0
 */
#define XML_DEFAULT_VERSION     "1.0"

/**
 * xmlParserInput:
 *
 * An xmlParserInput is an input flow for the XML processor.
 * Each entity parsed is associated an xmlParserInput (except the
 * few predefined ones). This is the case both for internal entities
 * - in which case the flow is already completely in memory - or
 * external entities - in which case we use the buf structure for
 * progressive reading and I18N conversions to the internal UTF-8 format.
 */

/**
 * xmlParserInputDeallocate:
 * @param str the string to deallocate
 *
 * Callback for freeing some parser input allocations.
 */
typedef void (* xmlParserInputDeallocate)(xmlChar *str);

struct _xmlParserInput {
    /* Input buffer */
    xmlParserInputBufferPtr buf;      /* UTF-8 encoded buffer */

    const char *filename;             /* The file analyzed, if any */
    const char *directory;            /* the directory/base of the file */
    const xmlChar *base;              /* Base of the array to parse */
    const xmlChar *cur;               /* Current char being parsed */
    const xmlChar *end;               /* end of the array to parse */
    int length;                       /* length if known */
    int line;                         /* Current line */
    int col;                          /* Current column */
    /*
     * NOTE: consumed is only tested for equality in the parser code,
     *       so even if there is an overflow this should not give troubles
     *       for parsing very large instances.
     */
    unsigned long consumed;           /* How many xmlChars already consumed */
    xmlParserInputDeallocate free;    /* function to deallocate the base */
    const xmlChar *encoding;          /* the encoding string for entity */
    const xmlChar *version;           /* the version string for entity */
    int standalone;                   /* Was that entity marked standalone */
    int id;                           /* an unique identifier for the entity */
};

/**
 * xmlParserNodeInfo:
 *
 * The parser can be asked to collect Node informations, i.e. at what
 * place in the file they were detected.
 * NOTE: This is off by default and not very well tested.
 */
typedef struct _xmlParserNodeInfo xmlParserNodeInfo;
typedef xmlParserNodeInfo *xmlParserNodeInfoPtr;

struct _xmlParserNodeInfo {
  const struct _xmlNode* node;
  /* Position & line # that text that created the node begins & ends on */
  unsigned long begin_pos;
  unsigned long begin_line;
  unsigned long end_pos;
  unsigned long end_line;
};

typedef struct _xmlParserNodeInfoSeq xmlParserNodeInfoSeq;
typedef xmlParserNodeInfoSeq *xmlParserNodeInfoSeqPtr;
struct _xmlParserNodeInfoSeq {
  unsigned long maximum;
  unsigned long length;
  xmlParserNodeInfo* buffer;
};

/**
 * xmlParserInputState:
 *
 * The parser is now working also as a state based parser.
 * The recursive one use the state info for entities processing.
 */
typedef enum {
    XML_PARSER_EOF = -1,        /* nothing is to be parsed */
    XML_PARSER_START = 0,       /* nothing has been parsed */
    XML_PARSER_MISC,            /* Misc* before int subset */
    XML_PARSER_PI,              /* Within a processing instruction */
    XML_PARSER_DTD,             /* within some DTD content */
    XML_PARSER_PROLOG,          /* Misc* after internal subset */
    XML_PARSER_COMMENT,         /* within a comment */
    XML_PARSER_START_TAG,       /* within a start tag */
    XML_PARSER_CONTENT,         /* within the content */
    XML_PARSER_CDATA_SECTION,   /* within a CDATA section */
    XML_PARSER_END_TAG,         /* within a closing tag */
    XML_PARSER_ENTITY_DECL,     /* within an entity declaration */
    XML_PARSER_ENTITY_VALUE,    /* within an entity value in a decl */
    XML_PARSER_ATTRIBUTE_VALUE, /* within an attribute value */
    XML_PARSER_SYSTEM_LITERAL,  /* within a SYSTEM value */
    XML_PARSER_EPILOG,          /* the Misc* after the last end tag */
    XML_PARSER_IGNORE,          /* within an IGNORED section */
    XML_PARSER_PUBLIC_LITERAL   /* within a PUBLIC value */
} xmlParserInputState;

/**
 * XML_DETECT_IDS:
 *
 * Bit in the loadsubset context field to tell to do ID/REFs lookups.
 * Use it to initialize xmlLoadExtDtdDefaultValue.
 */
#define XML_DETECT_IDS          2

/**
 * XML_COMPLETE_ATTRS:
 *
 * Bit in the loadsubset context field to tell to do complete the
 * elements attributes lists with the ones defaulted from the DTDs.
 * Use it to initialize xmlLoadExtDtdDefaultValue.
 */
#define XML_COMPLETE_ATTRS      4

/**
 * XML_SKIP_IDS:
 *
 * Bit in the loadsubset context field to tell to not do ID/REFs registration.
 * Used to initialize xmlLoadExtDtdDefaultValue in some special cases.
 */
#define XML_SKIP_IDS            8

/**
 * xmlParserCtxt:
 *
 * The parser context.
 * NOTE This doesn't completely define the parser state, the (current ?)
 *      design of the parser uses recursive function calls since this allow
 *      and easy mapping from the production rules of the specification
 *      to the actual code. The drawback is that the actual function call
 *      also reflect the parser state. However most of the parsing routines
 *      takes as the only argument the parser context pointer, so migrating
 *      to a state based parser for progressive parsing shouldn't be too hard.
 */
struct _xmlParserCtxt {
    struct _xmlSAXHandler *sax;       /* The SAX handler */
    void*            userData;        /* For SAX interface only, used by DOM build */
    xmlDocPtr           myDoc;        /* the document being built */
    int            wellFormed;        /* is the document well formed */
    int       replaceEntities;        /* shall we replace entities ? */
    const xmlChar*   encoding;        /* the declared encoding, if any */
    int            standalone;        /* standalone document */
    int                  html;        /* an HTML(1)/Docbook(2) document */

    /* Input stream stack */
    xmlParserInputPtr  input;         /* Current input stream */
    int                inputNr;       /* Number of current input streams */
    int                inputMax;      /* Max number of input streams */
    xmlParserInputPtr* inputTab;      /* stack of inputs */

#ifdef LIBXML_ENABLE_GS_CACHING_IN_CTXT
    // Note: location is chosen trying to get GS pointer into proximity to
    //       the data often referred to (to avoid cache misses)
    //XMLENGINE: NEW CODE
    void*             cachedGs;      /* cached GS pointer */
#endif
    /* Node analysis stack only used for DOM building */
    xmlNodePtr         node;          /* Current parsed Node */
    int                nodeNr;        /* Depth of the parsing stack */
    int                nodeMax;       /* Max depth of the parsing stack */
    xmlNodePtr*        nodeTab;       /* array of nodes */

    int                  errNo;        /* error code */

    int      hasExternalSubset;        /* reference and external subset */
    int              hasPErefs;        /* the internal subset has PE refs */
    int               external;        /* are we parsing an external entity */

    int                  valid;        /* is the document valid */
    int               validate;        /* shall we try to validate ? */

    xmlParserInputState instate;      /* current type of input */
    int                  token;        /* next char look-ahead */

    char*            directory;        /* the data directory */

    /* Node name stack */
    const xmlChar*        name;       /* Current parsed Node */
    int                 nameNr;       /* Depth of the parsing stack */
    int                nameMax;       /* Max depth of the parsing stack */
    const xmlChar**    nameTab;       /* array of nodes */

    long               nbChars;       /* number of xmlChar processed */
    long            checkIndex;       /* used by progressive parsing lookup */
    int             keepBlanks;       /* ugly but ... */
    int             disableSAX;       /* SAX callbacks are disabled */
    int               inSubset;       /* Parsing is in int 1/ext 2 subset */
    int			stackLowThreshold;	  /* minimum amount of thread's stack left */

    /* xml:space values */
    int*               space;         /* Should the parser preserve spaces */
    int                spaceNr;       /* Depth of the parsing stack */
    int                spaceMax;      /* Max depth of the parsing stack */
    int*               spaceTab;      /* array of space infos */

    int                depth;         /* to prevent entity substitution loops */
    int                charset;       /* encoding of the in-memory content
                                         actually an xmlCharEncoding */
    int                nodelen;       /* Those two fields are there to */
    int                nodemem;       /* Speed up large node parsing */
    int                pedantic;      /* signal pedantic warnings */
    void*              _private;      /* For user data, libxml won't touch it */

    int                loadsubset;    /* should the external subset be loaded */

    void*              catalogs;      /* document's own catalog */
    int             progressive;      /* is this a progressive parsing */
    xmlDictPtr             dict;      /* dictionnary for the parser */
    const xmlChar**        atts;      /* array for the attributes callbacks */
    int                 maxatts;      /* the size of the array */

    /*
     * pre-interned strings
     */
    const xmlChar* str_xml;
    const xmlChar* str_xmlns;
    const xmlChar* str_xml_ns;

    /*
     * Everything below is used only by the new SAX mode
     */
    int                sax2;          /* operating in the new SAX mode */
    int                nsNr;          /* the number of inherited namespaces */
    int                nsMax;         /* the size of the arrays */
    const xmlChar**    nsTab;         /* the array of prefix/namespace name */
    int*               attallocs;     /* which attribute were allocated */
    void**             pushTab;       /* array of data for push */
    xmlHashTablePtr    attsDefault;   /* defaulted attributes if any */
    xmlHashTablePtr    attsSpecial;   /* non-CDATA attributes if any */
    int                nsWellFormed;  /* is the document XML Nanespace okay */
    int                options;       /* Extra options */

    /*
     * Those fields are needed only for streaming parsing so far
     */
    int               dictNames;    /* Use dictionary names for the tree */
    int               freeElemsNr;  /* number of freed element nodes */
    xmlNodePtr        freeElems;    /* List of freed element nodes */
    int               freeAttrsNr;  /* number of freed attributes nodes */
    xmlAttrPtr        freeAttrs;    /* List of freed attributes nodes */

    /*
     * the complete error informations for the last error.
     */
    xmlError          lastError;

// XMLENGINE: BEGIN NEW CODE - lastNsNr attribute in parser context
    int               lastNsNr;     /* temporarily contains number of new namespaces in element*/
// XMLENGINE: END NEW CODE

//== Fields less used in libxml2, so put in the end of the structure (offset is > 255)
//
// Note: these fields were move from their original place in the structure
//
    const xmlChar*    version;        /* the XML version string */
    const xmlChar*  intSubName;       /* name of subset */
    xmlChar*         extSubURI;       /* URI of external subset */
    xmlChar*      extSubSystem;       /* SYSTEM ID of external subset */
    int                recovery;      /* run in recovery mode */
    int                 docdict;      /* use strings from dict to build tree */
    xmlParserInputPtr  entity;        /* used to check entities boundaries */

    xmlValidCtxt         vctxt;        /* The validity context */

//== Fields below are likely to stay disabled forever in XML ENGINE

#ifdef LIBXML_ENABLE_NODE_LINEINFO
    int             linenumbers;      /* set line number in element content */
#endif

#ifdef XMLENGINE_ENABLE_PARSER_RECORD_INFO
    int record_info;                   /* Whether node info should be kept */
    xmlParserNodeInfoSeq node_seq;     /* info about each node parsed */
#endif


}; // struct _xmlParserCtxt



/**
 * xmlSAXLocator:
 *
 * A SAX Locator.
 */
struct _xmlSAXLocator {
    const xmlChar* (*getPublicId)(void* ctx);
    const xmlChar* (*getSystemId)(void* ctx);
    int (*getLineNumber)(void* ctx);
    int (*getColumnNumber)(void* ctx);
};

/**
 * xmlSAXHandler:
 *
 * A SAX handler is bunch of callbacks called by the parser when processing
 * of the input generate data or structure informations.
 */

/**
 * resolveEntitySAXFunc:
 * @param ctx the user data (XML parser context)
 * @param publicId The public ID of the entity
 * @param systemId The system ID of the entity
 *
 * Callback:
 * The entity loader, to control the loading of external entities,
 * the application can either:
 *    - override this resolveEntity() 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.
 */
typedef xmlParserInputPtr (*resolveEntitySAXFunc) (
                void*          ctx,
                const xmlChar* publicId,
                const xmlChar* systemId);
/**
 * internalSubsetSAXFunc:
 * @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.
 */
typedef void (*internalSubsetSAXFunc) (
                void*          ctx,
                const xmlChar* name,
                const xmlChar* ExternalID,
                const xmlChar* SystemID);
/**
 * externalSubsetSAXFunc:
 * @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.
 */
typedef void (*externalSubsetSAXFunc) (
                void*          ctx,
                const xmlChar* name,
                const xmlChar* ExternalID,
                const xmlChar* SystemID);
/**
 * getEntitySAXFunc:
 * @param ctx the user data (XML parser context)
 * @param name The entity name
 *
 * Get an entity by name.
 *
 * Returns the xmlEntityPtr if found.
 */
typedef xmlEntityPtr (*getEntitySAXFunc) (
                void*          ctx,
                const xmlChar* name);
/**
 * getParameterEntitySAXFunc:
 * @param ctx the user data (XML parser context)
 * @param name The entity name
 *
 * Get a parameter entity by name.
 *
 * Returns the xmlEntityPtr if found.
 */
typedef xmlEntityPtr (*getParameterEntitySAXFunc) (
                void*          ctx,
                const xmlChar* name);
/**
 * entityDeclSAXFunc:
 * @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.
 */
typedef void (*entityDeclSAXFunc) (
                void*          ctx,
                const xmlChar* name,
                int            type,
                const xmlChar* publicId,
                const xmlChar* systemId,
                xmlChar*       content);
/**
 * notationDeclSAXFunc:
 * @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.
 */
typedef void (*notationDeclSAXFunc)(
                void* ctx,
                const xmlChar* name,
                const xmlChar* publicId,
                const xmlChar* systemId);
/**
 * attributeDeclSAXFunc:
 * @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.
 */
typedef void (*attributeDeclSAXFunc)(
                void*          ctx,
                const xmlChar* elem,
                const xmlChar* fullname,
                int            type,
                int            def,
                const xmlChar* defaultValue,
                xmlEnumerationPtr tree);
/**
 * elementDeclSAXFunc:
 * @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.
 */
typedef void (*elementDeclSAXFunc)(
                void*           ctx,
                const xmlChar* name,
                int            type,
                xmlElementContentPtr content);
/**
 * unparsedEntityDeclSAXFunc:
 * @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.
 */
typedef void (*unparsedEntityDeclSAXFunc)(void *ctx,
                const xmlChar *name,
                const xmlChar *publicId,
                const xmlChar *systemId,
                const xmlChar *notationName);
/**
 * setDocumentLocatorSAXFunc:
 * @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.
 */
typedef void (*setDocumentLocatorSAXFunc) (void *ctx,
                xmlSAXLocatorPtr loc);
/**
 * startDocumentSAXFunc:
 * @param ctx the user data (XML parser context)
 *
 * Called when the document start being processed.
 */
typedef void (*startDocumentSAXFunc) (void *ctx);
/**
 * endDocumentSAXFunc:
 * @param ctx the user data (XML parser context)
 *
 * Called when the document end has been detected.
 */
typedef void (*endDocumentSAXFunc) (void *ctx);
/**
 * startElementSAXFunc:
 * @param ctx the user data (XML parser context)
 * @param name 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.
 */
typedef void (*startElementSAXFunc) (void *ctx,
                const xmlChar *name,
                const xmlChar **atts);
/**
 * endElementSAXFunc:
 * @param ctx the user data (XML parser context)
 * @param name The element name
 *
 * Called when the end of an element has been detected.
 */
typedef void (*endElementSAXFunc) (void *ctx,
                const xmlChar *name);
/**
 * attributeSAXFunc:
 * @param ctx the user data (XML parser context)
 * @param name The attribute name, including namespace prefix
 * @param value 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.
 */
typedef void (*attributeSAXFunc) (void *ctx,
                const xmlChar *name,
                const xmlChar *value);
/**
 * referenceSAXFunc:
 * @param ctx the user data (XML parser context)
 * @param name The entity name
 *
 * Called when an entity reference is detected.
 */
typedef void (*referenceSAXFunc) (void *ctx,
                const xmlChar *name);
/**
 * charactersSAXFunc:
 * @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.
 */
typedef void (*charactersSAXFunc) (void *ctx,
                const xmlChar *ch,
                int len);
/**
 * ignorableWhitespaceSAXFunc:
 * @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 characters.
 */
typedef void (*ignorableWhitespaceSAXFunc) (void *ctx,
                const xmlChar *ch,
                int len);
/**
 * processingInstructionSAXFunc:
 * @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.
 */
typedef void (*processingInstructionSAXFunc) (void *ctx,
                const xmlChar *target,
                const xmlChar *data);
/**
 * commentSAXFunc:
 * @param ctx the user data (XML parser context)
 * @param value the comment content
 *
 * A comment has been parsed.
 */
typedef void (*commentSAXFunc) (void *ctx,
                const xmlChar *value);
/**
 * cdataBlockSAXFunc:
 * @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.
 */
typedef void (*cdataBlockSAXFunc) (
                            void *ctx,
                const xmlChar *value,
                int len);
/**
 * warningSAXFunc:
 * @param ctx an XML parser context
 * @param msg the message to display/transmit
 * @param # extra parameters for the message display
 *
 * Display and format a warning messages, callback.
 */
typedef void (*warningSAXFunc) (void *ctx,
                const char *msg, ...);
/**
 * errorSAXFunc:
 * @param ctx an XML parser context
 * @param msg the message to display/transmit
 * @param # extra parameters for the message display
 *
 * Display and format an error messages, callback.
 */
typedef void (*errorSAXFunc) (void *ctx,
                const char *msg, ...);
/**
 * fatalErrorSAXFunc:
 * @param ctx an XML parser context
 * @param msg the message to display/transmit
 * @param # extra parameters for the message display
 *
 * Display and format fatal error messages, callback.
 * Note: so far fatalError() SAX callbacks are not used, error()
 *       get all the callbacks for errors.
 */
typedef void (*fatalErrorSAXFunc) (void *ctx,
                const char *msg, ...);
/**
 * isStandaloneSAXFunc:
 * @param ctx the user data (XML parser context)
 *
 * Is this document tagged standalone?
 *
 * Returns 1 if true
 */
typedef int (*isStandaloneSAXFunc) (void *ctx);
/**
 * hasInternalSubsetSAXFunc:
 * @param ctx the user data (XML parser context)
 *
 * Does this document has an internal subset.
 *
 * Returns 1 if true
 */
typedef int (*hasInternalSubsetSAXFunc) (void *ctx);

/**
 * hasExternalSubsetSAXFunc:
 * @param ctx the user data (XML parser context)
 *
 * Does this document has an external subset?
 *
 * Returns 1 if true
 */
typedef int (*hasExternalSubsetSAXFunc) (void *ctx);

/************************************************************************
 *                                                                      *
 *                      The SAX version 2 API extensions                *
 *                                                                      *
 ************************************************************************/
/**
 * XML_SAX2_MAGIC:
 *
 * Special constant found in SAX2 blocks initialized fields
 */
#define XML_SAX2_MAGIC 0xDEEDBEAF

/**
 * startElementNsSAX2Func:
 * @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. The defaulted
 *                  ones are at the end of the array
 * @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.
 */

typedef void (*startElementNsSAX2Func) (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);

/**
 * endElementNsSAX2Func:
 * @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.
 */

typedef void (*endElementNsSAX2Func) (void *ctx,
                    const xmlChar *localname,
                    const xmlChar *prefix,
                    const xmlChar *URI);

// XE: BEGIN new code
/**
 * startPrefixMappingSAX2Func:
 * @param ctx     the user data (XML parser context)
 * @param prefix  the element namespace prefix if available, NULL if default namespace
 * @param URI     the element namespace name if available
 *
 * SAX2 callback when namespace prefix mapping is done.
 */

typedef void (*startPrefixMappingSAX2Func)  (void *ctx,
                    const xmlChar *prefix,
                    const xmlChar *URI);


/**
 * endPrefixMappingSAX2Func:
 * @param   ctx     the user data (XML parser context)
 * @param   prefix  the element namespace prefix if available, NULL otherwise
 *
 * SAX2 callback when namespace prefix mapping is getting out of scope.
 */

typedef void (*endPrefixMappingSAX2Func)  (void *ctx,
                    const xmlChar *prefix);

// XE: END new code

struct _xmlSAXHandler {
    internalSubsetSAXFunc       internalSubset;
    isStandaloneSAXFunc         isStandalone;
    hasInternalSubsetSAXFunc    hasInternalSubset;
    hasExternalSubsetSAXFunc    hasExternalSubset;
    resolveEntitySAXFunc        resolveEntity;
    getEntitySAXFunc            getEntity;
    entityDeclSAXFunc           entityDecl;
    notationDeclSAXFunc         notationDecl;
    attributeDeclSAXFunc        attributeDecl;
    elementDeclSAXFunc          elementDecl;
    unparsedEntityDeclSAXFunc   unparsedEntityDecl;
    setDocumentLocatorSAXFunc   setDocumentLocator;
    startDocumentSAXFunc        startDocument;
    endDocumentSAXFunc          endDocument;
    startElementSAXFunc         startElement;
    endElementSAXFunc           endElement;
    referenceSAXFunc            reference;
    charactersSAXFunc           characters;
    ignorableWhitespaceSAXFunc  ignorableWhitespace;
    processingInstructionSAXFunc processingInstruction;
    commentSAXFunc              comment;
    warningSAXFunc              warning;
    errorSAXFunc                error;
    fatalErrorSAXFunc           fatalError; /* unused - error() get all the errors */
    getParameterEntitySAXFunc   getParameterEntity;
    cdataBlockSAXFunc           cdataBlock;
    externalSubsetSAXFunc       externalSubset;
    unsigned int initialized;
    /* The following fields are extensions available only on version 2 */
    void *_private;
    startElementNsSAX2Func      startElementNs;
    endElementNsSAX2Func        endElementNs;
    xmlStructuredErrorFunc      serror;
    startPrefixMappingSAX2Func  startPrefixMapping;
    endPrefixMappingSAX2Func    endPrefixMapping;
};

/*
 * SAX Version 1
 */
typedef struct _xmlSAXHandlerV1 xmlSAXHandlerV1;
typedef xmlSAXHandlerV1 *xmlSAXHandlerV1Ptr;
struct _xmlSAXHandlerV1 {
    internalSubsetSAXFunc internalSubset;
    isStandaloneSAXFunc isStandalone;
    hasInternalSubsetSAXFunc hasInternalSubset;
    hasExternalSubsetSAXFunc hasExternalSubset;
    resolveEntitySAXFunc resolveEntity;
    getEntitySAXFunc getEntity;
    entityDeclSAXFunc entityDecl;
    notationDeclSAXFunc notationDecl;
    attributeDeclSAXFunc attributeDecl;
    elementDeclSAXFunc elementDecl;
    unparsedEntityDeclSAXFunc unparsedEntityDecl;
    setDocumentLocatorSAXFunc setDocumentLocator;
    startDocumentSAXFunc startDocument;
    endDocumentSAXFunc endDocument;
    startElementSAXFunc startElement;
    endElementSAXFunc endElement;
    referenceSAXFunc reference;
    charactersSAXFunc characters;
    ignorableWhitespaceSAXFunc ignorableWhitespace;
    processingInstructionSAXFunc processingInstruction;
    commentSAXFunc comment;
    warningSAXFunc warning;
    errorSAXFunc error;
    fatalErrorSAXFunc fatalError; /* unused error() get all the errors */
    getParameterEntitySAXFunc getParameterEntity;
    cdataBlockSAXFunc cdataBlock;
    externalSubsetSAXFunc externalSubset;
    unsigned int initialized;
};


/**
 * xmlExternalEntityLoader:
 * @param URL The System ID of the resource requested
 * @param ID The Public ID of the resource requested
 * @param context the XML parser context
 *
 * External entity loaders types.
 *
 * Returns the entity input parser.
 */
typedef xmlParserInputPtr (*xmlExternalEntityLoader) (const char *URL,
                     const char *ID,
                     xmlParserCtxtPtr context);

#ifdef __cplusplus
}
#endif

#ifdef __cplusplus
extern "C" {
#endif


/*
 * Init/Cleanup
 */
XMLPUBFUN void XMLCALL
                xmlInitParser           (void);
XMLPUBFUN void XMLCALL
                xmlCleanupParser        (void);

/*
 * Input functions
 */
XMLPUBFUN int XMLCALL
                xmlParserInputRead      (xmlParserInputPtr in,
                                         int len);
XMLPUBFUN int XMLCALL
                xmlParserInputGrow      (xmlParserInputPtr in,
                                         int len);

/*
 * Basic parsing Interfaces
 */
XMLPUBFUN xmlDocPtr XMLCALL
                xmlParseDoc             (xmlChar *cur);
XMLPUBFUN xmlDocPtr XMLCALL
                xmlParseMemory          (const char *buffer,
                                         int size);
XMLPUBFUN xmlDocPtr XMLCALL
                xmlParseFile            (const char *filename);
XMLPUBFUN int XMLCALL
                xmlSubstituteEntitiesDefault(int val);

#ifndef XMLENGINE_EXCLUDE_UNUSED
XMLPUBFUN int XMLCALL   xmlKeepBlanksDefault    (int val);
XMLPUBFUN int XMLCALL   xmlLineNumbersDefault   (int val);
#endif /* ifndef XMLENGINE_EXCLUDE_UNUSED */

XMLPUBFUN void XMLCALL
                xmlStopParser           (xmlParserCtxtPtr ctxt);
XMLPUBFUN int XMLCALL
                xmlPedanticParserDefault(int val);

/*
 * Recovery mode
 */
XMLPUBFUN xmlDocPtr XMLCALL
                xmlRecoverDoc           (xmlChar *cur);
XMLPUBFUN xmlDocPtr XMLCALL
                xmlRecoverMemory        (const char *buffer, int size);
XMLPUBFUN xmlDocPtr XMLCALL
                xmlRecoverFile          (const char *filename);

/*
 * Less common routines and SAX interfaces
 */
XMLPUBFUN int XMLCALL
                xmlParseDocument        (xmlParserCtxtPtr ctxt);
XMLPUBFUN int XMLCALL
                xmlParseExtParsedEnt(xmlParserCtxtPtr ctxt);
XMLPUBFUN xmlDocPtr XMLCALL
                xmlSAXParseDoc          (xmlSAXHandlerPtr sax,
                                         xmlChar *cur,
                                         int length,
                                         int recovery,
                                         int* /* out if !NULL */ errorCode);
XMLPUBFUN int XMLCALL
                xmlSAXUserParseFile     (xmlSAXHandlerPtr sax,
                                         void *user_data,
                                         const char *filename);
XMLPUBFUN int XMLCALL
                xmlSAXUserParseMemory   (xmlSAXHandlerPtr sax,
                                         void *user_data,
                                         const char *buffer,
                                         int size);
XMLPUBFUN xmlDocPtr XMLCALL
                xmlSAXParseMemory       (xmlSAXHandlerPtr sax,
                                         const char *buffer,
                     int size,
                                         int recovery);
XMLPUBFUN xmlDocPtr XMLCALL
                xmlSAXParseMemoryWithData (xmlSAXHandlerPtr sax,
                                         const char *buffer,
                     int size,
                                         int recovery,
                                         void *data);
XMLPUBFUN xmlDocPtr XMLCALL
                xmlSAXParseFile         (xmlSAXHandlerPtr sax,
                                         const char *filename,
                                         int recovery);
XMLPUBFUN xmlDocPtr XMLCALL
                xmlSAXParseFileWithData (xmlSAXHandlerPtr sax,
                                         const char *filename,
                                         int recovery,
                                         void *data);
XMLPUBFUN xmlDocPtr XMLCALL
                xmlSAXParseEntity       (xmlSAXHandlerPtr sax,
                                         const char *filename);
XMLPUBFUN xmlDocPtr XMLCALL
                xmlParseEntity          (const char *filename);
XMLPUBFUN xmlDtdPtr XMLCALL
                xmlParseDTD             (const xmlChar *ExternalID,
                                         const xmlChar *SystemID);
XMLPUBFUN xmlDtdPtr XMLCALL
                xmlSAXParseDTD          (xmlSAXHandlerPtr sax,
                                         const xmlChar *ExternalID,
                                         const xmlChar *SystemID);
XMLPUBFUN xmlDtdPtr XMLCALL
                xmlIOParseDTD           (xmlSAXHandlerPtr sax,
                                         xmlParserInputBufferPtr input,
                                         xmlCharEncoding enc);
XMLPUBFUN int XMLCALL
                xmlParseBalancedChunkMemory(xmlDocPtr doc,
                                         xmlSAXHandlerPtr sax,
                                         void *user_data,
                                         int depth,
                                         const xmlChar *string,
                                         xmlNodePtr *lst);
// XMLENGINE: added from v2.6.21
XMLPUBFUN xmlParserErrors XMLCALL
        xmlParseInNodeContext   (xmlNodePtr node,
                     const char *data,
                     int datalen,
                     int options,
                     xmlNodePtr *lst);
//--
XMLPUBFUN int XMLCALL
                xmlParseBalancedChunkMemoryRecover(xmlDocPtr doc,
                     xmlSAXHandlerPtr sax,
                     void *user_data,
                     int depth,
                     const xmlChar *string,
                     xmlNodePtr *lst,
                     int recover);
XMLPUBFUN int XMLCALL
                xmlParseExternalEntity  (xmlDocPtr doc,
                                         xmlSAXHandlerPtr sax,
                                         void *user_data,
                                         int depth,
                                         const xmlChar *URL,
                                         const xmlChar *ID,
                                         xmlNodePtr *lst);
XMLPUBFUN int XMLCALL
                xmlParseCtxtExternalEntity(xmlParserCtxtPtr ctx,
                                         const xmlChar *URL,
                                         const xmlChar *ID,
                                         xmlNodePtr *lst);

/*
 * Parser contexts handling.
 */
XMLPUBFUN xmlParserCtxtPtr XMLCALL
                xmlNewParserCtxt        (void);
XMLPUBFUN int XMLCALL
                xmlInitParserCtxt       (xmlParserCtxtPtr ctxt);
XMLPUBFUN void XMLCALL
                xmlClearParserCtxt      (xmlParserCtxtPtr ctxt);
XMLPUBFUN void XMLCALL
                xmlFreeParserCtxt       (xmlParserCtxtPtr ctxt);
XMLPUBFUN void XMLCALL
                xmlSetupParserForBuffer (xmlParserCtxtPtr ctxt,
                                         const xmlChar* buffer,
                                         const char *filename);
XMLPUBFUN xmlParserCtxtPtr XMLCALL
                xmlCreateDocParserCtxt  (const xmlChar *cur, int length);

/*
 * Reading/setting optional parsing features.
 */

XMLPUBFUN int XMLCALL
                xmlGetFeaturesList      (int *len,
                                                         const char **result);
XMLPUBFUN int XMLCALL
                xmlGetFeature           (xmlParserCtxtPtr ctxt,
                                                         const char *name,
                                                         void *result);
XMLPUBFUN int XMLCALL
                xmlSetFeature           (xmlParserCtxtPtr ctxt,
                                                         const char *name,
                                                         void *value);

#ifdef LIBXML_PUSH_ENABLED
/*
 * Interfaces for the Push mode.
 */
XMLPUBFUN xmlParserCtxtPtr XMLCALL
                xmlCreatePushParserCtxt(xmlSAXHandlerPtr sax,
                                         void *user_data,
                                         const char *chunk,
                                         int size,
                                         const char *filename);
XMLPUBFUN int XMLCALL
                xmlParseChunk           (xmlParserCtxtPtr ctxt,
                                         const char *chunk,
                                         int size,
                                         int terminate);
#endif /* LIBXML_PUSH_ENABLED */

/*
 * Special I/O mode.
 */
#ifndef XMLENGINE_EXCLUDE_UNUSED
XMLPUBFUN xmlParserCtxtPtr XMLCALL
                xmlCreateIOParserCtxt   (xmlSAXHandlerPtr sax,
                                         void *user_data,
                                         xmlInputReadCallback   ioread,
                                         xmlInputCloseCallback  ioclose,
                                         void *ioctx,
                                         xmlCharEncoding enc);
#endif /* ifndef XMLENGINE_EXCLUDE_UNUSED */


XMLPUBFUN xmlParserInputPtr XMLCALL
                xmlNewIOInputStream     (xmlParserCtxtPtr ctxt,
                                         xmlParserInputBufferPtr input,
                                         xmlCharEncoding enc);

#ifdef XMLENGINE_ENABLE_PARSER_RECORD_INFO
/*
 * Node infos.
 */
XMLPUBFUN const xmlParserNodeInfo* XMLCALL
                xmlParserFindNodeInfo   (const xmlParserCtxtPtr ctxt,
                                         const xmlNodePtr node);
XMLPUBFUN void XMLCALL
                xmlInitNodeInfoSeq      (xmlParserNodeInfoSeqPtr seq);
XMLPUBFUN void XMLCALL
                xmlClearNodeInfoSeq     (xmlParserNodeInfoSeqPtr seq);
XMLPUBFUN unsigned long XMLCALL
                xmlParserFindNodeInfoIndex(const xmlParserNodeInfoSeqPtr seq,
                                         const xmlNodePtr node);
XMLPUBFUN void XMLCALL
                xmlParserAddNodeInfo    (xmlParserCtxtPtr ctxt,
                                         const xmlParserNodeInfoPtr info);
#endif /* XMLENGINE_ENABLE_PARSER_RECORD_INFO */

/*
 * External entities handling actually implemented in xmlIO.
 */

#ifndef XMLENGINE_EXCLUDE_UNUSED
XMLPUBFUN void XMLCALL  xmlSetExternalEntityLoader(xmlExternalEntityLoader f);
XMLPUBFUN xmlExternalEntityLoader XMLCALL xmlGetExternalEntityLoader(void);
#endif /* ifndef XMLENGINE_EXCLUDE_UNUSED */

XMLPUBFUN xmlParserInputPtr XMLCALL
                xmlLoadExternalEntity   (const char *URL,
                                                                 const char *ID,
                                                                 xmlParserCtxtPtr ctxt);

/*
 * Index lookup, actually implemented in the encoding module
 */

#ifndef XMLENGINE_EXCLUDE_UNUSED
XMLPUBFUN long XMLCALL  xmlByteConsumed         (xmlParserCtxtPtr ctxt);
#endif /* ifndef XMLENGINE_EXCLUDE_UNUSED */

/*
 * New set of simpler/more flexible APIs
 */
/**
 * xmlParserOption:
 *
 * This is the set of XML parser options that can be passed down
 * to the xmlReadDoc() and similar calls.
 */
typedef enum {
    XML_PARSE_RECOVER   = 1<<0, /* recover on errors */
    XML_PARSE_NOENT     = 1<<1, /* substitute entities */
    XML_PARSE_DTDLOAD   = 1<<2, /* load the external subset */
    XML_PARSE_DTDATTR   = 1<<3, /* default DTD attributes */
    XML_PARSE_DTDVALID  = 1<<4, /* validate with the DTD */
    XML_PARSE_NOERROR   = 1<<5, /* suppress error reports */
    XML_PARSE_NOWARNING = 1<<6, /* suppress warning reports */
    XML_PARSE_PEDANTIC  = 1<<7, /* pedantic error reporting */
    XML_PARSE_NOBLANKS  = 1<<8, /* remove blank nodes */
    XML_PARSE_SAX1      = 1<<9, /* use the SAX1 interface internally */
    XML_PARSE_XINCLUDE  = 1<<10,/* Implement XInclude substitition  */
    XML_PARSE_NONET     = 1<<11,/* Forbid network access */
    XML_PARSE_NODICT    = 1<<12,/* Do not reuse the context dictionnary */
    XML_PARSE_NSCLEAN   = 1<<13,/* remove redundant namespaces declarations */
    XML_PARSE_NOCDATA   = 1<<14 /* merge CDATA as text nodes */
} xmlParserOption;

XMLPUBFUN void XMLCALL
                xmlCtxtReset            (xmlParserCtxtPtr ctxt);

#ifndef XMLENGINE_EXCLUDE_UNUSED
XMLPUBFUN int XMLCALL
                xmlCtxtResetPush        (xmlParserCtxtPtr ctxt,
                                         const char *chunk,
                                         int size,
                                         const char *filename,
                                         const char *encoding);
#endif /* ifndef XMLENGINE_EXCLUDE_UNUSED */

XMLPUBFUN int XMLCALL
                xmlCtxtUseOptions       (xmlParserCtxtPtr ctxt,
                                         int options);
XMLPUBFUN xmlDocPtr XMLCALL
                xmlReadDoc              (const xmlChar *cur,
                                         const char *URL,
                                         const char *encoding,
                                         int options);

#ifndef XMLENGINE_EXCLUDE_UNUSED
XMLPUBFUN xmlDocPtr XMLCALL
                xmlReadFile             (const char *URL,
                                         const char *encoding,
                                         int options);
#endif

XMLPUBFUN xmlDocPtr XMLCALL
                xmlReadMemory           (const char *buffer,
                                         int size,
                                         const char *URL,
                                         const char *encoding,
                                         int options);
XMLPUBFUN xmlDocPtr XMLCALL
                xmlReadFd               (int fd,
                                         const char *URL,
                                         const char *encoding,
                                         int options);
XMLPUBFUN xmlDocPtr XMLCALL
                xmlReadIO               (xmlInputReadCallback ioread,
                                         xmlInputCloseCallback ioclose,
                                         void *ioctx,
                                         const char *URL,
                                         const char *encoding,
                                         int options);

#ifndef XMLENGINE_EXCLUDE_UNUSED

XMLPUBFUN xmlDocPtr XMLCALL
                xmlCtxtReadDoc          (xmlParserCtxtPtr ctxt,
                                         const xmlChar *cur,
                                         const char *URL,
                                         const char *encoding,
                                         int options);
XMLPUBFUN xmlDocPtr XMLCALL
                xmlCtxtReadFd           (xmlParserCtxtPtr ctxt,
                                         int fd,
                                         const char *URL,
                                         const char *encoding,
                                         int options);
XMLPUBFUN xmlDocPtr XMLCALL
                xmlCtxtReadFile         (xmlParserCtxtPtr ctxt,
                                         const char *filename,
                                         const char *encoding,
                                         int options);
XMLPUBFUN xmlDocPtr XMLCALL
                xmlCtxtReadMemory               (xmlParserCtxtPtr ctxt,
                                         const char *buffer,
                                         int size,
                                         const char *URL,
                                         const char *encoding,
                                         int options);
XMLPUBFUN xmlDocPtr XMLCALL
                xmlCtxtReadIO           (xmlParserCtxtPtr ctxt,
                                         xmlInputReadCallback ioread,
                                         xmlInputCloseCallback ioclose,
                                         void *ioctx,
                                         const char *URL,
                                         const char *encoding,
                                         int options);
#endif /* ifndef XMLENGINE_EXCLUDE_UNUSED */

#ifdef __cplusplus
}
#endif
#endif /* XML_PARSER_H */


