gcc/testsuite/g++.dg/pr65240.h

// -*- C++ -*-

#include <stdio.h>
#include <stddef.h>
#include <stdint.h>
#include <ctype.h>
#include <unistd.h>
#include <string.h>
#include <stdlib.h>
#include <math.h>
#include <sys/types.h>
#include <time.h>
#include <signal.h>
#include <pthread.h>

void xmlCheckVersion (int version);
typedef unsigned char xmlChar;
xmlChar *xmlStrdup (const xmlChar * cur);
xmlChar *xmlStrndup (const xmlChar * cur, int len);
xmlChar *xmlCharStrndup (const char *cur, int len);
xmlChar *xmlCharStrdup (const char *cur);
xmlChar *xmlStrsub (const xmlChar * str, int start, int len);
const xmlChar *xmlStrchr (const xmlChar * str, xmlChar val);
const xmlChar *xmlStrstr (const xmlChar * str, const xmlChar * val);
const xmlChar *xmlStrcasestr (const xmlChar * str, const xmlChar * val);
int xmlStrcmp (const xmlChar * str1, const xmlChar * str2);
int xmlStrncmp (const xmlChar * str1, const xmlChar * str2, int len);
int xmlStrcasecmp (const xmlChar * str1, const xmlChar * str2);
int xmlStrncasecmp (const xmlChar * str1, const xmlChar * str2, int len);
int xmlStrEqual (const xmlChar * str1, const xmlChar * str2);
int xmlStrQEqual (const xmlChar * pref,
		  const xmlChar * name, const xmlChar * str);
int xmlStrlen (const xmlChar * str);
xmlChar *xmlStrcat (xmlChar * cur, const xmlChar * add);
xmlChar *xmlStrncat (xmlChar * cur, const xmlChar * add, int len);
xmlChar *xmlStrncatNew (const xmlChar * str1, const xmlChar * str2, int len);
int xmlStrPrintf (xmlChar * buf, int len, const xmlChar * msg, ...);
int xmlStrVPrintf (xmlChar * buf, int len, const xmlChar * msg, va_list ap);
int xmlGetUTF8Char (const unsigned char *utf, int *len);
int xmlCheckUTF8 (const unsigned char *utf);
int xmlUTF8Strsize (const xmlChar * utf, int len);
xmlChar *xmlUTF8Strndup (const xmlChar * utf, int len);
const xmlChar *xmlUTF8Strpos (const xmlChar * utf, int pos);
int xmlUTF8Strloc (const xmlChar * utf, const xmlChar * utfchar);
xmlChar *xmlUTF8Strsub (const xmlChar * utf, int start, int len);
int xmlUTF8Strlen (const xmlChar * utf);
int xmlUTF8Size (const xmlChar * utf);
int xmlUTF8Charcmp (const xmlChar * utf1, const xmlChar * utf2);

typedef struct _xmlParserInputBuffer xmlParserInputBuffer;
typedef xmlParserInputBuffer *xmlParserInputBufferPtr;
typedef struct _xmlOutputBuffer xmlOutputBuffer;
typedef xmlOutputBuffer *xmlOutputBufferPtr;
typedef struct _xmlParserInput xmlParserInput;
typedef xmlParserInput *xmlParserInputPtr;
typedef struct _xmlParserCtxt xmlParserCtxt;
typedef xmlParserCtxt *xmlParserCtxtPtr;
typedef struct _xmlSAXLocator xmlSAXLocator;
typedef xmlSAXLocator *xmlSAXLocatorPtr;
typedef struct _xmlSAXHandler xmlSAXHandler;
typedef xmlSAXHandler *xmlSAXHandlerPtr;
typedef struct _xmlEntity xmlEntity;
typedef xmlEntity *xmlEntityPtr;

typedef enum
{
  XML_BUFFER_ALLOC_DOUBLEIT,
  XML_BUFFER_ALLOC_EXACT,
  XML_BUFFER_ALLOC_IMMUTABLE,
  XML_BUFFER_ALLOC_IO,
  XML_BUFFER_ALLOC_HYBRID
} xmlBufferAllocationScheme;

typedef struct _xmlBuffer xmlBuffer;
typedef xmlBuffer *xmlBufferPtr;

struct _xmlBuffer
{
  xmlChar *content;
  unsigned int use;
  unsigned int size;
  xmlBufferAllocationScheme alloc;
  xmlChar *contentIO;
};

typedef struct _xmlBuf xmlBuf;
typedef xmlBuf *xmlBufPtr;

xmlChar *xmlBufContent (const xmlBuf * buf);
xmlChar *xmlBufEnd (xmlBufPtr buf);
size_t xmlBufUse (const xmlBufPtr buf);
size_t xmlBufShrink (xmlBufPtr buf, size_t len);

typedef enum
{
  XML_ELEMENT_NODE = 1,
  XML_ATTRIBUTE_NODE = 2,
  XML_TEXT_NODE = 3,
  XML_CDATA_SECTION_NODE = 4,
  XML_ENTITY_REF_NODE = 5,
  XML_ENTITY_NODE = 6,
  XML_PI_NODE = 7,
  XML_COMMENT_NODE = 8,
  XML_DOCUMENT_NODE = 9,
  XML_DOCUMENT_TYPE_NODE = 10,
  XML_DOCUMENT_FRAG_NODE = 11,
  XML_NOTATION_NODE = 12,
  XML_HTML_DOCUMENT_NODE = 13,
  XML_DTD_NODE = 14,
  XML_ELEMENT_DECL = 15,
  XML_ATTRIBUTE_DECL = 16,
  XML_ENTITY_DECL = 17,
  XML_NAMESPACE_DECL = 18,
  XML_XINCLUDE_START = 19,
  XML_XINCLUDE_END = 20, XML_DOCB_DOCUMENT_NODE = 21
} xmlElementType;

typedef struct _xmlNotation xmlNotation;
typedef xmlNotation *xmlNotationPtr;

struct _xmlNotation
{
  const xmlChar *name;
  const xmlChar *PublicID;
  const xmlChar *SystemID;
};

typedef enum
{
  XML_ATTRIBUTE_CDATA = 1,
  XML_ATTRIBUTE_ID,
  XML_ATTRIBUTE_IDREF,
  XML_ATTRIBUTE_IDREFS,
  XML_ATTRIBUTE_ENTITY,
  XML_ATTRIBUTE_ENTITIES,
  XML_ATTRIBUTE_NMTOKEN,
  XML_ATTRIBUTE_NMTOKENS,
  XML_ATTRIBUTE_ENUMERATION,
  XML_ATTRIBUTE_NOTATION
} xmlAttributeType;

typedef enum
{
  XML_ATTRIBUTE_NONE = 1,
  XML_ATTRIBUTE_REQUIRED,
  XML_ATTRIBUTE_IMPLIED,
  XML_ATTRIBUTE_FIXED
} xmlAttributeDefault;

typedef struct _xmlEnumeration xmlEnumeration;
typedef xmlEnumeration *xmlEnumerationPtr;

struct _xmlEnumeration
{
  struct _xmlEnumeration *next;
  const xmlChar *name;
};

typedef struct _xmlAttribute xmlAttribute;
typedef xmlAttribute *xmlAttributePtr;
struct _xmlAttribute
{
  void *_private;
  xmlElementType type;
  const xmlChar *name;
  struct _xmlNode *children;
  struct _xmlNode *last;
  struct _xmlDtd *parent;
  struct _xmlNode *next;
  struct _xmlNode *prev;
  struct _xmlDoc *doc;

  struct _xmlAttribute *nexth;
  xmlAttributeType atype;
  xmlAttributeDefault def;
  const xmlChar *defaultValue;
  xmlEnumerationPtr tree;
  const xmlChar *prefix;
  const xmlChar *elem;
};

typedef enum
{
  XML_ELEMENT_CONTENT_PCDATA = 1,
  XML_ELEMENT_CONTENT_ELEMENT,
  XML_ELEMENT_CONTENT_SEQ,
  XML_ELEMENT_CONTENT_OR
} xmlElementContentType;

typedef enum
{
  XML_ELEMENT_CONTENT_ONCE = 1,
  XML_ELEMENT_CONTENT_OPT,
  XML_ELEMENT_CONTENT_MULT,
  XML_ELEMENT_CONTENT_PLUS
} xmlElementContentOccur;

typedef struct _xmlElementContent xmlElementContent;
typedef xmlElementContent *xmlElementContentPtr;

struct _xmlElementContent
{
  xmlElementContentType type;
  xmlElementContentOccur ocur;
  const xmlChar *name;
  struct _xmlElementContent *c1;
  struct _xmlElementContent *c2;
  struct _xmlElementContent *parent;
  const xmlChar *prefix;
};

typedef enum
{
  XML_ELEMENT_TYPE_UNDEFINED = 0,
  XML_ELEMENT_TYPE_EMPTY = 1,
  XML_ELEMENT_TYPE_ANY,
  XML_ELEMENT_TYPE_MIXED,
  XML_ELEMENT_TYPE_ELEMENT
} xmlElementTypeVal;

typedef struct _xmlRegexp xmlRegexp;
typedef xmlRegexp *xmlRegexpPtr;
typedef struct _xmlRegExecCtxt xmlRegExecCtxt;
typedef xmlRegExecCtxt *xmlRegExecCtxtPtr;
typedef struct _xmlDict xmlDict;
typedef xmlDict *xmlDictPtr;

int xmlInitializeDict (void);
xmlDictPtr xmlDictCreate (void);
size_t xmlDictSetLimit (xmlDictPtr dict, size_t limit);
size_t xmlDictGetUsage (xmlDictPtr dict);
xmlDictPtr xmlDictCreateSub (xmlDictPtr sub);
int xmlDictReference (xmlDictPtr dict);
void xmlDictFree (xmlDictPtr dict);
const xmlChar *xmlDictLookup (xmlDictPtr dict, const xmlChar * name, int len);
const xmlChar *xmlDictExists (xmlDictPtr dict, const xmlChar * name, int len);
const xmlChar *xmlDictQLookup (xmlDictPtr dict,
			       const xmlChar * prefix, const xmlChar * name);
int xmlDictOwns (xmlDictPtr dict, const xmlChar * str);
int xmlDictSize (xmlDictPtr dict);
void xmlDictCleanup (void);
xmlRegexpPtr xmlRegexpCompile (const xmlChar * regexp);
void xmlRegFreeRegexp (xmlRegexpPtr regexp);
int xmlRegexpExec (xmlRegexpPtr comp, const xmlChar * value);
void xmlRegexpPrint (FILE * output, xmlRegexpPtr regexp);
int xmlRegexpIsDeterminist (xmlRegexpPtr comp);
typedef void (*xmlRegExecCallbacks) (xmlRegExecCtxtPtr exec,
				     const xmlChar * token,
				     void *transdata, void *inputdata);
xmlRegExecCtxtPtr
xmlRegNewExecCtxt (xmlRegexpPtr comp,
		   xmlRegExecCallbacks callback, void *data);
void xmlRegFreeExecCtxt (xmlRegExecCtxtPtr exec);
int xmlRegExecPushString (xmlRegExecCtxtPtr exec,
			  const xmlChar * value, void *data);
int xmlRegExecPushString2 (xmlRegExecCtxtPtr exec,
			   const xmlChar * value,
			   const xmlChar * value2, void *data);

int xmlRegExecNextValues (xmlRegExecCtxtPtr exec,
			  int *nbval,
			  int *nbneg, xmlChar ** values, int *terminal);
int xmlRegExecErrInfo (xmlRegExecCtxtPtr exec,
		       const xmlChar ** string,
		       int *nbval, int *nbneg, xmlChar ** values, int *terminal);

typedef struct _xmlExpCtxt xmlExpCtxt;
typedef xmlExpCtxt *xmlExpCtxtPtr;
void xmlExpFreeCtxt (xmlExpCtxtPtr ctxt);
xmlExpCtxtPtr xmlExpNewCtxt (int maxNodes, xmlDictPtr dict);
int xmlExpCtxtNbNodes (xmlExpCtxtPtr ctxt);
int xmlExpCtxtNbCons (xmlExpCtxtPtr ctxt);
typedef struct _xmlExpNode xmlExpNode;
typedef xmlExpNode *xmlExpNodePtr;

typedef enum
{
  XML_EXP_EMPTY = 0,
  XML_EXP_FORBID = 1,
  XML_EXP_ATOM = 2,
  XML_EXP_SEQ = 3,
  XML_EXP_OR = 4,
  XML_EXP_COUNT = 5
} xmlExpNodeType;

extern xmlExpNodePtr forbiddenExp;
extern xmlExpNodePtr emptyExp;

void xmlExpFree (xmlExpCtxtPtr ctxt, xmlExpNodePtr expr);
void xmlExpRef (xmlExpNodePtr expr);

xmlExpNodePtr xmlExpParse (xmlExpCtxtPtr ctxt, const char *expr);
xmlExpNodePtr xmlExpNewAtom (xmlExpCtxtPtr ctxt, const xmlChar * name, int len);
xmlExpNodePtr xmlExpNewOr (xmlExpCtxtPtr ctxt, xmlExpNodePtr left, xmlExpNodePtr right);
xmlExpNodePtr xmlExpNewSeq (xmlExpCtxtPtr ctxt, xmlExpNodePtr left, xmlExpNodePtr right);
xmlExpNodePtr xmlExpNewRange (xmlExpCtxtPtr ctxt, xmlExpNodePtr subset, int min, int max);

int xmlExpIsNillable (xmlExpNodePtr expr);
int xmlExpMaxToken (xmlExpNodePtr expr);
int xmlExpGetLanguage (xmlExpCtxtPtr ctxt,
		       xmlExpNodePtr expr, const xmlChar ** langList, int len);
int xmlExpGetStart (xmlExpCtxtPtr ctxt,
		    xmlExpNodePtr expr, const xmlChar ** tokList, int len);
xmlExpNodePtr xmlExpStringDerive (xmlExpCtxtPtr ctxt,
				  xmlExpNodePtr expr, const xmlChar * str, int len);
xmlExpNodePtr xmlExpExpDerive (xmlExpCtxtPtr ctxt, xmlExpNodePtr expr, xmlExpNodePtr sub);
int xmlExpSubsume (xmlExpCtxtPtr ctxt, xmlExpNodePtr expr, xmlExpNodePtr sub);
void xmlExpDump (xmlBufferPtr buf, xmlExpNodePtr expr);
typedef struct _xmlElement xmlElement;
typedef xmlElement *xmlElementPtr;

struct _xmlElement
{
  void *_private;
  xmlElementType type;
  const xmlChar *name;
  struct _xmlNode *children;
  struct _xmlNode *last;
  struct _xmlDtd *parent;
  struct _xmlNode *next;
  struct _xmlNode *prev;
  struct _xmlDoc *doc;
  xmlElementTypeVal etype;
  xmlElementContentPtr content;
  xmlAttributePtr attributes;
  const xmlChar *prefix;
  xmlRegexpPtr contModel;
};

typedef xmlElementType xmlNsType;
typedef struct _xmlNs xmlNs;
typedef xmlNs *xmlNsPtr;

struct _xmlNs
{
  struct _xmlNs *next;
  xmlNsType type;
  const xmlChar *href;
  const xmlChar *prefix;
  void *_private;
  struct _xmlDoc *context;
};

typedef struct _xmlDtd xmlDtd;
typedef xmlDtd *xmlDtdPtr;
struct _xmlDtd
{
  void *_private;
  xmlElementType type;
  const xmlChar *name;
  struct _xmlNode *children;
  struct _xmlNode *last;
  struct _xmlDoc *parent;
  struct _xmlNode *next;
  struct _xmlNode *prev;
  struct _xmlDoc *doc;
  void *notations;
  void *elements;
  void *attributes;
  void *entities;
  const xmlChar *ExternalID;
  const xmlChar *SystemID;
  void *pentities;
};

typedef struct _xmlAttr xmlAttr;
typedef xmlAttr *xmlAttrPtr;
struct _xmlAttr
{
  void *_private;
  xmlElementType type;
  const xmlChar *name;
  struct _xmlNode *children;
  struct _xmlNode *last;
  struct _xmlNode *parent;
  struct _xmlAttr *next;
  struct _xmlAttr *prev;
  struct _xmlDoc *doc;
  xmlNs *ns;
  xmlAttributeType atype;
  void *psvi;
};

typedef struct _xmlID xmlID;
typedef xmlID *xmlIDPtr;
struct _xmlID
{
  struct _xmlID *next;
  const xmlChar *value;
  xmlAttrPtr attr;
  const xmlChar *name;
  int lineno;
  struct _xmlDoc *doc;
};

typedef struct _xmlRef xmlRef;
typedef xmlRef *xmlRefPtr;
struct _xmlRef
{
  struct _xmlRef *next;
  const xmlChar *value;
  xmlAttrPtr attr;
  const xmlChar *name;
  int lineno;
};

typedef struct _xmlNode xmlNode;
typedef xmlNode *xmlNodePtr;
struct _xmlNode
{
  void *_private;
  xmlElementType type;
  const xmlChar *name;
  struct _xmlNode *children;
  struct _xmlNode *last;
  struct _xmlNode *parent;
  struct _xmlNode *next;
  struct _xmlNode *prev;
  struct _xmlDoc *doc;
  xmlNs *ns;
  xmlChar *content;
  struct _xmlAttr *properties;
  xmlNs *nsDef;
  void *psvi;
  unsigned short line;
  unsigned short extra;
};

typedef enum
{
  XML_DOC_WELLFORMED = 1 << 0,
  XML_DOC_NSVALID = 1 << 1,
  XML_DOC_OLD10 = 1 << 2,
  XML_DOC_DTDVALID = 1 << 3,
  XML_DOC_XINCLUDE = 1 << 4,
  XML_DOC_USERBUILT = 1 << 5,
  XML_DOC_INTERNAL = 1 << 6,
  XML_DOC_HTML = 1 << 7
} xmlDocProperties;

typedef struct _xmlDoc xmlDoc;
typedef xmlDoc *xmlDocPtr;

