Index: gcc/config/rs6000/predicates.md =================================================================== --- gcc/config/rs6000/predicates.md (revision 221194) +++ gcc/config/rs6000/predicates.md (working copy) @@ -432,9 +432,6 @@ (define_predicate "vsx_reg_or_cint_opera (define_predicate "easy_fp_constant" (match_code "const_double") { - long k[4]; - REAL_VALUE_TYPE rv; - if (GET_MODE (op) != mode || (!SCALAR_FLOAT_MODE_P (mode) && mode != DImode)) return 0; @@ -446,8 +443,7 @@ (define_predicate "easy_fp_constant" return 1; /* The constant 0.0 is easy under VSX. */ - if ((mode == SFmode || mode == DFmode || mode == SDmode || mode == DDmode) - && VECTOR_UNIT_VSX_P (DFmode) && op == CONST0_RTX (mode)) + if (TARGET_VSX && SCALAR_FLOAT_MODE_P (mode) && op == CONST0_RTX (mode)) return 1; if (DECIMAL_FLOAT_MODE_P (mode)) @@ -464,82 +460,28 @@ (define_predicate "easy_fp_constant" return 0; #endif + /* If we have real FPRs, consider floating point constants hard (other than + 0.0 under VSX), so that the constant gets pushed to memory during the + early RTL phases. This has the advantage that double precision constants + that can be represented in single precision without a loss of precision + will use single precision loads. */ + switch (mode) { case TFmode: - if (TARGET_E500_DOUBLE) - return 0; - - REAL_VALUE_FROM_CONST_DOUBLE (rv, op); - REAL_VALUE_TO_TARGET_LONG_DOUBLE (rv, k); - - return (num_insns_constant_wide ((HOST_WIDE_INT) k[0]) == 1 - && num_insns_constant_wide ((HOST_WIDE_INT) k[1]) == 1 - && num_insns_constant_wide ((HOST_WIDE_INT) k[2]) == 1 - && num_insns_constant_wide ((HOST_WIDE_INT) k[3]) == 1); - case DFmode: - /* Force constants to memory before reload to utilize - compress_float_constant. - Avoid this when flag_unsafe_math_optimizations is enabled - because RDIV division to reciprocal optimization is not able - to regenerate the division. */ - if (TARGET_E500_DOUBLE - || (!reload_in_progress && !reload_completed - && !flag_unsafe_math_optimizations)) - return 0; - - REAL_VALUE_FROM_CONST_DOUBLE (rv, op); - REAL_VALUE_TO_TARGET_DOUBLE (rv, k); - - return (num_insns_constant_wide ((HOST_WIDE_INT) k[0]) == 1 - && num_insns_constant_wide ((HOST_WIDE_INT) k[1]) == 1); - case SFmode: - /* Force constants to memory before reload to utilize - compress_float_constant. - Avoid this when flag_unsafe_math_optimizations is enabled - because RDIV division to reciprocal optimization is not able - to regenerate the division. */ - if (!reload_in_progress && !reload_completed - && !flag_unsafe_math_optimizations) - return 0; - - REAL_VALUE_FROM_CONST_DOUBLE (rv, op); - REAL_VALUE_TO_TARGET_SINGLE (rv, k[0]); - - return num_insns_constant_wide (k[0]) == 1; - - case DImode: - return (num_insns_constant (op, DImode) <= 2); - - case SImode: - return 1; - - default: - gcc_unreachable (); - } -}) + return 0; -;; Return 1 if the operand must be loaded from memory. This is used by a -;; define_split to insure constants get pushed to the constant pool before -;; reload. If -ffast-math is used, easy_fp_constant will allow move insns to -;; have constants in order not interfere with reciprocal estimation. However, -;; with -mupper-regs support, these constants must be moved to the constant -;; pool before register allocation. + case DImode: + return (num_insns_constant (op, DImode) <= 2); -(define_predicate "memory_fp_constant" - (match_code "const_double") -{ - if (TARGET_VSX && op == CONST0_RTX (mode)) - return 0; + case SImode: + return 1; - if (!TARGET_HARD_FLOAT || !TARGET_FPRS - || (mode == SFmode && !TARGET_SINGLE_FLOAT) - || (mode == DFmode && !TARGET_DOUBLE_FLOAT)) - return 0; - - return 1; + default: + gcc_unreachable (); + } }) ;; Return 1 if the operand is a CONST_VECTOR and can be loaded into a Index: gcc/config/rs6000/rs6000.md =================================================================== --- gcc/config/rs6000/rs6000.md (revision 221194) +++ gcc/config/rs6000/rs6000.md (working copy) @@ -8048,8 +8048,8 @@ (define_split }") (define_insn "mov_hardfloat" - [(set (match_operand:FMOVE32 0 "nonimmediate_operand" "=!r,!r,m,f,,,,,,Z,?,?r,*c*l,!r,*h,!r,!r") - (match_operand:FMOVE32 1 "input_operand" "r,m,r,f,,j,,,Z,,r,,r,h,0,G,Fn"))] + [(set (match_operand:FMOVE32 0 "nonimmediate_operand" "=!r,!r,m,f,,,!r,,,,Z,?,?r,*c*l,!r,*h") + (match_operand:FMOVE32 1 "input_operand" "r,m,r,f,,j,j,,,Z,,r,,r,h,0"))] "(gpc_reg_operand (operands[0], mode) || gpc_reg_operand (operands[1], mode)) && (TARGET_HARD_FLOAT && TARGET_FPRS && TARGET_SINGLE_FLOAT)" @@ -8060,6 +8060,7 @@ (define_insn "mov_hardfloat" fmr %0,%1 xxlor %x0,%x1,%x1 xxlxor %x0,%x0,%x0 + li %0,0 @@ -8068,11 +8069,9 @@ (define_insn "mov_hardfloat" mfvsrwz %0,%x1 mt%0 %1 mf%1 %0 - nop - # - #" - [(set_attr "type" "*,load,store,fp,vecsimple,vecsimple,fpload,fpstore,fpload,fpstore,mftgpr,mffgpr,mtjmpr,mfjmpr,*,*,*") - (set_attr "length" "4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,8")]) + nop" + [(set_attr "type" "*,load,store,fp,vecsimple,vecsimple,integer,fpload,fpstore,fpload,fpstore,mftgpr,mffgpr,mtjmpr,mfjmpr,*") + (set_attr "length" "4")]) (define_insn "*mov_softfloat" [(set (match_operand:FMOVE32 0 "nonimmediate_operand" "=r,cl,r,r,m,r,r,r,r,*h") @@ -8186,9 +8185,12 @@ (define_split ;; since the D-form version of the memory instructions does not need a GPR for ;; reloading. +;; If we have FPR registers, rs6000_emit_move has moved all constants to memory, +;; except for 0.0 which can be created on VSX with an xor instruction. + (define_insn "*mov_hardfloat32" - [(set (match_operand:FMOVE64 0 "nonimmediate_operand" "=m,d,d,,Z,,,Y,r,!r,!r,!r,!r") - (match_operand:FMOVE64 1 "input_operand" "d,m,d,Z,,,j,r,Y,r,G,H,F"))] + [(set (match_operand:FMOVE64 0 "nonimmediate_operand" "=m,d,d,,Z,,,!r,Y,r,!r") + (match_operand:FMOVE64 1 "input_operand" "d,m,d,Z,,,j,j,r,Y,r"))] "! TARGET_POWERPC64 && TARGET_HARD_FLOAT && TARGET_FPRS && TARGET_DOUBLE_FLOAT && (gpc_reg_operand (operands[0], mode) || gpc_reg_operand (operands[1], mode))" @@ -8203,11 +8205,9 @@ (define_insn "*mov_hardfloat32" # # # - # - # #" - [(set_attr "type" "fpstore,fpload,fp,fpload,fpstore,vecsimple,vecsimple,store,load,two,fp,fp,*") - (set_attr "length" "4,4,4,4,4,4,4,8,8,8,8,12,16")]) + [(set_attr "type" "fpstore,fpload,fp,fpload,fpstore,vecsimple,vecsimple,two,store,load,two") + (set_attr "length" "4,4,4,4,4,4,4,8,8,8,8")]) (define_insn "*mov_softfloat32" [(set (match_operand:FMOVE64 0 "nonimmediate_operand" "=Y,r,r,r,r,r") @@ -8225,8 +8225,8 @@ (define_insn "*mov_softfloat32" ; ld/std require word-aligned displacements -> 'Y' constraint. ; List Y->r and r->Y before r->r for reload. (define_insn "*mov_hardfloat64" - [(set (match_operand:FMOVE64 0 "nonimmediate_operand" "=m,d,d,,Z,,,Y,r,!r,*c*l,!r,*h,!r,!r,!r,r,wg,r,") - (match_operand:FMOVE64 1 "input_operand" "d,m,d,Z,,,j,r,Y,r,r,h,0,G,H,F,wg,r,,r"))] + [(set (match_operand:FMOVE64 0 "nonimmediate_operand" "=m,d,d,,Z,,,!r,Y,r,!r,*c*l,!r,*h,r,wg,r,") + (match_operand:FMOVE64 1 "input_operand" "d,m,d,Z,,,j,j,r,Y,r,r,h,0,wg,r,,r"))] "TARGET_POWERPC64 && TARGET_HARD_FLOAT && TARGET_FPRS && TARGET_DOUBLE_FLOAT && (gpc_reg_operand (operands[0], mode) || gpc_reg_operand (operands[1], mode))" @@ -8238,21 +8238,19 @@ (define_insn "*mov_hardfloat64" stxsd%U0x %x1,%y0 xxlor %x0,%x1,%x1 xxlxor %x0,%x0,%x0 + li %0,0 std%U0%X0 %1,%0 ld%U1%X1 %0,%1 mr %0,%1 mt%0 %1 mf%1 %0 nop - # - # - # mftgpr %0,%1 mffgpr %0,%1 mfvsrd %0,%x1 mtvsrd %x0,%1" - [(set_attr "type" "fpstore,fpload,fp,fpload,fpstore,vecsimple,vecsimple,store,load,*,mtjmpr,mfjmpr,*,*,*,*,mftgpr,mffgpr,mftgpr,mffgpr") - (set_attr "length" "4,4,4,4,4,4,4,4,4,4,4,4,4,8,12,16,4,4,4,4")]) + [(set_attr "type" "fpstore,fpload,fp,fpload,fpstore,vecsimple,vecsimple,integer,store,load,*,mtjmpr,mfjmpr,*,mftgpr,mffgpr,mftgpr,mffgpr") + (set_attr "length" "4")]) (define_insn "*mov_softfloat64" [(set (match_operand:FMOVE64 0 "nonimmediate_operand" "=Y,r,r,cl,r,r,r,r,*h") @@ -8289,7 +8287,7 @@ (define_expand "mov" (define_insn_and_split "*mov_64bit_dm" [(set (match_operand:FMOVE128 0 "nonimmediate_operand" "=m,d,d,ws,Y,r,r,r,wm") - (match_operand:FMOVE128 1 "input_operand" "d,m,d,j,r,jYGHF,r,wm,r"))] + (match_operand:FMOVE128 1 "input_operand" "d,m,d,j,r,jY,r,wm,r"))] "TARGET_HARD_FLOAT && TARGET_FPRS && TARGET_POWERPC64 && (mode != TDmode || WORDS_BIG_ENDIAN) && (gpc_reg_operand (operands[0], mode) @@ -8302,7 +8300,7 @@ (define_insn_and_split "*mov_64bit (define_insn_and_split "*movtd_64bit_nodm" [(set (match_operand:TD 0 "nonimmediate_operand" "=m,d,d,ws,Y,r,r") - (match_operand:TD 1 "input_operand" "d,m,d,j,r,jYGHF,r"))] + (match_operand:TD 1 "input_operand" "d,m,d,j,r,jY,r"))] "TARGET_HARD_FLOAT && TARGET_FPRS && TARGET_POWERPC64 && !WORDS_BIG_ENDIAN && (gpc_reg_operand (operands[0], TDmode) || gpc_reg_operand (operands[1], TDmode))" @@ -8314,7 +8312,7 @@ (define_insn_and_split "*movtd_64bit_nod (define_insn_and_split "*mov_32bit" [(set (match_operand:FMOVE128 0 "nonimmediate_operand" "=m,d,d,ws,Y,r,r") - (match_operand:FMOVE128 1 "input_operand" "d,m,d,j,r,jYGHF,r"))] + (match_operand:FMOVE128 1 "input_operand" "d,m,d,j,r,jY,r"))] "TARGET_HARD_FLOAT && TARGET_FPRS && !TARGET_POWERPC64 && (gpc_reg_operand (operands[0], mode) || gpc_reg_operand (operands[1], mode))" @@ -8336,21 +8334,6 @@ (define_insn_and_split "*mov_softf { rs6000_split_multireg_move (operands[0], operands[1]); DONE; } [(set_attr "length" "20,20,16")]) -;; If we are using -ffast-math, easy_fp_constant assumes all constants are -;; 'easy' in order to allow for reciprocal estimation. Make sure the constant -;; is in the constant pool before reload occurs. This simplifies accessing -;; scalars in the traditional Altivec registers. - -(define_split - [(set (match_operand:SFDF 0 "register_operand" "") - (match_operand:SFDF 1 "memory_fp_constant" ""))] - "TARGET__FPR && flag_unsafe_math_optimizations - && !reload_in_progress && !reload_completed && !lra_in_progress" - [(set (match_dup 0) (match_dup 2))] -{ - operands[2] = validize_mem (force_const_mem (mode, operands[1])); -}) - (define_expand "extenddftf2" [(set (match_operand:TF 0 "nonimmediate_operand" "") (float_extend:TF (match_operand:DF 1 "input_operand" "")))] @@ -8382,7 +8365,7 @@ (define_expand "extenddftf2_fprs" (define_insn_and_split "*extenddftf2_internal" [(set (match_operand:TF 0 "nonimmediate_operand" "=m,Y,d,&d,r") - (float_extend:TF (match_operand:DF 1 "input_operand" "d,r,md,md,rmGHF"))) + (float_extend:TF (match_operand:DF 1 "input_operand" "d,r,md,md,rm"))) (use (match_operand:DF 2 "zero_reg_mem_operand" "d,r,m,d,n"))] "!TARGET_IEEEQUAD && TARGET_HARD_FLOAT && TARGET_FPRS && TARGET_DOUBLE_FLOAT Index: gcc/testsuite/g++.dg/pr65240.h =================================================================== --- gcc/testsuite/g++.dg/pr65240.h (revision 0) +++ gcc/testsuite/g++.dg/pr65240.h (revision 0) @@ -0,0 +1,5518 @@ +// -*- C++ -*- + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +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; + +typedef enum + { + XLINK_TYPE_NONE = 0, + XLINK_TYPE_SIMPLE, + XLINK_TYPE_EXTENDED, + XLINK_TYPE_EXTENDED_SET + } xlinkType; + +typedef enum + { + XLINK_SHOW_NONE = 0, + XLINK_SHOW_NEW, + XLINK_SHOW_EMBED, + XLINK_SHOW_REPLACE + } xlinkShow; + +typedef enum + { + XLINK_ACTUATE_NONE = 0, + XLINK_ACTUATE_AUTO, + XLINK_ACTUATE_ONREQUEST + } xlinkActuate; +typedef void (*xlinkNodeDetectFunc) (void *ctx, xmlNodePtr node); +typedef void +(*xlinkSimpleLinkFunk) (void *ctx, + xmlNodePtr node, + const xlinkHRef href, + const xlinkRole role, const xlinkTitle title); +typedef void +(*xlinkExtendedLinkFunk) (void *ctx, + xmlNodePtr node, + int nbLocators, + const xlinkHRef * hrefs, + const xlinkRole * roles, + int nbArcs, + const xlinkRole * from, + const xlinkRole * to, + xlinkShow * show, + xlinkActuate * actuate, + int nbTitles, + const xlinkTitle * titles, + const xmlChar ** langs); +typedef void +(*xlinkExtendedLinkSetFunk) (void *ctx, + xmlNodePtr node, + int nbLocators, + const xlinkHRef * hrefs, + const xlinkRole * roles, + int nbTitles, + const xlinkTitle * titles, + const xmlChar ** langs); + + + + + + + +typedef struct _xlinkHandler xlinkHandler; +typedef xlinkHandler *xlinkHandlerPtr; +struct _xlinkHandler +{ + xlinkSimpleLinkFunk simple; + xlinkExtendedLinkFunk extended; + xlinkExtendedLinkSetFunk set; +}; + + + + + + +xlinkNodeDetectFunc +xlinkGetDefaultDetect (void); +void xlinkSetDefaultDetect (xlinkNodeDetectFunc func); + + + + +xlinkHandlerPtr +xlinkGetDefaultHandler (void); +void xlinkSetDefaultHandler (xlinkHandlerPtr handler); + + + + +xlinkType +xlinkIsLink (xmlDocPtr doc, xmlNodePtr node); + + + + + + +const xmlChar *getPublicId (void *ctx); +const xmlChar *getSystemId (void *ctx); +void setDocumentLocator (void *ctx, xmlSAXLocatorPtr loc); + +int getLineNumber (void *ctx); +int getColumnNumber (void *ctx); + +int isStandalone (void *ctx); +int hasInternalSubset (void *ctx); +int hasExternalSubset (void *ctx); + +void +internalSubset (void *ctx, + const xmlChar * name, + const xmlChar * ExternalID, const xmlChar * SystemID); +void +externalSubset (void *ctx, + const xmlChar * name, + const xmlChar * ExternalID, const xmlChar * SystemID); +xmlEntityPtr +getEntity (void *ctx, const xmlChar * name); +xmlEntityPtr +getParameterEntity (void *ctx, const xmlChar * name); +xmlParserInputPtr +resolveEntity (void *ctx, const xmlChar * publicId, const xmlChar * systemId); + +void +entityDecl (void *ctx, + const xmlChar * name, + int type, + const xmlChar * publicId, + const xmlChar * systemId, xmlChar * content); +void +attributeDecl (void *ctx, + const xmlChar * elem, + const xmlChar * fullname, + int type, + int def, + const xmlChar * defaultValue, xmlEnumerationPtr tree); +void +elementDecl (void *ctx, + const xmlChar * name, + int type, xmlElementContentPtr content); +void +notationDecl (void *ctx, + const xmlChar * name, + const xmlChar * publicId, const xmlChar * systemId); +void +unparsedEntityDecl (void *ctx, + const xmlChar * name, + const xmlChar * publicId, + const xmlChar * systemId, + const xmlChar * notationName); + +void startDocument (void *ctx); +void endDocument (void *ctx); +void +attribute (void *ctx, const xmlChar * fullname, const xmlChar * value); +void +startElement (void *ctx, + const xmlChar * fullname, const xmlChar ** atts); +void endElement (void *ctx, const xmlChar * name); +void reference (void *ctx, const xmlChar * name); +void characters (void *ctx, const xmlChar * ch, int len); +void ignorableWhitespace (void *ctx, const xmlChar * ch, int len); +void +processingInstruction (void *ctx, + const xmlChar * target, const xmlChar * data); +void +globalNamespace (void *ctx, + const xmlChar * href, const xmlChar * prefix); +void setNamespace (void *ctx, const xmlChar * name); +xmlNsPtr +getNamespace (void *ctx); +int checkNamespace (void *ctx, xmlChar * nameSpace); +void +namespaceDecl (void *ctx, + const xmlChar * href, const xmlChar * prefix); +void comment (void *ctx, const xmlChar * value); +void cdataBlock (void *ctx, const xmlChar * value, int len); + + +void initxmlDefaultSAXHandler (xmlSAXHandlerV1 * hdlr, int warning); + +void inithtmlDefaultSAXHandler (xmlSAXHandlerV1 * hdlr); + + +void initdocbDefaultSAXHandler (xmlSAXHandlerV1 * hdlr); +const xmlChar *xmlSAX2GetPublicId (void *ctx); +const xmlChar *xmlSAX2GetSystemId (void *ctx); +void xmlSAX2SetDocumentLocator (void *ctx, xmlSAXLocatorPtr loc); + +int xmlSAX2GetLineNumber (void *ctx); +int xmlSAX2GetColumnNumber (void *ctx); + +int xmlSAX2IsStandalone (void *ctx); +int xmlSAX2HasInternalSubset (void *ctx); +int xmlSAX2HasExternalSubset (void *ctx); + +void +xmlSAX2InternalSubset (void *ctx, + const xmlChar * name, + const xmlChar * ExternalID, + const xmlChar * SystemID); +void +xmlSAX2ExternalSubset (void *ctx, + const xmlChar * name, + const xmlChar * ExternalID, + const xmlChar * SystemID); +xmlEntityPtr +xmlSAX2GetEntity (void *ctx, const xmlChar * name); +xmlEntityPtr +xmlSAX2GetParameterEntity (void *ctx, const xmlChar * name); +xmlParserInputPtr +xmlSAX2ResolveEntity (void *ctx, + const xmlChar * publicId, const xmlChar * systemId); + +void +xmlSAX2EntityDecl (void *ctx, + const xmlChar * name, + int type, + const xmlChar * publicId, + const xmlChar * systemId, xmlChar * content); +void +xmlSAX2AttributeDecl (void *ctx, + const xmlChar * elem, + const xmlChar * fullname, + int type, + int def, + const xmlChar * defaultValue, + xmlEnumerationPtr tree); +void +xmlSAX2ElementDecl (void *ctx, + const xmlChar * name, + int type, xmlElementContentPtr content); +void +xmlSAX2NotationDecl (void *ctx, + const xmlChar * name, + const xmlChar * publicId, + const xmlChar * systemId); +void +xmlSAX2UnparsedEntityDecl (void *ctx, + const xmlChar * name, + const xmlChar * publicId, + const xmlChar * systemId, + const xmlChar * notationName); + +void xmlSAX2StartDocument (void *ctx); +void xmlSAX2EndDocument (void *ctx); + + + +void +xmlSAX2StartElement (void *ctx, + const xmlChar * fullname, const xmlChar ** atts); +void xmlSAX2EndElement (void *ctx, const xmlChar * name); + +void +xmlSAX2StartElementNs (void *ctx, + const xmlChar * localname, + const xmlChar * prefix, + const xmlChar * URI, + int nb_namespaces, + const xmlChar ** namespaces, + int nb_attributes, + int nb_defaulted, const xmlChar ** attributes); +void +xmlSAX2EndElementNs (void *ctx, + const xmlChar * localname, + const xmlChar * prefix, const xmlChar * URI); +void xmlSAX2Reference (void *ctx, const xmlChar * name); +void xmlSAX2Characters (void *ctx, const xmlChar * ch, int len); +void xmlSAX2IgnorableWhitespace (void *ctx, const xmlChar * ch, int len); +void +xmlSAX2ProcessingInstruction (void *ctx, + const xmlChar * target, + const xmlChar * data); +void xmlSAX2Comment (void *ctx, const xmlChar * value); +void xmlSAX2CDataBlock (void *ctx, const xmlChar * value, int len); + + +int xmlSAXDefaultVersion (int version); + + +int xmlSAXVersion (xmlSAXHandler * hdlr, int version); +void xmlSAX2InitDefaultSAXHandler (xmlSAXHandler * hdlr, int warning); + +void xmlSAX2InitHtmlDefaultSAXHandler (xmlSAXHandler * hdlr); +void htmlDefaultSAXHandlerInit (void); + + +void xmlSAX2InitDocbDefaultSAXHandler (xmlSAXHandler * hdlr); +void docbDefaultSAXHandlerInit (void); + +void xmlDefaultSAXHandlerInit (void); +typedef void (*xmlFreeFunc) (void *mem); +typedef void *( __attribute__ ((alloc_size (1))) * + xmlMallocFunc) (size_t size); +typedef void *(*xmlReallocFunc) (void *mem, size_t size); +typedef char *(*xmlStrdupFunc) (const char *str); +int +xmlMemSetup (xmlFreeFunc freeFunc, + xmlMallocFunc mallocFunc, + xmlReallocFunc reallocFunc, xmlStrdupFunc strdupFunc); +int +xmlMemGet (xmlFreeFunc * freeFunc, + xmlMallocFunc * mallocFunc, + xmlReallocFunc * reallocFunc, xmlStrdupFunc * strdupFunc); +int +xmlGcMemSetup (xmlFreeFunc freeFunc, + xmlMallocFunc mallocFunc, + xmlMallocFunc mallocAtomicFunc, + xmlReallocFunc reallocFunc, xmlStrdupFunc strdupFunc); +int +xmlGcMemGet (xmlFreeFunc * freeFunc, + xmlMallocFunc * mallocFunc, + xmlMallocFunc * mallocAtomicFunc, + xmlReallocFunc * reallocFunc, xmlStrdupFunc * strdupFunc); + + + + +int xmlInitMemory (void); + + + + +void xmlCleanupMemory (void); + + + +int xmlMemUsed (void); +int xmlMemBlocks (void); +void xmlMemDisplay (FILE * fp); +void xmlMemDisplayLast (FILE * fp, long nbBytes); +void xmlMemShow (FILE * fp, int nr); +void xmlMemoryDump (void); +void *xmlMemMalloc (size_t size) __attribute__ ((alloc_size (1))); +void *xmlMemRealloc (void *ptr, size_t size); +void xmlMemFree (void *ptr); +char *xmlMemoryStrdup (const char *str); +void *xmlMallocLoc (size_t size, const char *file, int line) + __attribute__ ((alloc_size (1))); +void *xmlReallocLoc (void *ptr, size_t size, const char *file, int line); +void *xmlMallocAtomicLoc (size_t size, const char *file, int line) + __attribute__ ((alloc_size (1))); +char *xmlMemStrdupLoc (const char *str, const char *file, int line); + + + + + +void xmlInitGlobals (void); +void xmlCleanupGlobals (void); +typedef +xmlParserInputBufferPtr (*xmlParserInputBufferCreateFilenameFunc) +(const char *URI, xmlCharEncoding enc); +typedef xmlOutputBufferPtr (*xmlOutputBufferCreateFilenameFunc) (const + char + *URI, + xmlCharEncodingHandlerPtr + encoder, + int + compression); + +xmlParserInputBufferCreateFilenameFunc +xmlParserInputBufferCreateFilenameDefault +(xmlParserInputBufferCreateFilenameFunc func); +xmlOutputBufferCreateFilenameFunc +xmlOutputBufferCreateFilenameDefault (xmlOutputBufferCreateFilenameFunc func); +typedef void (*xmlRegisterNodeFunc) (xmlNodePtr node); + + + + + + +typedef void (*xmlDeregisterNodeFunc) (xmlNodePtr node); + +typedef struct _xmlGlobalState xmlGlobalState; +typedef xmlGlobalState *xmlGlobalStatePtr; +struct _xmlGlobalState +{ + const char *xmlParserVersion; + + xmlSAXLocator xmlDefaultSAXLocator; + xmlSAXHandlerV1 xmlDefaultSAXHandler; + xmlSAXHandlerV1 docbDefaultSAXHandler; + xmlSAXHandlerV1 htmlDefaultSAXHandler; + + xmlFreeFunc xmlFree; + xmlMallocFunc xmlMalloc; + xmlStrdupFunc xmlMemStrdup; + xmlReallocFunc xmlRealloc; + + xmlGenericErrorFunc xmlGenericError; + xmlStructuredErrorFunc xmlStructuredError; + void *xmlGenericErrorContext; + + int oldXMLWDcompatibility; + + xmlBufferAllocationScheme xmlBufferAllocScheme; + int xmlDefaultBufferSize; + + int xmlSubstituteEntitiesDefaultValue; + int xmlDoValidityCheckingDefaultValue; + int xmlGetWarningsDefaultValue; + int xmlKeepBlanksDefaultValue; + int xmlLineNumbersDefaultValue; + int xmlLoadExtDtdDefaultValue; + int xmlParserDebugEntities; + int xmlPedanticParserDefaultValue; + + int xmlSaveNoEmptyTags; + int xmlIndentTreeOutput; + const char *xmlTreeIndentString; + + xmlRegisterNodeFunc xmlRegisterNodeDefaultValue; + xmlDeregisterNodeFunc xmlDeregisterNodeDefaultValue; + + xmlMallocFunc xmlMallocAtomic; + xmlError xmlLastError; + + xmlParserInputBufferCreateFilenameFunc + xmlParserInputBufferCreateFilenameValue; + xmlOutputBufferCreateFilenameFunc xmlOutputBufferCreateFilenameValue; + + void *xmlStructuredErrorContext; +}; + + + + +typedef struct _xmlMutex xmlMutex; +typedef xmlMutex *xmlMutexPtr; + + + + +typedef struct _xmlRMutex xmlRMutex; +typedef xmlRMutex *xmlRMutexPtr; + + + + + + + +xmlMutexPtr +xmlNewMutex (void); +void xmlMutexLock (xmlMutexPtr tok); +void xmlMutexUnlock (xmlMutexPtr tok); +void xmlFreeMutex (xmlMutexPtr tok); + +xmlRMutexPtr +xmlNewRMutex (void); +void xmlRMutexLock (xmlRMutexPtr tok); +void xmlRMutexUnlock (xmlRMutexPtr tok); +void xmlFreeRMutex (xmlRMutexPtr tok); + + + + +void xmlInitThreads (void); +void xmlLockLibrary (void); +void xmlUnlockLibrary (void); +int xmlGetThreadId (void); +int xmlIsMainThread (void); +void xmlCleanupThreads (void); +xmlGlobalStatePtr +xmlGetGlobalState (void); + + + + +void xmlInitializeGlobalState (xmlGlobalStatePtr gs); + +void xmlThrDefSetGenericErrorFunc (void *ctx, + xmlGenericErrorFunc handler); + +void xmlThrDefSetStructuredErrorFunc (void *ctx, + xmlStructuredErrorFunc handler); + +xmlRegisterNodeFunc xmlRegisterNodeDefault (xmlRegisterNodeFunc func); +xmlRegisterNodeFunc xmlThrDefRegisterNodeDefault (xmlRegisterNodeFunc + func); +xmlDeregisterNodeFunc xmlDeregisterNodeDefault (xmlDeregisterNodeFunc + func); +xmlDeregisterNodeFunc +xmlThrDefDeregisterNodeDefault (xmlDeregisterNodeFunc func); + +xmlOutputBufferCreateFilenameFunc +xmlThrDefOutputBufferCreateFilenameDefault (xmlOutputBufferCreateFilenameFunc + func); +xmlParserInputBufferCreateFilenameFunc +xmlThrDefParserInputBufferCreateFilenameDefault +(xmlParserInputBufferCreateFilenameFunc func); +extern xmlMallocFunc xmlMalloc; +extern xmlMallocFunc xmlMallocAtomic; +extern xmlReallocFunc xmlRealloc; +extern xmlFreeFunc xmlFree; +extern xmlStrdupFunc xmlMemStrdup; + + + +xmlSAXHandlerV1 *__docbDefaultSAXHandler (void); +xmlSAXHandlerV1 *__htmlDefaultSAXHandler (void); +xmlError *__xmlLastError (void); +int *__oldXMLWDcompatibility (void); + + + + + + + +xmlBufferAllocationScheme *__xmlBufferAllocScheme (void); + + + + + + +xmlBufferAllocationScheme +xmlThrDefBufferAllocScheme (xmlBufferAllocationScheme v); + +int *__xmlDefaultBufferSize (void); + + + + + + +int xmlThrDefDefaultBufferSize (int v); + +xmlSAXHandlerV1 *__xmlDefaultSAXHandler (void); + + + + + + + +xmlSAXLocator *__xmlDefaultSAXLocator (void); + + + + + + + +int *__xmlDoValidityCheckingDefaultValue (void); + + + + + + +int xmlThrDefDoValidityCheckingDefaultValue (int v); + +xmlGenericErrorFunc *__xmlGenericError (void); + + + + + + + +xmlStructuredErrorFunc *__xmlStructuredError (void); + + + + + + + +void **__xmlGenericErrorContext (void); + + + + + + + +void **__xmlStructuredErrorContext (void); + + + + + + + +int *__xmlGetWarningsDefaultValue (void); + + + + + + +int xmlThrDefGetWarningsDefaultValue (int v); + +int *__xmlIndentTreeOutput (void); + + + + + + +int xmlThrDefIndentTreeOutput (int v); + +const char **__xmlTreeIndentString (void); + + + + + + +const char *xmlThrDefTreeIndentString (const char *v); + +int *__xmlKeepBlanksDefaultValue (void); + + + + + + +int xmlThrDefKeepBlanksDefaultValue (int v); + +int *__xmlLineNumbersDefaultValue (void); + + + + + + +int xmlThrDefLineNumbersDefaultValue (int v); + +int *__xmlLoadExtDtdDefaultValue (void); + + + + + + +int xmlThrDefLoadExtDtdDefaultValue (int v); + +int *__xmlParserDebugEntities (void); + + + + + + +int xmlThrDefParserDebugEntities (int v); + +const char **__xmlParserVersion (void); + + + + + + + +int *__xmlPedanticParserDefaultValue (void); + + + + + + +int xmlThrDefPedanticParserDefaultValue (int v); + +int *__xmlSaveNoEmptyTags (void); + + + + + + +int xmlThrDefSaveNoEmptyTags (int v); + +int *__xmlSubstituteEntitiesDefaultValue (void); + + + + + + +int xmlThrDefSubstituteEntitiesDefaultValue (int v); + +xmlRegisterNodeFunc *__xmlRegisterNodeDefaultValue (void); + + + + + + + +xmlDeregisterNodeFunc *__xmlDeregisterNodeDefaultValue (void); + + + + + + + +xmlParserInputBufferCreateFilenameFunc +*__xmlParserInputBufferCreateFilenameValue (void); + + + + + + + +xmlOutputBufferCreateFilenameFunc +*__xmlOutputBufferCreateFilenameValue (void); + + + + + + + +struct _xmlParserInputBuffer +{ + void *context; + xmlInputReadCallback readcallback; + xmlInputCloseCallback closecallback; + + xmlCharEncodingHandlerPtr encoder; + + xmlBufPtr buffer; + xmlBufPtr raw; + int compressed; + int error; + unsigned long rawconsumed; +}; + + + +struct _xmlOutputBuffer +{ + void *context; + xmlOutputWriteCallback writecallback; + xmlOutputCloseCallback closecallback; + + xmlCharEncodingHandlerPtr encoder; + + xmlBufPtr buffer; + xmlBufPtr conv; + int written; + int error; +}; + + + + + +void xmlCleanupInputCallbacks (void); + +int xmlPopInputCallbacks (void); + +void xmlRegisterDefaultInputCallbacks (void); +xmlParserInputBufferPtr +xmlAllocParserInputBuffer (xmlCharEncoding enc); + +xmlParserInputBufferPtr +xmlParserInputBufferCreateFilename (const char *URI, xmlCharEncoding enc); +xmlParserInputBufferPtr +xmlParserInputBufferCreateFile (FILE * file, xmlCharEncoding enc); +xmlParserInputBufferPtr +xmlParserInputBufferCreateFd (int fd, xmlCharEncoding enc); +xmlParserInputBufferPtr +xmlParserInputBufferCreateMem (const char *mem, int size, + xmlCharEncoding enc); +xmlParserInputBufferPtr +xmlParserInputBufferCreateStatic (const char *mem, int size, + xmlCharEncoding enc); +xmlParserInputBufferPtr +xmlParserInputBufferCreateIO (xmlInputReadCallback ioread, + xmlInputCloseCallback ioclose, + void *ioctx, xmlCharEncoding enc); +int xmlParserInputBufferRead (xmlParserInputBufferPtr in, int len); +int xmlParserInputBufferGrow (xmlParserInputBufferPtr in, int len); +int +xmlParserInputBufferPush (xmlParserInputBufferPtr in, + int len, const char *buf); +void xmlFreeParserInputBuffer (xmlParserInputBufferPtr in); +char *xmlParserGetDirectory (const char *filename); + +int +xmlRegisterInputCallbacks (xmlInputMatchCallback matchFunc, + xmlInputOpenCallback openFunc, + xmlInputReadCallback readFunc, + xmlInputCloseCallback closeFunc); + +xmlParserInputBufferPtr +__xmlParserInputBufferCreateFilename (const char *URI, xmlCharEncoding enc); + + + + + +void xmlCleanupOutputCallbacks (void); +void xmlRegisterDefaultOutputCallbacks (void); +xmlOutputBufferPtr +xmlAllocOutputBuffer (xmlCharEncodingHandlerPtr encoder); + +xmlOutputBufferPtr +xmlOutputBufferCreateFilename (const char *URI, + xmlCharEncodingHandlerPtr encoder, + int compression); + +xmlOutputBufferPtr +xmlOutputBufferCreateFile (FILE * file, xmlCharEncodingHandlerPtr encoder); + +xmlOutputBufferPtr +xmlOutputBufferCreateBuffer (xmlBufferPtr buffer, + xmlCharEncodingHandlerPtr encoder); + +xmlOutputBufferPtr +xmlOutputBufferCreateFd (int fd, xmlCharEncodingHandlerPtr encoder); + +xmlOutputBufferPtr +xmlOutputBufferCreateIO (xmlOutputWriteCallback iowrite, + xmlOutputCloseCallback ioclose, + void *ioctx, xmlCharEncodingHandlerPtr encoder); + + +const xmlChar *xmlOutputBufferGetContent (xmlOutputBufferPtr out); +size_t +xmlOutputBufferGetSize (xmlOutputBufferPtr out); + +int +xmlOutputBufferWrite (xmlOutputBufferPtr out, + int len, const char *buf); +int xmlOutputBufferWriteString (xmlOutputBufferPtr out, const char *str); +int +xmlOutputBufferWriteEscape (xmlOutputBufferPtr out, + const xmlChar * str, + xmlCharEncodingOutputFunc escaping); + +int xmlOutputBufferFlush (xmlOutputBufferPtr out); +int xmlOutputBufferClose (xmlOutputBufferPtr out); + +int +xmlRegisterOutputCallbacks (xmlOutputMatchCallback matchFunc, + xmlOutputOpenCallback openFunc, + xmlOutputWriteCallback writeFunc, + xmlOutputCloseCallback closeFunc); + +xmlOutputBufferPtr +__xmlOutputBufferCreateFilename (const char *URI, + xmlCharEncodingHandlerPtr encoder, + int compression); + + + +void xmlRegisterHTTPPostCallbacks (void); + + + + +xmlParserInputPtr +xmlCheckHTTPInput (xmlParserCtxtPtr ctxt, xmlParserInputPtr ret); + + + + +xmlParserInputPtr +xmlNoNetExternalEntityLoader (const char *URL, + const char *ID, xmlParserCtxtPtr ctxt); + + + + + +xmlChar *xmlNormalizeWindowsPath (const xmlChar * path); + +int xmlCheckFilename (const char *path); + + + +int xmlFileMatch (const char *filename); +void *xmlFileOpen (const char *filename); +int xmlFileRead (void *context, char *buffer, int len); +int xmlFileClose (void *context); + + + + + +int xmlIOHTTPMatch (const char *filename); +void *xmlIOHTTPOpen (const char *filename); + +void *xmlIOHTTPOpenW (const char *post_uri, int compression); + +int xmlIOHTTPRead (void *context, char *buffer, int len); +int xmlIOHTTPClose (void *context); + + + + + + +int xmlIOFTPMatch (const char *filename); +void *xmlIOFTPOpen (const char *filename); +int xmlIOFTPRead (void *context, char *buffer, int len); +int xmlIOFTPClose (void *context); +void xmlInitParser (void); +void xmlCleanupParser (void); + + + + +int xmlParserInputRead (xmlParserInputPtr in, int len); +int xmlParserInputGrow (xmlParserInputPtr in, int len); + + + + + +xmlDocPtr +xmlParseDoc (const xmlChar * cur); +xmlDocPtr +xmlParseFile (const char *filename); +xmlDocPtr +xmlParseMemory (const char *buffer, int size); + +int xmlSubstituteEntitiesDefault (int val); +int xmlKeepBlanksDefault (int val); +void xmlStopParser (xmlParserCtxtPtr ctxt); +int xmlPedanticParserDefault (int val); +int xmlLineNumbersDefault (int val); + + + + + +xmlDocPtr +xmlRecoverDoc (const xmlChar * cur); +xmlDocPtr +xmlRecoverMemory (const char *buffer, int size); +xmlDocPtr +xmlRecoverFile (const char *filename); + + + + + +int xmlParseDocument (xmlParserCtxtPtr ctxt); +int xmlParseExtParsedEnt (xmlParserCtxtPtr ctxt); + +int +xmlSAXUserParseFile (xmlSAXHandlerPtr sax, + void *user_data, const char *filename); +int +xmlSAXUserParseMemory (xmlSAXHandlerPtr sax, + void *user_data, const char *buffer, int size); +xmlDocPtr +xmlSAXParseDoc (xmlSAXHandlerPtr sax, const xmlChar * cur, int recovery); +xmlDocPtr +xmlSAXParseMemory (xmlSAXHandlerPtr sax, + const char *buffer, int size, int recovery); +xmlDocPtr +xmlSAXParseMemoryWithData (xmlSAXHandlerPtr sax, + const char *buffer, + int size, int recovery, void *data); +xmlDocPtr +xmlSAXParseFile (xmlSAXHandlerPtr sax, const char *filename, int recovery); +xmlDocPtr +xmlSAXParseFileWithData (xmlSAXHandlerPtr sax, + const char *filename, int recovery, void *data); +xmlDocPtr +xmlSAXParseEntity (xmlSAXHandlerPtr sax, const char *filename); +xmlDocPtr +xmlParseEntity (const char *filename); + + + +xmlDtdPtr +xmlSAXParseDTD (xmlSAXHandlerPtr sax, + const xmlChar * ExternalID, const xmlChar * SystemID); +xmlDtdPtr +xmlParseDTD (const xmlChar * ExternalID, const xmlChar * SystemID); +xmlDtdPtr +xmlIOParseDTD (xmlSAXHandlerPtr sax, + xmlParserInputBufferPtr input, xmlCharEncoding enc); + + +int +xmlParseBalancedChunkMemory (xmlDocPtr doc, + xmlSAXHandlerPtr sax, + void *user_data, + int depth, + const xmlChar * string, xmlNodePtr * lst); + +xmlParserErrors +xmlParseInNodeContext (xmlNodePtr node, + const char *data, + int datalen, int options, xmlNodePtr * lst); + +int +xmlParseBalancedChunkMemoryRecover (xmlDocPtr doc, + xmlSAXHandlerPtr sax, + void *user_data, + int depth, + const xmlChar * string, + xmlNodePtr * lst, int recover); +int +xmlParseExternalEntity (xmlDocPtr doc, + xmlSAXHandlerPtr sax, + void *user_data, + int depth, + const xmlChar * URL, + const xmlChar * ID, xmlNodePtr * lst); + +int +xmlParseCtxtExternalEntity (xmlParserCtxtPtr ctx, + const xmlChar * URL, + const xmlChar * ID, xmlNodePtr * lst); + + + + +xmlParserCtxtPtr +xmlNewParserCtxt (void); +int xmlInitParserCtxt (xmlParserCtxtPtr ctxt); +void xmlClearParserCtxt (xmlParserCtxtPtr ctxt); +void xmlFreeParserCtxt (xmlParserCtxtPtr ctxt); + +void +xmlSetupParserForBuffer (xmlParserCtxtPtr ctxt, + const xmlChar * buffer, const char *filename); + +xmlParserCtxtPtr +xmlCreateDocParserCtxt (const xmlChar * cur); + + + + + +int xmlGetFeaturesList (int *len, const char **result); +int +xmlGetFeature (xmlParserCtxtPtr ctxt, const char *name, void *result); +int xmlSetFeature (xmlParserCtxtPtr ctxt, const char *name, void *value); + + + + + + +xmlParserCtxtPtr +xmlCreatePushParserCtxt (xmlSAXHandlerPtr sax, + void *user_data, + const char *chunk, int size, const char *filename); +int +xmlParseChunk (xmlParserCtxtPtr ctxt, + const char *chunk, int size, int terminate); + + + + + + +xmlParserCtxtPtr +xmlCreateIOParserCtxt (xmlSAXHandlerPtr sax, + void *user_data, + xmlInputReadCallback ioread, + xmlInputCloseCallback ioclose, + void *ioctx, xmlCharEncoding enc); + +xmlParserInputPtr +xmlNewIOInputStream (xmlParserCtxtPtr ctxt, + xmlParserInputBufferPtr input, xmlCharEncoding enc); + + + + +const xmlParserNodeInfo *xmlParserFindNodeInfo (const xmlParserCtxtPtr + ctxt, + const xmlNodePtr node); +void xmlInitNodeInfoSeq (xmlParserNodeInfoSeqPtr seq); +void xmlClearNodeInfoSeq (xmlParserNodeInfoSeqPtr seq); +unsigned long +xmlParserFindNodeInfoIndex (const xmlParserNodeInfoSeqPtr seq, + const xmlNodePtr node); +void +xmlParserAddNodeInfo (xmlParserCtxtPtr ctxt, + const xmlParserNodeInfoPtr info); + + + + + +void xmlSetExternalEntityLoader (xmlExternalEntityLoader f); +xmlExternalEntityLoader +xmlGetExternalEntityLoader (void); +xmlParserInputPtr +xmlLoadExternalEntity (const char *URL, + const char *ID, xmlParserCtxtPtr ctxt); + + + + +long xmlByteConsumed (xmlParserCtxtPtr ctxt); +typedef enum + { + XML_PARSE_RECOVER = 1 << 0, + XML_PARSE_NOENT = 1 << 1, + XML_PARSE_DTDLOAD = 1 << 2, + XML_PARSE_DTDATTR = 1 << 3, + XML_PARSE_DTDVALID = 1 << 4, + XML_PARSE_NOERROR = 1 << 5, + XML_PARSE_NOWARNING = 1 << 6, + XML_PARSE_PEDANTIC = 1 << 7, + XML_PARSE_NOBLANKS = 1 << 8, + XML_PARSE_SAX1 = 1 << 9, + XML_PARSE_XINCLUDE = 1 << 10, + XML_PARSE_NONET = 1 << 11, + XML_PARSE_NODICT = 1 << 12, + XML_PARSE_NSCLEAN = 1 << 13, + XML_PARSE_NOCDATA = 1 << 14, + XML_PARSE_NOXINCNODE = 1 << 15, + XML_PARSE_COMPACT = 1 << 16, + + + XML_PARSE_OLD10 = 1 << 17, + XML_PARSE_NOBASEFIX = 1 << 18, + XML_PARSE_HUGE = 1 << 19, + XML_PARSE_OLDSAX = 1 << 20, + XML_PARSE_IGNORE_ENC = 1 << 21, + XML_PARSE_BIG_LINES = 1 << 22 + } xmlParserOption; + +void xmlCtxtReset (xmlParserCtxtPtr ctxt); +int +xmlCtxtResetPush (xmlParserCtxtPtr ctxt, + const char *chunk, + int size, + const char *filename, const char *encoding); +int xmlCtxtUseOptions (xmlParserCtxtPtr ctxt, int options); +xmlDocPtr +xmlReadDoc (const xmlChar * cur, + const char *URL, const char *encoding, int options); +xmlDocPtr +xmlReadFile (const char *URL, const char *encoding, int options); +xmlDocPtr +xmlReadMemory (const char *buffer, + int size, const char *URL, const char *encoding, int options); +xmlDocPtr +xmlReadFd (int fd, const char *URL, const char *encoding, int options); +xmlDocPtr +xmlReadIO (xmlInputReadCallback ioread, + xmlInputCloseCallback ioclose, + void *ioctx, const char *URL, const char *encoding, int options); +xmlDocPtr +xmlCtxtReadDoc (xmlParserCtxtPtr ctxt, + const xmlChar * cur, + const char *URL, const char *encoding, int options); +xmlDocPtr +xmlCtxtReadFile (xmlParserCtxtPtr ctxt, + const char *filename, const char *encoding, int options); +xmlDocPtr +xmlCtxtReadMemory (xmlParserCtxtPtr ctxt, + const char *buffer, + int size, + const char *URL, const char *encoding, int options); +xmlDocPtr +xmlCtxtReadFd (xmlParserCtxtPtr ctxt, + int fd, const char *URL, const char *encoding, int options); +xmlDocPtr +xmlCtxtReadIO (xmlParserCtxtPtr ctxt, + xmlInputReadCallback ioread, + xmlInputCloseCallback ioclose, + void *ioctx, + const char *URL, const char *encoding, int options); +typedef enum + { + XML_WITH_THREAD = 1, + XML_WITH_TREE = 2, + XML_WITH_OUTPUT = 3, + XML_WITH_PUSH = 4, + XML_WITH_READER = 5, + XML_WITH_PATTERN = 6, + XML_WITH_WRITER = 7, + XML_WITH_SAX1 = 8, + XML_WITH_FTP = 9, + XML_WITH_HTTP = 10, + XML_WITH_VALID = 11, + XML_WITH_HTML = 12, + XML_WITH_LEGACY = 13, + XML_WITH_C14N = 14, + XML_WITH_CATALOG = 15, + XML_WITH_XPATH = 16, + XML_WITH_XPTR = 17, + XML_WITH_XINCLUDE = 18, + XML_WITH_ICONV = 19, + XML_WITH_ISO8859X = 20, + XML_WITH_UNICODE = 21, + XML_WITH_REGEXP = 22, + XML_WITH_AUTOMATA = 23, + XML_WITH_EXPR = 24, + XML_WITH_SCHEMAS = 25, + XML_WITH_SCHEMATRON = 26, + XML_WITH_MODULES = 27, + XML_WITH_DEBUG = 28, + XML_WITH_DEBUG_MEM = 29, + XML_WITH_DEBUG_RUN = 30, + XML_WITH_ZLIB = 31, + XML_WITH_ICU = 32, + XML_WITH_LZMA = 33, + XML_WITH_NONE = 99999 + } xmlFeature; + +int xmlHasFeature (xmlFeature feature); +typedef unsigned long int ub4; + + + +typedef signed long int sb4; + + + +typedef unsigned short int ub2; + + + +typedef signed short int sb2; + + + +typedef unsigned char ub1; + + + +typedef signed char sb1; + + + +typedef int word; +struct randctx +{ + ub4 randcnt; + ub4 randrsl[(1 << (4))]; + ub4 randmem[(1 << (4))]; + ub4 randa; + ub4 randb; + ub4 randc; +}; +typedef struct randctx randctx; + + + + + + +void irandinit (randctx * r, word flag); + +void isaac (randctx * r); +char *flam3_version (); +typedef struct +{ + double index; + double color[4]; +} flam3_palette_entry; + +typedef flam3_palette_entry flam3_palette[256]; + +int flam3_get_palette (int palette_index, flam3_palette p, + double hue_rotation); + + + + +extern char *flam3_variation_names[]; +typedef struct +{ + + double badvals; + long int num_iters; + int render_seconds; + +} stat_struct; + +typedef struct +{ + + unsigned int width, height; + int version; + int id; + + + double intensity_weight[256]; + unsigned int bin_size[256]; + unsigned int bin_offset[256]; + + + + + + unsigned short *rowcols; + +} flam3_image_store; + + +typedef struct xform +{ + double var[98]; + double c[3][2]; + double post[3][2]; + double density; + double color; + double color_speed; + double animate; + double opacity; + double vis_adjusted; + + int padding; + double wind[2]; + + int precalc_angles_flag; + int precalc_atan_xy_flag; + int precalc_atan_yx_flag; + double has_preblur; + int has_post; + + + + double blob_low; + double blob_high; + double blob_waves; + + + double pdj_a; + double pdj_b; + double pdj_c; + double pdj_d; + + + double fan2_x; + double fan2_y; + + + double rings2_val; + + + double perspective_angle; + double perspective_dist; + + + double julian_power; + double julian_dist; + + + double juliascope_power; + double juliascope_dist; + + + double radial_blur_angle; + + + double pie_slices; + double pie_rotation; + double pie_thickness; + + + double ngon_sides; + double ngon_power; + double ngon_circle; + double ngon_corners; + + + double curl_c1; + double curl_c2; + + + double rectangles_x; + double rectangles_y; + + + double amw_amp; + + + double disc2_rot; + double disc2_twist; + + + double super_shape_rnd; + double super_shape_m; + double super_shape_n1; + double super_shape_n2; + double super_shape_n3; + double super_shape_holes; + + + double flower_petals; + double flower_holes; + + + double conic_eccentricity; + double conic_holes; + + + double parabola_height; + double parabola_width; + + + double bent2_x; + double bent2_y; + + + double bipolar_shift; + + + double cell_size; + + + double cpow_r; + double cpow_i; + double cpow_power; + + + double curve_xamp, curve_yamp; + double curve_xlength, curve_ylength; + + + double escher_beta; + + + double lazysusan_spin; + double lazysusan_space; + double lazysusan_twist; + double lazysusan_x, lazysusan_y; + + + double modulus_x, modulus_y; + + + double oscope_separation; + double oscope_frequency; + double oscope_amplitude; + double oscope_damping; + + + double popcorn2_x, popcorn2_y, popcorn2_c; + + + double separation_x, separation_xinside; + double separation_y, separation_yinside; + + + double split_xsize; + double split_ysize; + + + double splits_x, splits_y; + + + double stripes_space; + double stripes_warp; + + + double wedge_angle, wedge_hole; + double wedge_count, wedge_swirl; + + + double wedge_julia_angle; + double wedge_julia_count; + double wedge_julia_power; + double wedge_julia_dist; + + + double wedge_sph_angle, wedge_sph_count; + double wedge_sph_hole, wedge_sph_swirl; + + + double whorl_inside, whorl_outside; + + + double waves2_freqx, waves2_scalex; + double waves2_freqy, waves2_scaley; + + + double auger_sym, auger_weight; + double auger_freq, auger_scale; + + + double flux_spread; + + + + double persp_vsin; + double persp_vfcos; + + + double julian_rN; + double julian_cn; + + + double juliascope_rN; + double juliascope_cn; + + + double wedgeJulia_rN; + double wedgeJulia_cn; + double wedgeJulia_cf; + + + double radialBlur_spinvar; + double radialBlur_zoomvar; + + + double waves_dx2; + double waves_dy2; + + + double disc2_sinadd; + double disc2_cosadd; + double disc2_timespi; + + + double super_shape_pm_4; + double super_shape_pneg1_n1; + + int num_active_vars; + double active_var_weights[98]; + int varFunc[98]; + + int motion_freq; + int motion_func; + + struct xform *motion; + int num_motion; + + +} flam3_xform; + +typedef struct +{ + char flame_name[64 + 1]; + double time; + int interpolation; + int interpolation_type; + int palette_interpolation; + int num_xforms; + int final_xform_index; + int final_xform_enable; + flam3_xform *xform; + + + double **chaos; + int chaos_enable; + + int genome_index; + char parent_fname[30]; + int symmetry; + flam3_palette palette; + char *input_image; + int palette_index; + double brightness; + double contrast; + double gamma; + double highlight_power; + int width, height; + int spatial_oversample; + double center[2]; + double rot_center[2]; + double rotate; + double vibrancy; + double hue_rotation; + double background[3]; + double zoom; + double pixels_per_unit; + double spatial_filter_radius; + int spatial_filter_select; + + + double sample_density; + + + + + + + int nbatches; + int ntemporal_samples; + + + double estimator; + double estimator_curve; + double estimator_minimum; + + + + xmlDocPtr edits; + + + double gam_lin_thresh; + + + int palette_index0; + double hue_rotation0; + int palette_index1; + double hue_rotation1; + double palette_blend; + + int temporal_filter_type; + double temporal_filter_width, temporal_filter_exp; + + int palette_mode; + + +} flam3_genome; + +typedef struct +{ + int from; + int to; + double scalar; +} flam3_chaos_entry; + + + +void flam3_add_motion_element (flam3_xform * xf); +void flam3_add_xforms (flam3_genome * cp, int num_to_add, + int interp_padding, int final_flag); +void flam3_delete_xform (flam3_genome * thiscp, int idx_to_delete); +void flam3_copy_xform (flam3_xform * dest, flam3_xform * src); +void flam3_copy (flam3_genome * dest, flam3_genome * src); +void flam3_copyx (flam3_genome * dest, flam3_genome * src, int num_std, + int num_final); +void flam3_copy_params (flam3_xform * dest, flam3_xform * src, int varn); +void flam3_delete_motion_elements (flam3_xform * xf); + +int flam3_xform_preview (flam3_genome * cp, int xi, double range, + int numvals, int depth, double *result, + randctx * rc); +unsigned short *flam3_create_xform_distrib (flam3_genome * cp); +int flam3_create_chaos_distrib (flam3_genome * cp, int xi, + unsigned short *xform_distrib); +int flam3_check_unity_chaos (flam3_genome * cp); +void clear_cp (flam3_genome * cp, int def_flag); + + + + + + +int flam3_iterate (flam3_genome * g, int nsamples, int fuse, + double *samples, unsigned short *xform_distrib, + randctx * rc); + +void apply_motion_parameters (flam3_xform * xf, flam3_xform * addto, + double blend); + + + +void flam3_interpolate (flam3_genome * genomes, int ngenomes, + double time, double stagger, + flam3_genome * result); + + +void flam3_print (FILE * f, flam3_genome * g, char *extra_attributes, + int print_edits); +void flam3_print_xform (FILE * f, flam3_xform * x, int final_flag, + int numstd, double *chaos_row, int motion_flag); +char *flam3_print_to_string (flam3_genome * cp); + + + + + +void flam3_random (flam3_genome * g, int *ivars, int ivars_n, int sym, + int spec_xforms); + +void add_to_action (char *action, char *addtoaction); + +void flam3_mutate (flam3_genome * cp, int mutate_mode, int *ivars, + int ivars_n, int sym, double speed, randctx * rc, + char *action); +void flam3_cross (flam3_genome * cp0, flam3_genome * cp1, + flam3_genome * out, int cross_mode, randctx * rc, + char *action); + + +flam3_genome *flam3_parse_xml2 (char *s, char *fn, int default_flag, + int *ncps); +flam3_genome *flam3_parse_from_file (FILE * f, char *fn, + int default_flag, int *ncps); + +void flam3_add_symmetry (flam3_genome * g, int sym); + +void flam3_improve_colors (flam3_genome * g, int ntries, + int change_palette, int color_resolution); +int flam3_colorhist (flam3_genome * cp, int num_batches, randctx * rc, + double *hist); +int flam3_estimate_bounding_box (flam3_genome * g, double eps, + int nsamples, double *bmin, + double *bmax, randctx * rc); +void flam3_rotate (flam3_genome * g, double angle, int interp_type); + +double flam3_dimension (flam3_genome * g, int ntries, + int clip_to_camera); +double flam3_lyapunov (flam3_genome * g, int ntries); + +void flam3_apply_template (flam3_genome * cp, flam3_genome * templ); + +int flam3_count_nthreads (void); + +typedef struct +{ + + double pixel_aspect_ratio; + flam3_genome *genomes; + int ngenomes; + int verbose; + int bits; + int bytes_per_channel; + int earlyclip; + double time; + int (*progress) (void *, double, int, double); + void *progress_parameter; + randctx rc; + int nthreads; + int sub_batch_size; +} flam3_frame; +int flam3_render (flam3_frame * f, void *out, int field, int nchan, + int transp, stat_struct * stats); + +double flam3_render_memory_required (flam3_frame * f); +int flam3_make_strip (flam3_genome * cp, int nstrips, int stripnum); +void rotate_by (double *p, double *center, double by); + + +double flam3_random01 (); +double flam3_random11 (); +int flam3_random_bit (); + + +double flam3_random_isaac_01 (randctx *); +double flam3_random_isaac_11 (randctx *); +int flam3_random_isaac_bit (randctx *); + +void flam3_init_frame (flam3_frame * f); + + +void *flam3_malloc (size_t size); +void flam3_free (void *ptr); + +void flam3_srandom (); + +flam3_genome *sheep_loop (flam3_genome * cp, double blend); +flam3_genome *sheep_edge (flam3_genome * cp, double blend, int seqflag, + double stagger); + + + + + +extern char *dirname (char *__path) + __attribute__ ((__nothrow__, __leaf__)); + + + + + + + +extern char *__xpg_basename (char *__path) + __attribute__ ((__nothrow__, __leaf__)); + + + + + + +void docstring (); + + +typedef struct +{ + unsigned short *xform_distrib; + flam3_frame *spec; + double bounds[4]; + double rot[2][2]; + double size[2]; + int width, height; + double ws0, wb0s0, hs1, hb1s1; + flam3_palette_entry *dmap; + double color_scalar; + void *buckets; + double badvals; + double batch_size; + int temporal_sample_num, ntemporal_samples; + int batch_num, nbatches, aborted; + time_t *progress_timer; + time_t *progress_timer_history; + double *progress_history; + int *progress_history_mark; + + + pthread_mutex_t bucket_mutex; + + +} flam3_iter_constants; + +typedef struct +{ + + double tx, ty; + + double precalc_atan, precalc_sina; + double precalc_cosa, precalc_sqrt; + double precalc_sumsq, precalc_atanyx; + + flam3_xform *xform; + + + + double p0, p1; + + + randctx *rc; + +} flam3_iter_helper; + +typedef struct +{ + double *iter_storage; + randctx rc; + flam3_genome cp; + int first_thread; + int timer_initialize; + flam3_iter_constants *fic; +} flam3_thread_helper; + +double flam3_sinc (double x); + + +double flam3_gaussian_filter (double x); +double flam3_hermite_filter (double t); +double flam3_box_filter (double t); +double flam3_triangle_filter (double t); +double flam3_bell_filter (double t); +double flam3_b_spline_filter (double t); +double flam3_lanczos3_filter (double t); +double flam3_lanczos2_filter (double t); +double flam3_mitchell_filter (double t); +double flam3_blackman_filter (double x); +double flam3_catrom_filter (double x); +double flam3_hamming_filter (double x); +double flam3_hanning_filter (double x); +double flam3_quadratic_filter (double x); + +double flam3_spatial_filter (int knum, double x); +typedef struct +{ + int max_filtered_counts; + int max_filter_index; + int kernel_size; + double *filter_widths; + double *filter_coefs; +} flam3_de_helper; + +extern double flam3_spatial_support[14]; + +double flam3_spatial_filter (int knum, double x); +int flam3_create_spatial_filter (flam3_frame * spec, int field, + double **filter); +flam3_de_helper flam3_create_de_filters (double max_rad, double min_rad, + double curve, int ss); +double flam3_create_temporal_filter (int numsteps, int filter_type, + double filter_exp, + double filter_width, + double **temporal_filter, + double **temporal_deltas); + +double flam3_spatial_support[14] = { + 1.5, + 1.0, + 0.5, + 1.0, + 1.5, + 2.0, + 2.0, + 1.0, + 2.0, + 1.0, + 1.0, + 3.0, + 2.0, + 1.5 +}; + +double +flam3_hermite_filter (double t) +{ + + if (t < 0.0) + t = -t; + if (t < 1.0) + return ((2.0 * t - 3.0) * t * t + 1.0); + return (0.0); +} + +double +flam3_box_filter (double t) +{ + if ((t > -0.5) && (t <= 0.5)) + return (1.0); + return (0.0); +} + +double +flam3_triangle_filter (double t) +{ + if (t < 0.0) + t = -t; + if (t < 1.0) + return (1.0 - t); + return (0.0); +} + +double +flam3_bell_filter (double t) +{ + + if (t < 0) + t = -t; + if (t < .5) + return (.75 - (t * t)); + if (t < 1.5) + { + t = (t - 1.5); + return (.5 * (t * t)); + } + return (0.0); +} + +double +flam3_b_spline_filter (double t) +{ + + + double tt; + + if (t < 0) + t = -t; + if (t < 1) + { + tt = t * t; + return ((.5 * tt * t) - tt + (2.0 / 3.0)); + } + else if (t < 2) + { + t = 2 - t; + return ((1.0 / 6.0) * (t * t * t)); + } + return (0.0); +} + +double +flam3_sinc (double x) +{ + x *= 3.14159265358979323846; + if (x != 0) + return (sin (x) / x); + return (1.0); +} + +double +flam3_blackman_filter (double x) +{ + return (0.42 + 0.5 * cos (3.14159265358979323846 * x) + 0.08 * cos (2 * 3.14159265358979323846 * x)); +} + +double +flam3_catrom_filter (double x) +{ + if (x < -2.0) + return (0.0); + if (x < -1.0) + return (0.5 * (4.0 + x * (8.0 + x * (5.0 + x)))); + if (x < 0.0) + return (0.5 * (2.0 + x * x * (-5.0 - 3.0 * x))); + if (x < 1.0) + return (0.5 * (2.0 + x * x * (-5.0 + 3.0 * x))); + if (x < 2.0) + return (0.5 * (4.0 + x * (-8.0 + x * (5.0 - x)))); + return (0.0); +} + +double +flam3_mitchell_filter (double t) +{ + double tt; + + tt = t * t; + if (t < 0) + t = -t; + if (t < 1.0) + { + t = (((12.0 - 9.0 * (1.0 / 3.0) - 6.0 * (1.0 / 3.0)) * (t * tt)) + + ((-18.0 + 12.0 * (1.0 / 3.0) + 6.0 * (1.0 / 3.0)) * tt) + + (6.0 - 2 * (1.0 / 3.0))); + return (t / 6.0); + } + else if (t < 2.0) + { + t = (((-1.0 * (1.0 / 3.0) - 6.0 * (1.0 / 3.0)) * (t * tt)) + + ((6.0 * (1.0 / 3.0) + 30.0 * (1.0 / 3.0)) * tt) + + ((-12.0 * (1.0 / 3.0) - 48.0 * (1.0 / 3.0)) * t) + + (8.0 * (1.0 / 3.0) + 24 * (1.0 / 3.0))); + return (t / 6.0); + } + return (0.0); +} + +double +flam3_hanning_filter (double x) +{ + return (0.5 + 0.5 * cos (3.14159265358979323846 * x)); +} + +double +flam3_hamming_filter (double x) +{ + return (0.54 + 0.46 * cos (3.14159265358979323846 * x)); +} + +double +flam3_lanczos3_filter (double t) +{ + if (t < 0) + t = -t; + if (t < 3.0) + return (flam3_sinc (t) * flam3_sinc (t / 3.0)); + return (0.0); +} + +double +flam3_lanczos2_filter (double t) +{ + if (t < 0) + t = -t; + if (t < 2.0) + return (flam3_sinc (t) * flam3_sinc (t / 2.0)); + return (0.0); +} + +double +flam3_gaussian_filter (double x) +{ + return (exp ((-2.0 * x * x)) * sqrt (2.0 / 3.14159265358979323846)); +} + +double +flam3_quadratic_filter (double x) +{ + if (x < -1.5) + return (0.0); + if (x < -0.5) + return (0.5 * (x + 1.5) * (x + 1.5)); + if (x < 0.5) + return (0.75 - x * x); + if (x < 1.5) + return (0.5 * (x - 1.5) * (x - 1.5)); + return (0.0); +} + +double +flam3_spatial_filter (int knum, double x) +{ + + if (knum == 0) + return flam3_gaussian_filter (x); + else if (knum == 1) + return flam3_hermite_filter (x); + else if (knum == 2) + return flam3_box_filter (x); + else if (knum == 3) + return flam3_triangle_filter (x); + else if (knum == 4) + return flam3_bell_filter (x); + else if (knum == 5) + return flam3_b_spline_filter (x); + else if (knum == 6) + return flam3_mitchell_filter (x); + else if (knum == 7) + return flam3_sinc (x) * flam3_blackman_filter (x); + else if (knum == 8) + return flam3_catrom_filter (x); + else if (knum == 9) + return flam3_sinc (x) * flam3_hanning_filter (x); + else if (knum == 10) + return flam3_sinc (x) * flam3_hamming_filter (x); + else if (knum == 11) + return flam3_lanczos3_filter (x) * flam3_sinc (x / 3.0); + else if (knum == 12) + return flam3_lanczos2_filter (x) * flam3_sinc (x / 2.0); + else if (knum == 13) + return flam3_quadratic_filter (x); +} + +int +normalize_vector (double *v, int n) +{ + double t = 0.0; + int i; + for (i = 0; i < n; i++) + t += v[i]; + if (0.0 == t) + return 1; + t = 1.0 / t; + for (i = 0; i < n; i++) + v[i] *= t; + return 0; +} + + +int +flam3_create_spatial_filter (flam3_frame * spec, int field, double **filter) +{ + + int sf_kernel = spec->genomes[0].spatial_filter_select; + int supersample = spec->genomes[0].spatial_oversample; + double sf_radius = spec->genomes[0].spatial_filter_radius; + double aspect_ratio = spec->pixel_aspect_ratio; + double sf_supp = flam3_spatial_support[sf_kernel]; + + double fw = 2.0 * sf_supp * supersample * sf_radius / aspect_ratio; + double adjust, ii, jj; + + int fwidth = ((int) fw) + 1; + int i, j; + + + + if ((fwidth ^ supersample) & 1) + fwidth++; + + + if (fw > 0.0) + adjust = sf_supp * fwidth / fw; + else + adjust = 1.0; + + + (*filter) = (double *) calloc (fwidth * fwidth, sizeof (double)); + + + for (i = 0; i < fwidth; i++) + for (j = 0; j < fwidth; j++) + { + + + ii = ((2.0 * i + 1.0) / (double) fwidth - 1.0) * adjust; + jj = ((2.0 * j + 1.0) / (double) fwidth - 1.0) * adjust; + + + if (field) + jj *= 2.0; + + + jj /= aspect_ratio; + + (*filter)[i + j * fwidth] = + flam3_spatial_filter (sf_kernel, + ii) * flam3_spatial_filter (sf_kernel, jj); + } + + + if (normalize_vector ((*filter), fwidth * fwidth)) + { + fprintf (stderr, + "Spatial filter value is too small: %g. Terminating.\n", + sf_radius); + return (-1); + } + + return (fwidth); +} + +flam3_de_helper +flam3_create_de_filters (double max_rad, double min_rad, double curve, int ss) +{ + + flam3_de_helper de; + double comp_max_radius, comp_min_radius; + double num_de_filters_d; + int num_de_filters, de_max_ind; + int de_row_size, de_half_size; + int filtloop; + int keep_thresh = 100; + + de.kernel_size = -1; + + if (curve <= 0.0) + { + fprintf (stderr, "estimator curve must be > 0\n"); + return (de); + } + + if (max_rad < min_rad) + { + fprintf (stderr, "estimator must be larger than estimator_minimum.\n"); + fprintf (stderr, "(%f > %f) ? \n", max_rad, min_rad); + return (de); + } + + + + comp_max_radius = max_rad * ss + 1; + comp_min_radius = min_rad * ss + 1; + + + + + + num_de_filters_d = pow (comp_max_radius / comp_min_radius, 1.0 / curve); + if (num_de_filters_d > 1e7) + { + fprintf (stderr, + "too many filters required in this configuration (%g)\n", + num_de_filters_d); + return (de); + } + num_de_filters = (int) ceil (num_de_filters_d); + + + if (num_de_filters > keep_thresh) + { + de_max_ind = (int) ceil (100 + pow (num_de_filters - 100, curve)) + 1; + de.max_filtered_counts = + (int) pow ((double) (de_max_ind - 100), 1.0 / curve) + 100; + } + else + { + de_max_ind = num_de_filters; + de.max_filtered_counts = de_max_ind; + } + + + + de_row_size = (int) (2 * ceil (comp_max_radius) - 1); + de_half_size = (de_row_size - 1) / 2; + de.kernel_size = (de_half_size + 1) * (2 + de_half_size) / 2; + + de.filter_coefs = + (double *) calloc (de_max_ind * de.kernel_size, sizeof (double)); + de.filter_widths = (double *) calloc (de_max_ind, sizeof (double)); + + + de.max_filter_index = 0; + for (filtloop = 0; filtloop < de_max_ind; filtloop++) + { + + double de_filt_sum = 0.0, de_filt_d; + double de_filt_h; + int dej, dek; + double adjloop; + int filter_coef_idx; + + + if (filtloop < keep_thresh) + de_filt_h = (comp_max_radius / pow (filtloop + 1, curve)); + else + { + adjloop = pow (filtloop - keep_thresh, (1.0 / curve)) + keep_thresh; + de_filt_h = (comp_max_radius / pow (adjloop + 1, curve)); + } + + + if (de_filt_h <= comp_min_radius) + { + de_filt_h = comp_min_radius; + de.max_filter_index = filtloop; + } + + de.filter_widths[filtloop] = de_filt_h; + + + for (dej = -de_half_size; dej <= de_half_size; dej++) + { + for (dek = -de_half_size; dek <= de_half_size; dek++) + { + + de_filt_d = sqrt ((double) (dej * dej + dek * dek)) / de_filt_h; + + + if (de_filt_d <= 1.0) + { + de_filt_sum += flam3_spatial_filter (0, flam3_spatial_support [0] * de_filt_d); + } + } + } + + filter_coef_idx = filtloop * de.kernel_size; + + + for (dej = 0; dej <= de_half_size; dej++) + { + for (dek = 0; dek <= dej; dek++) + { + de_filt_d = sqrt ((double) (dej * dej + dek * dek)) / de_filt_h; + + + if (de_filt_d > 1.0) + de.filter_coefs[filter_coef_idx] = 0.0; + else + { + de.filter_coefs[filter_coef_idx] = flam3_spatial_filter (0, flam3_spatial_support[0] * de_filt_d) / de_filt_sum; + } + + filter_coef_idx++; + } + } + + if (de.max_filter_index > 0) + break; + } + + if (de.max_filter_index == 0) + de.max_filter_index = de_max_ind - 1; + + + return (de); +} + +double +flam3_create_temporal_filter (int numsteps, int filter_type, + double filter_exp, double filter_width, + double **temporal_filter, + double **temporal_deltas) +{ + + double maxfilt = 0.0; + double sumfilt = 0.0; + double slpx, halfsteps; + double *deltas, *filter; + + int i; + + + deltas = (double *) malloc (numsteps * sizeof (double)); + filter = (double *) malloc (numsteps * sizeof (double)); + + + if (numsteps == 1) + { + deltas[0] = 0; + filter[0] = 1.0; + *temporal_deltas = deltas; + *temporal_filter = filter; + return (1.0); + } + + + for (i = 0; i < numsteps; i++) + deltas[i] = ((double) i / (double) (numsteps - 1) - 0.5) * filter_width; + + + if (2 == filter_type) + { + + for (i = 0; i < numsteps; i++) + { + + if (filter_exp >= 0) + slpx = ((double) i + 1.0) / numsteps; + else + slpx = (double) (numsteps - i) / numsteps; + + + filter[i] = pow (slpx, fabs (filter_exp)); + + + if (filter[i] > maxfilt) + maxfilt = filter[i]; + } + + } + else if (1 == filter_type) + { + + halfsteps = numsteps / 2.0; + for (i = 0; i < numsteps; i++) + { + + + filter[i] = flam3_spatial_filter (0, flam3_spatial_support[0] * fabs (i - halfsteps) / halfsteps); + if (filter[i] > maxfilt) + maxfilt = filter[i]; + } + + } + else + { + + for (i = 0; i < numsteps; i++) + filter[i] = 1.0; + + maxfilt = 1.0; + + } + + + + for (i = 0; i < numsteps; i++) + { + filter[i] /= maxfilt; + sumfilt += filter[i]; + } + + sumfilt /= numsteps; + + *temporal_deltas = deltas; + *temporal_filter = filter; + + return (sumfilt); +} Index: gcc/testsuite/g++.dg/pr65240-1.C =================================================================== --- gcc/testsuite/g++.dg/pr65240-1.C (revision 0) +++ gcc/testsuite/g++.dg/pr65240-1.C (revision 0) @@ -0,0 +1,9 @@ +/* { dg-do compile { target { powerpc*-*-* && lp64 } } } */ +/* { dg-skip-if "" { powerpc*-*-darwin* } { "*" } { "" } } */ +/* { dg-require-effective-target powerpc_p8vector_ok } */ +/* { dg-skip-if "do not override -mcpu" { powerpc*-*-* } { "-mcpu=*" } { "-mcpu=power8" } } */ +/* { dg-options "-mcpu=power8 -O3 -ffast-math -mcmodel=small -mno-fp-in-toc" } */ + +/* target/65240, compiler got a 'insn does not satisfy its constraints' error. */ + +#include "pr65240.h" Index: gcc/testsuite/g++.dg/pr65240-2.C =================================================================== --- gcc/testsuite/g++.dg/pr65240-2.C (revision 0) +++ gcc/testsuite/g++.dg/pr65240-2.C (revision 0) @@ -0,0 +1,9 @@ +/* { dg-do compile { target { powerpc*-*-* && lp64 } } } */ +/* { dg-skip-if "" { powerpc*-*-darwin* } { "*" } { "" } } */ +/* { dg-require-effective-target powerpc_p8vector_ok } */ +/* { dg-skip-if "do not override -mcpu" { powerpc*-*-* } { "-mcpu=*" } { "-mcpu=power8" } } */ +/* { dg-options "-mcpu=power8 -O3 -ffast-math -mcmodel=small -mfp-in-toc" } */ + +/* target/65240, compiler got a 'insn does not satisfy its constraints' error. */ + +#include "pr65240.h" Index: gcc/testsuite/g++.dg/pr65240-3.C =================================================================== --- gcc/testsuite/g++.dg/pr65240-3.C (revision 0) +++ gcc/testsuite/g++.dg/pr65240-3.C (revision 0) @@ -0,0 +1,9 @@ +/* { dg-do compile { target { powerpc*-*-* && lp64 } } } */ +/* { dg-skip-if "" { powerpc*-*-darwin* } { "*" } { "" } } */ +/* { dg-require-effective-target powerpc_p8vector_ok } */ +/* { dg-skip-if "do not override -mcpu" { powerpc*-*-* } { "-mcpu=*" } { "-mcpu=power8" } } */ +/* { dg-options "-mcpu=power8 -O3 -ffast-math -mcmodel=medium" } */ + +/* target/65240, compiler got a 'insn does not satisfy its constraints' error. */ + +#include "pr65240.h" Index: gcc/testsuite/g++.dg/pr65240-4.C =================================================================== --- gcc/testsuite/g++.dg/pr65240-4.C (revision 0) +++ gcc/testsuite/g++.dg/pr65240-4.C (revision 0) @@ -0,0 +1,9 @@ +/* { dg-do compile { target { powerpc*-*-* && lp64 } } } */ +/* { dg-skip-if "" { powerpc*-*-darwin* } { "*" } { "" } } */ +/* { dg-require-effective-target powerpc_vsx_ok } */ +/* { dg-skip-if "do not override -mcpu" { powerpc*-*-* } { "-mcpu=*" } { "-mcpu=power7" } } */ +/* { dg-options "-mcpu=power7 -O3 -ffast-math" } */ + +/* target/65240, compiler got a 'insn does not satisfy its constraints' error. */ + +#include "pr65240.h"