struct _xmlDoc
{
  void *_private;
  xmlElementType type;
  char *name;
  struct _xmlNode *children;
  struct _xmlNode *last;
  struct _xmlNode *parent;
  struct _xmlNode *next;
  struct _xmlNode *prev;
  struct _xmlDoc *doc;
  int compression;
  int standalone;
  struct _xmlDtd *intSubset;
  struct _xmlDtd *extSubset;
  struct _xmlNs *oldNs;
  const xmlChar *version;
  const xmlChar *encoding;
  void *ids;
  void *refs;
  const xmlChar *URL;
  int charset;
  struct _xmlDict *dict;
  void *psvi;
  int parseFlags;
  int properties;
};

typedef struct _xmlDOMWrapCtxt xmlDOMWrapCtxt;
typedef xmlDOMWrapCtxt *xmlDOMWrapCtxtPtr;
typedef xmlNsPtr (*xmlDOMWrapAcquireNsFunction) (xmlDOMWrapCtxtPtr ctxt,
						 xmlNodePtr node,
						 const xmlChar * nsName,
						 const xmlChar * nsPrefix);

struct _xmlDOMWrapCtxt
{
  void *_private;
  int type;
  void *namespaceMap;
  xmlDOMWrapAcquireNsFunction getNsForNodeFunc;
};

int xmlValidateNCName (const xmlChar * value, int space);
int xmlValidateQName (const xmlChar * value, int space);
int xmlValidateName (const xmlChar * value, int space);
int xmlValidateNMToken (const xmlChar * value, int space);
xmlChar *xmlBuildQName (const xmlChar * ncname,
			const xmlChar * prefix, xmlChar * memory, int len);
xmlChar *xmlSplitQName2 (const xmlChar * name, xmlChar ** prefix);
const xmlChar *xmlSplitQName3 (const xmlChar * name, int *len);
void xmlSetBufferAllocationScheme (xmlBufferAllocationScheme scheme);
xmlBufferAllocationScheme xmlGetBufferAllocationScheme (void);
xmlBufferPtr xmlBufferCreate (void);
xmlBufferPtr xmlBufferCreateSize (size_t size);
xmlBufferPtr xmlBufferCreateStatic (void *mem, size_t size);
int xmlBufferResize (xmlBufferPtr buf, unsigned int size);
void xmlBufferFree (xmlBufferPtr buf);
int xmlBufferDump (FILE * file, xmlBufferPtr buf);
int xmlBufferAdd (xmlBufferPtr buf, const xmlChar * str, int len);
int xmlBufferAddHead (xmlBufferPtr buf, const xmlChar * str, int len);
int xmlBufferCat (xmlBufferPtr buf, const xmlChar * str);
int xmlBufferCCat (xmlBufferPtr buf, const char *str);
int xmlBufferShrink (xmlBufferPtr buf, unsigned int len);
int xmlBufferGrow (xmlBufferPtr buf, unsigned int len);
void xmlBufferEmpty (xmlBufferPtr buf);
const xmlChar *xmlBufferContent (const xmlBuffer * buf);
xmlChar *xmlBufferDetach (xmlBufferPtr buf);
void xmlBufferSetAllocationScheme (xmlBufferPtr buf,
				   xmlBufferAllocationScheme scheme);
int xmlBufferLength (const xmlBuffer * buf);

xmlDtdPtr xmlCreateIntSubset (xmlDocPtr doc,
			      const xmlChar * name,
			      const xmlChar * ExternalID, const xmlChar * SystemID);
xmlDtdPtr xmlNewDtd (xmlDocPtr doc,
		     const xmlChar * name,
		     const xmlChar * ExternalID, const xmlChar * SystemID);
xmlDtdPtr xmlGetIntSubset (const xmlDoc * doc);
void xmlFreeDtd (xmlDtdPtr cur);

xmlNsPtr xmlNewGlobalNs (xmlDocPtr doc, const xmlChar * href, const xmlChar * prefix);

xmlNsPtr xmlNewNs (xmlNodePtr node, const xmlChar * href, const xmlChar * prefix);
void xmlFreeNs (xmlNsPtr cur);
void xmlFreeNsList (xmlNsPtr cur);
xmlDocPtr xmlNewDoc (const xmlChar * version);
void xmlFreeDoc (xmlDocPtr cur);
xmlAttrPtr xmlNewDocProp (xmlDocPtr doc, const xmlChar * name, const xmlChar * value);


xmlAttrPtr xmlNewProp (xmlNodePtr node, const xmlChar * name, const xmlChar * value);

xmlAttrPtr xmlNewNsProp (xmlNodePtr node,
			 xmlNsPtr ns, const xmlChar * name, const xmlChar * value);
xmlAttrPtr xmlNewNsPropEatName (xmlNodePtr node,
				xmlNsPtr ns, xmlChar * name, const xmlChar * value);
void xmlFreePropList (xmlAttrPtr cur);
void xmlFreeProp (xmlAttrPtr cur);
xmlAttrPtr xmlCopyProp (xmlNodePtr target, xmlAttrPtr cur);
xmlAttrPtr xmlCopyPropList (xmlNodePtr target, xmlAttrPtr cur);
xmlDtdPtr xmlCopyDtd (xmlDtdPtr dtd);
xmlDocPtr xmlCopyDoc (xmlDocPtr doc, int recursive);
xmlNodePtr xmlNewDocNode (xmlDocPtr doc,
			  xmlNsPtr ns, const xmlChar * name, const xmlChar * content);
xmlNodePtr xmlNewDocNodeEatName (xmlDocPtr doc,
				 xmlNsPtr ns, xmlChar * name, const xmlChar * content);
xmlNodePtr xmlNewNode (xmlNsPtr ns, const xmlChar * name);
xmlNodePtr xmlNewNodeEatName (xmlNsPtr ns, xmlChar * name);

xmlNodePtr xmlNewChild (xmlNodePtr parent,
			xmlNsPtr ns, const xmlChar * name, const xmlChar * content);
xmlNodePtr xmlNewDocText (const xmlDoc * doc, const xmlChar * content);
xmlNodePtr xmlNewText (const xmlChar * content);
xmlNodePtr xmlNewDocPI (xmlDocPtr doc, const xmlChar * name, const xmlChar * content);
xmlNodePtr xmlNewPI (const xmlChar * name, const xmlChar * content);
xmlNodePtr xmlNewDocTextLen (xmlDocPtr doc, const xmlChar * content, int len);
xmlNodePtr xmlNewTextLen (const xmlChar * content, int len);
xmlNodePtr xmlNewDocComment (xmlDocPtr doc, const xmlChar * content);
xmlNodePtr xmlNewComment (const xmlChar * content);
xmlNodePtr xmlNewCDataBlock (xmlDocPtr doc, const xmlChar * content, int len);
xmlNodePtr xmlNewCharRef (xmlDocPtr doc, const xmlChar * name);
xmlNodePtr xmlNewReference (const xmlDoc * doc, const xmlChar * name);
xmlNodePtr xmlCopyNode (xmlNodePtr node, int recursive);
xmlNodePtr xmlDocCopyNode (xmlNodePtr node, xmlDocPtr doc, int recursive);
xmlNodePtr xmlDocCopyNodeList (xmlDocPtr doc, xmlNodePtr node);
xmlNodePtr xmlCopyNodeList (xmlNodePtr node);

xmlNodePtr xmlNewTextChild (xmlNodePtr parent,
			    xmlNsPtr ns, const xmlChar * name, const xmlChar * content);
xmlNodePtr xmlNewDocRawNode (xmlDocPtr doc,
			     xmlNsPtr ns, const xmlChar * name, const xmlChar * content);
xmlNodePtr xmlNewDocFragment (xmlDocPtr doc);
long xmlGetLineNo (const xmlNode * node);
xmlChar *xmlGetNodePath (const xmlNode * node);
xmlNodePtr xmlDocGetRootElement (const xmlDoc * doc);
xmlNodePtr xmlGetLastChild (const xmlNode * parent);
int xmlNodeIsText (const xmlNode * node);
int xmlIsBlankNode (const xmlNode * node);
xmlNodePtr xmlDocSetRootElement (xmlDocPtr doc, xmlNodePtr root);
void xmlNodeSetName (xmlNodePtr cur, const xmlChar * name);
xmlNodePtr xmlAddChild (xmlNodePtr parent, xmlNodePtr cur);
xmlNodePtr xmlAddChildList (xmlNodePtr parent, xmlNodePtr cur);
xmlNodePtr xmlReplaceNode (xmlNodePtr old, xmlNodePtr cur);
xmlNodePtr xmlAddPrevSibling (xmlNodePtr cur, xmlNodePtr elem);
xmlNodePtr xmlAddSibling (xmlNodePtr cur, xmlNodePtr elem);
xmlNodePtr xmlAddNextSibling (xmlNodePtr cur, xmlNodePtr elem);
void xmlUnlinkNode (xmlNodePtr cur);
xmlNodePtr xmlTextMerge (xmlNodePtr first, xmlNodePtr second);
int xmlTextConcat (xmlNodePtr node, const xmlChar * content, int len);
void xmlFreeNodeList (xmlNodePtr cur);
void xmlFreeNode (xmlNodePtr cur);
void xmlSetTreeDoc (xmlNodePtr tree, xmlDocPtr doc);
void xmlSetListDoc (xmlNodePtr list, xmlDocPtr doc);

xmlNsPtr xmlSearchNs (xmlDocPtr doc, xmlNodePtr node, const xmlChar * nameSpace);
xmlNsPtr xmlSearchNsByHref (xmlDocPtr doc, xmlNodePtr node, const xmlChar * href);
xmlNsPtr *xmlGetNsList (const xmlDoc * doc, const xmlNode * node);
void xmlSetNs (xmlNodePtr node, xmlNsPtr ns);
xmlNsPtr xmlCopyNamespace (xmlNsPtr cur);
xmlNsPtr xmlCopyNamespaceList (xmlNsPtr cur);
xmlAttrPtr xmlSetProp (xmlNodePtr node, const xmlChar * name, const xmlChar * value);
xmlAttrPtr xmlSetNsProp (xmlNodePtr node,
			 xmlNsPtr ns, const xmlChar * name, const xmlChar * value);

xmlChar *xmlGetNoNsProp (const xmlNode * node, const xmlChar * name);
xmlChar *xmlGetProp (const xmlNode * node, const xmlChar * name);
xmlAttrPtr xmlHasProp (const xmlNode * node, const xmlChar * name);
xmlAttrPtr xmlHasNsProp (const xmlNode * node,
			 const xmlChar * name, const xmlChar * nameSpace);
xmlChar *xmlGetNsProp (const xmlNode * node,
		       const xmlChar * name, const xmlChar * nameSpace);
xmlNodePtr xmlStringGetNodeList (const xmlDoc * doc, const xmlChar * value);
xmlNodePtr xmlStringLenGetNodeList (const xmlDoc * doc, const xmlChar * value, int len);
xmlChar *xmlNodeListGetString (xmlDocPtr doc,
			       const xmlNode * list, int inLine);

xmlChar *xmlNodeListGetRawString (const xmlDoc * doc,
				  const xmlNode * list, int inLine);

void xmlNodeSetContent (xmlNodePtr cur, const xmlChar * content);
void xmlNodeSetContentLen (xmlNodePtr cur, const xmlChar * content, int len);
void xmlNodeAddContent (xmlNodePtr cur, const xmlChar * content);
void xmlNodeAddContentLen (xmlNodePtr cur, const xmlChar * content, int len);
xmlChar *xmlNodeGetContent (const xmlNode * cur);
int xmlNodeBufGetContent (xmlBufferPtr buffer, const xmlNode * cur);
int xmlBufGetNodeContent (xmlBufPtr buf, const xmlNode * cur);
xmlChar *xmlNodeGetLang (const xmlNode * cur);
int xmlNodeGetSpacePreserve (const xmlNode * cur);
void xmlNodeSetLang (xmlNodePtr cur, const xmlChar * lang);
void xmlNodeSetSpacePreserve (xmlNodePtr cur, int val);
xmlChar *xmlNodeGetBase (const xmlDoc * doc, const xmlNode * cur);
void xmlNodeSetBase (xmlNodePtr cur, const xmlChar * uri);
int xmlRemoveProp (xmlAttrPtr cur);
int xmlUnsetNsProp (xmlNodePtr node, xmlNsPtr ns, const xmlChar * name);
int xmlUnsetProp (xmlNodePtr node, const xmlChar * name);
void xmlBufferWriteCHAR (xmlBufferPtr buf, const xmlChar * string);
void xmlBufferWriteChar (xmlBufferPtr buf, const char *string);
void xmlBufferWriteQuotedString (xmlBufferPtr buf, const xmlChar * string);
void xmlAttrSerializeTxtContent (xmlBufferPtr buf,
				 xmlDocPtr doc,
				 xmlAttrPtr attr, const xmlChar * string);
int xmlReconciliateNs (xmlDocPtr doc, xmlNodePtr tree);
void xmlDocDumpFormatMemory (xmlDocPtr cur, xmlChar ** mem, int *size, int format);
void xmlDocDumpMemory (xmlDocPtr cur, xmlChar ** mem, int *size);
void xmlDocDumpMemoryEnc (xmlDocPtr out_doc,
			  xmlChar ** doc_txt_ptr,
			  int *doc_txt_len, const char *txt_encoding);
void xmlDocDumpFormatMemoryEnc (xmlDocPtr out_doc,
				xmlChar ** doc_txt_ptr,
				int *doc_txt_len,
				const char *txt_encoding, int format);
int xmlDocFormatDump (FILE * f, xmlDocPtr cur, int format);
int xmlDocDump (FILE * f, xmlDocPtr cur);
void xmlElemDump (FILE * f, xmlDocPtr doc, xmlNodePtr cur);
int xmlSaveFile (const char *filename, xmlDocPtr cur);
int xmlSaveFormatFile (const char *filename, xmlDocPtr cur, int format);
size_t xmlBufNodeDump (xmlBufPtr buf,
		       xmlDocPtr doc, xmlNodePtr cur, int level, int format);
int xmlNodeDump (xmlBufferPtr buf,
		 xmlDocPtr doc, xmlNodePtr cur, int level, int format);

int xmlSaveFileTo (xmlOutputBufferPtr buf, xmlDocPtr cur, const char *encoding);
int xmlSaveFormatFileTo (xmlOutputBufferPtr buf,
			 xmlDocPtr cur, const char *encoding, int format);
void xmlNodeDumpOutput (xmlOutputBufferPtr buf,
			xmlDocPtr doc,
			xmlNodePtr cur,
			int level, int format, const char *encoding);

int xmlSaveFormatFileEnc (const char *filename,
			  xmlDocPtr cur, const char *encoding, int format);

int xmlSaveFileEnc (const char *filename, xmlDocPtr cur, const char *encoding);
int xmlIsXHTML (const xmlChar * systemID, const xmlChar * publicID);
int xmlGetDocCompressMode (const xmlDoc * doc);
void xmlSetDocCompressMode (xmlDocPtr doc, int mode);
int xmlGetCompressMode (void);
void xmlSetCompressMode (int mode);
xmlDOMWrapCtxtPtr xmlDOMWrapNewCtxt (void);
void xmlDOMWrapFreeCtxt (xmlDOMWrapCtxtPtr ctxt);
int xmlDOMWrapReconcileNamespaces (xmlDOMWrapCtxtPtr ctxt,
				   xmlNodePtr elem, int options);
int xmlDOMWrapAdoptNode (xmlDOMWrapCtxtPtr ctxt,
			 xmlDocPtr sourceDoc,
			 xmlNodePtr node,
			 xmlDocPtr destDoc, xmlNodePtr destParent, int options);
int xmlDOMWrapRemoveNode (xmlDOMWrapCtxtPtr ctxt,
			  xmlDocPtr doc, xmlNodePtr node, int options);
int xmlDOMWrapCloneNode (xmlDOMWrapCtxtPtr ctxt,
			 xmlDocPtr sourceDoc,
			 xmlNodePtr node,
			 xmlNodePtr * clonedNode,
			 xmlDocPtr destDoc,
			 xmlNodePtr destParent, int deep, int options);

unsigned long xmlChildElementCount (xmlNodePtr parent);
xmlNodePtr xmlNextElementSibling (xmlNodePtr node);
xmlNodePtr xmlFirstElementChild (xmlNodePtr parent);
xmlNodePtr xmlLastElementChild (xmlNodePtr parent);
xmlNodePtr xmlPreviousElementSibling (xmlNodePtr node);
typedef struct _xmlHashTable xmlHashTable;
typedef xmlHashTable *xmlHashTablePtr;
typedef void (*xmlHashDeallocator) (void *payload, xmlChar * name);
typedef void *(*xmlHashCopier) (void *payload, xmlChar * name);
typedef void (*xmlHashScanner) (void *payload, void *data, xmlChar * name);
typedef void (*xmlHashScannerFull) (void *payload, void *data,
				    const xmlChar * name,
				    const xmlChar * name2,
				    const xmlChar * name3);




xmlHashTablePtr xmlHashCreate (int size);
xmlHashTablePtr xmlHashCreateDict (int size, xmlDictPtr dict);
void xmlHashFree (xmlHashTablePtr table, xmlHashDeallocator f);

int xmlHashAddEntry (xmlHashTablePtr table, const xmlChar * name, void *userdata);
int xmlHashUpdateEntry (xmlHashTablePtr table,
			const xmlChar * name,
			void *userdata, xmlHashDeallocator f);
int xmlHashAddEntry2 (xmlHashTablePtr table,
		      const xmlChar * name,
		      const xmlChar * name2, void *userdata);
int xmlHashUpdateEntry2 (xmlHashTablePtr table,
			 const xmlChar * name,
			 const xmlChar * name2,
			 void *userdata, xmlHashDeallocator f);
int xmlHashAddEntry3 (xmlHashTablePtr table,
		      const xmlChar * name,
		      const xmlChar * name2,
		      const xmlChar * name3, void *userdata);
int xmlHashUpdateEntry3 (xmlHashTablePtr table,
			 const xmlChar * name,
			 const xmlChar * name2,
			 const xmlChar * name3,
			 void *userdata, xmlHashDeallocator f);

int xmlHashRemoveEntry (xmlHashTablePtr table, const xmlChar * name,
			xmlHashDeallocator f);
int xmlHashRemoveEntry2 (xmlHashTablePtr table, const xmlChar * name,
			 const xmlChar * name2, xmlHashDeallocator f);
int xmlHashRemoveEntry3 (xmlHashTablePtr table, const xmlChar * name,
			 const xmlChar * name2, const xmlChar * name3,
			 xmlHashDeallocator f);

void *xmlHashLookup (xmlHashTablePtr table, const xmlChar * name);
void *xmlHashLookup2 (xmlHashTablePtr table,
		      const xmlChar * name, const xmlChar * name2);
void *xmlHashLookup3 (xmlHashTablePtr table,
		      const xmlChar * name,
		      const xmlChar * name2, const xmlChar * name3);
void *xmlHashQLookup (xmlHashTablePtr table,
		      const xmlChar * name, const xmlChar * prefix);
void *xmlHashQLookup2 (xmlHashTablePtr table,
		       const xmlChar * name,
		       const xmlChar * prefix,
		       const xmlChar * name2, const xmlChar * prefix2);
void *xmlHashQLookup3 (xmlHashTablePtr table,
		       const xmlChar * name,
		       const xmlChar * prefix,
		       const xmlChar * name2,
		       const xmlChar * prefix2,
		       const xmlChar * name3, const xmlChar * prefix3);

xmlHashTablePtr xmlHashCopy (xmlHashTablePtr table, xmlHashCopier f);
int xmlHashSize (xmlHashTablePtr table);
void xmlHashScan (xmlHashTablePtr table, xmlHashScanner f, void *data);
void xmlHashScan3 (xmlHashTablePtr table,
		   const xmlChar * name,
		   const xmlChar * name2,
		   const xmlChar * name3, xmlHashScanner f, void *data);
void xmlHashScanFull (xmlHashTablePtr table, xmlHashScannerFull f, void *data);
void xmlHashScanFull3 (xmlHashTablePtr table,
		       const xmlChar * name,
		       const xmlChar * name2,
		       const xmlChar * name3, xmlHashScannerFull f, void *data);
typedef enum
{
  XML_ERR_NONE = 0,
  XML_ERR_WARNING = 1,
  XML_ERR_ERROR = 2,
  XML_ERR_FATAL = 3
} xmlErrorLevel;

typedef enum
{
  XML_FROM_NONE = 0,
  XML_FROM_PARSER,
  XML_FROM_TREE,
  XML_FROM_NAMESPACE,
  XML_FROM_DTD,
  XML_FROM_HTML,
  XML_FROM_MEMORY,
  XML_FROM_OUTPUT,
  XML_FROM_IO,
  XML_FROM_FTP,
  XML_FROM_HTTP,
  XML_FROM_XINCLUDE,
  XML_FROM_XPATH,
  XML_FROM_XPOINTER,
  XML_FROM_REGEXP,
  XML_FROM_DATATYPE,
  XML_FROM_SCHEMASP,
  XML_FROM_SCHEMASV,
  XML_FROM_RELAXNGP,
  XML_FROM_RELAXNGV,
  XML_FROM_CATALOG,
  XML_FROM_C14N,
  XML_FROM_XSLT,
  XML_FROM_VALID,
  XML_FROM_CHECK,
  XML_FROM_WRITER,
  XML_FROM_MODULE,
  XML_FROM_I18N,
  XML_FROM_SCHEMATRONV,
  XML_FROM_BUFFER,
  XML_FROM_URI
} xmlErrorDomain;

typedef struct _xmlError xmlError;
typedef xmlError *xmlErrorPtr;
struct _xmlError
{
  int domain;
  int code;
  char *message;
  xmlErrorLevel level;
  char *file;
  int line;
  char *str1;
  char *str2;
  char *str3;
  int int1;
  int int2;
  void *ctxt;
  void *node;
};

typedef enum
{
  XML_ERR_OK = 0,
  XML_ERR_INTERNAL_ERROR,
  XML_ERR_NO_MEMORY,
  XML_ERR_DOCUMENT_START,
  XML_ERR_DOCUMENT_EMPTY,
  XML_ERR_DOCUMENT_END,
  XML_ERR_INVALID_HEX_CHARREF,
  XML_ERR_INVALID_DEC_CHARREF,
  XML_ERR_INVALID_CHARREF,
  XML_ERR_INVALID_CHAR,
  XML_ERR_CHARREF_AT_EOF,
  XML_ERR_CHARREF_IN_PROLOG,
  XML_ERR_CHARREF_IN_EPILOG,
  XML_ERR_CHARREF_IN_DTD,
  XML_ERR_ENTITYREF_AT_EOF,
  XML_ERR_ENTITYREF_IN_PROLOG,
  XML_ERR_ENTITYREF_IN_EPILOG,
  XML_ERR_ENTITYREF_IN_DTD,
  XML_ERR_PEREF_AT_EOF,
  XML_ERR_PEREF_IN_PROLOG,
  XML_ERR_PEREF_IN_EPILOG,
  XML_ERR_PEREF_IN_INT_SUBSET,
  XML_ERR_ENTITYREF_NO_NAME,
  XML_ERR_ENTITYREF_SEMICOL_MISSING,
  XML_ERR_PEREF_NO_NAME,
  XML_ERR_PEREF_SEMICOL_MISSING,
  XML_ERR_UNDECLARED_ENTITY,
  XML_WAR_UNDECLARED_ENTITY,
  XML_ERR_UNPARSED_ENTITY,
  XML_ERR_ENTITY_IS_EXTERNAL,
  XML_ERR_ENTITY_IS_PARAMETER,
  XML_ERR_UNKNOWN_ENCODING,
  XML_ERR_UNSUPPORTED_ENCODING,
  XML_ERR_STRING_NOT_STARTED,
  XML_ERR_STRING_NOT_CLOSED,
  XML_ERR_NS_DECL_ERROR,
  XML_ERR_ENTITY_NOT_STARTED,
  XML_ERR_ENTITY_NOT_FINISHED,
  XML_ERR_LT_IN_ATTRIBUTE,
  XML_ERR_ATTRIBUTE_NOT_STARTED,
  XML_ERR_ATTRIBUTE_NOT_FINISHED,
  XML_ERR_ATTRIBUTE_WITHOUT_VALUE,
  XML_ERR_ATTRIBUTE_REDEFINED,
  XML_ERR_LITERAL_NOT_STARTED,
  XML_ERR_LITERAL_NOT_FINISHED,
  XML_ERR_COMMENT_NOT_FINISHED,
  XML_ERR_PI_NOT_STARTED,
  XML_ERR_PI_NOT_FINISHED,
  XML_ERR_NOTATION_NOT_STARTED,
  XML_ERR_NOTATION_NOT_FINISHED,
  XML_ERR_ATTLIST_NOT_STARTED,
  XML_ERR_ATTLIST_NOT_FINISHED,
  XML_ERR_MIXED_NOT_STARTED,
  XML_ERR_MIXED_NOT_FINISHED,
  XML_ERR_ELEMCONTENT_NOT_STARTED,
  XML_ERR_ELEMCONTENT_NOT_FINISHED,
  XML_ERR_XMLDECL_NOT_STARTED,
  XML_ERR_XMLDECL_NOT_FINISHED,
  XML_ERR_CONDSEC_NOT_STARTED,
  XML_ERR_CONDSEC_NOT_FINISHED,
  XML_ERR_EXT_SUBSET_NOT_FINISHED,
  XML_ERR_DOCTYPE_NOT_FINISHED,
  XML_ERR_MISPLACED_CDATA_END,
  XML_ERR_CDATA_NOT_FINISHED,
  XML_ERR_RESERVED_XML_NAME,
  XML_ERR_SPACE_REQUIRED,
  XML_ERR_SEPARATOR_REQUIRED,
  XML_ERR_NMTOKEN_REQUIRED,
  XML_ERR_NAME_REQUIRED,
  XML_ERR_PCDATA_REQUIRED,
  XML_ERR_URI_REQUIRED,
  XML_ERR_PUBID_REQUIRED,
  XML_ERR_LT_REQUIRED,
  XML_ERR_GT_REQUIRED,
  XML_ERR_LTSLASH_REQUIRED,
  XML_ERR_EQUAL_REQUIRED,
  XML_ERR_TAG_NAME_MISMATCH,
  XML_ERR_TAG_NOT_FINISHED,
  XML_ERR_STANDALONE_VALUE,
  XML_ERR_ENCODING_NAME,
  XML_ERR_HYPHEN_IN_COMMENT,
  XML_ERR_INVALID_ENCODING,
  XML_ERR_EXT_ENTITY_STANDALONE,
  XML_ERR_CONDSEC_INVALID,
  XML_ERR_VALUE_REQUIRED,
  XML_ERR_NOT_WELL_BALANCED,
  XML_ERR_EXTRA_CONTENT,
  XML_ERR_ENTITY_CHAR_ERROR,
  XML_ERR_ENTITY_PE_INTERNAL,
  XML_ERR_ENTITY_LOOP,
  XML_ERR_ENTITY_BOUNDARY,
  XML_ERR_INVALID_URI,
  XML_ERR_URI_FRAGMENT,
  XML_WAR_CATALOG_PI,
  XML_ERR_NO_DTD,
  XML_ERR_CONDSEC_INVALID_KEYWORD,
  XML_ERR_VERSION_MISSING,
  XML_WAR_UNKNOWN_VERSION,
  XML_WAR_LANG_VALUE,
  XML_WAR_NS_URI,
  XML_WAR_NS_URI_RELATIVE,
  XML_ERR_MISSING_ENCODING,
  XML_WAR_SPACE_VALUE,
  XML_ERR_NOT_STANDALONE,
  XML_ERR_ENTITY_PROCESSING,
  XML_ERR_NOTATION_PROCESSING,
  XML_WAR_NS_COLUMN,
  XML_WAR_ENTITY_REDEFINED,
  XML_ERR_UNKNOWN_VERSION,
  XML_ERR_VERSION_MISMATCH,
  XML_ERR_NAME_TOO_LONG,
  XML_ERR_USER_STOP,
  XML_NS_ERR_XML_NAMESPACE = 200,
  XML_NS_ERR_UNDEFINED_NAMESPACE,
  XML_NS_ERR_QNAME,
  XML_NS_ERR_ATTRIBUTE_REDEFINED,
  XML_NS_ERR_EMPTY,
  XML_NS_ERR_COLON,
  XML_DTD_ATTRIBUTE_DEFAULT = 500,
  XML_DTD_ATTRIBUTE_REDEFINED,
  XML_DTD_ATTRIBUTE_VALUE,
  XML_DTD_CONTENT_ERROR,
  XML_DTD_CONTENT_MODEL,
  XML_DTD_CONTENT_NOT_DETERMINIST,
  XML_DTD_DIFFERENT_PREFIX,
  XML_DTD_ELEM_DEFAULT_NAMESPACE,
  XML_DTD_ELEM_NAMESPACE,
  XML_DTD_ELEM_REDEFINED,
  XML_DTD_EMPTY_NOTATION,
  XML_DTD_ENTITY_TYPE,
  XML_DTD_ID_FIXED,
  XML_DTD_ID_REDEFINED,
  XML_DTD_ID_SUBSET,
  XML_DTD_INVALID_CHILD,
  XML_DTD_INVALID_DEFAULT,
  XML_DTD_LOAD_ERROR,
  XML_DTD_MISSING_ATTRIBUTE,
  XML_DTD_MIXED_CORRUPT,
  XML_DTD_MULTIPLE_ID,
  XML_DTD_NO_DOC,
  XML_DTD_NO_DTD,
  XML_DTD_NO_ELEM_NAME,
  XML_DTD_NO_PREFIX,
  XML_DTD_NO_ROOT,
  XML_DTD_NOTATION_REDEFINED,
  XML_DTD_NOTATION_VALUE,
  XML_DTD_NOT_EMPTY,
  XML_DTD_NOT_PCDATA,
  XML_DTD_NOT_STANDALONE,
  XML_DTD_ROOT_NAME,
  XML_DTD_STANDALONE_WHITE_SPACE,
  XML_DTD_UNKNOWN_ATTRIBUTE,
  XML_DTD_UNKNOWN_ELEM,
  XML_DTD_UNKNOWN_ENTITY,
  XML_DTD_UNKNOWN_ID,
  XML_DTD_UNKNOWN_NOTATION,
  XML_DTD_STANDALONE_DEFAULTED,
  XML_DTD_XMLID_VALUE,
  XML_DTD_XMLID_TYPE,
  XML_DTD_DUP_TOKEN,
  XML_HTML_STRUCURE_ERROR = 800,
  XML_HTML_UNKNOWN_TAG,
  XML_RNGP_ANYNAME_ATTR_ANCESTOR = 1000,
  XML_RNGP_ATTR_CONFLICT,
  XML_RNGP_ATTRIBUTE_CHILDREN,
  XML_RNGP_ATTRIBUTE_CONTENT,
  XML_RNGP_ATTRIBUTE_EMPTY,
  XML_RNGP_ATTRIBUTE_NOOP,
  XML_RNGP_CHOICE_CONTENT,
  XML_RNGP_CHOICE_EMPTY,
  XML_RNGP_CREATE_FAILURE,
  XML_RNGP_DATA_CONTENT,
  XML_RNGP_DEF_CHOICE_AND_INTERLEAVE,
  XML_RNGP_DEFINE_CREATE_FAILED,
  XML_RNGP_DEFINE_EMPTY,
  XML_RNGP_DEFINE_MISSING,
  XML_RNGP_DEFINE_NAME_MISSING,
  XML_RNGP_ELEM_CONTENT_EMPTY,
  XML_RNGP_ELEM_CONTENT_ERROR,
  XML_RNGP_ELEMENT_EMPTY,
  XML_RNGP_ELEMENT_CONTENT,
  XML_RNGP_ELEMENT_NAME,
  XML_RNGP_ELEMENT_NO_CONTENT,
  XML_RNGP_ELEM_TEXT_CONFLICT,
  XML_RNGP_EMPTY,
  XML_RNGP_EMPTY_CONSTRUCT,
  XML_RNGP_EMPTY_CONTENT,
  XML_RNGP_EMPTY_NOT_EMPTY,
  XML_RNGP_ERROR_TYPE_LIB,
  XML_RNGP_EXCEPT_EMPTY,
  XML_RNGP_EXCEPT_MISSING,
  XML_RNGP_EXCEPT_MULTIPLE,
  XML_RNGP_EXCEPT_NO_CONTENT,
  XML_RNGP_EXTERNALREF_EMTPY,
  XML_RNGP_EXTERNAL_REF_FAILURE,
  XML_RNGP_EXTERNALREF_RECURSE,
  XML_RNGP_FORBIDDEN_ATTRIBUTE,
  XML_RNGP_FOREIGN_ELEMENT,
  XML_RNGP_GRAMMAR_CONTENT,
  XML_RNGP_GRAMMAR_EMPTY,
  XML_RNGP_GRAMMAR_MISSING,
  XML_RNGP_GRAMMAR_NO_START,
  XML_RNGP_GROUP_ATTR_CONFLICT,
  XML_RNGP_HREF_ERROR,
  XML_RNGP_INCLUDE_EMPTY,
  XML_RNGP_INCLUDE_FAILURE,
  XML_RNGP_INCLUDE_RECURSE,
  XML_RNGP_INTERLEAVE_ADD,
  XML_RNGP_INTERLEAVE_CREATE_FAILED,
  XML_RNGP_INTERLEAVE_EMPTY,
  XML_RNGP_INTERLEAVE_NO_CONTENT,
  XML_RNGP_INVALID_DEFINE_NAME,
  XML_RNGP_INVALID_URI,
  XML_RNGP_INVALID_VALUE,
  XML_RNGP_MISSING_HREF,
  XML_RNGP_NAME_MISSING,
  XML_RNGP_NEED_COMBINE,
  XML_RNGP_NOTALLOWED_NOT_EMPTY,
  XML_RNGP_NSNAME_ATTR_ANCESTOR,
  XML_RNGP_NSNAME_NO_NS,
  XML_RNGP_PARAM_FORBIDDEN,
  XML_RNGP_PARAM_NAME_MISSING,
  XML_RNGP_PARENTREF_CREATE_FAILED,
  XML_RNGP_PARENTREF_NAME_INVALID,
  XML_RNGP_PARENTREF_NO_NAME,
  XML_RNGP_PARENTREF_NO_PARENT,
  XML_RNGP_PARENTREF_NOT_EMPTY,
  XML_RNGP_PARSE_ERROR,
  XML_RNGP_PAT_ANYNAME_EXCEPT_ANYNAME,
  XML_RNGP_PAT_ATTR_ATTR,
  XML_RNGP_PAT_ATTR_ELEM,
  XML_RNGP_PAT_DATA_EXCEPT_ATTR,
  XML_RNGP_PAT_DATA_EXCEPT_ELEM,
  XML_RNGP_PAT_DATA_EXCEPT_EMPTY,
  XML_RNGP_PAT_DATA_EXCEPT_GROUP,
  XML_RNGP_PAT_DATA_EXCEPT_INTERLEAVE,
  XML_RNGP_PAT_DATA_EXCEPT_LIST,
  XML_RNGP_PAT_DATA_EXCEPT_ONEMORE,
  XML_RNGP_PAT_DATA_EXCEPT_REF,
  XML_RNGP_PAT_DATA_EXCEPT_TEXT,
  XML_RNGP_PAT_LIST_ATTR,
  XML_RNGP_PAT_LIST_ELEM,
  XML_RNGP_PAT_LIST_INTERLEAVE,
  XML_RNGP_PAT_LIST_LIST,
  XML_RNGP_PAT_LIST_REF,
  XML_RNGP_PAT_LIST_TEXT,
  XML_RNGP_PAT_NSNAME_EXCEPT_ANYNAME,
  XML_RNGP_PAT_NSNAME_EXCEPT_NSNAME,
  XML_RNGP_PAT_ONEMORE_GROUP_ATTR,
  XML_RNGP_PAT_ONEMORE_INTERLEAVE_ATTR,
  XML_RNGP_PAT_START_ATTR,
  XML_RNGP_PAT_START_DATA,
  XML_RNGP_PAT_START_EMPTY,
  XML_RNGP_PAT_START_GROUP,
  XML_RNGP_PAT_START_INTERLEAVE,
  XML_RNGP_PAT_START_LIST,
  XML_RNGP_PAT_START_ONEMORE,
  XML_RNGP_PAT_START_TEXT,
  XML_RNGP_PAT_START_VALUE,
  XML_RNGP_PREFIX_UNDEFINED,
  XML_RNGP_REF_CREATE_FAILED,
  XML_RNGP_REF_CYCLE,
  XML_RNGP_REF_NAME_INVALID,
  XML_RNGP_REF_NO_DEF,
  XML_RNGP_REF_NO_NAME,
  XML_RNGP_REF_NOT_EMPTY,
  XML_RNGP_START_CHOICE_AND_INTERLEAVE,
  XML_RNGP_START_CONTENT,
  XML_RNGP_START_EMPTY,
  XML_RNGP_START_MISSING,
  XML_RNGP_TEXT_EXPECTED,
  XML_RNGP_TEXT_HAS_CHILD,
  XML_RNGP_TYPE_MISSING,
  XML_RNGP_TYPE_NOT_FOUND,
  XML_RNGP_TYPE_VALUE,
  XML_RNGP_UNKNOWN_ATTRIBUTE,
  XML_RNGP_UNKNOWN_COMBINE,
  XML_RNGP_UNKNOWN_CONSTRUCT,
  XML_RNGP_UNKNOWN_TYPE_LIB,
  XML_RNGP_URI_FRAGMENT,
  XML_RNGP_URI_NOT_ABSOLUTE,
  XML_RNGP_VALUE_EMPTY,
  XML_RNGP_VALUE_NO_CONTENT,
  XML_RNGP_XMLNS_NAME,
  XML_RNGP_XML_NS,
  XML_XPATH_EXPRESSION_OK = 1200,
  XML_XPATH_NUMBER_ERROR,
  XML_XPATH_UNFINISHED_LITERAL_ERROR,
  XML_XPATH_START_LITERAL_ERROR,
  XML_XPATH_VARIABLE_REF_ERROR,
  XML_XPATH_UNDEF_VARIABLE_ERROR,
  XML_XPATH_INVALID_PREDICATE_ERROR,
  XML_XPATH_EXPR_ERROR,
  XML_XPATH_UNCLOSED_ERROR,
  XML_XPATH_UNKNOWN_FUNC_ERROR,
  XML_XPATH_INVALID_OPERAND,
  XML_XPATH_INVALID_TYPE,
  XML_XPATH_INVALID_ARITY,
  XML_XPATH_INVALID_CTXT_SIZE,
  XML_XPATH_INVALID_CTXT_POSITION,
  XML_XPATH_MEMORY_ERROR,
  XML_XPTR_SYNTAX_ERROR,
  XML_XPTR_RESOURCE_ERROR,
  XML_XPTR_SUB_RESOURCE_ERROR,
  XML_XPATH_UNDEF_PREFIX_ERROR,
  XML_XPATH_ENCODING_ERROR,
  XML_XPATH_INVALID_CHAR_ERROR,
  XML_TREE_INVALID_HEX = 1300,
  XML_TREE_INVALID_DEC,
  XML_TREE_UNTERMINATED_ENTITY,
  XML_TREE_NOT_UTF8,
  XML_SAVE_NOT_UTF8 = 1400,
  XML_SAVE_CHAR_INVALID,
  XML_SAVE_NO_DOCTYPE,
  XML_SAVE_UNKNOWN_ENCODING,
  XML_REGEXP_COMPILE_ERROR = 1450,
  XML_IO_UNKNOWN = 1500,
  XML_IO_EACCES,
  XML_IO_EAGAIN,
  XML_IO_EBADF,
  XML_IO_EBADMSG,
  XML_IO_EBUSY,
  XML_IO_ECANCELED,
  XML_IO_ECHILD,
  XML_IO_EDEADLK,
  XML_IO_EDOM,
  XML_IO_EEXIST,
  XML_IO_EFAULT,
  XML_IO_EFBIG,
  XML_IO_EINPROGRESS,
  XML_IO_EINTR,
  XML_IO_EINVAL,
  XML_IO_EIO,
  XML_IO_EISDIR,
  XML_IO_EMFILE,
  XML_IO_EMLINK,
  XML_IO_EMSGSIZE,
  XML_IO_ENAMETOOLONG,
  XML_IO_ENFILE,
  XML_IO_ENODEV,
  XML_IO_ENOENT,
  XML_IO_ENOEXEC,
  XML_IO_ENOLCK,
  XML_IO_ENOMEM,
  XML_IO_ENOSPC,
  XML_IO_ENOSYS,
  XML_IO_ENOTDIR,
  XML_IO_ENOTEMPTY,
  XML_IO_ENOTSUP,
  XML_IO_ENOTTY,
  XML_IO_ENXIO,
  XML_IO_EPERM,
  XML_IO_EPIPE,
  XML_IO_ERANGE,
  XML_IO_EROFS,
  XML_IO_ESPIPE,
  XML_IO_ESRCH,
  XML_IO_ETIMEDOUT,
  XML_IO_EXDEV,
  XML_IO_NETWORK_ATTEMPT,
  XML_IO_ENCODER,
  XML_IO_FLUSH,
  XML_IO_WRITE,
  XML_IO_NO_INPUT,
  XML_IO_BUFFER_FULL,
  XML_IO_LOAD_ERROR,
  XML_IO_ENOTSOCK,
  XML_IO_EISCONN,
  XML_IO_ECONNREFUSED,
  XML_IO_ENETUNREACH,
  XML_IO_EADDRINUSE,
  XML_IO_EALREADY,
  XML_IO_EAFNOSUPPORT,
  XML_XINCLUDE_RECURSION = 1600,
  XML_XINCLUDE_PARSE_VALUE,
  XML_XINCLUDE_ENTITY_DEF_MISMATCH,
  XML_XINCLUDE_NO_HREF,
  XML_XINCLUDE_NO_FALLBACK,
  XML_XINCLUDE_HREF_URI,
  XML_XINCLUDE_TEXT_FRAGMENT,
  XML_XINCLUDE_TEXT_DOCUMENT,
  XML_XINCLUDE_INVALID_CHAR,
  XML_XINCLUDE_BUILD_FAILED,
  XML_XINCLUDE_UNKNOWN_ENCODING,
  XML_XINCLUDE_MULTIPLE_ROOT,
  XML_XINCLUDE_XPTR_FAILED,
  XML_XINCLUDE_XPTR_RESULT,
  XML_XINCLUDE_INCLUDE_IN_INCLUDE,
  XML_XINCLUDE_FALLBACKS_IN_INCLUDE,
  XML_XINCLUDE_FALLBACK_NOT_IN_INCLUDE,
  XML_XINCLUDE_DEPRECATED_NS,
  XML_XINCLUDE_FRAGMENT_ID,
  XML_CATALOG_MISSING_ATTR = 1650,
  XML_CATALOG_ENTRY_BROKEN,
  XML_CATALOG_PREFER_VALUE,
  XML_CATALOG_NOT_CATALOG,
  XML_CATALOG_RECURSION,
  XML_SCHEMAP_PREFIX_UNDEFINED = 1700,
  XML_SCHEMAP_ATTRFORMDEFAULT_VALUE,
  XML_SCHEMAP_ATTRGRP_NONAME_NOREF,
  XML_SCHEMAP_ATTR_NONAME_NOREF,
  XML_SCHEMAP_COMPLEXTYPE_NONAME_NOREF,
  XML_SCHEMAP_ELEMFORMDEFAULT_VALUE,
  XML_SCHEMAP_ELEM_NONAME_NOREF,
  XML_SCHEMAP_EXTENSION_NO_BASE,
  XML_SCHEMAP_FACET_NO_VALUE,
  XML_SCHEMAP_FAILED_BUILD_IMPORT,
  XML_SCHEMAP_GROUP_NONAME_NOREF,
  XML_SCHEMAP_IMPORT_NAMESPACE_NOT_URI,
  XML_SCHEMAP_IMPORT_REDEFINE_NSNAME,
  XML_SCHEMAP_IMPORT_SCHEMA_NOT_URI,
  XML_SCHEMAP_INVALID_BOOLEAN,
  XML_SCHEMAP_INVALID_ENUM,
  XML_SCHEMAP_INVALID_FACET,
  XML_SCHEMAP_INVALID_FACET_VALUE,
  XML_SCHEMAP_INVALID_MAXOCCURS,
  XML_SCHEMAP_INVALID_MINOCCURS,
  XML_SCHEMAP_INVALID_REF_AND_SUBTYPE,
  XML_SCHEMAP_INVALID_WHITE_SPACE,
  XML_SCHEMAP_NOATTR_NOREF,
  XML_SCHEMAP_NOTATION_NO_NAME,
  XML_SCHEMAP_NOTYPE_NOREF,
  XML_SCHEMAP_REF_AND_SUBTYPE,
  XML_SCHEMAP_RESTRICTION_NONAME_NOREF,
  XML_SCHEMAP_SIMPLETYPE_NONAME,
  XML_SCHEMAP_TYPE_AND_SUBTYPE,
  XML_SCHEMAP_UNKNOWN_ALL_CHILD,
  XML_SCHEMAP_UNKNOWN_ANYATTRIBUTE_CHILD,
  XML_SCHEMAP_UNKNOWN_ATTR_CHILD,
  XML_SCHEMAP_UNKNOWN_ATTRGRP_CHILD,
  XML_SCHEMAP_UNKNOWN_ATTRIBUTE_GROUP,
  XML_SCHEMAP_UNKNOWN_BASE_TYPE,
  XML_SCHEMAP_UNKNOWN_CHOICE_CHILD,
  XML_SCHEMAP_UNKNOWN_COMPLEXCONTENT_CHILD,
  XML_SCHEMAP_UNKNOWN_COMPLEXTYPE_CHILD,
  XML_SCHEMAP_UNKNOWN_ELEM_CHILD,
  XML_SCHEMAP_UNKNOWN_EXTENSION_CHILD,
  XML_SCHEMAP_UNKNOWN_FACET_CHILD,
  XML_SCHEMAP_UNKNOWN_FACET_TYPE,
  XML_SCHEMAP_UNKNOWN_GROUP_CHILD,
  XML_SCHEMAP_UNKNOWN_IMPORT_CHILD,
  XML_SCHEMAP_UNKNOWN_LIST_CHILD,
  XML_SCHEMAP_UNKNOWN_NOTATION_CHILD,
  XML_SCHEMAP_UNKNOWN_PROCESSCONTENT_CHILD,
  XML_SCHEMAP_UNKNOWN_REF,
  XML_SCHEMAP_UNKNOWN_RESTRICTION_CHILD,
  XML_SCHEMAP_UNKNOWN_SCHEMAS_CHILD,
  XML_SCHEMAP_UNKNOWN_SEQUENCE_CHILD,
  XML_SCHEMAP_UNKNOWN_SIMPLECONTENT_CHILD,
  XML_SCHEMAP_UNKNOWN_SIMPLETYPE_CHILD,
  XML_SCHEMAP_UNKNOWN_TYPE,
  XML_SCHEMAP_UNKNOWN_UNION_CHILD,
  XML_SCHEMAP_ELEM_DEFAULT_FIXED,
  XML_SCHEMAP_REGEXP_INVALID,
  XML_SCHEMAP_FAILED_LOAD,
  XML_SCHEMAP_NOTHING_TO_PARSE,
  XML_SCHEMAP_NOROOT,
  XML_SCHEMAP_REDEFINED_GROUP,
  XML_SCHEMAP_REDEFINED_TYPE,
  XML_SCHEMAP_REDEFINED_ELEMENT,
  XML_SCHEMAP_REDEFINED_ATTRGROUP,
  XML_SCHEMAP_REDEFINED_ATTR,
  XML_SCHEMAP_REDEFINED_NOTATION,
  XML_SCHEMAP_FAILED_PARSE,
  XML_SCHEMAP_UNKNOWN_PREFIX,
  XML_SCHEMAP_DEF_AND_PREFIX,
  XML_SCHEMAP_UNKNOWN_INCLUDE_CHILD,
  XML_SCHEMAP_INCLUDE_SCHEMA_NOT_URI,
  XML_SCHEMAP_INCLUDE_SCHEMA_NO_URI,
  XML_SCHEMAP_NOT_SCHEMA,
  XML_SCHEMAP_UNKNOWN_MEMBER_TYPE,
  XML_SCHEMAP_INVALID_ATTR_USE,
  XML_SCHEMAP_RECURSIVE,
  XML_SCHEMAP_SUPERNUMEROUS_LIST_ITEM_TYPE,
  XML_SCHEMAP_INVALID_ATTR_COMBINATION,
  XML_SCHEMAP_INVALID_ATTR_INLINE_COMBINATION,
  XML_SCHEMAP_MISSING_SIMPLETYPE_CHILD,
  XML_SCHEMAP_INVALID_ATTR_NAME,
  XML_SCHEMAP_REF_AND_CONTENT,
  XML_SCHEMAP_CT_PROPS_CORRECT_1,
  XML_SCHEMAP_CT_PROPS_CORRECT_2,
  XML_SCHEMAP_CT_PROPS_CORRECT_3,
  XML_SCHEMAP_CT_PROPS_CORRECT_4,
  XML_SCHEMAP_CT_PROPS_CORRECT_5,
  XML_SCHEMAP_DERIVATION_OK_RESTRICTION_1,
  XML_SCHEMAP_DERIVATION_OK_RESTRICTION_2_1_1,
  XML_SCHEMAP_DERIVATION_OK_RESTRICTION_2_1_2,
  XML_SCHEMAP_DERIVATION_OK_RESTRICTION_2_2,
  XML_SCHEMAP_DERIVATION_OK_RESTRICTION_3,
  XML_SCHEMAP_WILDCARD_INVALID_NS_MEMBER,
  XML_SCHEMAP_INTERSECTION_NOT_EXPRESSIBLE,
  XML_SCHEMAP_UNION_NOT_EXPRESSIBLE,
  XML_SCHEMAP_SRC_IMPORT_3_1,
  XML_SCHEMAP_SRC_IMPORT_3_2,
  XML_SCHEMAP_DERIVATION_OK_RESTRICTION_4_1,
  XML_SCHEMAP_DERIVATION_OK_RESTRICTION_4_2,
  XML_SCHEMAP_DERIVATION_OK_RESTRICTION_4_3,
  XML_SCHEMAP_COS_CT_EXTENDS_1_3,
  XML_SCHEMAV_NOROOT = 1801,
  XML_SCHEMAV_UNDECLAREDELEM,
  XML_SCHEMAV_NOTTOPLEVEL,
  XML_SCHEMAV_MISSING,
  XML_SCHEMAV_WRONGELEM,
  XML_SCHEMAV_NOTYPE,
  XML_SCHEMAV_NOROLLBACK,
  XML_SCHEMAV_ISABSTRACT,
  XML_SCHEMAV_NOTEMPTY,
  XML_SCHEMAV_ELEMCONT,
  XML_SCHEMAV_HAVEDEFAULT,
  XML_SCHEMAV_NOTNILLABLE,
  XML_SCHEMAV_EXTRACONTENT,
  XML_SCHEMAV_INVALIDATTR,
  XML_SCHEMAV_INVALIDELEM,
  XML_SCHEMAV_NOTDETERMINIST,
  XML_SCHEMAV_CONSTRUCT,
  XML_SCHEMAV_INTERNAL,
  XML_SCHEMAV_NOTSIMPLE,
  XML_SCHEMAV_ATTRUNKNOWN,
  XML_SCHEMAV_ATTRINVALID,
  XML_SCHEMAV_VALUE,
  XML_SCHEMAV_FACET,
  XML_SCHEMAV_CVC_DATATYPE_VALID_1_2_1,
  XML_SCHEMAV_CVC_DATATYPE_VALID_1_2_2,
  XML_SCHEMAV_CVC_DATATYPE_VALID_1_2_3,
  XML_SCHEMAV_CVC_TYPE_3_1_1,
  XML_SCHEMAV_CVC_TYPE_3_1_2,
  XML_SCHEMAV_CVC_FACET_VALID,
  XML_SCHEMAV_CVC_LENGTH_VALID,
  XML_SCHEMAV_CVC_MINLENGTH_VALID,
  XML_SCHEMAV_CVC_MAXLENGTH_VALID,
  XML_SCHEMAV_CVC_MININCLUSIVE_VALID,
  XML_SCHEMAV_CVC_MAXINCLUSIVE_VALID,
  XML_SCHEMAV_CVC_MINEXCLUSIVE_VALID,
  XML_SCHEMAV_CVC_MAXEXCLUSIVE_VALID,
  XML_SCHEMAV_CVC_TOTALDIGITS_VALID,
  XML_SCHEMAV_CVC_FRACTIONDIGITS_VALID,
  XML_SCHEMAV_CVC_PATTERN_VALID,
  XML_SCHEMAV_CVC_ENUMERATION_VALID,
  XML_SCHEMAV_CVC_COMPLEX_TYPE_2_1,
  XML_SCHEMAV_CVC_COMPLEX_TYPE_2_2,
  XML_SCHEMAV_CVC_COMPLEX_TYPE_2_3,
  XML_SCHEMAV_CVC_COMPLEX_TYPE_2_4,
  XML_SCHEMAV_CVC_ELT_1,
  XML_SCHEMAV_CVC_ELT_2,
  XML_SCHEMAV_CVC_ELT_3_1,
  XML_SCHEMAV_CVC_ELT_3_2_1,
  XML_SCHEMAV_CVC_ELT_3_2_2,
  XML_SCHEMAV_CVC_ELT_4_1,
  XML_SCHEMAV_CVC_ELT_4_2,
  XML_SCHEMAV_CVC_ELT_4_3,
  XML_SCHEMAV_CVC_ELT_5_1_1,
  XML_SCHEMAV_CVC_ELT_5_1_2,
  XML_SCHEMAV_CVC_ELT_5_2_1,
  XML_SCHEMAV_CVC_ELT_5_2_2_1,
  XML_SCHEMAV_CVC_ELT_5_2_2_2_1,
  XML_SCHEMAV_CVC_ELT_5_2_2_2_2,
  XML_SCHEMAV_CVC_ELT_6,
  XML_SCHEMAV_CVC_ELT_7,
  XML_SCHEMAV_CVC_ATTRIBUTE_1,
  XML_SCHEMAV_CVC_ATTRIBUTE_2,
  XML_SCHEMAV_CVC_ATTRIBUTE_3,
  XML_SCHEMAV_CVC_ATTRIBUTE_4,
  XML_SCHEMAV_CVC_COMPLEX_TYPE_3_1,
  XML_SCHEMAV_CVC_COMPLEX_TYPE_3_2_1,
  XML_SCHEMAV_CVC_COMPLEX_TYPE_3_2_2,
  XML_SCHEMAV_CVC_COMPLEX_TYPE_4,
  XML_SCHEMAV_CVC_COMPLEX_TYPE_5_1,
  XML_SCHEMAV_CVC_COMPLEX_TYPE_5_2,
  XML_SCHEMAV_ELEMENT_CONTENT,
  XML_SCHEMAV_DOCUMENT_ELEMENT_MISSING,
  XML_SCHEMAV_CVC_COMPLEX_TYPE_1,
  XML_SCHEMAV_CVC_AU,
  XML_SCHEMAV_CVC_TYPE_1,
  XML_SCHEMAV_CVC_TYPE_2,
  XML_SCHEMAV_CVC_IDC,
  XML_SCHEMAV_CVC_WILDCARD,
  XML_SCHEMAV_MISC,
  XML_XPTR_UNKNOWN_SCHEME = 1900,
  XML_XPTR_CHILDSEQ_START,
  XML_XPTR_EVAL_FAILED,
  XML_XPTR_EXTRA_OBJECTS,
  XML_C14N_CREATE_CTXT = 1950,
  XML_C14N_REQUIRES_UTF8,
  XML_C14N_CREATE_STACK,
  XML_C14N_INVALID_NODE,
  XML_C14N_UNKNOW_NODE,
  XML_C14N_RELATIVE_NAMESPACE,
  XML_FTP_PASV_ANSWER = 2000,
  XML_FTP_EPSV_ANSWER,
  XML_FTP_ACCNT,
  XML_FTP_URL_SYNTAX,
  XML_HTTP_URL_SYNTAX = 2020,
  XML_HTTP_USE_IP,
  XML_HTTP_UNKNOWN_HOST,
  XML_SCHEMAP_SRC_SIMPLE_TYPE_1 = 3000,
  XML_SCHEMAP_SRC_SIMPLE_TYPE_2,
  XML_SCHEMAP_SRC_SIMPLE_TYPE_3,
  XML_SCHEMAP_SRC_SIMPLE_TYPE_4,
  XML_SCHEMAP_SRC_RESOLVE,
  XML_SCHEMAP_SRC_RESTRICTION_BASE_OR_SIMPLETYPE,
  XML_SCHEMAP_SRC_LIST_ITEMTYPE_OR_SIMPLETYPE,
  XML_SCHEMAP_SRC_UNION_MEMBERTYPES_OR_SIMPLETYPES,
  XML_SCHEMAP_ST_PROPS_CORRECT_1,
  XML_SCHEMAP_ST_PROPS_CORRECT_2,
  XML_SCHEMAP_ST_PROPS_CORRECT_3,
  XML_SCHEMAP_COS_ST_RESTRICTS_1_1,
  XML_SCHEMAP_COS_ST_RESTRICTS_1_2,
  XML_SCHEMAP_COS_ST_RESTRICTS_1_3_1,
  XML_SCHEMAP_COS_ST_RESTRICTS_1_3_2,
  XML_SCHEMAP_COS_ST_RESTRICTS_2_1,
  XML_SCHEMAP_COS_ST_RESTRICTS_2_3_1_1,
  XML_SCHEMAP_COS_ST_RESTRICTS_2_3_1_2,
  XML_SCHEMAP_COS_ST_RESTRICTS_2_3_2_1,
  XML_SCHEMAP_COS_ST_RESTRICTS_2_3_2_2,
  XML_SCHEMAP_COS_ST_RESTRICTS_2_3_2_3,
  XML_SCHEMAP_COS_ST_RESTRICTS_2_3_2_4,
  XML_SCHEMAP_COS_ST_RESTRICTS_2_3_2_5,
  XML_SCHEMAP_COS_ST_RESTRICTS_3_1,
  XML_SCHEMAP_COS_ST_RESTRICTS_3_3_1,
  XML_SCHEMAP_COS_ST_RESTRICTS_3_3_1_2,
  XML_SCHEMAP_COS_ST_RESTRICTS_3_3_2_2,
  XML_SCHEMAP_COS_ST_RESTRICTS_3_3_2_1,
  XML_SCHEMAP_COS_ST_RESTRICTS_3_3_2_3,
  XML_SCHEMAP_COS_ST_RESTRICTS_3_3_2_4,
  XML_SCHEMAP_COS_ST_RESTRICTS_3_3_2_5,
  XML_SCHEMAP_COS_ST_DERIVED_OK_2_1,
  XML_SCHEMAP_COS_ST_DERIVED_OK_2_2,
  XML_SCHEMAP_S4S_ELEM_NOT_ALLOWED,
  XML_SCHEMAP_S4S_ELEM_MISSING,
  XML_SCHEMAP_S4S_ATTR_NOT_ALLOWED,
  XML_SCHEMAP_S4S_ATTR_MISSING,
  XML_SCHEMAP_S4S_ATTR_INVALID_VALUE,
  XML_SCHEMAP_SRC_ELEMENT_1,
  XML_SCHEMAP_SRC_ELEMENT_2_1,
  XML_SCHEMAP_SRC_ELEMENT_2_2,
  XML_SCHEMAP_SRC_ELEMENT_3,
  XML_SCHEMAP_P_PROPS_CORRECT_1,
  XML_SCHEMAP_P_PROPS_CORRECT_2_1,
  XML_SCHEMAP_P_PROPS_CORRECT_2_2,
  XML_SCHEMAP_E_PROPS_CORRECT_2,
  XML_SCHEMAP_E_PROPS_CORRECT_3,
  XML_SCHEMAP_E_PROPS_CORRECT_4,
  XML_SCHEMAP_E_PROPS_CORRECT_5,
  XML_SCHEMAP_E_PROPS_CORRECT_6,
  XML_SCHEMAP_SRC_INCLUDE,
  XML_SCHEMAP_SRC_ATTRIBUTE_1,
  XML_SCHEMAP_SRC_ATTRIBUTE_2,
  XML_SCHEMAP_SRC_ATTRIBUTE_3_1,
  XML_SCHEMAP_SRC_ATTRIBUTE_3_2,
  XML_SCHEMAP_SRC_ATTRIBUTE_4,
  XML_SCHEMAP_NO_XMLNS,
  XML_SCHEMAP_NO_XSI,
  XML_SCHEMAP_COS_VALID_DEFAULT_1,
  XML_SCHEMAP_COS_VALID_DEFAULT_2_1,
  XML_SCHEMAP_COS_VALID_DEFAULT_2_2_1,
  XML_SCHEMAP_COS_VALID_DEFAULT_2_2_2,
  XML_SCHEMAP_CVC_SIMPLE_TYPE,
  XML_SCHEMAP_COS_CT_EXTENDS_1_1,
  XML_SCHEMAP_SRC_IMPORT_1_1,
  XML_SCHEMAP_SRC_IMPORT_1_2,
  XML_SCHEMAP_SRC_IMPORT_2,
  XML_SCHEMAP_SRC_IMPORT_2_1,
  XML_SCHEMAP_SRC_IMPORT_2_2,
  XML_SCHEMAP_INTERNAL,
  XML_SCHEMAP_NOT_DETERMINISTIC,
  XML_SCHEMAP_SRC_ATTRIBUTE_GROUP_1,
  XML_SCHEMAP_SRC_ATTRIBUTE_GROUP_2,
  XML_SCHEMAP_SRC_ATTRIBUTE_GROUP_3,
  XML_SCHEMAP_MG_PROPS_CORRECT_1,
  XML_SCHEMAP_MG_PROPS_CORRECT_2,
  XML_SCHEMAP_SRC_CT_1,
  XML_SCHEMAP_DERIVATION_OK_RESTRICTION_2_1_3,
  XML_SCHEMAP_AU_PROPS_CORRECT_2,
  XML_SCHEMAP_A_PROPS_CORRECT_2,
  XML_SCHEMAP_C_PROPS_CORRECT,
  XML_SCHEMAP_SRC_REDEFINE,
  XML_SCHEMAP_SRC_IMPORT,
  XML_SCHEMAP_WARN_SKIP_SCHEMA,
  XML_SCHEMAP_WARN_UNLOCATED_SCHEMA,
  XML_SCHEMAP_WARN_ATTR_REDECL_PROH,
  XML_SCHEMAP_WARN_ATTR_POINTLESS_PROH,
  XML_SCHEMAP_AG_PROPS_CORRECT,
  XML_SCHEMAP_COS_CT_EXTENDS_1_2,
  XML_SCHEMAP_AU_PROPS_CORRECT,
  XML_SCHEMAP_A_PROPS_CORRECT_3,
  XML_SCHEMAP_COS_ALL_LIMITED,
  XML_SCHEMATRONV_ASSERT = 4000,
  XML_SCHEMATRONV_REPORT,
  XML_MODULE_OPEN = 4900,
  XML_MODULE_CLOSE,
  XML_CHECK_FOUND_ELEMENT = 5000,
  XML_CHECK_FOUND_ATTRIBUTE,
  XML_CHECK_FOUND_TEXT,
  XML_CHECK_FOUND_CDATA,
  XML_CHECK_FOUND_ENTITYREF,
  XML_CHECK_FOUND_ENTITY,
  XML_CHECK_FOUND_PI,
  XML_CHECK_FOUND_COMMENT,
  XML_CHECK_FOUND_DOCTYPE,
  XML_CHECK_FOUND_FRAGMENT,
  XML_CHECK_FOUND_NOTATION,
  XML_CHECK_UNKNOWN_NODE,
  XML_CHECK_ENTITY_TYPE,
  XML_CHECK_NO_PARENT,
  XML_CHECK_NO_DOC,
  XML_CHECK_NO_NAME,
  XML_CHECK_NO_ELEM,
  XML_CHECK_WRONG_DOC,
  XML_CHECK_NO_PREV,
  XML_CHECK_WRONG_PREV,
  XML_CHECK_NO_NEXT,
  XML_CHECK_WRONG_NEXT,
  XML_CHECK_NOT_DTD,
  XML_CHECK_NOT_ATTR,
  XML_CHECK_NOT_ATTR_DECL,
  XML_CHECK_NOT_ELEM_DECL,
  XML_CHECK_NOT_ENTITY_DECL,
  XML_CHECK_NOT_NS_DECL,
  XML_CHECK_NO_HREF,
  XML_CHECK_WRONG_PARENT,
  XML_CHECK_NS_SCOPE,
  XML_CHECK_NS_ANCESTOR,
  XML_CHECK_NOT_UTF8,
  XML_CHECK_NO_DICT,
  XML_CHECK_NOT_NCNAME,
  XML_CHECK_OUTSIDE_DICT,
  XML_CHECK_WRONG_NAME,
  XML_CHECK_NAME_NOT_NULL,
  XML_I18N_NO_NAME = 6000,
  XML_I18N_NO_HANDLER,
  XML_I18N_EXCESS_HANDLER,
  XML_I18N_CONV_FAILED,
  XML_I18N_NO_OUTPUT,
  XML_BUF_OVERFLOW = 7000
} xmlParserErrors;

typedef void (*xmlGenericErrorFunc) (void *ctx, const char *msg, ...)
  __attribute__ ((__format__ (__printf__, 2, 3)));
typedef void (*xmlStructuredErrorFunc) (void *userData, xmlErrorPtr error);

void xmlSetGenericErrorFunc (void *ctx, xmlGenericErrorFunc handler);
void initGenericErrorDefaultFunc (xmlGenericErrorFunc * handler);
void xmlSetStructuredErrorFunc (void *ctx, xmlStructuredErrorFunc handler);

void xmlParserError (void *ctx, const char *msg, ...)
  __attribute__ ((__format__ (__printf__, 2, 3)));
void xmlParserWarning (void *ctx, const char *msg, ...)
  __attribute__ ((__format__ (__printf__, 2, 3)));
void xmlParserValidityError (void *ctx, const char *msg, ...)
  __attribute__ ((__format__ (__printf__, 2, 3)));
void xmlParserValidityWarning (void *ctx, const char *msg, ...)
  __attribute__ ((__format__ (__printf__, 2, 3)));
void xmlParserPrintFileInfo (xmlParserInputPtr input);
void xmlParserPrintFileContext (xmlParserInputPtr input);
xmlErrorPtr xmlGetLastError (void);
void xmlResetLastError (void);
xmlErrorPtr xmlCtxtGetLastError (void *ctx);
void xmlCtxtResetLastError (void *ctx);
void xmlResetError (xmlErrorPtr err);
int xmlCopyError (xmlErrorPtr from, xmlErrorPtr to);
typedef struct _xmlLink xmlLink;
typedef xmlLink *xmlLinkPtr;
typedef struct _xmlList xmlList;
typedef xmlList *xmlListPtr;
typedef void (*xmlListDeallocator) (xmlLinkPtr lk);
typedef int (*xmlListDataCompare) (const void *data0, const void *data1);
typedef int (*xmlListWalker) (const void *data, const void *user);

xmlListPtr xmlListCreate (xmlListDeallocator deallocator, xmlListDataCompare compare);
void xmlListDelete (xmlListPtr l);
void *xmlListSearch (xmlListPtr l, void *data);
void *xmlListReverseSearch (xmlListPtr l, void *data);
int xmlListInsert (xmlListPtr l, void *data);
int xmlListAppend (xmlListPtr l, void *data);
int xmlListRemoveFirst (xmlListPtr l, void *data);
int xmlListRemoveLast (xmlListPtr l, void *data);
int xmlListRemoveAll (xmlListPtr l, void *data);
void xmlListClear (xmlListPtr l);
int xmlListEmpty (xmlListPtr l);
xmlLinkPtr xmlListFront (xmlListPtr l);
xmlLinkPtr xmlListEnd (xmlListPtr l);
int xmlListSize (xmlListPtr l);
void xmlListPopFront (xmlListPtr l);
void xmlListPopBack (xmlListPtr l);
int xmlListPushFront (xmlListPtr l, void *data);
int xmlListPushBack (xmlListPtr l, void *data);
void xmlListReverse (xmlListPtr l);
void xmlListSort (xmlListPtr l);
void xmlListWalk (xmlListPtr l, xmlListWalker walker, const void *user);
void xmlListReverseWalk (xmlListPtr l, xmlListWalker walker, const void *user);
void xmlListMerge (xmlListPtr l1, xmlListPtr l2);
xmlListPtr xmlListDup (const xmlListPtr old);
int xmlListCopy (xmlListPtr cur, const xmlListPtr old);
void *xmlLinkGetData (xmlLinkPtr lk);
typedef struct _xmlAutomata xmlAutomata;
typedef xmlAutomata *xmlAutomataPtr;

typedef struct _xmlAutomataState xmlAutomataState;
typedef xmlAutomataState *xmlAutomataStatePtr;

xmlAutomataPtr xmlNewAutomata (void);
void xmlFreeAutomata (xmlAutomataPtr am);

xmlAutomataStatePtr xmlAutomataGetInitState (xmlAutomataPtr am);
int xmlAutomataSetFinalState (xmlAutomataPtr am, xmlAutomataStatePtr state);
xmlAutomataStatePtr xmlAutomataNewState (xmlAutomataPtr am);
xmlAutomataStatePtr
xmlAutomataNewTransition (xmlAutomataPtr am,
			  xmlAutomataStatePtr from,
			  xmlAutomataStatePtr to,
			  const xmlChar * token, void *data);
xmlAutomataStatePtr
xmlAutomataNewTransition2 (xmlAutomataPtr am,
			   xmlAutomataStatePtr from,
			   xmlAutomataStatePtr to,
			   const xmlChar * token,
			   const xmlChar * token2, void *data);
xmlAutomataStatePtr
xmlAutomataNewNegTrans (xmlAutomataPtr am,
			xmlAutomataStatePtr from,
			xmlAutomataStatePtr to,
			const xmlChar * token,
			const xmlChar * token2, void *data);

xmlAutomataStatePtr
xmlAutomataNewCountTrans (xmlAutomataPtr am,
			  xmlAutomataStatePtr from,
			  xmlAutomataStatePtr to,
			  const xmlChar * token,
			  int min, int max, void *data);
xmlAutomataStatePtr
xmlAutomataNewCountTrans2 (xmlAutomataPtr am,
			   xmlAutomataStatePtr from,
			   xmlAutomataStatePtr to,
			   const xmlChar * token,
			   const xmlChar * token2,
			   int min, int max, void *data);
xmlAutomataStatePtr
xmlAutomataNewOnceTrans (xmlAutomataPtr am,
			 xmlAutomataStatePtr from,
			 xmlAutomataStatePtr to,
			 const xmlChar * token, int min, int max, void *data);
xmlAutomataStatePtr
xmlAutomataNewOnceTrans2 (xmlAutomataPtr am,
			  xmlAutomataStatePtr from,
			  xmlAutomataStatePtr to,
			  const xmlChar * token,
			  const xmlChar * token2,
			  int min, int max, void *data);
xmlAutomataStatePtr
xmlAutomataNewAllTrans (xmlAutomataPtr am,
			xmlAutomataStatePtr from,
			xmlAutomataStatePtr to, int lax);
xmlAutomataStatePtr
xmlAutomataNewEpsilon (xmlAutomataPtr am,
		       xmlAutomataStatePtr from, xmlAutomataStatePtr to);
xmlAutomataStatePtr
xmlAutomataNewCountedTrans (xmlAutomataPtr am,
			    xmlAutomataStatePtr from,
			    xmlAutomataStatePtr to, int counter);
xmlAutomataStatePtr
xmlAutomataNewCounterTrans (xmlAutomataPtr am,
			    xmlAutomataStatePtr from,
			    xmlAutomataStatePtr to, int counter);
int xmlAutomataNewCounter (xmlAutomataPtr am, int min, int max);

xmlRegexpPtr xmlAutomataCompile (xmlAutomataPtr am);
int xmlAutomataIsDeterminist (xmlAutomataPtr am);
typedef struct _xmlValidState xmlValidState;
typedef xmlValidState *xmlValidStatePtr;
typedef void (*xmlValidityErrorFunc) (void *ctx, const char *msg, ...)
  __attribute__ ((__format__ (__printf__, 2, 3)));
typedef void (*xmlValidityWarningFunc) (void *ctx, const char *msg, ...)
  __attribute__ ((__format__ (__printf__, 2, 3)));
typedef struct _xmlValidCtxt xmlValidCtxt;
typedef xmlValidCtxt *xmlValidCtxtPtr;

struct _xmlValidCtxt
{
  void *userData;
  xmlValidityErrorFunc error;
  xmlValidityWarningFunc warning;
  xmlNodePtr node;
  int nodeNr;
  int nodeMax;
  xmlNodePtr *nodeTab;
  unsigned int finishDtd;
  xmlDocPtr doc;
  int valid;
  xmlValidState *vstate;
  int vstateNr;
  int vstateMax;
  xmlValidState *vstateTab;
  xmlAutomataPtr am;
  xmlAutomataStatePtr state;
};

typedef struct _xmlHashTable xmlNotationTable;
typedef xmlNotationTable *xmlNotationTablePtr;
typedef struct _xmlHashTable xmlElementTable;
typedef xmlElementTable *xmlElementTablePtr;
typedef struct _xmlHashTable xmlAttributeTable;
typedef xmlAttributeTable *xmlAttributeTablePtr;
typedef struct _xmlHashTable xmlIDTable;
typedef xmlIDTable *xmlIDTablePtr;
typedef struct _xmlHashTable xmlRefTable;
typedef xmlRefTable *xmlRefTablePtr;

xmlNotationPtr xmlAddNotationDecl (xmlValidCtxtPtr ctxt,
				   xmlDtdPtr dtd,
				   const xmlChar * name,
				   const xmlChar * PublicID, const xmlChar * SystemID);

xmlNotationTablePtr xmlCopyNotationTable (xmlNotationTablePtr table);

void xmlFreeNotationTable (xmlNotationTablePtr table);

void xmlDumpNotationDecl (xmlBufferPtr buf, xmlNotationPtr nota);
void xmlDumpNotationTable (xmlBufferPtr buf, xmlNotationTablePtr table);

xmlElementContentPtr xmlNewElementContent (const xmlChar * name, xmlElementContentType type);
xmlElementContentPtr xmlCopyElementContent (xmlElementContentPtr content);
void xmlFreeElementContent (xmlElementContentPtr cur);

xmlElementContentPtr xmlNewDocElementContent (xmlDocPtr doc,
					      const xmlChar * name, xmlElementContentType type);
xmlElementContentPtr xmlCopyDocElementContent (xmlDocPtr doc, xmlElementContentPtr content);
void xmlFreeDocElementContent (xmlDocPtr doc, xmlElementContentPtr cur);
void xmlSnprintfElementContent (char *buf,
				int size,
				xmlElementContentPtr content, int englob);

void xmlSprintfElementContent (char *buf,
			       xmlElementContentPtr content, int englob);

xmlElementPtr xmlAddElementDecl (xmlValidCtxtPtr ctxt,
				 xmlDtdPtr dtd,
				 const xmlChar * name,
				 xmlElementTypeVal type, xmlElementContentPtr content);

xmlElementTablePtr xmlCopyElementTable (xmlElementTablePtr table);

void xmlFreeElementTable (xmlElementTablePtr table);
void xmlDumpElementTable (xmlBufferPtr buf, xmlElementTablePtr table);
void xmlDumpElementDecl (xmlBufferPtr buf, xmlElementPtr elem);
xmlEnumerationPtr xmlCreateEnumeration (const xmlChar * name);
void xmlFreeEnumeration (xmlEnumerationPtr cur);
xmlEnumerationPtr xmlCopyEnumeration (xmlEnumerationPtr cur);

xmlAttributePtr xmlAddAttributeDecl (xmlValidCtxtPtr ctxt,
				     xmlDtdPtr dtd,
				     const xmlChar * elem,
				     const xmlChar * name,
				     const xmlChar * ns,
				     xmlAttributeType type,
				     xmlAttributeDefault def,
				     const xmlChar * defaultValue, xmlEnumerationPtr tree);

xmlAttributeTablePtr xmlCopyAttributeTable (xmlAttributeTablePtr table);
void xmlFreeAttributeTable (xmlAttributeTablePtr table);
void xmlDumpAttributeTable (xmlBufferPtr buf, xmlAttributeTablePtr table);
void xmlDumpAttributeDecl (xmlBufferPtr buf, xmlAttributePtr attr);

xmlIDPtr xmlAddID (xmlValidCtxtPtr ctxt,
		   xmlDocPtr doc, const xmlChar * value, xmlAttrPtr attr);
void xmlFreeIDTable (xmlIDTablePtr table);
xmlAttrPtr xmlGetID (xmlDocPtr doc, const xmlChar * ID);
int xmlIsID (xmlDocPtr doc, xmlNodePtr elem, xmlAttrPtr attr);
int xmlRemoveID (xmlDocPtr doc, xmlAttrPtr attr);

xmlRefPtr xmlAddRef (xmlValidCtxtPtr ctxt,
		     xmlDocPtr doc, const xmlChar * value, xmlAttrPtr attr);
void xmlFreeRefTable (xmlRefTablePtr table);
int xmlIsRef (xmlDocPtr doc, xmlNodePtr elem, xmlAttrPtr attr);
int xmlRemoveRef (xmlDocPtr doc, xmlAttrPtr attr);
xmlListPtr xmlGetRefs (xmlDocPtr doc, const xmlChar * ID);

xmlValidCtxtPtr xmlNewValidCtxt (void);
void xmlFreeValidCtxt (xmlValidCtxtPtr);
int xmlValidateRoot (xmlValidCtxtPtr ctxt, xmlDocPtr doc);
int xmlValidateElementDecl (xmlValidCtxtPtr ctxt,
			    xmlDocPtr doc, xmlElementPtr elem);
xmlChar *xmlValidNormalizeAttributeValue (xmlDocPtr doc,
					  xmlNodePtr elem,
					  const xmlChar * name,
					  const xmlChar * value);
xmlChar *xmlValidCtxtNormalizeAttributeValue (xmlValidCtxtPtr ctxt,
					      xmlDocPtr doc,
					      xmlNodePtr elem,
					      const xmlChar * name,
					      const xmlChar * value);
int xmlValidateAttributeDecl (xmlValidCtxtPtr ctxt,
			      xmlDocPtr doc, xmlAttributePtr attr);
int xmlValidateAttributeValue (xmlAttributeType type, const xmlChar * value);
int xmlValidateNotationDecl (xmlValidCtxtPtr ctxt,
			     xmlDocPtr doc, xmlNotationPtr nota);
int xmlValidateDtd (xmlValidCtxtPtr ctxt, xmlDocPtr doc, xmlDtdPtr dtd);
int xmlValidateDtdFinal (xmlValidCtxtPtr ctxt, xmlDocPtr doc);
int xmlValidateDocument (xmlValidCtxtPtr ctxt, xmlDocPtr doc);
int xmlValidateElement (xmlValidCtxtPtr ctxt, xmlDocPtr doc, xmlNodePtr elem);
int xmlValidateOneElement (xmlValidCtxtPtr ctxt, xmlDocPtr doc, xmlNodePtr elem);
int xmlValidateOneAttribute (xmlValidCtxtPtr ctxt,
			     xmlDocPtr doc,
			     xmlNodePtr elem,
			     xmlAttrPtr attr, const xmlChar * value);
int xmlValidateOneNamespace (xmlValidCtxtPtr ctxt,
			     xmlDocPtr doc,
			     xmlNodePtr elem,
			     const xmlChar * prefix,
			     xmlNsPtr ns, const xmlChar * value);
int xmlValidateDocumentFinal (xmlValidCtxtPtr ctxt, xmlDocPtr doc);



int
xmlValidateNotationUse (xmlValidCtxtPtr ctxt,
			xmlDocPtr doc, const xmlChar * notationName);


int xmlIsMixedElement (xmlDocPtr doc, const xmlChar * name);
xmlAttributePtr xmlGetDtdAttrDesc (xmlDtdPtr dtd, const xmlChar * elem, const xmlChar * name);
xmlAttributePtr xmlGetDtdQAttrDesc (xmlDtdPtr dtd,
				    const xmlChar * elem,
				    const xmlChar * name, const xmlChar * prefix);
xmlNotationPtr xmlGetDtdNotationDesc (xmlDtdPtr dtd, const xmlChar * name);
xmlElementPtr xmlGetDtdQElementDesc (xmlDtdPtr dtd,
				     const xmlChar * name, const xmlChar * prefix);
xmlElementPtr xmlGetDtdElementDesc (xmlDtdPtr dtd, const xmlChar * name);

int xmlValidGetPotentialChildren (xmlElementContent * ctree,
				  const xmlChar ** names, int *len, int max);

int xmlValidGetValidElements (xmlNode * prev,
			      xmlNode * next, const xmlChar ** names, int max);
int xmlValidateNameValue (const xmlChar * value);
int xmlValidateNamesValue (const xmlChar * value);
int xmlValidateNmtokenValue (const xmlChar * value);
int xmlValidateNmtokensValue (const xmlChar * value);

int xmlValidBuildContentModel (xmlValidCtxtPtr ctxt, xmlElementPtr elem);

int
xmlValidatePushElement (xmlValidCtxtPtr ctxt,
			xmlDocPtr doc,
			xmlNodePtr elem, const xmlChar * qname);
int
xmlValidatePushCData (xmlValidCtxtPtr ctxt, const xmlChar * data, int len);
int
xmlValidatePopElement (xmlValidCtxtPtr ctxt,
		       xmlDocPtr doc, xmlNodePtr elem, const xmlChar * qname);
typedef enum
  {
    XML_INTERNAL_GENERAL_ENTITY = 1,
    XML_EXTERNAL_GENERAL_PARSED_ENTITY = 2,
    XML_EXTERNAL_GENERAL_UNPARSED_ENTITY = 3,
    XML_INTERNAL_PARAMETER_ENTITY = 4,
    XML_EXTERNAL_PARAMETER_ENTITY = 5,
    XML_INTERNAL_PREDEFINED_ENTITY = 6
  } xmlEntityType;

struct _xmlEntity
{
  void *_private;
  xmlElementType type;
  const xmlChar *name;
  struct _xmlNode *children;
  struct _xmlNode *last;
  struct _xmlDtd *parent;
  struct _xmlNode *next;
  struct _xmlNode *prev;
  struct _xmlDoc *doc;

  xmlChar *orig;
  xmlChar *content;
  int length;
  xmlEntityType etype;
  const xmlChar *ExternalID;
  const xmlChar *SystemID;

  struct _xmlEntity *nexte;
  const xmlChar *URI;
  int owner;
  int checked;
};

typedef struct _xmlHashTable xmlEntitiesTable;
typedef xmlEntitiesTable *xmlEntitiesTablePtr;
void xmlInitializePredefinedEntities (void);

xmlEntityPtr
xmlNewEntity (xmlDocPtr doc,
	      const xmlChar * name,
	      int type,
	      const xmlChar * ExternalID,
	      const xmlChar * SystemID, const xmlChar * content);
xmlEntityPtr
xmlAddDocEntity (xmlDocPtr doc,
		 const xmlChar * name,
		 int type,
		 const xmlChar * ExternalID,
		 const xmlChar * SystemID, const xmlChar * content);
xmlEntityPtr
xmlAddDtdEntity (xmlDocPtr doc,
		 const xmlChar * name,
		 int type,
		 const xmlChar * ExternalID,
		 const xmlChar * SystemID, const xmlChar * content);
xmlEntityPtr xmlGetPredefinedEntity (const xmlChar * name);
xmlEntityPtr xmlGetDocEntity (const xmlDoc * doc, const xmlChar * name);
xmlEntityPtr xmlGetDtdEntity (xmlDocPtr doc, const xmlChar * name);
xmlEntityPtr xmlGetParameterEntity (xmlDocPtr doc, const xmlChar * name);
const xmlChar *xmlEncodeEntities (xmlDocPtr doc, const xmlChar * input);
xmlChar *xmlEncodeEntitiesReentrant (xmlDocPtr doc, const xmlChar * input);
xmlChar *xmlEncodeSpecialChars (const xmlDoc * doc, const xmlChar * input);
xmlEntitiesTablePtr xmlCreateEntitiesTable (void);

xmlEntitiesTablePtr xmlCopyEntitiesTable (xmlEntitiesTablePtr table);
void xmlFreeEntitiesTable (xmlEntitiesTablePtr table);
void xmlDumpEntitiesTable (xmlBufferPtr buf, xmlEntitiesTablePtr table);
void xmlDumpEntityDecl (xmlBufferPtr buf, xmlEntityPtr ent);
void xmlCleanupPredefinedEntities (void);
typedef void (*xmlParserInputDeallocate) (xmlChar * str);

struct _xmlParserInput
{
  xmlParserInputBufferPtr buf;
  const char *filename;
  const char *directory;
  const xmlChar *base;
  const xmlChar *cur;
  const xmlChar *end;
  int length;
  int line;
  int col;
  unsigned long consumed;
  xmlParserInputDeallocate free;
  const xmlChar *encoding;
  const xmlChar *version;
  int standalone;
  int id;
};

typedef struct _xmlParserNodeInfo xmlParserNodeInfo;
typedef xmlParserNodeInfo *xmlParserNodeInfoPtr;

struct _xmlParserNodeInfo
{
  const struct _xmlNode *node;
  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;
};

typedef enum
  {
    XML_PARSER_EOF = -1,
    XML_PARSER_START = 0,
    XML_PARSER_MISC,
    XML_PARSER_PI,
    XML_PARSER_DTD,
    XML_PARSER_PROLOG,
    XML_PARSER_COMMENT,
    XML_PARSER_START_TAG,
    XML_PARSER_CONTENT,
    XML_PARSER_CDATA_SECTION,
    XML_PARSER_END_TAG,
    XML_PARSER_ENTITY_DECL,
    XML_PARSER_ENTITY_VALUE,
    XML_PARSER_ATTRIBUTE_VALUE,
    XML_PARSER_SYSTEM_LITERAL,
    XML_PARSER_EPILOG,
    XML_PARSER_IGNORE,
    XML_PARSER_PUBLIC_LITERAL
  } xmlParserInputState;

typedef enum
  {
    XML_PARSE_UNKNOWN = 0,
    XML_PARSE_DOM = 1,
    XML_PARSE_SAX = 2,
    XML_PARSE_PUSH_DOM = 3,
    XML_PARSE_PUSH_SAX = 4,
    XML_PARSE_READER = 5
  } xmlParserMode;

struct _xmlParserCtxt
{
  struct _xmlSAXHandler *sax;
  void *userData;
  xmlDocPtr myDoc;
  int wellFormed;
  int replaceEntities;
  const xmlChar *version;
  const xmlChar *encoding;
  int standalone;
  int html;
  xmlParserInputPtr input;
  int inputNr;
  int inputMax;
  xmlParserInputPtr *inputTab;
  xmlNodePtr node;
  int nodeNr;
  int nodeMax;
  xmlNodePtr *nodeTab;
  int record_info;
  xmlParserNodeInfoSeq node_seq;
  int errNo;
  int hasExternalSubset;
  int hasPErefs;
  int external;
  int valid;
  int validate;
  xmlValidCtxt vctxt;
  xmlParserInputState instate;
  int token;
  char *directory;
  const xmlChar *name;
  int nameNr;
  int nameMax;
  const xmlChar **nameTab;
  long nbChars;
  long checkIndex;
  int keepBlanks;
  int disableSAX;
  int inSubset;
  const xmlChar *intSubName;
  xmlChar *extSubURI;
  xmlChar *extSubSystem;
  int *space;
  int spaceNr;
  int spaceMax;
  int *spaceTab;
  int depth;
  xmlParserInputPtr entity;
  int charset;
  int nodelen;
  int nodemem;
  int pedantic;
  void *_private;
  int loadsubset;
  int linenumbers;
  void *catalogs;
  int recovery;
  int progressive;
  xmlDictPtr dict;
  const xmlChar **atts;
  int maxatts;
  int docdict;
  const xmlChar *str_xml;
  const xmlChar *str_xmlns;
  const xmlChar *str_xml_ns;
  int sax2;
  int nsNr;
  int nsMax;
  const xmlChar **nsTab;
  int *attallocs;
  void **pushTab;
  xmlHashTablePtr attsDefault;
  xmlHashTablePtr attsSpecial;
  int nsWellFormed;
  int options;
  int dictNames;
  int freeElemsNr;
  xmlNodePtr freeElems;
  int freeAttrsNr;
  xmlAttrPtr freeAttrs;
  xmlError lastError;
  xmlParserMode parseMode;
  unsigned long nbentities;
  unsigned long sizeentities;
  xmlParserNodeInfo *nodeInfo;
  int nodeInfoNr;
  int nodeInfoMax;
  xmlParserNodeInfo *nodeInfoTab;
  int input_id;
  unsigned long sizeentcopy;
};

struct _xmlSAXLocator
{
  const xmlChar *(*getPublicId) (void *ctx);
  const xmlChar *(*getSystemId) (void *ctx);
  int (*getLineNumber) (void *ctx);
  int (*getColumnNumber) (void *ctx);
};

typedef xmlParserInputPtr (*resolveEntitySAXFunc) (void *ctx,
						   const xmlChar * publicId,
						   const xmlChar * systemId);
typedef void (*internalSubsetSAXFunc) (void *ctx,
				       const xmlChar * name,
				       const xmlChar * ExternalID,
				       const xmlChar * SystemID);
typedef void (*externalSubsetSAXFunc) (void *ctx,
				       const xmlChar * name,
				       const xmlChar * ExternalID,
				       const xmlChar * SystemID);
typedef xmlEntityPtr (*getEntitySAXFunc) (void *ctx, const xmlChar * name);
typedef xmlEntityPtr (*getParameterEntitySAXFunc) (void *ctx,
						   const xmlChar * name);
typedef void (*entityDeclSAXFunc) (void *ctx,
				   const xmlChar * name,
				   int type,
				   const xmlChar * publicId,
				   const xmlChar * systemId,
				   xmlChar * content);
typedef void (*notationDeclSAXFunc) (void *ctx,
				     const xmlChar * name,
				     const xmlChar * publicId,
				     const xmlChar * systemId);
typedef void (*attributeDeclSAXFunc) (void *ctx,
				      const xmlChar * elem,
				      const xmlChar * fullname,
				      int type,
				      int def,
				      const xmlChar * defaultValue,
				      xmlEnumerationPtr tree);
typedef void (*elementDeclSAXFunc) (void *ctx,
				    const xmlChar * name,
				    int type, xmlElementContentPtr content);
typedef void (*unparsedEntityDeclSAXFunc) (void *ctx,
					   const xmlChar * name,
					   const xmlChar * publicId,
					   const xmlChar * systemId,
					   const xmlChar * notationName);
typedef void (*setDocumentLocatorSAXFunc) (void *ctx, xmlSAXLocatorPtr loc);
typedef void (*startDocumentSAXFunc) (void *ctx);
typedef void (*endDocumentSAXFunc) (void *ctx);
typedef void (*startElementSAXFunc) (void *ctx,
				     const xmlChar * name,
				     const xmlChar ** atts);
typedef void (*endElementSAXFunc) (void *ctx, const xmlChar * name);
typedef void (*attributeSAXFunc) (void *ctx,
				  const xmlChar * name,
				  const xmlChar * value);
typedef void (*referenceSAXFunc) (void *ctx, const xmlChar * name);
typedef void (*charactersSAXFunc) (void *ctx, const xmlChar * ch, int len);
typedef void (*ignorableWhitespaceSAXFunc) (void *ctx,
					    const xmlChar * ch, int len);
typedef void (*processingInstructionSAXFunc) (void *ctx,
					      const xmlChar * target,
					      const xmlChar * data);

typedef void (*commentSAXFunc) (void *ctx, const xmlChar * value);
typedef void (*cdataBlockSAXFunc) (void *ctx, const xmlChar * value, int len);
typedef void (*warningSAXFunc) (void *ctx,
				const char *msg, ...)
  __attribute__ ((__format__ (__printf__, 2, 3)));
typedef void (*errorSAXFunc) (void *ctx, const char *msg, ...)
  __attribute__ ((__format__ (__printf__, 2, 3)));
typedef void (*fatalErrorSAXFunc) (void *ctx, const char *msg, ...)
  __attribute__ ((__format__ (__printf__, 2, 3)));
typedef int (*isStandaloneSAXFunc) (void *ctx);
typedef int (*hasInternalSubsetSAXFunc) (void *ctx);
typedef int (*hasExternalSubsetSAXFunc) (void *ctx);
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);
typedef void (*endElementNsSAX2Func) (void *ctx,
				      const xmlChar * localname,
				      const xmlChar * prefix,
				      const xmlChar * URI);


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;
  getParameterEntitySAXFunc getParameterEntity;
  cdataBlockSAXFunc cdataBlock;
  externalSubsetSAXFunc externalSubset;
  unsigned int initialized;

  void *_private;
  startElementNsSAX2Func startElementNs;
  endElementNsSAX2Func endElementNs;
  xmlStructuredErrorFunc serror;
};

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;
  getParameterEntitySAXFunc getParameterEntity;
  cdataBlockSAXFunc cdataBlock;
  externalSubsetSAXFunc externalSubset;
  unsigned int initialized;
};
typedef xmlParserInputPtr (*xmlExternalEntityLoader) (const char *URL,
						      const char *ID,
						      xmlParserCtxtPtr
						      context);

typedef void *iconv_t;
extern iconv_t iconv_open (const char *__tocode, const char *__fromcode);
extern size_t iconv (iconv_t __cd, char **__restrict __inbuf,
		     size_t * __restrict __inbytesleft,
		     char **__restrict __outbuf,
		     size_t * __restrict __outbytesleft);

extern int iconv_close (iconv_t __cd);
typedef int8_t UBool;
typedef short unsigned int UChar;
typedef int32_t UChar32;
typedef uint8_t UVersionInfo[4];

extern __attribute__ ((visibility ("default")))
void u_versionFromString_52 (UVersionInfo versionArray,
			     const char *versionString);
extern __attribute__ ((visibility ("default")))
void u_versionFromUString_52 (UVersionInfo versionArray,
			      const UChar * versionString);
extern __attribute__ ((visibility ("default")))
void u_versionToString_52 (const UVersionInfo versionArray,
			   char *versionString);
extern __attribute__ ((visibility ("default")))
void u_getVersion_52 (UVersionInfo versionArray);

extern const uint8_t utf8_countTrailBytes_52[256];
extern __attribute__ ((visibility ("default")))
UChar32 utf8_nextCharSafeBody_52 (const uint8_t * s, int32_t * pi, int32_t length,
				  UChar32 c, UBool strict);
extern __attribute__ ((visibility ("default")))
int32_t utf8_appendCharSafeBody_52 (uint8_t * s, int32_t i, int32_t length,
				    UChar32 c, UBool * pIsError);
extern __attribute__ ((visibility ("default")))
UChar32   utf8_prevCharSafeBody_52 (const uint8_t * s, int32_t start, int32_t * pi,
				    UChar32 c, UBool strict);
extern __attribute__ ((visibility ("default"))) int32_t
utf8_back1SafeBody_52 (const uint8_t * s, int32_t start, int32_t i);

typedef double UDate;

typedef enum UErrorCode {
  U_USING_FALLBACK_WARNING = -128,
  U_ERROR_WARNING_START = -128,
  U_USING_DEFAULT_WARNING = -127,
  U_SAFECLONE_ALLOCATED_WARNING = -126,
  U_STATE_OLD_WARNING = -125,
  U_STRING_NOT_TERMINATED_WARNING = -124,
  U_SORT_KEY_TOO_SHORT_WARNING = -123,
  U_AMBIGUOUS_ALIAS_WARNING = -122,
  U_DIFFERENT_UCA_VERSION = -121,
  U_PLUGIN_CHANGED_LEVEL_WARNING = -120,
  U_ERROR_WARNING_LIMIT,
  U_ZERO_ERROR = 0,
  U_ILLEGAL_ARGUMENT_ERROR = 1,
  U_MISSING_RESOURCE_ERROR = 2,
  U_INVALID_FORMAT_ERROR = 3,
  U_FILE_ACCESS_ERROR = 4,
  U_INTERNAL_PROGRAM_ERROR = 5,
  U_MESSAGE_PARSE_ERROR = 6,
  U_MEMORY_ALLOCATION_ERROR = 7,
  U_INDEX_OUTOFBOUNDS_ERROR = 8,
  U_PARSE_ERROR = 9,
  U_INVALID_CHAR_FOUND = 10,
  U_TRUNCATED_CHAR_FOUND = 11,
  U_ILLEGAL_CHAR_FOUND = 12,
  U_INVALID_TABLE_FORMAT = 13,
  U_INVALID_TABLE_FILE = 14,
  U_BUFFER_OVERFLOW_ERROR = 15,
  U_UNSUPPORTED_ERROR = 16,
  U_RESOURCE_TYPE_MISMATCH = 17,
  U_ILLEGAL_ESCAPE_SEQUENCE = 18,
  U_UNSUPPORTED_ESCAPE_SEQUENCE = 19,
  U_NO_SPACE_AVAILABLE = 20,
  U_CE_NOT_FOUND_ERROR = 21,
  U_PRIMARY_TOO_LONG_ERROR = 22,
  U_STATE_TOO_OLD_ERROR = 23,
  U_TOO_MANY_ALIASES_ERROR = 24,
  U_ENUM_OUT_OF_SYNC_ERROR = 25,
  U_INVARIANT_CONVERSION_ERROR = 26,
  U_INVALID_STATE_ERROR = 27,
  U_COLLATOR_VERSION_MISMATCH = 28,
  U_USELESS_COLLATOR_ERROR = 29,
  U_NO_WRITE_PERMISSION = 30,
  U_STANDARD_ERROR_LIMIT,
  U_BAD_VARIABLE_DEFINITION = 0x10000,
  U_PARSE_ERROR_START = 0x10000,
  U_MALFORMED_RULE,
  U_MALFORMED_SET,
  U_MALFORMED_SYMBOL_REFERENCE,
  U_MALFORMED_UNICODE_ESCAPE,
  U_MALFORMED_VARIABLE_DEFINITION,
  U_MALFORMED_VARIABLE_REFERENCE,
  U_MISMATCHED_SEGMENT_DELIMITERS,
  U_MISPLACED_ANCHOR_START,
  U_MISPLACED_CURSOR_OFFSET,
  U_MISPLACED_QUANTIFIER,
  U_MISSING_OPERATOR,
  U_MISSING_SEGMENT_CLOSE,
  U_MULTIPLE_ANTE_CONTEXTS,
  U_MULTIPLE_CURSORS,
  U_MULTIPLE_POST_CONTEXTS,
  U_TRAILING_BACKSLASH,
  U_UNDEFINED_SEGMENT_REFERENCE,
  U_UNDEFINED_VARIABLE,
  U_UNQUOTED_SPECIAL,
  U_UNTERMINATED_QUOTE,
  U_RULE_MASK_ERROR,
  U_MISPLACED_COMPOUND_FILTER,
  U_MULTIPLE_COMPOUND_FILTERS,
  U_INVALID_RBT_SYNTAX,
  U_INVALID_PROPERTY_PATTERN,
  U_MALFORMED_PRAGMA,
  U_UNCLOSED_SEGMENT,
  U_ILLEGAL_CHAR_IN_SEGMENT,
  U_VARIABLE_RANGE_EXHAUSTED,
  U_VARIABLE_RANGE_OVERLAP,
  U_ILLEGAL_CHARACTER,
  U_INTERNAL_TRANSLITERATOR_ERROR,
  U_INVALID_ID,
  U_INVALID_FUNCTION,
  U_PARSE_ERROR_LIMIT,
  U_UNEXPECTED_TOKEN = 0x10100,
  U_FMT_PARSE_ERROR_START = 0x10100,
  U_MULTIPLE_DECIMAL_SEPARATORS,
  U_MULTIPLE_DECIMAL_SEPERATORS = U_MULTIPLE_DECIMAL_SEPARATORS,
  U_MULTIPLE_EXPONENTIAL_SYMBOLS,
  U_MALFORMED_EXPONENTIAL_PATTERN,
  U_MULTIPLE_PERCENT_SYMBOLS,
  U_MULTIPLE_PERMILL_SYMBOLS,
  U_MULTIPLE_PAD_SPECIFIERS,
  U_PATTERN_SYNTAX_ERROR,
  U_ILLEGAL_PAD_POSITION,
  U_UNMATCHED_BRACES,
  U_UNSUPPORTED_PROPERTY,
  U_UNSUPPORTED_ATTRIBUTE,
  U_ARGUMENT_TYPE_MISMATCH,
  U_DUPLICATE_KEYWORD,
  U_UNDEFINED_KEYWORD,
  U_DEFAULT_KEYWORD_MISSING,
  U_DECIMAL_NUMBER_SYNTAX_ERROR,
  U_FORMAT_INEXACT_ERROR,
  U_FMT_PARSE_ERROR_LIMIT,
  U_BRK_INTERNAL_ERROR = 0x10200,
  U_BRK_ERROR_START = 0x10200,
  U_BRK_HEX_DIGITS_EXPECTED,
  U_BRK_SEMICOLON_EXPECTED,
  U_BRK_RULE_SYNTAX,
  U_BRK_UNCLOSED_SET,
  U_BRK_ASSIGN_ERROR,
  U_BRK_VARIABLE_REDFINITION,
  U_BRK_MISMATCHED_PAREN,
  U_BRK_NEW_LINE_IN_QUOTED_STRING,
  U_BRK_UNDEFINED_VARIABLE,
  U_BRK_INIT_ERROR,
  U_BRK_RULE_EMPTY_SET,
  U_BRK_UNRECOGNIZED_OPTION,
  U_BRK_MALFORMED_RULE_TAG,
  U_BRK_ERROR_LIMIT,
  U_REGEX_INTERNAL_ERROR = 0x10300,
  U_REGEX_ERROR_START = 0x10300,
  U_REGEX_RULE_SYNTAX,
  U_REGEX_INVALID_STATE,
  U_REGEX_BAD_ESCAPE_SEQUENCE,
  U_REGEX_PROPERTY_SYNTAX,
  U_REGEX_UNIMPLEMENTED,
  U_REGEX_MISMATCHED_PAREN,
  U_REGEX_NUMBER_TOO_BIG,
  U_REGEX_BAD_INTERVAL,
  U_REGEX_MAX_LT_MIN,
  U_REGEX_INVALID_BACK_REF,
  U_REGEX_INVALID_FLAG,
  U_REGEX_LOOK_BEHIND_LIMIT,
  U_REGEX_SET_CONTAINS_STRING,
  U_REGEX_OCTAL_TOO_BIG,
  U_REGEX_MISSING_CLOSE_BRACKET,
  U_REGEX_INVALID_RANGE,
  U_REGEX_STACK_OVERFLOW,
  U_REGEX_TIME_OUT,
  U_REGEX_STOPPED_BY_CALLER,
  U_REGEX_PATTERN_TOO_BIG,
  U_REGEX_ERROR_LIMIT,
  U_IDNA_PROHIBITED_ERROR = 0x10400,
  U_IDNA_ERROR_START = 0x10400,
  U_IDNA_UNASSIGNED_ERROR,
  U_IDNA_CHECK_BIDI_ERROR,
  U_IDNA_STD3_ASCII_RULES_ERROR,
  U_IDNA_ACE_PREFIX_ERROR,
  U_IDNA_VERIFICATION_ERROR,
  U_IDNA_LABEL_TOO_LONG_ERROR,
  U_IDNA_ZERO_LENGTH_LABEL_ERROR,
  U_IDNA_DOMAIN_NAME_TOO_LONG_ERROR,
  U_IDNA_ERROR_LIMIT,
  U_STRINGPREP_PROHIBITED_ERROR = U_IDNA_PROHIBITED_ERROR,
  U_STRINGPREP_UNASSIGNED_ERROR = U_IDNA_UNASSIGNED_ERROR,
  U_STRINGPREP_CHECK_BIDI_ERROR = U_IDNA_CHECK_BIDI_ERROR,
  U_PLUGIN_ERROR_START = 0x10500,
  U_PLUGIN_TOO_HIGH = 0x10500,
  U_PLUGIN_DIDNT_SET_LEVEL,
  U_PLUGIN_ERROR_LIMIT,
  U_ERROR_LIMIT = U_PLUGIN_ERROR_LIMIT
} UErrorCode;

extern __attribute__ ((visibility ("default")))
const char * u_errorName_52 (UErrorCode code);

struct UConverter;

typedef struct UConverter UConverter;
typedef enum {
  UCNV_UNASSIGNED = 0,
  UCNV_ILLEGAL = 1,
  UCNV_IRREGULAR = 2,
  UCNV_RESET = 3,
  UCNV_CLOSE = 4,
  UCNV_CLONE = 5
} UConverterCallbackReason;

typedef struct
{
  uint16_t size;
  UBool flush;
  UConverter *converter;
  const UChar *source;
  const UChar *sourceLimit;
  char *target;
  const char *targetLimit;
  int32_t * offsets;
} UConverterFromUnicodeArgs;

typedef struct
{
  uint16_t size;
  UBool flush;
  UConverter *converter;
  const char *source;
  const char *sourceLimit;
  UChar *target;
  const UChar *targetLimit;
  int32_t *offsets;
} UConverterToUnicodeArgs;

extern __attribute__ ((visibility ("default")))
void UCNV_FROM_U_CALLBACK_STOP_52 (const void *context,
				   UConverterFromUnicodeArgs * fromUArgs,
				   const UChar * codeUnits,
				   int32_t length,
				   UChar32 codePoint,
				   UConverterCallbackReason reason,
				   UErrorCode * err);

extern __attribute__ ((visibility ("default")))
void UCNV_TO_U_CALLBACK_STOP_52 (const void *context,
				 UConverterToUnicodeArgs * toUArgs,
				 const char *codeUnits,
				 int32_t length,
				 UConverterCallbackReason reason,
				 UErrorCode * err);

extern __attribute__ ((visibility ("default")))
void UCNV_FROM_U_CALLBACK_SKIP_52 (const void *context,
				   UConverterFromUnicodeArgs * fromUArgs,
				   const UChar * codeUnits,
				   int32_t length,
				   UChar32 codePoint,
				   UConverterCallbackReason reason,
				   UErrorCode * err);

extern __attribute__ ((visibility ("default")))
void UCNV_FROM_U_CALLBACK_SUBSTITUTE_52 (const void *context,
					 UConverterFromUnicodeArgs *
					 fromUArgs, const UChar * codeUnits,
					 int32_t length, UChar32 codePoint,
					 UConverterCallbackReason reason,
					 UErrorCode * err);

extern __attribute__ ((visibility ("default")))
void UCNV_FROM_U_CALLBACK_ESCAPE_52 (const void *context,
				     UConverterFromUnicodeArgs * fromUArgs,
				     const UChar * codeUnits,
				     int32_t length,
				     UChar32 codePoint,
				     UConverterCallbackReason reason,
				     UErrorCode * err);

extern __attribute__ ((visibility ("default")))
void UCNV_TO_U_CALLBACK_SKIP_52 (const void *context,
				 UConverterToUnicodeArgs * toUArgs,
				 const char *codeUnits,
				 int32_t length,
				 UConverterCallbackReason reason,
				 UErrorCode * err);

extern __attribute__ ((visibility ("default")))
void UCNV_TO_U_CALLBACK_SUBSTITUTE_52 (const void *context,
				       UConverterToUnicodeArgs * toUArgs,
				       const char *codeUnits,
				       int32_t length,
				       UConverterCallbackReason reason,
				       UErrorCode * err);

extern __attribute__ ((visibility ("default")))
void UCNV_TO_U_CALLBACK_ESCAPE_52 (const void *context,
				   UConverterToUnicodeArgs * toUArgs,
				   const char *codeUnits,
				   int32_t length,
				   UConverterCallbackReason reason,
				   UErrorCode * err);
struct UEnumeration;

typedef struct UEnumeration UEnumeration;

extern __attribute__ ((visibility ("default")))
void uenum_close_52 (UEnumeration * en);

extern __attribute__ ((visibility ("default")))
int32_t uenum_count_52 (UEnumeration * en, UErrorCode * status);

extern __attribute__ ((visibility ("default")))
const UChar *uenum_unext_52 (UEnumeration * en,
			     int32_t * resultLength, UErrorCode * status);

extern __attribute__ ((visibility ("default")))
const char *uenum_next_52 (UEnumeration * en,
			   int32_t * resultLength, UErrorCode * status);

extern __attribute__ ((visibility ("default")))
void uenum_reset_52 (UEnumeration * en, UErrorCode * status);

extern __attribute__ ((visibility ("default")))
UEnumeration *uenum_openUCharStringsEnumeration_52 (const UChar * const strings[],
						    int32_t count, UErrorCode * ec);

extern __attribute__ ((visibility ("default")))
UEnumeration *uenum_openCharStringsEnumeration_52 (const char *const strings[],
						   int32_t count, UErrorCode * ec);

struct USet;
typedef struct USet USet;

typedef enum {
  UCNV_UNSUPPORTED_CONVERTER = -1,
  UCNV_SBCS = 0,
  UCNV_DBCS = 1,
  UCNV_MBCS = 2,
  UCNV_LATIN_1 = 3,
  UCNV_UTF8 = 4,
  UCNV_UTF16_BigEndian = 5,
  UCNV_UTF16_LittleEndian = 6,
  UCNV_UTF32_BigEndian = 7,
  UCNV_UTF32_LittleEndian = 8,
  UCNV_EBCDIC_STATEFUL = 9,
  UCNV_ISO_2022 = 10,
  UCNV_LMBCS_1 = 11,
  UCNV_LMBCS_2,
  UCNV_LMBCS_3,
  UCNV_LMBCS_4,
  UCNV_LMBCS_5,
  UCNV_LMBCS_6,
  UCNV_LMBCS_8,
  UCNV_LMBCS_11,
  UCNV_LMBCS_16,
  UCNV_LMBCS_17,
  UCNV_LMBCS_18,
  UCNV_LMBCS_19,
  UCNV_LMBCS_LAST = UCNV_LMBCS_19,
  UCNV_HZ,
  UCNV_SCSU,
  UCNV_ISCII,
  UCNV_US_ASCII,
  UCNV_UTF7,
  UCNV_BOCU1,
  UCNV_UTF16,
  UCNV_UTF32,
  UCNV_CESU8,
  UCNV_IMAP_MAILBOX,
  UCNV_COMPOUND_TEXT,
  UCNV_NUMBER_OF_SUPPORTED_CONVERTER_TYPES
} UConverterType;

typedef enum {
  UCNV_UNKNOWN = -1,
  UCNV_IBM = 0
} UConverterPlatform;

typedef void (*UConverterToUCallback) (const void *context,
				       UConverterToUnicodeArgs * args,
				       const char *codeUnits,
				       int32_t length,
				       UConverterCallbackReason reason,
				       UErrorCode * pErrorCode);

typedef void (*UConverterFromUCallback) (const void *context,
					 UConverterFromUnicodeArgs *
					 args, const UChar * codeUnits,
					 int32_t length,
					 UChar32 codePoint,
					 UConverterCallbackReason reason,
					 UErrorCode * pErrorCode);

extern __attribute__ ((visibility ("default")))
int ucnv_compareNames_52 (const char *name1, const char *name2);

extern __attribute__ ((visibility ("default")))
UConverter *ucnv_open_52 (const char *converterName, UErrorCode * err);

extern __attribute__ ((visibility ("default")))
UConverter *ucnv_openU_52 (const UChar * name, UErrorCode * err);

extern __attribute__ ((visibility ("default")))
UConverter *ucnv_openCCSID_52 (int32_t codepage,
			       UConverterPlatform platform, UErrorCode * err);

extern __attribute__ ((visibility ("default")))
UConverter *ucnv_openPackage_52 (const char *packageName, const char *converterName,
				 UErrorCode * err);
extern __attribute__ ((visibility ("default")))
UConverter *
ucnv_safeClone_52 (const UConverter * cnv,
		   void *stackBuffer,
		   int32_t * pBufferSize, UErrorCode * status);
extern __attribute__ ((visibility ("default")))
void
ucnv_close_52 (UConverter * converter);
extern __attribute__ ((visibility ("default")))
void
ucnv_getSubstChars_52 (const UConverter * converter,
		       char *subChars, int8_t * len, UErrorCode * err);
extern __attribute__ ((visibility ("default")))
void
ucnv_setSubstChars_52 (UConverter * converter,
		       const char *subChars,
		       int8_t len, UErrorCode * err);
extern __attribute__ ((visibility ("default")))
void
ucnv_setSubstString_52 (UConverter * cnv,
			const UChar * s,
			int32_t length, UErrorCode * err);
extern __attribute__ ((visibility ("default")))
void
ucnv_getInvalidChars_52 (const UConverter * converter,
			 char *errBytes, int8_t * len, UErrorCode * err);
extern __attribute__ ((visibility ("default")))
void
ucnv_getInvalidUChars_52 (const UConverter * converter,
			  UChar * errUChars,
			  int8_t * len, UErrorCode * err);
extern __attribute__ ((visibility ("default")))
void
ucnv_reset_52 (UConverter * converter);
extern __attribute__ ((visibility ("default")))
void
ucnv_resetToUnicode_52 (UConverter * converter);
extern __attribute__ ((visibility ("default")))
void
ucnv_resetFromUnicode_52 (UConverter * converter);
extern __attribute__ ((visibility ("default"))) int8_t
ucnv_getMaxCharSize_52 (const UConverter * converter);
extern __attribute__ ((visibility ("default"))) int8_t
ucnv_getMinCharSize_52 (const UConverter * converter);
extern __attribute__ ((visibility ("default"))) int32_t
ucnv_getDisplayName_52 (const UConverter * converter,
			const char *displayLocale,
			UChar * displayName,
			int32_t displayNameCapacity, UErrorCode * err);
extern __attribute__ ((visibility ("default")))
const char *
ucnv_getName_52 (const UConverter * converter, UErrorCode * err);
extern __attribute__ ((visibility ("default"))) int32_t
ucnv_getCCSID_52 (const UConverter * converter, UErrorCode * err);
extern __attribute__ ((visibility ("default"))) UConverterPlatform
ucnv_getPlatform_52 (const UConverter * converter, UErrorCode * err);
extern __attribute__ ((visibility ("default"))) UConverterType
ucnv_getType_52 (const UConverter * converter);
extern __attribute__ ((visibility ("default")))
void
ucnv_getStarters_52 (const UConverter * converter,
		     UBool starters[256], UErrorCode * err);

typedef enum UConverterUnicodeSet {

  UCNV_ROUNDTRIP_SET,

  UCNV_ROUNDTRIP_AND_FALLBACK_SET,

  UCNV_SET_COUNT
} UConverterUnicodeSet;
extern __attribute__ ((visibility ("default")))
void
ucnv_getUnicodeSet_52 (const UConverter * cnv,
		       USet * setFillIn,
		       UConverterUnicodeSet whichSet,
		       UErrorCode * pErrorCode);
extern __attribute__ ((visibility ("default")))
void
ucnv_getToUCallBack_52 (const UConverter * converter,
			UConverterToUCallback * action,
			const void **context);
extern __attribute__ ((visibility ("default")))
void
ucnv_getFromUCallBack_52 (const UConverter * converter,
			  UConverterFromUCallback * action,
			  const void **context);
extern __attribute__ ((visibility ("default")))
void
ucnv_setToUCallBack_52 (UConverter * converter,
			UConverterToUCallback newAction,
			const void *newContext,
			UConverterToUCallback * oldAction,
			const void **oldContext, UErrorCode * err);
extern __attribute__ ((visibility ("default")))
void
ucnv_setFromUCallBack_52 (UConverter * converter,
			  UConverterFromUCallback newAction,
			  const void *newContext,
			  UConverterFromUCallback * oldAction,
			  const void **oldContext, UErrorCode * err);
extern __attribute__ ((visibility ("default")))
void
ucnv_fromUnicode_52 (UConverter * converter,
		     char **target,
		     const char *targetLimit,
		     const UChar ** source,
		     const UChar * sourceLimit,
		     int32_t * offsets, UBool flush, UErrorCode * err);
extern __attribute__ ((visibility ("default")))
void
ucnv_toUnicode_52 (UConverter * converter,
		   UChar ** target,
		   const UChar * targetLimit,
		   const char **source,
		   const char *sourceLimit,
		   int32_t * offsets, UBool flush, UErrorCode * err);
extern __attribute__ ((visibility ("default"))) int32_t
ucnv_fromUChars_52 (UConverter * cnv,
		    char *dest, int32_t destCapacity,
		    const UChar * src, int32_t srcLength,
		    UErrorCode * pErrorCode);
extern __attribute__ ((visibility ("default"))) int32_t
ucnv_toUChars_52 (UConverter * cnv,
		  UChar * dest, int32_t destCapacity,
		  const char *src, int32_t srcLength,
		  UErrorCode * pErrorCode);
extern __attribute__ ((visibility ("default"))) UChar32
ucnv_getNextUChar_52 (UConverter * converter,
		      const char **source,
		      const char *sourceLimit, UErrorCode * err);
extern __attribute__ ((visibility ("default")))
void
ucnv_convertEx_52 (UConverter * targetCnv, UConverter * sourceCnv,
		   char **target, const char *targetLimit,
		   const char **source, const char *sourceLimit,
		   UChar * pivotStart, UChar ** pivotSource,
		   UChar ** pivotTarget, const UChar * pivotLimit,
		   UBool reset, UBool flush, UErrorCode * pErrorCode);
extern __attribute__ ((visibility ("default"))) int32_t
ucnv_convert_52 (const char *toConverterName,
		 const char *fromConverterName,
		 char *target,
		 int32_t targetCapacity,
		 const char *source,
		 int32_t sourceLength, UErrorCode * pErrorCode);
extern __attribute__ ((visibility ("default"))) int32_t
ucnv_toAlgorithmic_52 (UConverterType algorithmicType,
		       UConverter * cnv,
		       char *target, int32_t targetCapacity,
		       const char *source, int32_t sourceLength,
		       UErrorCode * pErrorCode);
extern __attribute__ ((visibility ("default"))) int32_t
ucnv_fromAlgorithmic_52 (UConverter * cnv,
			 UConverterType algorithmicType,
			 char *target, int32_t targetCapacity,
			 const char *source, int32_t sourceLength,
			 UErrorCode * pErrorCode);
extern __attribute__ ((visibility ("default"))) int32_t
ucnv_flushCache_52 (void);
extern __attribute__ ((visibility ("default"))) int32_t
ucnv_countAvailable_52 (void);
extern __attribute__ ((visibility ("default")))
const char *
ucnv_getAvailableName_52 (int32_t n);
extern __attribute__ ((visibility ("default")))
UEnumeration *
ucnv_openAllNames_52 (UErrorCode * pErrorCode);
extern __attribute__ ((visibility ("default"))) uint16_t
ucnv_countAliases_52 (const char *alias, UErrorCode * pErrorCode);
extern __attribute__ ((visibility ("default")))
const char *
ucnv_getAlias_52 (const char *alias, uint16_t n,
		  UErrorCode * pErrorCode);
extern __attribute__ ((visibility ("default")))
void
ucnv_getAliases_52 (const char *alias, const char **aliases,
		    UErrorCode * pErrorCode);
extern __attribute__ ((visibility ("default")))
UEnumeration *
ucnv_openStandardNames_52 (const char *convName,
			   const char *standard,
			   UErrorCode * pErrorCode);






extern __attribute__ ((visibility ("default"))) uint16_t
ucnv_countStandards_52 (void);
extern __attribute__ ((visibility ("default")))
const char *
ucnv_getStandard_52 (uint16_t n, UErrorCode * pErrorCode);
extern __attribute__ ((visibility ("default")))
const char *
ucnv_getStandardName_52 (const char *name, const char *standard,
			 UErrorCode * pErrorCode);
extern __attribute__ ((visibility ("default")))
const char *
ucnv_getCanonicalName_52 (const char *alias, const char *standard,
			  UErrorCode * pErrorCode);
extern __attribute__ ((visibility ("default")))
const char *
ucnv_getDefaultName_52 (void);
extern __attribute__ ((visibility ("default")))
void
ucnv_setDefaultName_52 (const char *name);
extern __attribute__ ((visibility ("default")))
void
ucnv_fixFileSeparator_52 (const UConverter * cnv, UChar * source,
			  int32_t sourceLen);
extern
__attribute__ ((visibility ("default"))) UBool
ucnv_isAmbiguous_52 (const UConverter * cnv);
extern __attribute__ ((visibility ("default")))
void
ucnv_setFallback_52 (UConverter * cnv, UBool usesFallback);
extern __attribute__ ((visibility ("default"))) UBool
ucnv_usesFallback_52 (const UConverter * cnv);
extern __attribute__ ((visibility ("default")))
const char *
ucnv_detectUnicodeSignature_52 (const char *source,
				int32_t sourceLength,
				int32_t * signatureLength,
				UErrorCode * pErrorCode);
extern __attribute__ ((visibility ("default"))) int32_t
ucnv_fromUCountPending_52 (const UConverter * cnv, UErrorCode * status);
extern __attribute__ ((visibility ("default"))) int32_t
ucnv_toUCountPending_52 (const UConverter * cnv, UErrorCode * status);
extern __attribute__ ((visibility ("default"))) UBool
ucnv_isFixedWidth_52 (UConverter * cnv, UErrorCode * status);

typedef enum
  {
    XML_CHAR_ENCODING_ERROR = -1,
    XML_CHAR_ENCODING_NONE = 0,
    XML_CHAR_ENCODING_UTF8 = 1,
    XML_CHAR_ENCODING_UTF16LE = 2,
    XML_CHAR_ENCODING_UTF16BE = 3,
    XML_CHAR_ENCODING_UCS4LE = 4,
    XML_CHAR_ENCODING_UCS4BE = 5,
    XML_CHAR_ENCODING_EBCDIC = 6,
    XML_CHAR_ENCODING_UCS4_2143 = 7,
    XML_CHAR_ENCODING_UCS4_3412 = 8,
    XML_CHAR_ENCODING_UCS2 = 9,
    XML_CHAR_ENCODING_8859_1 = 10,
    XML_CHAR_ENCODING_8859_2 = 11,
    XML_CHAR_ENCODING_8859_3 = 12,
    XML_CHAR_ENCODING_8859_4 = 13,
    XML_CHAR_ENCODING_8859_5 = 14,
    XML_CHAR_ENCODING_8859_6 = 15,
    XML_CHAR_ENCODING_8859_7 = 16,
    XML_CHAR_ENCODING_8859_8 = 17,
    XML_CHAR_ENCODING_8859_9 = 18,
    XML_CHAR_ENCODING_2022_JP = 19,
    XML_CHAR_ENCODING_SHIFT_JIS = 20,
    XML_CHAR_ENCODING_EUC_JP = 21,
    XML_CHAR_ENCODING_ASCII = 22
  } xmlCharEncoding;
typedef int (*xmlCharEncodingInputFunc) (unsigned char *out, int *outlen,
					 const unsigned char *in,
					 int *inlen);
typedef int (*xmlCharEncodingOutputFunc) (unsigned char *out,
					  int *outlen,
					  const unsigned char *in,
					  int *inlen);







struct _uconv_t
{
  UConverter *
  uconv;
  UConverter *
  utf8;
};
typedef struct _uconv_t
uconv_t;


typedef struct _xmlCharEncodingHandler
xmlCharEncodingHandler;
typedef xmlCharEncodingHandler *
xmlCharEncodingHandlerPtr;
struct _xmlCharEncodingHandler
{
  char *
  name;
  xmlCharEncodingInputFunc
  input;
  xmlCharEncodingOutputFunc
  output;

  iconv_t
  iconv_in;
  iconv_t
  iconv_out;


  uconv_t *
  uconv_in;
  uconv_t *
  uconv_out;

};
void
xmlInitCharEncodingHandlers (void);
void
xmlCleanupCharEncodingHandlers (void);
void
xmlRegisterCharEncodingHandler (xmlCharEncodingHandlerPtr handler);
xmlCharEncodingHandlerPtr
xmlGetCharEncodingHandler (xmlCharEncoding enc);
xmlCharEncodingHandlerPtr
xmlFindCharEncodingHandler (const char *name);
xmlCharEncodingHandlerPtr
xmlNewCharEncodingHandler (const char *name,
			   xmlCharEncodingInputFunc input,
			   xmlCharEncodingOutputFunc output);




int xmlAddEncodingAlias (const char *name, const char *alias);
int xmlDelEncodingAlias (const char *alias);
const char *xmlGetEncodingAlias (const char *alias);
void xmlCleanupEncodingAliases (void);
xmlCharEncoding
xmlParseCharEncoding (const char *name);
const char *xmlGetCharEncodingName (xmlCharEncoding enc);




xmlCharEncoding
xmlDetectCharEncoding (const unsigned char *in, int len);

int
xmlCharEncOutFunc (xmlCharEncodingHandler * handler,
		   xmlBufferPtr out, xmlBufferPtr in);

int
xmlCharEncInFunc (xmlCharEncodingHandler * handler,
		  xmlBufferPtr out, xmlBufferPtr in);
int
xmlCharEncFirstLine (xmlCharEncodingHandler * handler,
		     xmlBufferPtr out, xmlBufferPtr in);
int xmlCharEncCloseFunc (xmlCharEncodingHandler * handler);





int
UTF8Toisolat1 (unsigned char *out,
	       int *outlen, const unsigned char *in, int *inlen);

int
isolat1ToUTF8 (unsigned char *out,
	       int *outlen, const unsigned char *in, int *inlen);
typedef int (*xmlInputMatchCallback) (char const *filename);
typedef void *(*xmlInputOpenCallback) (char const *filename);
typedef int (*xmlInputReadCallback) (void *context, char *buffer,
				     int len);
typedef int (*xmlInputCloseCallback) (void *context);
typedef int (*xmlOutputMatchCallback) (char const *filename);
typedef void *(*xmlOutputOpenCallback) (char const *filename);
typedef int (*xmlOutputWriteCallback) (void *context, const char *buffer,
				       int len);
typedef int (*xmlOutputCloseCallback) (void *context);







typedef xmlChar *xlinkHRef;
typedef xmlChar *xlinkRole;
typedef xmlChar *xlinkTitle;