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

   1 // -*- C++ -*-
   2
   3 #include <stdio.h>
   4 #include <stddef.h>
   5 #include <stdint.h>
   6 #include <ctype.h>
   7 #include <unistd.h>
   8 #include <string.h>
   9 #include <stdlib.h>
  10 #include <math.h>
  11 #include <sys/types.h>
  12 #include <time.h>
  13 #include <signal.h>
  14 #include <pthread.h>
  15
  16 void xmlCheckVersion (int version);
  17 typedef unsigned char xmlChar;
  18 xmlChar *xmlStrdup (const xmlChar * cur);
  19 xmlChar *xmlStrndup (const xmlChar * cur, int len);
  20 xmlChar *xmlCharStrndup (const char *cur, int len);
  21 xmlChar *xmlCharStrdup (const char *cur);
  22 xmlChar *xmlStrsub (const xmlChar * str, int start, int len);
  23 const xmlChar *xmlStrchr (const xmlChar * str, xmlChar val);
  24 const xmlChar *xmlStrstr (const xmlChar * str, const xmlChar * val);
  25 const xmlChar *xmlStrcasestr (const xmlChar * str, const xmlChar * val);
  26 int xmlStrcmp (const xmlChar * str1, const xmlChar * str2);
  27 int xmlStrncmp (const xmlChar * str1, const xmlChar * str2, int len);
  28 int xmlStrcasecmp (const xmlChar * str1, const xmlChar * str2);
  29 int xmlStrncasecmp (const xmlChar * str1, const xmlChar * str2, int len);
  30 int xmlStrEqual (const xmlChar * str1, const xmlChar * str2);
  31 int xmlStrQEqual (const xmlChar * pref,
  32                   const xmlChar * name, const xmlChar * str);
  33 int xmlStrlen (const xmlChar * str);
  34 xmlChar *xmlStrcat (xmlChar * cur, const xmlChar * add);
  35 xmlChar *xmlStrncat (xmlChar * cur, const xmlChar * add, int len);
  36 xmlChar *xmlStrncatNew (const xmlChar * str1, const xmlChar * str2, int len);
  37 int xmlStrPrintf (xmlChar * buf, int len, const xmlChar * msg, ...);
  38 int xmlStrVPrintf (xmlChar * buf, int len, const xmlChar * msg, va_list ap);
  39 int xmlGetUTF8Char (const unsigned char *utf, int *len);
  40 int xmlCheckUTF8 (const unsigned char *utf);
  41 int xmlUTF8Strsize (const xmlChar * utf, int len);
  42 xmlChar *xmlUTF8Strndup (const xmlChar * utf, int len);
  43 const xmlChar *xmlUTF8Strpos (const xmlChar * utf, int pos);
  44 int xmlUTF8Strloc (const xmlChar * utf, const xmlChar * utfchar);
  45 xmlChar *xmlUTF8Strsub (const xmlChar * utf, int start, int len);
  46 int xmlUTF8Strlen (const xmlChar * utf);
  47 int xmlUTF8Size (const xmlChar * utf);
  48 int xmlUTF8Charcmp (const xmlChar * utf1, const xmlChar * utf2);
  49
  50 typedef struct _xmlParserInputBuffer xmlParserInputBuffer;
  51 typedef xmlParserInputBuffer *xmlParserInputBufferPtr;
  52 typedef struct _xmlOutputBuffer xmlOutputBuffer;
  53 typedef xmlOutputBuffer *xmlOutputBufferPtr;
  54 typedef struct _xmlParserInput xmlParserInput;
  55 typedef xmlParserInput *xmlParserInputPtr;
  56 typedef struct _xmlParserCtxt xmlParserCtxt;
  57 typedef xmlParserCtxt *xmlParserCtxtPtr;
  58 typedef struct _xmlSAXLocator xmlSAXLocator;
  59 typedef xmlSAXLocator *xmlSAXLocatorPtr;
  60 typedef struct _xmlSAXHandler xmlSAXHandler;
  61 typedef xmlSAXHandler *xmlSAXHandlerPtr;
  62 typedef struct _xmlEntity xmlEntity;
  63 typedef xmlEntity *xmlEntityPtr;
  64
  65 typedef enum
  66 {
  67   XML_BUFFER_ALLOC_DOUBLEIT,
  68   XML_BUFFER_ALLOC_EXACT,
  69   XML_BUFFER_ALLOC_IMMUTABLE,
  70   XML_BUFFER_ALLOC_IO,
  71   XML_BUFFER_ALLOC_HYBRID
  72 } xmlBufferAllocationScheme;
  73
  74 typedef struct _xmlBuffer xmlBuffer;
  75 typedef xmlBuffer *xmlBufferPtr;
  76
  77 struct _xmlBuffer
  78 {
  79   xmlChar *content;
  80   unsigned int use;
  81   unsigned int size;
  82   xmlBufferAllocationScheme alloc;
  83   xmlChar *contentIO;
  84 };
  85
  86 typedef struct _xmlBuf xmlBuf;
  87 typedef xmlBuf *xmlBufPtr;
  88
  89 xmlChar *xmlBufContent (const xmlBuf * buf);
  90 xmlChar *xmlBufEnd (xmlBufPtr buf);
  91 size_t xmlBufUse (const xmlBufPtr buf);
  92 size_t xmlBufShrink (xmlBufPtr buf, size_t len);
  93
  94 typedef enum
  95 {
  96   XML_ELEMENT_NODE = 1,
  97   XML_ATTRIBUTE_NODE = 2,
  98   XML_TEXT_NODE = 3,
  99   XML_CDATA_SECTION_NODE = 4,
 100   XML_ENTITY_REF_NODE = 5,
 101   XML_ENTITY_NODE = 6,
 102   XML_PI_NODE = 7,
 103   XML_COMMENT_NODE = 8,
 104   XML_DOCUMENT_NODE = 9,
 105   XML_DOCUMENT_TYPE_NODE = 10,
 106   XML_DOCUMENT_FRAG_NODE = 11,
 107   XML_NOTATION_NODE = 12,
 108   XML_HTML_DOCUMENT_NODE = 13,
 109   XML_DTD_NODE = 14,
 110   XML_ELEMENT_DECL = 15,
 111   XML_ATTRIBUTE_DECL = 16,
 112   XML_ENTITY_DECL = 17,
 113   XML_NAMESPACE_DECL = 18,
 114   XML_XINCLUDE_START = 19,
 115   XML_XINCLUDE_END = 20, XML_DOCB_DOCUMENT_NODE = 21
 116 } xmlElementType;
 117
 118 typedef struct _xmlNotation xmlNotation;
 119 typedef xmlNotation *xmlNotationPtr;
 120
 121 struct _xmlNotation
 122 {
 123   const xmlChar *name;
 124   const xmlChar *PublicID;
 125   const xmlChar *SystemID;
 126 };
 127
 128 typedef enum
 129 {
 130   XML_ATTRIBUTE_CDATA = 1,
 131   XML_ATTRIBUTE_ID,
 132   XML_ATTRIBUTE_IDREF,
 133   XML_ATTRIBUTE_IDREFS,
 134   XML_ATTRIBUTE_ENTITY,
 135   XML_ATTRIBUTE_ENTITIES,
 136   XML_ATTRIBUTE_NMTOKEN,
 137   XML_ATTRIBUTE_NMTOKENS,
 138   XML_ATTRIBUTE_ENUMERATION,
 139   XML_ATTRIBUTE_NOTATION
 140 } xmlAttributeType;
 141
 142 typedef enum
 143 {
 144   XML_ATTRIBUTE_NONE = 1,
 145   XML_ATTRIBUTE_REQUIRED,
 146   XML_ATTRIBUTE_IMPLIED,
 147   XML_ATTRIBUTE_FIXED
 148 } xmlAttributeDefault;
 149
 150 typedef struct _xmlEnumeration xmlEnumeration;
 151 typedef xmlEnumeration *xmlEnumerationPtr;
 152
 153 struct _xmlEnumeration
 154 {
 155   struct _xmlEnumeration *next;
 156   const xmlChar *name;
 157 };
 158
 159 typedef struct _xmlAttribute xmlAttribute;
 160 typedef xmlAttribute *xmlAttributePtr;
 161 struct _xmlAttribute
 162 {
 163   void *_private;
 164   xmlElementType type;
 165   const xmlChar *name;
 166   struct _xmlNode *children;
 167   struct _xmlNode *last;
 168   struct _xmlDtd *parent;
 169   struct _xmlNode *next;
 170   struct _xmlNode *prev;
 171   struct _xmlDoc *doc;
 172
 173   struct _xmlAttribute *nexth;
 174   xmlAttributeType atype;
 175   xmlAttributeDefault def;
 176   const xmlChar *defaultValue;
 177   xmlEnumerationPtr tree;
 178   const xmlChar *prefix;
 179   const xmlChar *elem;
 180 };
 181
 182 typedef enum
 183 {
 184   XML_ELEMENT_CONTENT_PCDATA = 1,
 185   XML_ELEMENT_CONTENT_ELEMENT,
 186   XML_ELEMENT_CONTENT_SEQ,
 187   XML_ELEMENT_CONTENT_OR
 188 } xmlElementContentType;
 189
 190 typedef enum
 191 {
 192   XML_ELEMENT_CONTENT_ONCE = 1,
 193   XML_ELEMENT_CONTENT_OPT,
 194   XML_ELEMENT_CONTENT_MULT,
 195   XML_ELEMENT_CONTENT_PLUS
 196 } xmlElementContentOccur;
 197
 198 typedef struct _xmlElementContent xmlElementContent;
 199 typedef xmlElementContent *xmlElementContentPtr;
 200
 201 struct _xmlElementContent
 202 {
 203   xmlElementContentType type;
 204   xmlElementContentOccur ocur;
 205   const xmlChar *name;
 206   struct _xmlElementContent *c1;
 207   struct _xmlElementContent *c2;
 208   struct _xmlElementContent *parent;
 209   const xmlChar *prefix;
 210 };
 211
 212 typedef enum
 213 {
 214   XML_ELEMENT_TYPE_UNDEFINED = 0,
 215   XML_ELEMENT_TYPE_EMPTY = 1,
 216   XML_ELEMENT_TYPE_ANY,
 217   XML_ELEMENT_TYPE_MIXED,
 218   XML_ELEMENT_TYPE_ELEMENT
 219 } xmlElementTypeVal;
 220
 221 typedef struct _xmlRegexp xmlRegexp;
 222 typedef xmlRegexp *xmlRegexpPtr;
 223 typedef struct _xmlRegExecCtxt xmlRegExecCtxt;
 224 typedef xmlRegExecCtxt *xmlRegExecCtxtPtr;
 225 typedef struct _xmlDict xmlDict;
 226 typedef xmlDict *xmlDictPtr;
 227
 228 int xmlInitializeDict (void);
 229 xmlDictPtr xmlDictCreate (void);
 230 size_t xmlDictSetLimit (xmlDictPtr dict, size_t limit);
 231 size_t xmlDictGetUsage (xmlDictPtr dict);
 232 xmlDictPtr xmlDictCreateSub (xmlDictPtr sub);
 233 int xmlDictReference (xmlDictPtr dict);
 234 void xmlDictFree (xmlDictPtr dict);
 235 const xmlChar *xmlDictLookup (xmlDictPtr dict, const xmlChar * name, int len);
 236 const xmlChar *xmlDictExists (xmlDictPtr dict, const xmlChar * name, int len);
 237 const xmlChar *xmlDictQLookup (xmlDictPtr dict,
 238                                const xmlChar * prefix, const xmlChar * name);
 239 int xmlDictOwns (xmlDictPtr dict, const xmlChar * str);
 240 int xmlDictSize (xmlDictPtr dict);
 241 void xmlDictCleanup (void);
 242 xmlRegexpPtr xmlRegexpCompile (const xmlChar * regexp);
 243 void xmlRegFreeRegexp (xmlRegexpPtr regexp);
 244 int xmlRegexpExec (xmlRegexpPtr comp, const xmlChar * value);
 245 void xmlRegexpPrint (FILE * output, xmlRegexpPtr regexp);
 246 int xmlRegexpIsDeterminist (xmlRegexpPtr comp);
 247 typedef void (*xmlRegExecCallbacks) (xmlRegExecCtxtPtr exec,
 248                                      const xmlChar * token,
 249                                      void *transdata, void *inputdata);
 250 xmlRegExecCtxtPtr
 251 xmlRegNewExecCtxt (xmlRegexpPtr comp,
 252                    xmlRegExecCallbacks callback, void *data);
 253 void xmlRegFreeExecCtxt (xmlRegExecCtxtPtr exec);
 254 int xmlRegExecPushString (xmlRegExecCtxtPtr exec,
 255                           const xmlChar * value, void *data);
 256 int xmlRegExecPushString2 (xmlRegExecCtxtPtr exec,
 257                            const xmlChar * value,
 258                            const xmlChar * value2, void *data);
 259
 260 int xmlRegExecNextValues (xmlRegExecCtxtPtr exec,
 261                           int *nbval,
 262                           int *nbneg, xmlChar ** values, int *terminal);
 263 int xmlRegExecErrInfo (xmlRegExecCtxtPtr exec,
 264                        const xmlChar ** string,
 265                        int *nbval, int *nbneg, xmlChar ** values, int *terminal);
 266
 267 typedef struct _xmlExpCtxt xmlExpCtxt;
 268 typedef xmlExpCtxt *xmlExpCtxtPtr;
 269 void xmlExpFreeCtxt (xmlExpCtxtPtr ctxt);
 270 xmlExpCtxtPtr xmlExpNewCtxt (int maxNodes, xmlDictPtr dict);
 271 int xmlExpCtxtNbNodes (xmlExpCtxtPtr ctxt);
 272 int xmlExpCtxtNbCons (xmlExpCtxtPtr ctxt);
 273 typedef struct _xmlExpNode xmlExpNode;
 274 typedef xmlExpNode *xmlExpNodePtr;
 275
 276 typedef enum
 277 {
 278   XML_EXP_EMPTY = 0,
 279   XML_EXP_FORBID = 1,
 280   XML_EXP_ATOM = 2,
 281   XML_EXP_SEQ = 3,
 282   XML_EXP_OR = 4,
 283   XML_EXP_COUNT = 5
 284 } xmlExpNodeType;
 285
 286 extern xmlExpNodePtr forbiddenExp;
 287 extern xmlExpNodePtr emptyExp;
 288
 289 void xmlExpFree (xmlExpCtxtPtr ctxt, xmlExpNodePtr expr);
 290 void xmlExpRef (xmlExpNodePtr expr);
 291
 292 xmlExpNodePtr xmlExpParse (xmlExpCtxtPtr ctxt, const char *expr);
 293 xmlExpNodePtr xmlExpNewAtom (xmlExpCtxtPtr ctxt, const xmlChar * name, int len);
 294 xmlExpNodePtr xmlExpNewOr (xmlExpCtxtPtr ctxt, xmlExpNodePtr left, xmlExpNodePtr right);
 295 xmlExpNodePtr xmlExpNewSeq (xmlExpCtxtPtr ctxt, xmlExpNodePtr left, xmlExpNodePtr right);
 296 xmlExpNodePtr xmlExpNewRange (xmlExpCtxtPtr ctxt, xmlExpNodePtr subset, int min, int max);
 297
 298 int xmlExpIsNillable (xmlExpNodePtr expr);
 299 int xmlExpMaxToken (xmlExpNodePtr expr);
 300 int xmlExpGetLanguage (xmlExpCtxtPtr ctxt,
 301                        xmlExpNodePtr expr, const xmlChar ** langList, int len);
 302 int xmlExpGetStart (xmlExpCtxtPtr ctxt,
 303                     xmlExpNodePtr expr, const xmlChar ** tokList, int len);
 304 xmlExpNodePtr xmlExpStringDerive (xmlExpCtxtPtr ctxt,
 305                                   xmlExpNodePtr expr, const xmlChar * str, int len);
 306 xmlExpNodePtr xmlExpExpDerive (xmlExpCtxtPtr ctxt, xmlExpNodePtr expr, xmlExpNodePtr sub);
 307 int xmlExpSubsume (xmlExpCtxtPtr ctxt, xmlExpNodePtr expr, xmlExpNodePtr sub);
 308 void xmlExpDump (xmlBufferPtr buf, xmlExpNodePtr expr);
 309 typedef struct _xmlElement xmlElement;
 310 typedef xmlElement *xmlElementPtr;
 311
 312 struct _xmlElement
 313 {
 314   void *_private;
 315   xmlElementType type;
 316   const xmlChar *name;
 317   struct _xmlNode *children;
 318   struct _xmlNode *last;
 319   struct _xmlDtd *parent;
 320   struct _xmlNode *next;
 321   struct _xmlNode *prev;
 322   struct _xmlDoc *doc;
 323   xmlElementTypeVal etype;
 324   xmlElementContentPtr content;
 325   xmlAttributePtr attributes;
 326   const xmlChar *prefix;
 327   xmlRegexpPtr contModel;
 328 };
 329
 330 typedef xmlElementType xmlNsType;
 331 typedef struct _xmlNs xmlNs;
 332 typedef xmlNs *xmlNsPtr;
 333
 334 struct _xmlNs
 335 {
 336   struct _xmlNs *next;
 337   xmlNsType type;
 338   const xmlChar *href;
 339   const xmlChar *prefix;
 340   void *_private;
 341   struct _xmlDoc *context;
 342 };
 343
 344 typedef struct _xmlDtd xmlDtd;
 345 typedef xmlDtd *xmlDtdPtr;
 346 struct _xmlDtd
 347 {
 348   void *_private;
 349   xmlElementType type;
 350   const xmlChar *name;
 351   struct _xmlNode *children;
 352   struct _xmlNode *last;
 353   struct _xmlDoc *parent;
 354   struct _xmlNode *next;
 355   struct _xmlNode *prev;
 356   struct _xmlDoc *doc;
 357   void *notations;
 358   void *elements;
 359   void *attributes;
 360   void *entities;
 361   const xmlChar *ExternalID;
 362   const xmlChar *SystemID;
 363   void *pentities;
 364 };
 365
 366 typedef struct _xmlAttr xmlAttr;
 367 typedef xmlAttr *xmlAttrPtr;
 368 struct _xmlAttr
 369 {
 370   void *_private;
 371   xmlElementType type;
 372   const xmlChar *name;
 373   struct _xmlNode *children;
 374   struct _xmlNode *last;
 375   struct _xmlNode *parent;
 376   struct _xmlAttr *next;
 377   struct _xmlAttr *prev;
 378   struct _xmlDoc *doc;
 379   xmlNs *ns;
 380   xmlAttributeType atype;
 381   void *psvi;
 382 };
 383
 384 typedef struct _xmlID xmlID;
 385 typedef xmlID *xmlIDPtr;
 386 struct _xmlID
 387 {
 388   struct _xmlID *next;
 389   const xmlChar *value;
 390   xmlAttrPtr attr;
 391   const xmlChar *name;
 392   int lineno;
 393   struct _xmlDoc *doc;
 394 };
 395
 396 typedef struct _xmlRef xmlRef;
 397 typedef xmlRef *xmlRefPtr;
 398 struct _xmlRef
 399 {
 400   struct _xmlRef *next;
 401   const xmlChar *value;
 402   xmlAttrPtr attr;
 403   const xmlChar *name;
 404   int lineno;
 405 };
 406
 407 typedef struct _xmlNode xmlNode;
 408 typedef xmlNode *xmlNodePtr;
 409 struct _xmlNode
 410 {
 411   void *_private;
 412   xmlElementType type;
 413   const xmlChar *name;
 414   struct _xmlNode *children;
 415   struct _xmlNode *last;
 416   struct _xmlNode *parent;
 417   struct _xmlNode *next;
 418   struct _xmlNode *prev;
 419   struct _xmlDoc *doc;
 420   xmlNs *ns;
 421   xmlChar *content;
 422   struct _xmlAttr *properties;
 423   xmlNs *nsDef;
 424   void *psvi;
 425   unsigned short line;
 426   unsigned short extra;
 427 };
 428
 429 typedef enum
 430 {
 431   XML_DOC_WELLFORMED = 1 << 0,
 432   XML_DOC_NSVALID = 1 << 1,
 433   XML_DOC_OLD10 = 1 << 2,
 434   XML_DOC_DTDVALID = 1 << 3,
 435   XML_DOC_XINCLUDE = 1 << 4,
 436   XML_DOC_USERBUILT = 1 << 5,
 437   XML_DOC_INTERNAL = 1 << 6,
 438   XML_DOC_HTML = 1 << 7
 439 } xmlDocProperties;
 440
 441 typedef struct _xmlDoc xmlDoc;
 442 typedef xmlDoc *xmlDocPtr;
 443
 444 struct _xmlDoc
 445 {
 446   void *_private;
 447   xmlElementType type;
 448   char *name;
 449   struct _xmlNode *children;
 450   struct _xmlNode *last;
 451   struct _xmlNode *parent;
 452   struct _xmlNode *next;
 453   struct _xmlNode *prev;
 454   struct _xmlDoc *doc;
 455   int compression;
 456   int standalone;
 457   struct _xmlDtd *intSubset;
 458   struct _xmlDtd *extSubset;
 459   struct _xmlNs *oldNs;
 460   const xmlChar *version;
 461   const xmlChar *encoding;
 462   void *ids;
 463   void *refs;
 464   const xmlChar *URL;
 465   int charset;
 466   struct _xmlDict *dict;
 467   void *psvi;
 468   int parseFlags;
 469   int properties;
 470 };
 471
 472 typedef struct _xmlDOMWrapCtxt xmlDOMWrapCtxt;
 473 typedef xmlDOMWrapCtxt *xmlDOMWrapCtxtPtr;
 474 typedef xmlNsPtr (*xmlDOMWrapAcquireNsFunction) (xmlDOMWrapCtxtPtr ctxt,
 475                                                  xmlNodePtr node,
 476                                                  const xmlChar * nsName,
 477                                                  const xmlChar * nsPrefix);
 478
 479 struct _xmlDOMWrapCtxt
 480 {
 481   void *_private;
 482   int type;
 483   void *namespaceMap;
 484   xmlDOMWrapAcquireNsFunction getNsForNodeFunc;
 485 };
 486
 487 int xmlValidateNCName (const xmlChar * value, int space);
 488 int xmlValidateQName (const xmlChar * value, int space);
 489 int xmlValidateName (const xmlChar * value, int space);
 490 int xmlValidateNMToken (const xmlChar * value, int space);
 491 xmlChar *xmlBuildQName (const xmlChar * ncname,
 492                         const xmlChar * prefix, xmlChar * memory, int len);
 493 xmlChar *xmlSplitQName2 (const xmlChar * name, xmlChar ** prefix);
 494 const xmlChar *xmlSplitQName3 (const xmlChar * name, int *len);
 495 void xmlSetBufferAllocationScheme (xmlBufferAllocationScheme scheme);
 496 xmlBufferAllocationScheme xmlGetBufferAllocationScheme (void);
 497 xmlBufferPtr xmlBufferCreate (void);
 498 xmlBufferPtr xmlBufferCreateSize (size_t size);
 499 xmlBufferPtr xmlBufferCreateStatic (void *mem, size_t size);
 500 int xmlBufferResize (xmlBufferPtr buf, unsigned int size);
 501 void xmlBufferFree (xmlBufferPtr buf);
 502 int xmlBufferDump (FILE * file, xmlBufferPtr buf);
 503 int xmlBufferAdd (xmlBufferPtr buf, const xmlChar * str, int len);
 504 int xmlBufferAddHead (xmlBufferPtr buf, const xmlChar * str, int len);
 505 int xmlBufferCat (xmlBufferPtr buf, const xmlChar * str);
 506 int xmlBufferCCat (xmlBufferPtr buf, const char *str);
 507 int xmlBufferShrink (xmlBufferPtr buf, unsigned int len);
 508 int xmlBufferGrow (xmlBufferPtr buf, unsigned int len);
 509 void xmlBufferEmpty (xmlBufferPtr buf);
 510 const xmlChar *xmlBufferContent (const xmlBuffer * buf);
 511 xmlChar *xmlBufferDetach (xmlBufferPtr buf);
 512 void xmlBufferSetAllocationScheme (xmlBufferPtr buf,
 513                                    xmlBufferAllocationScheme scheme);
 514 int xmlBufferLength (const xmlBuffer * buf);
 515
 516 xmlDtdPtr xmlCreateIntSubset (xmlDocPtr doc,
 517                               const xmlChar * name,
 518                               const xmlChar * ExternalID, const xmlChar * SystemID);
 519 xmlDtdPtr xmlNewDtd (xmlDocPtr doc,
 520                      const xmlChar * name,
 521                      const xmlChar * ExternalID, const xmlChar * SystemID);
 522 xmlDtdPtr xmlGetIntSubset (const xmlDoc * doc);
 523 void xmlFreeDtd (xmlDtdPtr cur);
 524
 525 xmlNsPtr xmlNewGlobalNs (xmlDocPtr doc, const xmlChar * href, const xmlChar * prefix);
 526
 527 xmlNsPtr xmlNewNs (xmlNodePtr node, const xmlChar * href, const xmlChar * prefix);
 528 void xmlFreeNs (xmlNsPtr cur);
 529 void xmlFreeNsList (xmlNsPtr cur);
 530 xmlDocPtr xmlNewDoc (const xmlChar * version);
 531 void xmlFreeDoc (xmlDocPtr cur);
 532 xmlAttrPtr xmlNewDocProp (xmlDocPtr doc, const xmlChar * name, const xmlChar * value);
 533
 534
 535 xmlAttrPtr xmlNewProp (xmlNodePtr node, const xmlChar * name, const xmlChar * value);
 536
 537 xmlAttrPtr xmlNewNsProp (xmlNodePtr node,
 538                          xmlNsPtr ns, const xmlChar * name, const xmlChar * value);
 539 xmlAttrPtr xmlNewNsPropEatName (xmlNodePtr node,
 540                                 xmlNsPtr ns, xmlChar * name, const xmlChar * value);
 541 void xmlFreePropList (xmlAttrPtr cur);
 542 void xmlFreeProp (xmlAttrPtr cur);
 543 xmlAttrPtr xmlCopyProp (xmlNodePtr target, xmlAttrPtr cur);
 544 xmlAttrPtr xmlCopyPropList (xmlNodePtr target, xmlAttrPtr cur);
 545 xmlDtdPtr xmlCopyDtd (xmlDtdPtr dtd);
 546 xmlDocPtr xmlCopyDoc (xmlDocPtr doc, int recursive);
 547 xmlNodePtr xmlNewDocNode (xmlDocPtr doc,
 548                           xmlNsPtr ns, const xmlChar * name, const xmlChar * content);
 549 xmlNodePtr xmlNewDocNodeEatName (xmlDocPtr doc,
 550                                  xmlNsPtr ns, xmlChar * name, const xmlChar * content);
 551 xmlNodePtr xmlNewNode (xmlNsPtr ns, const xmlChar * name);
 552 xmlNodePtr xmlNewNodeEatName (xmlNsPtr ns, xmlChar * name);
 553
 554 xmlNodePtr xmlNewChild (xmlNodePtr parent,
 555                         xmlNsPtr ns, const xmlChar * name, const xmlChar * content);
 556 xmlNodePtr xmlNewDocText (const xmlDoc * doc, const xmlChar * content);
 557 xmlNodePtr xmlNewText (const xmlChar * content);
 558 xmlNodePtr xmlNewDocPI (xmlDocPtr doc, const xmlChar * name, const xmlChar * content);
 559 xmlNodePtr xmlNewPI (const xmlChar * name, const xmlChar * content);
 560 xmlNodePtr xmlNewDocTextLen (xmlDocPtr doc, const xmlChar * content, int len);
 561 xmlNodePtr xmlNewTextLen (const xmlChar * content, int len);
 562 xmlNodePtr xmlNewDocComment (xmlDocPtr doc, const xmlChar * content);
 563 xmlNodePtr xmlNewComment (const xmlChar * content);
 564 xmlNodePtr xmlNewCDataBlock (xmlDocPtr doc, const xmlChar * content, int len);
 565 xmlNodePtr xmlNewCharRef (xmlDocPtr doc, const xmlChar * name);
 566 xmlNodePtr xmlNewReference (const xmlDoc * doc, const xmlChar * name);
 567 xmlNodePtr xmlCopyNode (xmlNodePtr node, int recursive);
 568 xmlNodePtr xmlDocCopyNode (xmlNodePtr node, xmlDocPtr doc, int recursive);
 569 xmlNodePtr xmlDocCopyNodeList (xmlDocPtr doc, xmlNodePtr node);
 570 xmlNodePtr xmlCopyNodeList (xmlNodePtr node);
 571
 572 xmlNodePtr xmlNewTextChild (xmlNodePtr parent,
 573                             xmlNsPtr ns, const xmlChar * name, const xmlChar * content);
 574 xmlNodePtr xmlNewDocRawNode (xmlDocPtr doc,
 575                              xmlNsPtr ns, const xmlChar * name, const xmlChar * content);
 576 xmlNodePtr xmlNewDocFragment (xmlDocPtr doc);
 577 long xmlGetLineNo (const xmlNode * node);
 578 xmlChar *xmlGetNodePath (const xmlNode * node);
 579 xmlNodePtr xmlDocGetRootElement (const xmlDoc * doc);
 580 xmlNodePtr xmlGetLastChild (const xmlNode * parent);
 581 int xmlNodeIsText (const xmlNode * node);
 582 int xmlIsBlankNode (const xmlNode * node);
 583 xmlNodePtr xmlDocSetRootElement (xmlDocPtr doc, xmlNodePtr root);
 584 void xmlNodeSetName (xmlNodePtr cur, const xmlChar * name);
 585 xmlNodePtr xmlAddChild (xmlNodePtr parent, xmlNodePtr cur);
 586 xmlNodePtr xmlAddChildList (xmlNodePtr parent, xmlNodePtr cur);
 587 xmlNodePtr xmlReplaceNode (xmlNodePtr old, xmlNodePtr cur);
 588 xmlNodePtr xmlAddPrevSibling (xmlNodePtr cur, xmlNodePtr elem);
 589 xmlNodePtr xmlAddSibling (xmlNodePtr cur, xmlNodePtr elem);
 590 xmlNodePtr xmlAddNextSibling (xmlNodePtr cur, xmlNodePtr elem);
 591 void xmlUnlinkNode (xmlNodePtr cur);
 592 xmlNodePtr xmlTextMerge (xmlNodePtr first, xmlNodePtr second);
 593 int xmlTextConcat (xmlNodePtr node, const xmlChar * content, int len);
 594 void xmlFreeNodeList (xmlNodePtr cur);
 595 void xmlFreeNode (xmlNodePtr cur);
 596 void xmlSetTreeDoc (xmlNodePtr tree, xmlDocPtr doc);
 597 void xmlSetListDoc (xmlNodePtr list, xmlDocPtr doc);
 598
 599 xmlNsPtr xmlSearchNs (xmlDocPtr doc, xmlNodePtr node, const xmlChar * nameSpace);
 600 xmlNsPtr xmlSearchNsByHref (xmlDocPtr doc, xmlNodePtr node, const xmlChar * href);
 601 xmlNsPtr *xmlGetNsList (const xmlDoc * doc, const xmlNode * node);
 602 void xmlSetNs (xmlNodePtr node, xmlNsPtr ns);
 603 xmlNsPtr xmlCopyNamespace (xmlNsPtr cur);
 604 xmlNsPtr xmlCopyNamespaceList (xmlNsPtr cur);
 605 xmlAttrPtr xmlSetProp (xmlNodePtr node, const xmlChar * name, const xmlChar * value);
 606 xmlAttrPtr xmlSetNsProp (xmlNodePtr node,
 607                          xmlNsPtr ns, const xmlChar * name, const xmlChar * value);
 608
 609 xmlChar *xmlGetNoNsProp (const xmlNode * node, const xmlChar * name);
 610 xmlChar *xmlGetProp (const xmlNode * node, const xmlChar * name);
 611 xmlAttrPtr xmlHasProp (const xmlNode * node, const xmlChar * name);
 612 xmlAttrPtr xmlHasNsProp (const xmlNode * node,
 613                          const xmlChar * name, const xmlChar * nameSpace);
 614 xmlChar *xmlGetNsProp (const xmlNode * node,
 615                        const xmlChar * name, const xmlChar * nameSpace);
 616 xmlNodePtr xmlStringGetNodeList (const xmlDoc * doc, const xmlChar * value);
 617 xmlNodePtr xmlStringLenGetNodeList (const xmlDoc * doc, const xmlChar * value, int len);
 618 xmlChar *xmlNodeListGetString (xmlDocPtr doc,
 619                                const xmlNode * list, int inLine);
 620
 621 xmlChar *xmlNodeListGetRawString (const xmlDoc * doc,
 622                                   const xmlNode * list, int inLine);
 623
 624 void xmlNodeSetContent (xmlNodePtr cur, const xmlChar * content);
 625 void xmlNodeSetContentLen (xmlNodePtr cur, const xmlChar * content, int len);
 626 void xmlNodeAddContent (xmlNodePtr cur, const xmlChar * content);
 627 void xmlNodeAddContentLen (xmlNodePtr cur, const xmlChar * content, int len);
 628 xmlChar *xmlNodeGetContent (const xmlNode * cur);
 629 int xmlNodeBufGetContent (xmlBufferPtr buffer, const xmlNode * cur);
 630 int xmlBufGetNodeContent (xmlBufPtr buf, const xmlNode * cur);
 631 xmlChar *xmlNodeGetLang (const xmlNode * cur);
 632 int xmlNodeGetSpacePreserve (const xmlNode * cur);
 633 void xmlNodeSetLang (xmlNodePtr cur, const xmlChar * lang);
 634 void xmlNodeSetSpacePreserve (xmlNodePtr cur, int val);
 635 xmlChar *xmlNodeGetBase (const xmlDoc * doc, const xmlNode * cur);
 636 void xmlNodeSetBase (xmlNodePtr cur, const xmlChar * uri);
 637 int xmlRemoveProp (xmlAttrPtr cur);
 638 int xmlUnsetNsProp (xmlNodePtr node, xmlNsPtr ns, const xmlChar * name);
 639 int xmlUnsetProp (xmlNodePtr node, const xmlChar * name);
 640 void xmlBufferWriteCHAR (xmlBufferPtr buf, const xmlChar * string);
 641 void xmlBufferWriteChar (xmlBufferPtr buf, const char *string);
 642 void xmlBufferWriteQuotedString (xmlBufferPtr buf, const xmlChar * string);
 643 void xmlAttrSerializeTxtContent (xmlBufferPtr buf,
 644                                  xmlDocPtr doc,
 645                                  xmlAttrPtr attr, const xmlChar * string);
 646 int xmlReconciliateNs (xmlDocPtr doc, xmlNodePtr tree);
 647 void xmlDocDumpFormatMemory (xmlDocPtr cur, xmlChar ** mem, int *size, int format);
 648 void xmlDocDumpMemory (xmlDocPtr cur, xmlChar ** mem, int *size);
 649 void xmlDocDumpMemoryEnc (xmlDocPtr out_doc,
 650                           xmlChar ** doc_txt_ptr,
 651                           int *doc_txt_len, const char *txt_encoding);
 652 void xmlDocDumpFormatMemoryEnc (xmlDocPtr out_doc,
 653                                 xmlChar ** doc_txt_ptr,
 654                                 int *doc_txt_len,
 655                                 const char *txt_encoding, int format);
 656 int xmlDocFormatDump (FILE * f, xmlDocPtr cur, int format);
 657 int xmlDocDump (FILE * f, xmlDocPtr cur);
 658 void xmlElemDump (FILE * f, xmlDocPtr doc, xmlNodePtr cur);
 659 int xmlSaveFile (const char *filename, xmlDocPtr cur);
 660 int xmlSaveFormatFile (const char *filename, xmlDocPtr cur, int format);
 661 size_t xmlBufNodeDump (xmlBufPtr buf,
 662                        xmlDocPtr doc, xmlNodePtr cur, int level, int format);
 663 int xmlNodeDump (xmlBufferPtr buf,
 664                  xmlDocPtr doc, xmlNodePtr cur, int level, int format);
 665
 666 int xmlSaveFileTo (xmlOutputBufferPtr buf, xmlDocPtr cur, const char *encoding);
 667 int xmlSaveFormatFileTo (xmlOutputBufferPtr buf,
 668                          xmlDocPtr cur, const char *encoding, int format);
 669 void xmlNodeDumpOutput (xmlOutputBufferPtr buf,
 670                         xmlDocPtr doc,
 671                         xmlNodePtr cur,
 672                         int level, int format, const char *encoding);
 673
 674 int xmlSaveFormatFileEnc (const char *filename,
 675                           xmlDocPtr cur, const char *encoding, int format);
 676
 677 int xmlSaveFileEnc (const char *filename, xmlDocPtr cur, const char *encoding);
 678 int xmlIsXHTML (const xmlChar * systemID, const xmlChar * publicID);
 679 int xmlGetDocCompressMode (const xmlDoc * doc);
 680 void xmlSetDocCompressMode (xmlDocPtr doc, int mode);
 681 int xmlGetCompressMode (void);
 682 void xmlSetCompressMode (int mode);
 683 xmlDOMWrapCtxtPtr xmlDOMWrapNewCtxt (void);
 684 void xmlDOMWrapFreeCtxt (xmlDOMWrapCtxtPtr ctxt);
 685 int xmlDOMWrapReconcileNamespaces (xmlDOMWrapCtxtPtr ctxt,
 686                                    xmlNodePtr elem, int options);
 687 int xmlDOMWrapAdoptNode (xmlDOMWrapCtxtPtr ctxt,
 688                          xmlDocPtr sourceDoc,
 689                          xmlNodePtr node,
 690                          xmlDocPtr destDoc, xmlNodePtr destParent, int options);
 691 int xmlDOMWrapRemoveNode (xmlDOMWrapCtxtPtr ctxt,
 692                           xmlDocPtr doc, xmlNodePtr node, int options);
 693 int xmlDOMWrapCloneNode (xmlDOMWrapCtxtPtr ctxt,
 694                          xmlDocPtr sourceDoc,
 695                          xmlNodePtr node,
 696                          xmlNodePtr * clonedNode,
 697                          xmlDocPtr destDoc,
 698                          xmlNodePtr destParent, int deep, int options);
 699
 700 unsigned long xmlChildElementCount (xmlNodePtr parent);
 701 xmlNodePtr xmlNextElementSibling (xmlNodePtr node);
 702 xmlNodePtr xmlFirstElementChild (xmlNodePtr parent);
 703 xmlNodePtr xmlLastElementChild (xmlNodePtr parent);
 704 xmlNodePtr xmlPreviousElementSibling (xmlNodePtr node);
 705 typedef struct _xmlHashTable xmlHashTable;
 706 typedef xmlHashTable *xmlHashTablePtr;
 707 typedef void (*xmlHashDeallocator) (void *payload, xmlChar * name);
 708 typedef void *(*xmlHashCopier) (void *payload, xmlChar * name);
 709 typedef void (*xmlHashScanner) (void *payload, void *data, xmlChar * name);
 710 typedef void (*xmlHashScannerFull) (void *payload, void *data,
 711                                     const xmlChar * name,
 712                                     const xmlChar * name2,
 713                                     const xmlChar * name3);
 714
 715
 716
 717
 718 xmlHashTablePtr xmlHashCreate (int size);
 719 xmlHashTablePtr xmlHashCreateDict (int size, xmlDictPtr dict);
 720 void xmlHashFree (xmlHashTablePtr table, xmlHashDeallocator f);
 721
 722 int xmlHashAddEntry (xmlHashTablePtr table, const xmlChar * name, void *userdata);
 723 int xmlHashUpdateEntry (xmlHashTablePtr table,
 724                         const xmlChar * name,
 725                         void *userdata, xmlHashDeallocator f);
 726 int xmlHashAddEntry2 (xmlHashTablePtr table,
 727                       const xmlChar * name,
 728                       const xmlChar * name2, void *userdata);
 729 int xmlHashUpdateEntry2 (xmlHashTablePtr table,
 730                          const xmlChar * name,
 731                          const xmlChar * name2,
 732                          void *userdata, xmlHashDeallocator f);
 733 int xmlHashAddEntry3 (xmlHashTablePtr table,
 734                       const xmlChar * name,
 735                       const xmlChar * name2,
 736                       const xmlChar * name3, void *userdata);
 737 int xmlHashUpdateEntry3 (xmlHashTablePtr table,
 738                          const xmlChar * name,
 739                          const xmlChar * name2,
 740                          const xmlChar * name3,
 741                          void *userdata, xmlHashDeallocator f);
 742
 743 int xmlHashRemoveEntry (xmlHashTablePtr table, const xmlChar * name,
 744                         xmlHashDeallocator f);
 745 int xmlHashRemoveEntry2 (xmlHashTablePtr table, const xmlChar * name,
 746                          const xmlChar * name2, xmlHashDeallocator f);
 747 int xmlHashRemoveEntry3 (xmlHashTablePtr table, const xmlChar * name,
 748                          const xmlChar * name2, const xmlChar * name3,
 749                          xmlHashDeallocator f);
 750
 751 void *xmlHashLookup (xmlHashTablePtr table, const xmlChar * name);
 752 void *xmlHashLookup2 (xmlHashTablePtr table,
 753                       const xmlChar * name, const xmlChar * name2);
 754 void *xmlHashLookup3 (xmlHashTablePtr table,
 755                       const xmlChar * name,
 756                       const xmlChar * name2, const xmlChar * name3);
 757 void *xmlHashQLookup (xmlHashTablePtr table,
 758                       const xmlChar * name, const xmlChar * prefix);
 759 void *xmlHashQLookup2 (xmlHashTablePtr table,
 760                        const xmlChar * name,
 761                        const xmlChar * prefix,
 762                        const xmlChar * name2, const xmlChar * prefix2);
 763 void *xmlHashQLookup3 (xmlHashTablePtr table,
 764                        const xmlChar * name,
 765                        const xmlChar * prefix,
 766                        const xmlChar * name2,
 767                        const xmlChar * prefix2,
 768                        const xmlChar * name3, const xmlChar * prefix3);
 769
 770 xmlHashTablePtr xmlHashCopy (xmlHashTablePtr table, xmlHashCopier f);
 771 int xmlHashSize (xmlHashTablePtr table);
 772 void xmlHashScan (xmlHashTablePtr table, xmlHashScanner f, void *data);
 773 void xmlHashScan3 (xmlHashTablePtr table,
 774                    const xmlChar * name,
 775                    const xmlChar * name2,
 776                    const xmlChar * name3, xmlHashScanner f, void *data);
 777 void xmlHashScanFull (xmlHashTablePtr table, xmlHashScannerFull f, void *data);
 778 void xmlHashScanFull3 (xmlHashTablePtr table,
 779                        const xmlChar * name,
 780                        const xmlChar * name2,
 781                        const xmlChar * name3, xmlHashScannerFull f, void *data);
 782 typedef enum
 783 {
 784   XML_ERR_NONE = 0,
 785   XML_ERR_WARNING = 1,
 786   XML_ERR_ERROR = 2,
 787   XML_ERR_FATAL = 3
 788 } xmlErrorLevel;
 789
 790 typedef enum
 791 {
 792   XML_FROM_NONE = 0,
 793   XML_FROM_PARSER,
 794   XML_FROM_TREE,
 795   XML_FROM_NAMESPACE,
 796   XML_FROM_DTD,
 797   XML_FROM_HTML,
 798   XML_FROM_MEMORY,
 799   XML_FROM_OUTPUT,
 800   XML_FROM_IO,
 801   XML_FROM_FTP,
 802   XML_FROM_HTTP,
 803   XML_FROM_XINCLUDE,
 804   XML_FROM_XPATH,
 805   XML_FROM_XPOINTER,
 806   XML_FROM_REGEXP,
 807   XML_FROM_DATATYPE,
 808   XML_FROM_SCHEMASP,
 809   XML_FROM_SCHEMASV,
 810   XML_FROM_RELAXNGP,
 811   XML_FROM_RELAXNGV,
 812   XML_FROM_CATALOG,
 813   XML_FROM_C14N,
 814   XML_FROM_XSLT,
 815   XML_FROM_VALID,
 816   XML_FROM_CHECK,
 817   XML_FROM_WRITER,
 818   XML_FROM_MODULE,
 819   XML_FROM_I18N,
 820   XML_FROM_SCHEMATRONV,
 821   XML_FROM_BUFFER,
 822   XML_FROM_URI
 823 } xmlErrorDomain;
 824
 825 typedef struct _xmlError xmlError;
 826 typedef xmlError *xmlErrorPtr;
 827 struct _xmlError
 828 {
 829   int domain;
 830   int code;
 831   char *message;
 832   xmlErrorLevel level;
 833   char *file;
 834   int line;
 835   char *str1;
 836   char *str2;
 837   char *str3;
 838   int int1;
 839   int int2;
 840   void *ctxt;
 841   void *node;
 842 };
 843
 844 typedef enum
 845 {
 846   XML_ERR_OK = 0,
 847   XML_ERR_INTERNAL_ERROR,
 848   XML_ERR_NO_MEMORY,
 849   XML_ERR_DOCUMENT_START,
 850   XML_ERR_DOCUMENT_EMPTY,
 851   XML_ERR_DOCUMENT_END,
 852   XML_ERR_INVALID_HEX_CHARREF,
 853   XML_ERR_INVALID_DEC_CHARREF,
 854   XML_ERR_INVALID_CHARREF,
 855   XML_ERR_INVALID_CHAR,
 856   XML_ERR_CHARREF_AT_EOF,
 857   XML_ERR_CHARREF_IN_PROLOG,
 858   XML_ERR_CHARREF_IN_EPILOG,
 859   XML_ERR_CHARREF_IN_DTD,
 860   XML_ERR_ENTITYREF_AT_EOF,
 861   XML_ERR_ENTITYREF_IN_PROLOG,
 862   XML_ERR_ENTITYREF_IN_EPILOG,
 863   XML_ERR_ENTITYREF_IN_DTD,
 864   XML_ERR_PEREF_AT_EOF,
 865   XML_ERR_PEREF_IN_PROLOG,
 866   XML_ERR_PEREF_IN_EPILOG,
 867   XML_ERR_PEREF_IN_INT_SUBSET,
 868   XML_ERR_ENTITYREF_NO_NAME,
 869   XML_ERR_ENTITYREF_SEMICOL_MISSING,
 870   XML_ERR_PEREF_NO_NAME,
 871   XML_ERR_PEREF_SEMICOL_MISSING,
 872   XML_ERR_UNDECLARED_ENTITY,
 873   XML_WAR_UNDECLARED_ENTITY,
 874   XML_ERR_UNPARSED_ENTITY,
 875   XML_ERR_ENTITY_IS_EXTERNAL,
 876   XML_ERR_ENTITY_IS_PARAMETER,
 877   XML_ERR_UNKNOWN_ENCODING,
 878   XML_ERR_UNSUPPORTED_ENCODING,
 879   XML_ERR_STRING_NOT_STARTED,
 880   XML_ERR_STRING_NOT_CLOSED,
 881   XML_ERR_NS_DECL_ERROR,
 882   XML_ERR_ENTITY_NOT_STARTED,
 883   XML_ERR_ENTITY_NOT_FINISHED,
 884   XML_ERR_LT_IN_ATTRIBUTE,
 885   XML_ERR_ATTRIBUTE_NOT_STARTED,
 886   XML_ERR_ATTRIBUTE_NOT_FINISHED,
 887   XML_ERR_ATTRIBUTE_WITHOUT_VALUE,
 888   XML_ERR_ATTRIBUTE_REDEFINED,
 889   XML_ERR_LITERAL_NOT_STARTED,
 890   XML_ERR_LITERAL_NOT_FINISHED,
 891   XML_ERR_COMMENT_NOT_FINISHED,
 892   XML_ERR_PI_NOT_STARTED,
 893   XML_ERR_PI_NOT_FINISHED,
 894   XML_ERR_NOTATION_NOT_STARTED,
 895   XML_ERR_NOTATION_NOT_FINISHED,
 896   XML_ERR_ATTLIST_NOT_STARTED,
 897   XML_ERR_ATTLIST_NOT_FINISHED,
 898   XML_ERR_MIXED_NOT_STARTED,
 899   XML_ERR_MIXED_NOT_FINISHED,
 900   XML_ERR_ELEMCONTENT_NOT_STARTED,
 901   XML_ERR_ELEMCONTENT_NOT_FINISHED,
 902   XML_ERR_XMLDECL_NOT_STARTED,
 903   XML_ERR_XMLDECL_NOT_FINISHED,
 904   XML_ERR_CONDSEC_NOT_STARTED,
 905   XML_ERR_CONDSEC_NOT_FINISHED,
 906   XML_ERR_EXT_SUBSET_NOT_FINISHED,
 907   XML_ERR_DOCTYPE_NOT_FINISHED,
 908   XML_ERR_MISPLACED_CDATA_END,
 909   XML_ERR_CDATA_NOT_FINISHED,
 910   XML_ERR_RESERVED_XML_NAME,
 911   XML_ERR_SPACE_REQUIRED,
 912   XML_ERR_SEPARATOR_REQUIRED,
 913   XML_ERR_NMTOKEN_REQUIRED,
 914   XML_ERR_NAME_REQUIRED,
 915   XML_ERR_PCDATA_REQUIRED,
 916   XML_ERR_URI_REQUIRED,
 917   XML_ERR_PUBID_REQUIRED,
 918   XML_ERR_LT_REQUIRED,
 919   XML_ERR_GT_REQUIRED,
 920   XML_ERR_LTSLASH_REQUIRED,
 921   XML_ERR_EQUAL_REQUIRED,
 922   XML_ERR_TAG_NAME_MISMATCH,
 923   XML_ERR_TAG_NOT_FINISHED,
 924   XML_ERR_STANDALONE_VALUE,
 925   XML_ERR_ENCODING_NAME,
 926   XML_ERR_HYPHEN_IN_COMMENT,
 927   XML_ERR_INVALID_ENCODING,
 928   XML_ERR_EXT_ENTITY_STANDALONE,
 929   XML_ERR_CONDSEC_INVALID,
 930   XML_ERR_VALUE_REQUIRED,
 931   XML_ERR_NOT_WELL_BALANCED,
 932   XML_ERR_EXTRA_CONTENT,
 933   XML_ERR_ENTITY_CHAR_ERROR,
 934   XML_ERR_ENTITY_PE_INTERNAL,
 935   XML_ERR_ENTITY_LOOP,
 936   XML_ERR_ENTITY_BOUNDARY,
 937   XML_ERR_INVALID_URI,
 938   XML_ERR_URI_FRAGMENT,
 939   XML_WAR_CATALOG_PI,
 940   XML_ERR_NO_DTD,
 941   XML_ERR_CONDSEC_INVALID_KEYWORD,
 942   XML_ERR_VERSION_MISSING,
 943   XML_WAR_UNKNOWN_VERSION,
 944   XML_WAR_LANG_VALUE,
 945   XML_WAR_NS_URI,
 946   XML_WAR_NS_URI_RELATIVE,
 947   XML_ERR_MISSING_ENCODING,
 948   XML_WAR_SPACE_VALUE,
 949   XML_ERR_NOT_STANDALONE,
 950   XML_ERR_ENTITY_PROCESSING,
 951   XML_ERR_NOTATION_PROCESSING,
 952   XML_WAR_NS_COLUMN,
 953   XML_WAR_ENTITY_REDEFINED,
 954   XML_ERR_UNKNOWN_VERSION,
 955   XML_ERR_VERSION_MISMATCH,
 956   XML_ERR_NAME_TOO_LONG,
 957   XML_ERR_USER_STOP,
 958   XML_NS_ERR_XML_NAMESPACE = 200,
 959   XML_NS_ERR_UNDEFINED_NAMESPACE,
 960   XML_NS_ERR_QNAME,
 961   XML_NS_ERR_ATTRIBUTE_REDEFINED,
 962   XML_NS_ERR_EMPTY,
 963   XML_NS_ERR_COLON,
 964   XML_DTD_ATTRIBUTE_DEFAULT = 500,
 965   XML_DTD_ATTRIBUTE_REDEFINED,
 966   XML_DTD_ATTRIBUTE_VALUE,
 967   XML_DTD_CONTENT_ERROR,
 968   XML_DTD_CONTENT_MODEL,
 969   XML_DTD_CONTENT_NOT_DETERMINIST,
 970   XML_DTD_DIFFERENT_PREFIX,
 971   XML_DTD_ELEM_DEFAULT_NAMESPACE,
 972   XML_DTD_ELEM_NAMESPACE,
 973   XML_DTD_ELEM_REDEFINED,
 974   XML_DTD_EMPTY_NOTATION,
 975   XML_DTD_ENTITY_TYPE,
 976   XML_DTD_ID_FIXED,
 977   XML_DTD_ID_REDEFINED,
 978   XML_DTD_ID_SUBSET,
 979   XML_DTD_INVALID_CHILD,
 980   XML_DTD_INVALID_DEFAULT,
 981   XML_DTD_LOAD_ERROR,
 982   XML_DTD_MISSING_ATTRIBUTE,
 983   XML_DTD_MIXED_CORRUPT,
 984   XML_DTD_MULTIPLE_ID,
 985   XML_DTD_NO_DOC,
 986   XML_DTD_NO_DTD,
 987   XML_DTD_NO_ELEM_NAME,
 988   XML_DTD_NO_PREFIX,
 989   XML_DTD_NO_ROOT,
 990   XML_DTD_NOTATION_REDEFINED,
 991   XML_DTD_NOTATION_VALUE,
 992   XML_DTD_NOT_EMPTY,
 993   XML_DTD_NOT_PCDATA,
 994   XML_DTD_NOT_STANDALONE,
 995   XML_DTD_ROOT_NAME,
 996   XML_DTD_STANDALONE_WHITE_SPACE,
 997   XML_DTD_UNKNOWN_ATTRIBUTE,
 998   XML_DTD_UNKNOWN_ELEM,
 999   XML_DTD_UNKNOWN_ENTITY,
1000   XML_DTD_UNKNOWN_ID,
1001   XML_DTD_UNKNOWN_NOTATION,
1002   XML_DTD_STANDALONE_DEFAULTED,
1003   XML_DTD_XMLID_VALUE,
1004   XML_DTD_XMLID_TYPE,
1005   XML_DTD_DUP_TOKEN,
1006   XML_HTML_STRUCURE_ERROR = 800,
1007   XML_HTML_UNKNOWN_TAG,
1008   XML_RNGP_ANYNAME_ATTR_ANCESTOR = 1000,
1009   XML_RNGP_ATTR_CONFLICT,
1010   XML_RNGP_ATTRIBUTE_CHILDREN,
1011   XML_RNGP_ATTRIBUTE_CONTENT,
1012   XML_RNGP_ATTRIBUTE_EMPTY,
1013   XML_RNGP_ATTRIBUTE_NOOP,
1014   XML_RNGP_CHOICE_CONTENT,
1015   XML_RNGP_CHOICE_EMPTY,
1016   XML_RNGP_CREATE_FAILURE,
1017   XML_RNGP_DATA_CONTENT,
1018   XML_RNGP_DEF_CHOICE_AND_INTERLEAVE,
1019   XML_RNGP_DEFINE_CREATE_FAILED,
1020   XML_RNGP_DEFINE_EMPTY,
1021   XML_RNGP_DEFINE_MISSING,
1022   XML_RNGP_DEFINE_NAME_MISSING,
1023   XML_RNGP_ELEM_CONTENT_EMPTY,
1024   XML_RNGP_ELEM_CONTENT_ERROR,
1025   XML_RNGP_ELEMENT_EMPTY,
1026   XML_RNGP_ELEMENT_CONTENT,
1027   XML_RNGP_ELEMENT_NAME,
1028   XML_RNGP_ELEMENT_NO_CONTENT,
1029   XML_RNGP_ELEM_TEXT_CONFLICT,
1030   XML_RNGP_EMPTY,
1031   XML_RNGP_EMPTY_CONSTRUCT,
1032   XML_RNGP_EMPTY_CONTENT,
1033   XML_RNGP_EMPTY_NOT_EMPTY,
1034   XML_RNGP_ERROR_TYPE_LIB,
1035   XML_RNGP_EXCEPT_EMPTY,
1036   XML_RNGP_EXCEPT_MISSING,
1037   XML_RNGP_EXCEPT_MULTIPLE,
1038   XML_RNGP_EXCEPT_NO_CONTENT,
1039   XML_RNGP_EXTERNALREF_EMTPY,
1040   XML_RNGP_EXTERNAL_REF_FAILURE,
1041   XML_RNGP_EXTERNALREF_RECURSE,
1042   XML_RNGP_FORBIDDEN_ATTRIBUTE,
1043   XML_RNGP_FOREIGN_ELEMENT,
1044   XML_RNGP_GRAMMAR_CONTENT,
1045   XML_RNGP_GRAMMAR_EMPTY,
1046   XML_RNGP_GRAMMAR_MISSING,
1047   XML_RNGP_GRAMMAR_NO_START,
1048   XML_RNGP_GROUP_ATTR_CONFLICT,
1049   XML_RNGP_HREF_ERROR,
1050   XML_RNGP_INCLUDE_EMPTY,
1051   XML_RNGP_INCLUDE_FAILURE,
1052   XML_RNGP_INCLUDE_RECURSE,
1053   XML_RNGP_INTERLEAVE_ADD,
1054   XML_RNGP_INTERLEAVE_CREATE_FAILED,
1055   XML_RNGP_INTERLEAVE_EMPTY,
1056   XML_RNGP_INTERLEAVE_NO_CONTENT,
1057   XML_RNGP_INVALID_DEFINE_NAME,
1058   XML_RNGP_INVALID_URI,
1059   XML_RNGP_INVALID_VALUE,
1060   XML_RNGP_MISSING_HREF,
1061   XML_RNGP_NAME_MISSING,
1062   XML_RNGP_NEED_COMBINE,
1063   XML_RNGP_NOTALLOWED_NOT_EMPTY,
1064   XML_RNGP_NSNAME_ATTR_ANCESTOR,
1065   XML_RNGP_NSNAME_NO_NS,
1066   XML_RNGP_PARAM_FORBIDDEN,
1067   XML_RNGP_PARAM_NAME_MISSING,
1068   XML_RNGP_PARENTREF_CREATE_FAILED,
1069   XML_RNGP_PARENTREF_NAME_INVALID,
1070   XML_RNGP_PARENTREF_NO_NAME,
1071   XML_RNGP_PARENTREF_NO_PARENT,
1072   XML_RNGP_PARENTREF_NOT_EMPTY,
1073   XML_RNGP_PARSE_ERROR,
1074   XML_RNGP_PAT_ANYNAME_EXCEPT_ANYNAME,
1075   XML_RNGP_PAT_ATTR_ATTR,
1076   XML_RNGP_PAT_ATTR_ELEM,
1077   XML_RNGP_PAT_DATA_EXCEPT_ATTR,
1078   XML_RNGP_PAT_DATA_EXCEPT_ELEM,
1079   XML_RNGP_PAT_DATA_EXCEPT_EMPTY,
1080   XML_RNGP_PAT_DATA_EXCEPT_GROUP,
1081   XML_RNGP_PAT_DATA_EXCEPT_INTERLEAVE,
1082   XML_RNGP_PAT_DATA_EXCEPT_LIST,
1083   XML_RNGP_PAT_DATA_EXCEPT_ONEMORE,
1084   XML_RNGP_PAT_DATA_EXCEPT_REF,
1085   XML_RNGP_PAT_DATA_EXCEPT_TEXT,
1086   XML_RNGP_PAT_LIST_ATTR,
1087   XML_RNGP_PAT_LIST_ELEM,
1088   XML_RNGP_PAT_LIST_INTERLEAVE,
1089   XML_RNGP_PAT_LIST_LIST,
1090   XML_RNGP_PAT_LIST_REF,
1091   XML_RNGP_PAT_LIST_TEXT,
1092   XML_RNGP_PAT_NSNAME_EXCEPT_ANYNAME,
1093   XML_RNGP_PAT_NSNAME_EXCEPT_NSNAME,
1094   XML_RNGP_PAT_ONEMORE_GROUP_ATTR,
1095   XML_RNGP_PAT_ONEMORE_INTERLEAVE_ATTR,
1096   XML_RNGP_PAT_START_ATTR,
1097   XML_RNGP_PAT_START_DATA,
1098   XML_RNGP_PAT_START_EMPTY,
1099   XML_RNGP_PAT_START_GROUP,
1100   XML_RNGP_PAT_START_INTERLEAVE,
1101   XML_RNGP_PAT_START_LIST,
1102   XML_RNGP_PAT_START_ONEMORE,
1103   XML_RNGP_PAT_START_TEXT,
1104   XML_RNGP_PAT_START_VALUE,
1105   XML_RNGP_PREFIX_UNDEFINED,
1106   XML_RNGP_REF_CREATE_FAILED,
1107   XML_RNGP_REF_CYCLE,
1108   XML_RNGP_REF_NAME_INVALID,
1109   XML_RNGP_REF_NO_DEF,
1110   XML_RNGP_REF_NO_NAME,
1111   XML_RNGP_REF_NOT_EMPTY,
1112   XML_RNGP_START_CHOICE_AND_INTERLEAVE,
1113   XML_RNGP_START_CONTENT,
1114   XML_RNGP_START_EMPTY,
1115   XML_RNGP_START_MISSING,
1116   XML_RNGP_TEXT_EXPECTED,
1117   XML_RNGP_TEXT_HAS_CHILD,
1118   XML_RNGP_TYPE_MISSING,
1119   XML_RNGP_TYPE_NOT_FOUND,
1120   XML_RNGP_TYPE_VALUE,
1121   XML_RNGP_UNKNOWN_ATTRIBUTE,
1122   XML_RNGP_UNKNOWN_COMBINE,
1123   XML_RNGP_UNKNOWN_CONSTRUCT,
1124   XML_RNGP_UNKNOWN_TYPE_LIB,
1125   XML_RNGP_URI_FRAGMENT,
1126   XML_RNGP_URI_NOT_ABSOLUTE,
1127   XML_RNGP_VALUE_EMPTY,
1128   XML_RNGP_VALUE_NO_CONTENT,
1129   XML_RNGP_XMLNS_NAME,
1130   XML_RNGP_XML_NS,
1131   XML_XPATH_EXPRESSION_OK = 1200,
1132   XML_XPATH_NUMBER_ERROR,
1133   XML_XPATH_UNFINISHED_LITERAL_ERROR,
1134   XML_XPATH_START_LITERAL_ERROR,
1135   XML_XPATH_VARIABLE_REF_ERROR,
1136   XML_XPATH_UNDEF_VARIABLE_ERROR,
1137   XML_XPATH_INVALID_PREDICATE_ERROR,
1138   XML_XPATH_EXPR_ERROR,
1139   XML_XPATH_UNCLOSED_ERROR,
1140   XML_XPATH_UNKNOWN_FUNC_ERROR,
1141   XML_XPATH_INVALID_OPERAND,
1142   XML_XPATH_INVALID_TYPE,
1143   XML_XPATH_INVALID_ARITY,
1144   XML_XPATH_INVALID_CTXT_SIZE,
1145   XML_XPATH_INVALID_CTXT_POSITION,
1146   XML_XPATH_MEMORY_ERROR,
1147   XML_XPTR_SYNTAX_ERROR,
1148   XML_XPTR_RESOURCE_ERROR,
1149   XML_XPTR_SUB_RESOURCE_ERROR,
1150   XML_XPATH_UNDEF_PREFIX_ERROR,
1151   XML_XPATH_ENCODING_ERROR,
1152   XML_XPATH_INVALID_CHAR_ERROR,
1153   XML_TREE_INVALID_HEX = 1300,
1154   XML_TREE_INVALID_DEC,
1155   XML_TREE_UNTERMINATED_ENTITY,
1156   XML_TREE_NOT_UTF8,
1157   XML_SAVE_NOT_UTF8 = 1400,
1158   XML_SAVE_CHAR_INVALID,
1159   XML_SAVE_NO_DOCTYPE,
1160   XML_SAVE_UNKNOWN_ENCODING,
1161   XML_REGEXP_COMPILE_ERROR = 1450,
1162   XML_IO_UNKNOWN = 1500,
1163   XML_IO_EACCES,
1164   XML_IO_EAGAIN,
1165   XML_IO_EBADF,
1166   XML_IO_EBADMSG,
1167   XML_IO_EBUSY,
1168   XML_IO_ECANCELED,
1169   XML_IO_ECHILD,
1170   XML_IO_EDEADLK,
1171   XML_IO_EDOM,
1172   XML_IO_EEXIST,
1173   XML_IO_EFAULT,
1174   XML_IO_EFBIG,
1175   XML_IO_EINPROGRESS,
1176   XML_IO_EINTR,
1177   XML_IO_EINVAL,
1178   XML_IO_EIO,
1179   XML_IO_EISDIR,
1180   XML_IO_EMFILE,
1181   XML_IO_EMLINK,
1182   XML_IO_EMSGSIZE,
1183   XML_IO_ENAMETOOLONG,
1184   XML_IO_ENFILE,
1185   XML_IO_ENODEV,
1186   XML_IO_ENOENT,
1187   XML_IO_ENOEXEC,
1188   XML_IO_ENOLCK,
1189   XML_IO_ENOMEM,
1190   XML_IO_ENOSPC,
1191   XML_IO_ENOSYS,
1192   XML_IO_ENOTDIR,
1193   XML_IO_ENOTEMPTY,
1194   XML_IO_ENOTSUP,
1195   XML_IO_ENOTTY,
1196   XML_IO_ENXIO,
1197   XML_IO_EPERM,
1198   XML_IO_EPIPE,
1199   XML_IO_ERANGE,
1200   XML_IO_EROFS,
1201   XML_IO_ESPIPE,
1202   XML_IO_ESRCH,
1203   XML_IO_ETIMEDOUT,
1204   XML_IO_EXDEV,
1205   XML_IO_NETWORK_ATTEMPT,
1206   XML_IO_ENCODER,
1207   XML_IO_FLUSH,
1208   XML_IO_WRITE,
1209   XML_IO_NO_INPUT,
1210   XML_IO_BUFFER_FULL,
1211   XML_IO_LOAD_ERROR,
1212   XML_IO_ENOTSOCK,
1213   XML_IO_EISCONN,
1214   XML_IO_ECONNREFUSED,
1215   XML_IO_ENETUNREACH,
1216   XML_IO_EADDRINUSE,
1217   XML_IO_EALREADY,
1218   XML_IO_EAFNOSUPPORT,
1219   XML_XINCLUDE_RECURSION = 1600,
1220   XML_XINCLUDE_PARSE_VALUE,
1221   XML_XINCLUDE_ENTITY_DEF_MISMATCH,
1222   XML_XINCLUDE_NO_HREF,
1223   XML_XINCLUDE_NO_FALLBACK,
1224   XML_XINCLUDE_HREF_URI,
1225   XML_XINCLUDE_TEXT_FRAGMENT,
1226   XML_XINCLUDE_TEXT_DOCUMENT,
1227   XML_XINCLUDE_INVALID_CHAR,
1228   XML_XINCLUDE_BUILD_FAILED,
1229   XML_XINCLUDE_UNKNOWN_ENCODING,
1230   XML_XINCLUDE_MULTIPLE_ROOT,
1231   XML_XINCLUDE_XPTR_FAILED,
1232   XML_XINCLUDE_XPTR_RESULT,
1233   XML_XINCLUDE_INCLUDE_IN_INCLUDE,
1234   XML_XINCLUDE_FALLBACKS_IN_INCLUDE,
1235   XML_XINCLUDE_FALLBACK_NOT_IN_INCLUDE,
1236   XML_XINCLUDE_DEPRECATED_NS,
1237   XML_XINCLUDE_FRAGMENT_ID,
1238   XML_CATALOG_MISSING_ATTR = 1650,
1239   XML_CATALOG_ENTRY_BROKEN,
1240   XML_CATALOG_PREFER_VALUE,
1241   XML_CATALOG_NOT_CATALOG,
1242   XML_CATALOG_RECURSION,
1243   XML_SCHEMAP_PREFIX_UNDEFINED = 1700,
1244   XML_SCHEMAP_ATTRFORMDEFAULT_VALUE,
1245   XML_SCHEMAP_ATTRGRP_NONAME_NOREF,
1246   XML_SCHEMAP_ATTR_NONAME_NOREF,
1247   XML_SCHEMAP_COMPLEXTYPE_NONAME_NOREF,
1248   XML_SCHEMAP_ELEMFORMDEFAULT_VALUE,
1249   XML_SCHEMAP_ELEM_NONAME_NOREF,
1250   XML_SCHEMAP_EXTENSION_NO_BASE,
1251   XML_SCHEMAP_FACET_NO_VALUE,
1252   XML_SCHEMAP_FAILED_BUILD_IMPORT,
1253   XML_SCHEMAP_GROUP_NONAME_NOREF,
1254   XML_SCHEMAP_IMPORT_NAMESPACE_NOT_URI,
1255   XML_SCHEMAP_IMPORT_REDEFINE_NSNAME,
1256   XML_SCHEMAP_IMPORT_SCHEMA_NOT_URI,
1257   XML_SCHEMAP_INVALID_BOOLEAN,
1258   XML_SCHEMAP_INVALID_ENUM,
1259   XML_SCHEMAP_INVALID_FACET,
1260   XML_SCHEMAP_INVALID_FACET_VALUE,
1261   XML_SCHEMAP_INVALID_MAXOCCURS,
1262   XML_SCHEMAP_INVALID_MINOCCURS,
1263   XML_SCHEMAP_INVALID_REF_AND_SUBTYPE,
1264   XML_SCHEMAP_INVALID_WHITE_SPACE,
1265   XML_SCHEMAP_NOATTR_NOREF,
1266   XML_SCHEMAP_NOTATION_NO_NAME,
1267   XML_SCHEMAP_NOTYPE_NOREF,
1268   XML_SCHEMAP_REF_AND_SUBTYPE,
1269   XML_SCHEMAP_RESTRICTION_NONAME_NOREF,
1270   XML_SCHEMAP_SIMPLETYPE_NONAME,
1271   XML_SCHEMAP_TYPE_AND_SUBTYPE,
1272   XML_SCHEMAP_UNKNOWN_ALL_CHILD,
1273   XML_SCHEMAP_UNKNOWN_ANYATTRIBUTE_CHILD,
1274   XML_SCHEMAP_UNKNOWN_ATTR_CHILD,
1275   XML_SCHEMAP_UNKNOWN_ATTRGRP_CHILD,
1276   XML_SCHEMAP_UNKNOWN_ATTRIBUTE_GROUP,
1277   XML_SCHEMAP_UNKNOWN_BASE_TYPE,
1278   XML_SCHEMAP_UNKNOWN_CHOICE_CHILD,
1279   XML_SCHEMAP_UNKNOWN_COMPLEXCONTENT_CHILD,
1280   XML_SCHEMAP_UNKNOWN_COMPLEXTYPE_CHILD,
1281   XML_SCHEMAP_UNKNOWN_ELEM_CHILD,
1282   XML_SCHEMAP_UNKNOWN_EXTENSION_CHILD,
1283   XML_SCHEMAP_UNKNOWN_FACET_CHILD,
1284   XML_SCHEMAP_UNKNOWN_FACET_TYPE,
1285   XML_SCHEMAP_UNKNOWN_GROUP_CHILD,
1286   XML_SCHEMAP_UNKNOWN_IMPORT_CHILD,
1287   XML_SCHEMAP_UNKNOWN_LIST_CHILD,
1288   XML_SCHEMAP_UNKNOWN_NOTATION_CHILD,
1289   XML_SCHEMAP_UNKNOWN_PROCESSCONTENT_CHILD,
1290   XML_SCHEMAP_UNKNOWN_REF,
1291   XML_SCHEMAP_UNKNOWN_RESTRICTION_CHILD,
1292   XML_SCHEMAP_UNKNOWN_SCHEMAS_CHILD,
1293   XML_SCHEMAP_UNKNOWN_SEQUENCE_CHILD,
1294   XML_SCHEMAP_UNKNOWN_SIMPLECONTENT_CHILD,
1295   XML_SCHEMAP_UNKNOWN_SIMPLETYPE_CHILD,
1296   XML_SCHEMAP_UNKNOWN_TYPE,
1297   XML_SCHEMAP_UNKNOWN_UNION_CHILD,
1298   XML_SCHEMAP_ELEM_DEFAULT_FIXED,
1299   XML_SCHEMAP_REGEXP_INVALID,
1300   XML_SCHEMAP_FAILED_LOAD,
1301   XML_SCHEMAP_NOTHING_TO_PARSE,
1302   XML_SCHEMAP_NOROOT,
1303   XML_SCHEMAP_REDEFINED_GROUP,
1304   XML_SCHEMAP_REDEFINED_TYPE,
1305   XML_SCHEMAP_REDEFINED_ELEMENT,
1306   XML_SCHEMAP_REDEFINED_ATTRGROUP,
1307   XML_SCHEMAP_REDEFINED_ATTR,
1308   XML_SCHEMAP_REDEFINED_NOTATION,
1309   XML_SCHEMAP_FAILED_PARSE,
1310   XML_SCHEMAP_UNKNOWN_PREFIX,
1311   XML_SCHEMAP_DEF_AND_PREFIX,
1312   XML_SCHEMAP_UNKNOWN_INCLUDE_CHILD,
1313   XML_SCHEMAP_INCLUDE_SCHEMA_NOT_URI,
1314   XML_SCHEMAP_INCLUDE_SCHEMA_NO_URI,
1315   XML_SCHEMAP_NOT_SCHEMA,
1316   XML_SCHEMAP_UNKNOWN_MEMBER_TYPE,
1317   XML_SCHEMAP_INVALID_ATTR_USE,
1318   XML_SCHEMAP_RECURSIVE,
1319   XML_SCHEMAP_SUPERNUMEROUS_LIST_ITEM_TYPE,
1320   XML_SCHEMAP_INVALID_ATTR_COMBINATION,
1321   XML_SCHEMAP_INVALID_ATTR_INLINE_COMBINATION,
1322   XML_SCHEMAP_MISSING_SIMPLETYPE_CHILD,
1323   XML_SCHEMAP_INVALID_ATTR_NAME,
1324   XML_SCHEMAP_REF_AND_CONTENT,
1325   XML_SCHEMAP_CT_PROPS_CORRECT_1,
1326   XML_SCHEMAP_CT_PROPS_CORRECT_2,
1327   XML_SCHEMAP_CT_PROPS_CORRECT_3,
1328   XML_SCHEMAP_CT_PROPS_CORRECT_4,
1329   XML_SCHEMAP_CT_PROPS_CORRECT_5,
1330   XML_SCHEMAP_DERIVATION_OK_RESTRICTION_1,
1331   XML_SCHEMAP_DERIVATION_OK_RESTRICTION_2_1_1,
1332   XML_SCHEMAP_DERIVATION_OK_RESTRICTION_2_1_2,
1333   XML_SCHEMAP_DERIVATION_OK_RESTRICTION_2_2,
1334   XML_SCHEMAP_DERIVATION_OK_RESTRICTION_3,
1335   XML_SCHEMAP_WILDCARD_INVALID_NS_MEMBER,
1336   XML_SCHEMAP_INTERSECTION_NOT_EXPRESSIBLE,
1337   XML_SCHEMAP_UNION_NOT_EXPRESSIBLE,
1338   XML_SCHEMAP_SRC_IMPORT_3_1,
1339   XML_SCHEMAP_SRC_IMPORT_3_2,
1340   XML_SCHEMAP_DERIVATION_OK_RESTRICTION_4_1,
1341   XML_SCHEMAP_DERIVATION_OK_RESTRICTION_4_2,
1342   XML_SCHEMAP_DERIVATION_OK_RESTRICTION_4_3,
1343   XML_SCHEMAP_COS_CT_EXTENDS_1_3,
1344   XML_SCHEMAV_NOROOT = 1801,
1345   XML_SCHEMAV_UNDECLAREDELEM,
1346   XML_SCHEMAV_NOTTOPLEVEL,
1347   XML_SCHEMAV_MISSING,
1348   XML_SCHEMAV_WRONGELEM,
1349   XML_SCHEMAV_NOTYPE,
1350   XML_SCHEMAV_NOROLLBACK,
1351   XML_SCHEMAV_ISABSTRACT,
1352   XML_SCHEMAV_NOTEMPTY,
1353   XML_SCHEMAV_ELEMCONT,
1354   XML_SCHEMAV_HAVEDEFAULT,
1355   XML_SCHEMAV_NOTNILLABLE,
1356   XML_SCHEMAV_EXTRACONTENT,
1357   XML_SCHEMAV_INVALIDATTR,
1358   XML_SCHEMAV_INVALIDELEM,
1359   XML_SCHEMAV_NOTDETERMINIST,
1360   XML_SCHEMAV_CONSTRUCT,
1361   XML_SCHEMAV_INTERNAL,
1362   XML_SCHEMAV_NOTSIMPLE,
1363   XML_SCHEMAV_ATTRUNKNOWN,
1364   XML_SCHEMAV_ATTRINVALID,
1365   XML_SCHEMAV_VALUE,
1366   XML_SCHEMAV_FACET,
1367   XML_SCHEMAV_CVC_DATATYPE_VALID_1_2_1,
1368   XML_SCHEMAV_CVC_DATATYPE_VALID_1_2_2,
1369   XML_SCHEMAV_CVC_DATATYPE_VALID_1_2_3,
1370   XML_SCHEMAV_CVC_TYPE_3_1_1,
1371   XML_SCHEMAV_CVC_TYPE_3_1_2,
1372   XML_SCHEMAV_CVC_FACET_VALID,
1373   XML_SCHEMAV_CVC_LENGTH_VALID,
1374   XML_SCHEMAV_CVC_MINLENGTH_VALID,
1375   XML_SCHEMAV_CVC_MAXLENGTH_VALID,
1376   XML_SCHEMAV_CVC_MININCLUSIVE_VALID,
1377   XML_SCHEMAV_CVC_MAXINCLUSIVE_VALID,
1378   XML_SCHEMAV_CVC_MINEXCLUSIVE_VALID,
1379   XML_SCHEMAV_CVC_MAXEXCLUSIVE_VALID,
1380   XML_SCHEMAV_CVC_TOTALDIGITS_VALID,
1381   XML_SCHEMAV_CVC_FRACTIONDIGITS_VALID,
1382   XML_SCHEMAV_CVC_PATTERN_VALID,
1383   XML_SCHEMAV_CVC_ENUMERATION_VALID,
1384   XML_SCHEMAV_CVC_COMPLEX_TYPE_2_1,
1385   XML_SCHEMAV_CVC_COMPLEX_TYPE_2_2,
1386   XML_SCHEMAV_CVC_COMPLEX_TYPE_2_3,
1387   XML_SCHEMAV_CVC_COMPLEX_TYPE_2_4,
1388   XML_SCHEMAV_CVC_ELT_1,
1389   XML_SCHEMAV_CVC_ELT_2,
1390   XML_SCHEMAV_CVC_ELT_3_1,
1391   XML_SCHEMAV_CVC_ELT_3_2_1,
1392   XML_SCHEMAV_CVC_ELT_3_2_2,
1393   XML_SCHEMAV_CVC_ELT_4_1,
1394   XML_SCHEMAV_CVC_ELT_4_2,
1395   XML_SCHEMAV_CVC_ELT_4_3,
1396   XML_SCHEMAV_CVC_ELT_5_1_1,
1397   XML_SCHEMAV_CVC_ELT_5_1_2,
1398   XML_SCHEMAV_CVC_ELT_5_2_1,
1399   XML_SCHEMAV_CVC_ELT_5_2_2_1,
1400   XML_SCHEMAV_CVC_ELT_5_2_2_2_1,
1401   XML_SCHEMAV_CVC_ELT_5_2_2_2_2,
1402   XML_SCHEMAV_CVC_ELT_6,
1403   XML_SCHEMAV_CVC_ELT_7,
1404   XML_SCHEMAV_CVC_ATTRIBUTE_1,
1405   XML_SCHEMAV_CVC_ATTRIBUTE_2,
1406   XML_SCHEMAV_CVC_ATTRIBUTE_3,
1407   XML_SCHEMAV_CVC_ATTRIBUTE_4,
1408   XML_SCHEMAV_CVC_COMPLEX_TYPE_3_1,
1409   XML_SCHEMAV_CVC_COMPLEX_TYPE_3_2_1,
1410   XML_SCHEMAV_CVC_COMPLEX_TYPE_3_2_2,
1411   XML_SCHEMAV_CVC_COMPLEX_TYPE_4,
1412   XML_SCHEMAV_CVC_COMPLEX_TYPE_5_1,
1413   XML_SCHEMAV_CVC_COMPLEX_TYPE_5_2,
1414   XML_SCHEMAV_ELEMENT_CONTENT,
1415   XML_SCHEMAV_DOCUMENT_ELEMENT_MISSING,
1416   XML_SCHEMAV_CVC_COMPLEX_TYPE_1,
1417   XML_SCHEMAV_CVC_AU,
1418   XML_SCHEMAV_CVC_TYPE_1,
1419   XML_SCHEMAV_CVC_TYPE_2,
1420   XML_SCHEMAV_CVC_IDC,
1421   XML_SCHEMAV_CVC_WILDCARD,
1422   XML_SCHEMAV_MISC,
1423   XML_XPTR_UNKNOWN_SCHEME = 1900,
1424   XML_XPTR_CHILDSEQ_START,
1425   XML_XPTR_EVAL_FAILED,
1426   XML_XPTR_EXTRA_OBJECTS,
1427   XML_C14N_CREATE_CTXT = 1950,
1428   XML_C14N_REQUIRES_UTF8,
1429   XML_C14N_CREATE_STACK,
1430   XML_C14N_INVALID_NODE,
1431   XML_C14N_UNKNOW_NODE,
1432   XML_C14N_RELATIVE_NAMESPACE,
1433   XML_FTP_PASV_ANSWER = 2000,
1434   XML_FTP_EPSV_ANSWER,
1435   XML_FTP_ACCNT,
1436   XML_FTP_URL_SYNTAX,
1437   XML_HTTP_URL_SYNTAX = 2020,
1438   XML_HTTP_USE_IP,
1439   XML_HTTP_UNKNOWN_HOST,
1440   XML_SCHEMAP_SRC_SIMPLE_TYPE_1 = 3000,
1441   XML_SCHEMAP_SRC_SIMPLE_TYPE_2,
1442   XML_SCHEMAP_SRC_SIMPLE_TYPE_3,
1443   XML_SCHEMAP_SRC_SIMPLE_TYPE_4,
1444   XML_SCHEMAP_SRC_RESOLVE,
1445   XML_SCHEMAP_SRC_RESTRICTION_BASE_OR_SIMPLETYPE,
1446   XML_SCHEMAP_SRC_LIST_ITEMTYPE_OR_SIMPLETYPE,
1447   XML_SCHEMAP_SRC_UNION_MEMBERTYPES_OR_SIMPLETYPES,
1448   XML_SCHEMAP_ST_PROPS_CORRECT_1,
1449   XML_SCHEMAP_ST_PROPS_CORRECT_2,
1450   XML_SCHEMAP_ST_PROPS_CORRECT_3,
1451   XML_SCHEMAP_COS_ST_RESTRICTS_1_1,
1452   XML_SCHEMAP_COS_ST_RESTRICTS_1_2,
1453   XML_SCHEMAP_COS_ST_RESTRICTS_1_3_1,
1454   XML_SCHEMAP_COS_ST_RESTRICTS_1_3_2,
1455   XML_SCHEMAP_COS_ST_RESTRICTS_2_1,
1456   XML_SCHEMAP_COS_ST_RESTRICTS_2_3_1_1,
1457   XML_SCHEMAP_COS_ST_RESTRICTS_2_3_1_2,
1458   XML_SCHEMAP_COS_ST_RESTRICTS_2_3_2_1,
1459   XML_SCHEMAP_COS_ST_RESTRICTS_2_3_2_2,
1460   XML_SCHEMAP_COS_ST_RESTRICTS_2_3_2_3,
1461   XML_SCHEMAP_COS_ST_RESTRICTS_2_3_2_4,
1462   XML_SCHEMAP_COS_ST_RESTRICTS_2_3_2_5,
1463   XML_SCHEMAP_COS_ST_RESTRICTS_3_1,
1464   XML_SCHEMAP_COS_ST_RESTRICTS_3_3_1,
1465   XML_SCHEMAP_COS_ST_RESTRICTS_3_3_1_2,
1466   XML_SCHEMAP_COS_ST_RESTRICTS_3_3_2_2,
1467   XML_SCHEMAP_COS_ST_RESTRICTS_3_3_2_1,
1468   XML_SCHEMAP_COS_ST_RESTRICTS_3_3_2_3,
1469   XML_SCHEMAP_COS_ST_RESTRICTS_3_3_2_4,
1470   XML_SCHEMAP_COS_ST_RESTRICTS_3_3_2_5,
1471   XML_SCHEMAP_COS_ST_DERIVED_OK_2_1,
1472   XML_SCHEMAP_COS_ST_DERIVED_OK_2_2,
1473   XML_SCHEMAP_S4S_ELEM_NOT_ALLOWED,
1474   XML_SCHEMAP_S4S_ELEM_MISSING,
1475   XML_SCHEMAP_S4S_ATTR_NOT_ALLOWED,
1476   XML_SCHEMAP_S4S_ATTR_MISSING,
1477   XML_SCHEMAP_S4S_ATTR_INVALID_VALUE,
1478   XML_SCHEMAP_SRC_ELEMENT_1,
1479   XML_SCHEMAP_SRC_ELEMENT_2_1,
1480   XML_SCHEMAP_SRC_ELEMENT_2_2,
1481   XML_SCHEMAP_SRC_ELEMENT_3,
1482   XML_SCHEMAP_P_PROPS_CORRECT_1,
1483   XML_SCHEMAP_P_PROPS_CORRECT_2_1,
1484   XML_SCHEMAP_P_PROPS_CORRECT_2_2,
1485   XML_SCHEMAP_E_PROPS_CORRECT_2,
1486   XML_SCHEMAP_E_PROPS_CORRECT_3,
1487   XML_SCHEMAP_E_PROPS_CORRECT_4,
1488   XML_SCHEMAP_E_PROPS_CORRECT_5,
1489   XML_SCHEMAP_E_PROPS_CORRECT_6,
1490   XML_SCHEMAP_SRC_INCLUDE,
1491   XML_SCHEMAP_SRC_ATTRIBUTE_1,
1492   XML_SCHEMAP_SRC_ATTRIBUTE_2,
1493   XML_SCHEMAP_SRC_ATTRIBUTE_3_1,
1494   XML_SCHEMAP_SRC_ATTRIBUTE_3_2,
1495   XML_SCHEMAP_SRC_ATTRIBUTE_4,
1496   XML_SCHEMAP_NO_XMLNS,
1497   XML_SCHEMAP_NO_XSI,
1498   XML_SCHEMAP_COS_VALID_DEFAULT_1,
1499   XML_SCHEMAP_COS_VALID_DEFAULT_2_1,
1500   XML_SCHEMAP_COS_VALID_DEFAULT_2_2_1,
1501   XML_SCHEMAP_COS_VALID_DEFAULT_2_2_2,
1502   XML_SCHEMAP_CVC_SIMPLE_TYPE,
1503   XML_SCHEMAP_COS_CT_EXTENDS_1_1,
1504   XML_SCHEMAP_SRC_IMPORT_1_1,
1505   XML_SCHEMAP_SRC_IMPORT_1_2,
1506   XML_SCHEMAP_SRC_IMPORT_2,
1507   XML_SCHEMAP_SRC_IMPORT_2_1,
1508   XML_SCHEMAP_SRC_IMPORT_2_2,
1509   XML_SCHEMAP_INTERNAL,
1510   XML_SCHEMAP_NOT_DETERMINISTIC,
1511   XML_SCHEMAP_SRC_ATTRIBUTE_GROUP_1,
1512   XML_SCHEMAP_SRC_ATTRIBUTE_GROUP_2,
1513   XML_SCHEMAP_SRC_ATTRIBUTE_GROUP_3,
1514   XML_SCHEMAP_MG_PROPS_CORRECT_1,
1515   XML_SCHEMAP_MG_PROPS_CORRECT_2,
1516   XML_SCHEMAP_SRC_CT_1,
1517   XML_SCHEMAP_DERIVATION_OK_RESTRICTION_2_1_3,
1518   XML_SCHEMAP_AU_PROPS_CORRECT_2,
1519   XML_SCHEMAP_A_PROPS_CORRECT_2,
1520   XML_SCHEMAP_C_PROPS_CORRECT,
1521   XML_SCHEMAP_SRC_REDEFINE,
1522   XML_SCHEMAP_SRC_IMPORT,
1523   XML_SCHEMAP_WARN_SKIP_SCHEMA,
1524   XML_SCHEMAP_WARN_UNLOCATED_SCHEMA,
1525   XML_SCHEMAP_WARN_ATTR_REDECL_PROH,
1526   XML_SCHEMAP_WARN_ATTR_POINTLESS_PROH,
1527   XML_SCHEMAP_AG_PROPS_CORRECT,
1528   XML_SCHEMAP_COS_CT_EXTENDS_1_2,
1529   XML_SCHEMAP_AU_PROPS_CORRECT,
1530   XML_SCHEMAP_A_PROPS_CORRECT_3,
1531   XML_SCHEMAP_COS_ALL_LIMITED,
1532   XML_SCHEMATRONV_ASSERT = 4000,
1533   XML_SCHEMATRONV_REPORT,
1534   XML_MODULE_OPEN = 4900,
1535   XML_MODULE_CLOSE,
1536   XML_CHECK_FOUND_ELEMENT = 5000,
1537   XML_CHECK_FOUND_ATTRIBUTE,
1538   XML_CHECK_FOUND_TEXT,
1539   XML_CHECK_FOUND_CDATA,
1540   XML_CHECK_FOUND_ENTITYREF,
1541   XML_CHECK_FOUND_ENTITY,
1542   XML_CHECK_FOUND_PI,
1543   XML_CHECK_FOUND_COMMENT,
1544   XML_CHECK_FOUND_DOCTYPE,
1545   XML_CHECK_FOUND_FRAGMENT,
1546   XML_CHECK_FOUND_NOTATION,
1547   XML_CHECK_UNKNOWN_NODE,
1548   XML_CHECK_ENTITY_TYPE,
1549   XML_CHECK_NO_PARENT,
1550   XML_CHECK_NO_DOC,
1551   XML_CHECK_NO_NAME,
1552   XML_CHECK_NO_ELEM,
1553   XML_CHECK_WRONG_DOC,
1554   XML_CHECK_NO_PREV,
1555   XML_CHECK_WRONG_PREV,
1556   XML_CHECK_NO_NEXT,
1557   XML_CHECK_WRONG_NEXT,
1558   XML_CHECK_NOT_DTD,
1559   XML_CHECK_NOT_ATTR,
1560   XML_CHECK_NOT_ATTR_DECL,
1561   XML_CHECK_NOT_ELEM_DECL,
1562   XML_CHECK_NOT_ENTITY_DECL,
1563   XML_CHECK_NOT_NS_DECL,
1564   XML_CHECK_NO_HREF,
1565   XML_CHECK_WRONG_PARENT,
1566   XML_CHECK_NS_SCOPE,
1567   XML_CHECK_NS_ANCESTOR,
1568   XML_CHECK_NOT_UTF8,
1569   XML_CHECK_NO_DICT,
1570   XML_CHECK_NOT_NCNAME,
1571   XML_CHECK_OUTSIDE_DICT,
1572   XML_CHECK_WRONG_NAME,
1573   XML_CHECK_NAME_NOT_NULL,
1574   XML_I18N_NO_NAME = 6000,
1575   XML_I18N_NO_HANDLER,
1576   XML_I18N_EXCESS_HANDLER,
1577   XML_I18N_CONV_FAILED,
1578   XML_I18N_NO_OUTPUT,
1579   XML_BUF_OVERFLOW = 7000
1580 } xmlParserErrors;
1581
1582 typedef void (*xmlGenericErrorFunc) (void *ctx, const char *msg, ...)
1583   __attribute__ ((__format__ (__printf__, 2, 3)));
1584 typedef void (*xmlStructuredErrorFunc) (void *userData, xmlErrorPtr error);
1585
1586 void xmlSetGenericErrorFunc (void *ctx, xmlGenericErrorFunc handler);
1587 void initGenericErrorDefaultFunc (xmlGenericErrorFunc * handler);
1588 void xmlSetStructuredErrorFunc (void *ctx, xmlStructuredErrorFunc handler);
1589
1590 void xmlParserError (void *ctx, const char *msg, ...)
1591   __attribute__ ((__format__ (__printf__, 2, 3)));
1592 void xmlParserWarning (void *ctx, const char *msg, ...)
1593   __attribute__ ((__format__ (__printf__, 2, 3)));
1594 void xmlParserValidityError (void *ctx, const char *msg, ...)
1595   __attribute__ ((__format__ (__printf__, 2, 3)));
1596 void xmlParserValidityWarning (void *ctx, const char *msg, ...)
1597   __attribute__ ((__format__ (__printf__, 2, 3)));
1598 void xmlParserPrintFileInfo (xmlParserInputPtr input);
1599 void xmlParserPrintFileContext (xmlParserInputPtr input);
1600 xmlErrorPtr xmlGetLastError (void);
1601 void xmlResetLastError (void);
1602 xmlErrorPtr xmlCtxtGetLastError (void *ctx);
1603 void xmlCtxtResetLastError (void *ctx);
1604 void xmlResetError (xmlErrorPtr err);
1605 int xmlCopyError (xmlErrorPtr from, xmlErrorPtr to);
1606 typedef struct _xmlLink xmlLink;
1607 typedef xmlLink *xmlLinkPtr;
1608 typedef struct _xmlList xmlList;
1609 typedef xmlList *xmlListPtr;
1610 typedef void (*xmlListDeallocator) (xmlLinkPtr lk);
1611 typedef int (*xmlListDataCompare) (const void *data0, const void *data1);
1612 typedef int (*xmlListWalker) (const void *data, const void *user);
1613
1614 xmlListPtr xmlListCreate (xmlListDeallocator deallocator, xmlListDataCompare compare);
1615 void xmlListDelete (xmlListPtr l);
1616 void *xmlListSearch (xmlListPtr l, void *data);
1617 void *xmlListReverseSearch (xmlListPtr l, void *data);
1618 int xmlListInsert (xmlListPtr l, void *data);
1619 int xmlListAppend (xmlListPtr l, void *data);
1620 int xmlListRemoveFirst (xmlListPtr l, void *data);
1621 int xmlListRemoveLast (xmlListPtr l, void *data);
1622 int xmlListRemoveAll (xmlListPtr l, void *data);
1623 void xmlListClear (xmlListPtr l);
1624 int xmlListEmpty (xmlListPtr l);
1625 xmlLinkPtr xmlListFront (xmlListPtr l);
1626 xmlLinkPtr xmlListEnd (xmlListPtr l);
1627 int xmlListSize (xmlListPtr l);
1628 void xmlListPopFront (xmlListPtr l);
1629 void xmlListPopBack (xmlListPtr l);
1630 int xmlListPushFront (xmlListPtr l, void *data);
1631 int xmlListPushBack (xmlListPtr l, void *data);
1632 void xmlListReverse (xmlListPtr l);
1633 void xmlListSort (xmlListPtr l);
1634 void xmlListWalk (xmlListPtr l, xmlListWalker walker, const void *user);
1635 void xmlListReverseWalk (xmlListPtr l, xmlListWalker walker, const void *user);
1636 void xmlListMerge (xmlListPtr l1, xmlListPtr l2);
1637 xmlListPtr xmlListDup (const xmlListPtr old);
1638 int xmlListCopy (xmlListPtr cur, const xmlListPtr old);
1639 void *xmlLinkGetData (xmlLinkPtr lk);
1640 typedef struct _xmlAutomata xmlAutomata;
1641 typedef xmlAutomata *xmlAutomataPtr;
1642
1643 typedef struct _xmlAutomataState xmlAutomataState;
1644 typedef xmlAutomataState *xmlAutomataStatePtr;
1645
1646 xmlAutomataPtr xmlNewAutomata (void);
1647 void xmlFreeAutomata (xmlAutomataPtr am);
1648
1649 xmlAutomataStatePtr xmlAutomataGetInitState (xmlAutomataPtr am);
1650 int xmlAutomataSetFinalState (xmlAutomataPtr am, xmlAutomataStatePtr state);
1651 xmlAutomataStatePtr xmlAutomataNewState (xmlAutomataPtr am);
1652 xmlAutomataStatePtr
1653 xmlAutomataNewTransition (xmlAutomataPtr am,
1654                           xmlAutomataStatePtr from,
1655                           xmlAutomataStatePtr to,
1656                           const xmlChar * token, void *data);
1657 xmlAutomataStatePtr
1658 xmlAutomataNewTransition2 (xmlAutomataPtr am,
1659                            xmlAutomataStatePtr from,
1660                            xmlAutomataStatePtr to,
1661                            const xmlChar * token,
1662                            const xmlChar * token2, void *data);
1663 xmlAutomataStatePtr
1664 xmlAutomataNewNegTrans (xmlAutomataPtr am,
1665                         xmlAutomataStatePtr from,
1666                         xmlAutomataStatePtr to,
1667                         const xmlChar * token,
1668                         const xmlChar * token2, void *data);
1669
1670 xmlAutomataStatePtr
1671 xmlAutomataNewCountTrans (xmlAutomataPtr am,
1672                           xmlAutomataStatePtr from,
1673                           xmlAutomataStatePtr to,
1674                           const xmlChar * token,
1675                           int min, int max, void *data);
1676 xmlAutomataStatePtr
1677 xmlAutomataNewCountTrans2 (xmlAutomataPtr am,
1678                            xmlAutomataStatePtr from,
1679                            xmlAutomataStatePtr to,
1680                            const xmlChar * token,
1681                            const xmlChar * token2,
1682                            int min, int max, void *data);
1683 xmlAutomataStatePtr
1684 xmlAutomataNewOnceTrans (xmlAutomataPtr am,
1685                          xmlAutomataStatePtr from,
1686                          xmlAutomataStatePtr to,
1687                          const xmlChar * token, int min, int max, void *data);
1688 xmlAutomataStatePtr
1689 xmlAutomataNewOnceTrans2 (xmlAutomataPtr am,
1690                           xmlAutomataStatePtr from,
1691                           xmlAutomataStatePtr to,
1692                           const xmlChar * token,
1693                           const xmlChar * token2,
1694                           int min, int max, void *data);
1695 xmlAutomataStatePtr
1696 xmlAutomataNewAllTrans (xmlAutomataPtr am,
1697                         xmlAutomataStatePtr from,
1698                         xmlAutomataStatePtr to, int lax);
1699 xmlAutomataStatePtr
1700 xmlAutomataNewEpsilon (xmlAutomataPtr am,
1701                        xmlAutomataStatePtr from, xmlAutomataStatePtr to);
1702 xmlAutomataStatePtr
1703 xmlAutomataNewCountedTrans (xmlAutomataPtr am,
1704                             xmlAutomataStatePtr from,
1705                             xmlAutomataStatePtr to, int counter);
1706 xmlAutomataStatePtr
1707 xmlAutomataNewCounterTrans (xmlAutomataPtr am,
1708                             xmlAutomataStatePtr from,
1709                             xmlAutomataStatePtr to, int counter);
1710 int xmlAutomataNewCounter (xmlAutomataPtr am, int min, int max);
1711
1712 xmlRegexpPtr xmlAutomataCompile (xmlAutomataPtr am);
1713 int xmlAutomataIsDeterminist (xmlAutomataPtr am);
1714 typedef struct _xmlValidState xmlValidState;
1715 typedef xmlValidState *xmlValidStatePtr;
1716 typedef void (*xmlValidityErrorFunc) (void *ctx, const char *msg, ...)
1717   __attribute__ ((__format__ (__printf__, 2, 3)));
1718 typedef void (*xmlValidityWarningFunc) (void *ctx, const char *msg, ...)
1719   __attribute__ ((__format__ (__printf__, 2, 3)));
1720 typedef struct _xmlValidCtxt xmlValidCtxt;
1721 typedef xmlValidCtxt *xmlValidCtxtPtr;
1722
1723 struct _xmlValidCtxt
1724 {
1725   void *userData;
1726   xmlValidityErrorFunc error;
1727   xmlValidityWarningFunc warning;
1728   xmlNodePtr node;
1729   int nodeNr;
1730   int nodeMax;
1731   xmlNodePtr *nodeTab;
1732   unsigned int finishDtd;
1733   xmlDocPtr doc;
1734   int valid;
1735   xmlValidState *vstate;
1736   int vstateNr;
1737   int vstateMax;
1738   xmlValidState *vstateTab;
1739   xmlAutomataPtr am;
1740   xmlAutomataStatePtr state;
1741 };
1742
1743 typedef struct _xmlHashTable xmlNotationTable;
1744 typedef xmlNotationTable *xmlNotationTablePtr;
1745 typedef struct _xmlHashTable xmlElementTable;
1746 typedef xmlElementTable *xmlElementTablePtr;
1747 typedef struct _xmlHashTable xmlAttributeTable;
1748 typedef xmlAttributeTable *xmlAttributeTablePtr;
1749 typedef struct _xmlHashTable xmlIDTable;
1750 typedef xmlIDTable *xmlIDTablePtr;
1751 typedef struct _xmlHashTable xmlRefTable;
1752 typedef xmlRefTable *xmlRefTablePtr;
1753
1754 xmlNotationPtr xmlAddNotationDecl (xmlValidCtxtPtr ctxt,
1755                                    xmlDtdPtr dtd,
1756                                    const xmlChar * name,
1757                                    const xmlChar * PublicID, const xmlChar * SystemID);
1758
1759 xmlNotationTablePtr xmlCopyNotationTable (xmlNotationTablePtr table);
1760
1761 void xmlFreeNotationTable (xmlNotationTablePtr table);
1762
1763 void xmlDumpNotationDecl (xmlBufferPtr buf, xmlNotationPtr nota);
1764 void xmlDumpNotationTable (xmlBufferPtr buf, xmlNotationTablePtr table);
1765
1766 xmlElementContentPtr xmlNewElementContent (const xmlChar * name, xmlElementContentType type);
1767 xmlElementContentPtr xmlCopyElementContent (xmlElementContentPtr content);
1768 void xmlFreeElementContent (xmlElementContentPtr cur);
1769
1770 xmlElementContentPtr xmlNewDocElementContent (xmlDocPtr doc,
1771                                               const xmlChar * name, xmlElementContentType type);
1772 xmlElementContentPtr xmlCopyDocElementContent (xmlDocPtr doc, xmlElementContentPtr content);
1773 void xmlFreeDocElementContent (xmlDocPtr doc, xmlElementContentPtr cur);
1774 void xmlSnprintfElementContent (char *buf,
1775                                 int size,
1776                                 xmlElementContentPtr content, int englob);
1777
1778 void xmlSprintfElementContent (char *buf,
1779                                xmlElementContentPtr content, int englob);
1780
1781 xmlElementPtr xmlAddElementDecl (xmlValidCtxtPtr ctxt,
1782                                  xmlDtdPtr dtd,
1783                                  const xmlChar * name,
1784                                  xmlElementTypeVal type, xmlElementContentPtr content);
1785
1786 xmlElementTablePtr xmlCopyElementTable (xmlElementTablePtr table);
1787
1788 void xmlFreeElementTable (xmlElementTablePtr table);
1789 void xmlDumpElementTable (xmlBufferPtr buf, xmlElementTablePtr table);
1790 void xmlDumpElementDecl (xmlBufferPtr buf, xmlElementPtr elem);
1791 xmlEnumerationPtr xmlCreateEnumeration (const xmlChar * name);
1792 void xmlFreeEnumeration (xmlEnumerationPtr cur);
1793 xmlEnumerationPtr xmlCopyEnumeration (xmlEnumerationPtr cur);
1794
1795 xmlAttributePtr xmlAddAttributeDecl (xmlValidCtxtPtr ctxt,
1796                                      xmlDtdPtr dtd,
1797                                      const xmlChar * elem,
1798                                      const xmlChar * name,
1799                                      const xmlChar * ns,
1800                                      xmlAttributeType type,
1801                                      xmlAttributeDefault def,
1802                                      const xmlChar * defaultValue, xmlEnumerationPtr tree);
1803
1804 xmlAttributeTablePtr xmlCopyAttributeTable (xmlAttributeTablePtr table);
1805 void xmlFreeAttributeTable (xmlAttributeTablePtr table);
1806 void xmlDumpAttributeTable (xmlBufferPtr buf, xmlAttributeTablePtr table);
1807 void xmlDumpAttributeDecl (xmlBufferPtr buf, xmlAttributePtr attr);
1808
1809 xmlIDPtr xmlAddID (xmlValidCtxtPtr ctxt,
1810                    xmlDocPtr doc, const xmlChar * value, xmlAttrPtr attr);
1811 void xmlFreeIDTable (xmlIDTablePtr table);
1812 xmlAttrPtr xmlGetID (xmlDocPtr doc, const xmlChar * ID);
1813 int xmlIsID (xmlDocPtr doc, xmlNodePtr elem, xmlAttrPtr attr);
1814 int xmlRemoveID (xmlDocPtr doc, xmlAttrPtr attr);
1815
1816 xmlRefPtr xmlAddRef (xmlValidCtxtPtr ctxt,
1817                      xmlDocPtr doc, const xmlChar * value, xmlAttrPtr attr);
1818 void xmlFreeRefTable (xmlRefTablePtr table);
1819 int xmlIsRef (xmlDocPtr doc, xmlNodePtr elem, xmlAttrPtr attr);
1820 int xmlRemoveRef (xmlDocPtr doc, xmlAttrPtr attr);
1821 xmlListPtr xmlGetRefs (xmlDocPtr doc, const xmlChar * ID);
1822
1823 xmlValidCtxtPtr xmlNewValidCtxt (void);
1824 void xmlFreeValidCtxt (xmlValidCtxtPtr);
1825 int xmlValidateRoot (xmlValidCtxtPtr ctxt, xmlDocPtr doc);
1826 int xmlValidateElementDecl (xmlValidCtxtPtr ctxt,
1827                             xmlDocPtr doc, xmlElementPtr elem);
1828 xmlChar *xmlValidNormalizeAttributeValue (xmlDocPtr doc,
1829                                           xmlNodePtr elem,
1830                                           const xmlChar * name,
1831                                           const xmlChar * value);
1832 xmlChar *xmlValidCtxtNormalizeAttributeValue (xmlValidCtxtPtr ctxt,
1833                                               xmlDocPtr doc,
1834                                               xmlNodePtr elem,
1835                                               const xmlChar * name,
1836                                               const xmlChar * value);
1837 int xmlValidateAttributeDecl (xmlValidCtxtPtr ctxt,
1838                               xmlDocPtr doc, xmlAttributePtr attr);
1839 int xmlValidateAttributeValue (xmlAttributeType type, const xmlChar * value);
1840 int xmlValidateNotationDecl (xmlValidCtxtPtr ctxt,
1841                              xmlDocPtr doc, xmlNotationPtr nota);
1842 int xmlValidateDtd (xmlValidCtxtPtr ctxt, xmlDocPtr doc, xmlDtdPtr dtd);
1843 int xmlValidateDtdFinal (xmlValidCtxtPtr ctxt, xmlDocPtr doc);
1844 int xmlValidateDocument (xmlValidCtxtPtr ctxt, xmlDocPtr doc);
1845 int xmlValidateElement (xmlValidCtxtPtr ctxt, xmlDocPtr doc, xmlNodePtr elem);
1846 int xmlValidateOneElement (xmlValidCtxtPtr ctxt, xmlDocPtr doc, xmlNodePtr elem);
1847 int xmlValidateOneAttribute (xmlValidCtxtPtr ctxt,
1848                              xmlDocPtr doc,
1849                              xmlNodePtr elem,
1850                              xmlAttrPtr attr, const xmlChar * value);
1851 int xmlValidateOneNamespace (xmlValidCtxtPtr ctxt,
1852                              xmlDocPtr doc,
1853                              xmlNodePtr elem,
1854                              const xmlChar * prefix,
1855                              xmlNsPtr ns, const xmlChar * value);
1856 int xmlValidateDocumentFinal (xmlValidCtxtPtr ctxt, xmlDocPtr doc);
1857
1858
1859
1860 int
1861 xmlValidateNotationUse (xmlValidCtxtPtr ctxt,
1862                         xmlDocPtr doc, const xmlChar * notationName);
1863
1864
1865 int xmlIsMixedElement (xmlDocPtr doc, const xmlChar * name);
1866 xmlAttributePtr xmlGetDtdAttrDesc (xmlDtdPtr dtd, const xmlChar * elem, const xmlChar * name);
1867 xmlAttributePtr xmlGetDtdQAttrDesc (xmlDtdPtr dtd,
1868                                     const xmlChar * elem,
1869                                     const xmlChar * name, const xmlChar * prefix);
1870 xmlNotationPtr xmlGetDtdNotationDesc (xmlDtdPtr dtd, const xmlChar * name);
1871 xmlElementPtr xmlGetDtdQElementDesc (xmlDtdPtr dtd,
1872                                      const xmlChar * name, const xmlChar * prefix);
1873 xmlElementPtr xmlGetDtdElementDesc (xmlDtdPtr dtd, const xmlChar * name);
1874
1875 int xmlValidGetPotentialChildren (xmlElementContent * ctree,
1876                                   const xmlChar ** names, int *len, int max);
1877
1878 int xmlValidGetValidElements (xmlNode * prev,
1879                               xmlNode * next, const xmlChar ** names, int max);
1880 int xmlValidateNameValue (const xmlChar * value);
1881 int xmlValidateNamesValue (const xmlChar * value);
1882 int xmlValidateNmtokenValue (const xmlChar * value);
1883 int xmlValidateNmtokensValue (const xmlChar * value);
1884
1885 int xmlValidBuildContentModel (xmlValidCtxtPtr ctxt, xmlElementPtr elem);
1886
1887 int
1888 xmlValidatePushElement (xmlValidCtxtPtr ctxt,
1889                         xmlDocPtr doc,
1890                         xmlNodePtr elem, const xmlChar * qname);
1891 int
1892 xmlValidatePushCData (xmlValidCtxtPtr ctxt, const xmlChar * data, int len);
1893 int
1894 xmlValidatePopElement (xmlValidCtxtPtr ctxt,
1895                        xmlDocPtr doc, xmlNodePtr elem, const xmlChar * qname);
1896 typedef enum
1897   {
1898     XML_INTERNAL_GENERAL_ENTITY = 1,
1899     XML_EXTERNAL_GENERAL_PARSED_ENTITY = 2,
1900     XML_EXTERNAL_GENERAL_UNPARSED_ENTITY = 3,
1901     XML_INTERNAL_PARAMETER_ENTITY = 4,
1902     XML_EXTERNAL_PARAMETER_ENTITY = 5,
1903     XML_INTERNAL_PREDEFINED_ENTITY = 6
1904   } xmlEntityType;
1905
1906 struct _xmlEntity
1907 {
1908   void *_private;
1909   xmlElementType type;
1910   const xmlChar *name;
1911   struct _xmlNode *children;
1912   struct _xmlNode *last;
1913   struct _xmlDtd *parent;
1914   struct _xmlNode *next;
1915   struct _xmlNode *prev;
1916   struct _xmlDoc *doc;
1917
1918   xmlChar *orig;
1919   xmlChar *content;
1920   int length;
1921   xmlEntityType etype;
1922   const xmlChar *ExternalID;
1923   const xmlChar *SystemID;
1924
1925   struct _xmlEntity *nexte;
1926   const xmlChar *URI;
1927   int owner;
1928   int checked;
1929 };
1930
1931 typedef struct _xmlHashTable xmlEntitiesTable;
1932 typedef xmlEntitiesTable *xmlEntitiesTablePtr;
1933 void xmlInitializePredefinedEntities (void);
1934
1935 xmlEntityPtr
1936 xmlNewEntity (xmlDocPtr doc,
1937               const xmlChar * name,
1938               int type,
1939               const xmlChar * ExternalID,
1940               const xmlChar * SystemID, const xmlChar * content);
1941 xmlEntityPtr
1942 xmlAddDocEntity (xmlDocPtr doc,
1943                  const xmlChar * name,
1944                  int type,
1945                  const xmlChar * ExternalID,
1946                  const xmlChar * SystemID, const xmlChar * content);
1947 xmlEntityPtr
1948 xmlAddDtdEntity (xmlDocPtr doc,
1949                  const xmlChar * name,
1950                  int type,
1951                  const xmlChar * ExternalID,
1952                  const xmlChar * SystemID, const xmlChar * content);
1953 xmlEntityPtr xmlGetPredefinedEntity (const xmlChar * name);
1954 xmlEntityPtr xmlGetDocEntity (const xmlDoc * doc, const xmlChar * name);
1955 xmlEntityPtr xmlGetDtdEntity (xmlDocPtr doc, const xmlChar * name);
1956 xmlEntityPtr xmlGetParameterEntity (xmlDocPtr doc, const xmlChar * name);
1957 const xmlChar *xmlEncodeEntities (xmlDocPtr doc, const xmlChar * input);
1958 xmlChar *xmlEncodeEntitiesReentrant (xmlDocPtr doc, const xmlChar * input);
1959 xmlChar *xmlEncodeSpecialChars (const xmlDoc * doc, const xmlChar * input);
1960 xmlEntitiesTablePtr xmlCreateEntitiesTable (void);
1961
1962 xmlEntitiesTablePtr xmlCopyEntitiesTable (xmlEntitiesTablePtr table);
1963 void xmlFreeEntitiesTable (xmlEntitiesTablePtr table);
1964 void xmlDumpEntitiesTable (xmlBufferPtr buf, xmlEntitiesTablePtr table);
1965 void xmlDumpEntityDecl (xmlBufferPtr buf, xmlEntityPtr ent);
1966 void xmlCleanupPredefinedEntities (void);
1967 typedef void (*xmlParserInputDeallocate) (xmlChar * str);
1968
1969 struct _xmlParserInput
1970 {
1971   xmlParserInputBufferPtr buf;
1972   const char *filename;
1973   const char *directory;
1974   const xmlChar *base;
1975   const xmlChar *cur;
1976   const xmlChar *end;
1977   int length;
1978   int line;
1979   int col;
1980   unsigned long consumed;
1981   xmlParserInputDeallocate free;
1982   const xmlChar *encoding;
1983   const xmlChar *version;
1984   int standalone;
1985   int id;
1986 };
1987
1988 typedef struct _xmlParserNodeInfo xmlParserNodeInfo;
1989 typedef xmlParserNodeInfo *xmlParserNodeInfoPtr;
1990
1991 struct _xmlParserNodeInfo
1992 {
1993   const struct _xmlNode *node;
1994   unsigned long begin_pos;
1995   unsigned long begin_line;
1996   unsigned long end_pos;
1997   unsigned long end_line;
1998 };
1999
2000 typedef struct _xmlParserNodeInfoSeq xmlParserNodeInfoSeq;
2001 typedef xmlParserNodeInfoSeq *xmlParserNodeInfoSeqPtr;
2002 struct _xmlParserNodeInfoSeq
2003 {
2004   unsigned long maximum;
2005   unsigned long length;
2006   xmlParserNodeInfo *buffer;
2007 };
2008
2009 typedef enum
2010   {
2011     XML_PARSER_EOF = -1,
2012     XML_PARSER_START = 0,
2013     XML_PARSER_MISC,
2014     XML_PARSER_PI,
2015     XML_PARSER_DTD,
2016     XML_PARSER_PROLOG,
2017     XML_PARSER_COMMENT,
2018     XML_PARSER_START_TAG,
2019     XML_PARSER_CONTENT,
2020     XML_PARSER_CDATA_SECTION,
2021     XML_PARSER_END_TAG,
2022     XML_PARSER_ENTITY_DECL,
2023     XML_PARSER_ENTITY_VALUE,
2024     XML_PARSER_ATTRIBUTE_VALUE,
2025     XML_PARSER_SYSTEM_LITERAL,
2026     XML_PARSER_EPILOG,
2027     XML_PARSER_IGNORE,
2028     XML_PARSER_PUBLIC_LITERAL
2029   } xmlParserInputState;
2030
2031 typedef enum
2032   {
2033     XML_PARSE_UNKNOWN = 0,
2034     XML_PARSE_DOM = 1,
2035     XML_PARSE_SAX = 2,
2036     XML_PARSE_PUSH_DOM = 3,
2037     XML_PARSE_PUSH_SAX = 4,
2038     XML_PARSE_READER = 5
2039   } xmlParserMode;
2040
2041 struct _xmlParserCtxt
2042 {
2043   struct _xmlSAXHandler *sax;
2044   void *userData;
2045   xmlDocPtr myDoc;
2046   int wellFormed;
2047   int replaceEntities;
2048   const xmlChar *version;
2049   const xmlChar *encoding;
2050   int standalone;
2051   int html;
2052   xmlParserInputPtr input;
2053   int inputNr;
2054   int inputMax;
2055   xmlParserInputPtr *inputTab;
2056   xmlNodePtr node;
2057   int nodeNr;
2058   int nodeMax;
2059   xmlNodePtr *nodeTab;
2060   int record_info;
2061   xmlParserNodeInfoSeq node_seq;
2062   int errNo;
2063   int hasExternalSubset;
2064   int hasPErefs;
2065   int external;
2066   int valid;
2067   int validate;
2068   xmlValidCtxt vctxt;
2069   xmlParserInputState instate;
2070   int token;
2071   char *directory;
2072   const xmlChar *name;
2073   int nameNr;
2074   int nameMax;
2075   const xmlChar **nameTab;
2076   long nbChars;
2077   long checkIndex;
2078   int keepBlanks;
2079   int disableSAX;
2080   int inSubset;
2081   const xmlChar *intSubName;
2082   xmlChar *extSubURI;
2083   xmlChar *extSubSystem;
2084   int *space;
2085   int spaceNr;
2086   int spaceMax;
2087   int *spaceTab;
2088   int depth;
2089   xmlParserInputPtr entity;
2090   int charset;
2091   int nodelen;
2092   int nodemem;
2093   int pedantic;
2094   void *_private;
2095   int loadsubset;
2096   int linenumbers;
2097   void *catalogs;
2098   int recovery;
2099   int progressive;
2100   xmlDictPtr dict;
2101   const xmlChar **atts;
2102   int maxatts;
2103   int docdict;
2104   const xmlChar *str_xml;
2105   const xmlChar *str_xmlns;
2106   const xmlChar *str_xml_ns;
2107   int sax2;
2108   int nsNr;
2109   int nsMax;
2110   const xmlChar **nsTab;
2111   int *attallocs;
2112   void **pushTab;
2113   xmlHashTablePtr attsDefault;
2114   xmlHashTablePtr attsSpecial;
2115   int nsWellFormed;
2116   int options;
2117   int dictNames;
2118   int freeElemsNr;
2119   xmlNodePtr freeElems;
2120   int freeAttrsNr;
2121   xmlAttrPtr freeAttrs;
2122   xmlError lastError;
2123   xmlParserMode parseMode;
2124   unsigned long nbentities;
2125   unsigned long sizeentities;
2126   xmlParserNodeInfo *nodeInfo;
2127   int nodeInfoNr;
2128   int nodeInfoMax;
2129   xmlParserNodeInfo *nodeInfoTab;
2130   int input_id;
2131   unsigned long sizeentcopy;
2132 };
2133
2134 struct _xmlSAXLocator
2135 {
2136   const xmlChar *(*getPublicId) (void *ctx);
2137   const xmlChar *(*getSystemId) (void *ctx);
2138   int (*getLineNumber) (void *ctx);
2139   int (*getColumnNumber) (void *ctx);
2140 };
2141
2142 typedef xmlParserInputPtr (*resolveEntitySAXFunc) (void *ctx,
2143                                                    const xmlChar * publicId,
2144                                                    const xmlChar * systemId);
2145 typedef void (*internalSubsetSAXFunc) (void *ctx,
2146                                        const xmlChar * name,
2147                                        const xmlChar * ExternalID,
2148                                        const xmlChar * SystemID);
2149 typedef void (*externalSubsetSAXFunc) (void *ctx,
2150                                        const xmlChar * name,
2151                                        const xmlChar * ExternalID,
2152                                        const xmlChar * SystemID);
2153 typedef xmlEntityPtr (*getEntitySAXFunc) (void *ctx, const xmlChar * name);
2154 typedef xmlEntityPtr (*getParameterEntitySAXFunc) (void *ctx,
2155                                                    const xmlChar * name);
2156 typedef void (*entityDeclSAXFunc) (void *ctx,
2157                                    const xmlChar * name,
2158                                    int type,
2159                                    const xmlChar * publicId,
2160                                    const xmlChar * systemId,
2161                                    xmlChar * content);
2162 typedef void (*notationDeclSAXFunc) (void *ctx,
2163                                      const xmlChar * name,
2164                                      const xmlChar * publicId,
2165                                      const xmlChar * systemId);
2166 typedef void (*attributeDeclSAXFunc) (void *ctx,
2167                                       const xmlChar * elem,
2168                                       const xmlChar * fullname,
2169                                       int type,
2170                                       int def,
2171                                       const xmlChar * defaultValue,
2172                                       xmlEnumerationPtr tree);
2173 typedef void (*elementDeclSAXFunc) (void *ctx,
2174                                     const xmlChar * name,
2175                                     int type, xmlElementContentPtr content);
2176 typedef void (*unparsedEntityDeclSAXFunc) (void *ctx,
2177                                            const xmlChar * name,
2178                                            const xmlChar * publicId,
2179                                            const xmlChar * systemId,
2180                                            const xmlChar * notationName);
2181 typedef void (*setDocumentLocatorSAXFunc) (void *ctx, xmlSAXLocatorPtr loc);
2182 typedef void (*startDocumentSAXFunc) (void *ctx);
2183 typedef void (*endDocumentSAXFunc) (void *ctx);
2184 typedef void (*startElementSAXFunc) (void *ctx,
2185                                      const xmlChar * name,
2186                                      const xmlChar ** atts);
2187 typedef void (*endElementSAXFunc) (void *ctx, const xmlChar * name);
2188 typedef void (*attributeSAXFunc) (void *ctx,
2189                                   const xmlChar * name,
2190                                   const xmlChar * value);
2191 typedef void (*referenceSAXFunc) (void *ctx, const xmlChar * name);
2192 typedef void (*charactersSAXFunc) (void *ctx, const xmlChar * ch, int len);
2193 typedef void (*ignorableWhitespaceSAXFunc) (void *ctx,
2194                                             const xmlChar * ch, int len);
2195 typedef void (*processingInstructionSAXFunc) (void *ctx,
2196                                               const xmlChar * target,
2197                                               const xmlChar * data);
2198
2199 typedef void (*commentSAXFunc) (void *ctx, const xmlChar * value);
2200 typedef void (*cdataBlockSAXFunc) (void *ctx, const xmlChar * value, int len);
2201 typedef void (*warningSAXFunc) (void *ctx,
2202                                 const char *msg, ...)
2203   __attribute__ ((__format__ (__printf__, 2, 3)));
2204 typedef void (*errorSAXFunc) (void *ctx, const char *msg, ...)
2205   __attribute__ ((__format__ (__printf__, 2, 3)));
2206 typedef void (*fatalErrorSAXFunc) (void *ctx, const char *msg, ...)
2207   __attribute__ ((__format__ (__printf__, 2, 3)));
2208 typedef int (*isStandaloneSAXFunc) (void *ctx);
2209 typedef int (*hasInternalSubsetSAXFunc) (void *ctx);
2210 typedef int (*hasExternalSubsetSAXFunc) (void *ctx);
2211 typedef void (*startElementNsSAX2Func) (void *ctx,
2212                                         const xmlChar * localname,
2213                                         const xmlChar * prefix,
2214                                         const xmlChar * URI,
2215                                         int nb_namespaces,
2216                                         const xmlChar ** namespaces,
2217                                         int nb_attributes,
2218                                         int nb_defaulted,
2219                                         const xmlChar ** attributes);
2220 typedef void (*endElementNsSAX2Func) (void *ctx,
2221                                       const xmlChar * localname,
2222                                       const xmlChar * prefix,
2223                                       const xmlChar * URI);
2224
2225
2226 struct _xmlSAXHandler
2227 {
2228   internalSubsetSAXFunc internalSubset;
2229   isStandaloneSAXFunc isStandalone;
2230   hasInternalSubsetSAXFunc hasInternalSubset;
2231   hasExternalSubsetSAXFunc hasExternalSubset;
2232   resolveEntitySAXFunc resolveEntity;
2233   getEntitySAXFunc getEntity;
2234   entityDeclSAXFunc entityDecl;
2235   notationDeclSAXFunc notationDecl;
2236   attributeDeclSAXFunc attributeDecl;
2237   elementDeclSAXFunc elementDecl;
2238   unparsedEntityDeclSAXFunc unparsedEntityDecl;
2239   setDocumentLocatorSAXFunc setDocumentLocator;
2240   startDocumentSAXFunc startDocument;
2241   endDocumentSAXFunc endDocument;
2242   startElementSAXFunc startElement;
2243   endElementSAXFunc endElement;
2244   referenceSAXFunc reference;
2245   charactersSAXFunc characters;
2246   ignorableWhitespaceSAXFunc ignorableWhitespace;
2247   processingInstructionSAXFunc processingInstruction;
2248   commentSAXFunc comment;
2249   warningSAXFunc warning;
2250   errorSAXFunc error;
2251   fatalErrorSAXFunc fatalError;
2252   getParameterEntitySAXFunc getParameterEntity;
2253   cdataBlockSAXFunc cdataBlock;
2254   externalSubsetSAXFunc externalSubset;
2255   unsigned int initialized;
2256
2257   void *_private;
2258   startElementNsSAX2Func startElementNs;
2259   endElementNsSAX2Func endElementNs;
2260   xmlStructuredErrorFunc serror;
2261 };
2262
2263 typedef struct _xmlSAXHandlerV1 xmlSAXHandlerV1;
2264 typedef xmlSAXHandlerV1 *xmlSAXHandlerV1Ptr;
2265 struct _xmlSAXHandlerV1
2266 {
2267   internalSubsetSAXFunc internalSubset;
2268   isStandaloneSAXFunc isStandalone;
2269   hasInternalSubsetSAXFunc hasInternalSubset;
2270   hasExternalSubsetSAXFunc hasExternalSubset;
2271   resolveEntitySAXFunc resolveEntity;
2272   getEntitySAXFunc getEntity;
2273   entityDeclSAXFunc entityDecl;
2274   notationDeclSAXFunc notationDecl;
2275   attributeDeclSAXFunc attributeDecl;
2276   elementDeclSAXFunc elementDecl;
2277   unparsedEntityDeclSAXFunc unparsedEntityDecl;
2278   setDocumentLocatorSAXFunc setDocumentLocator;
2279   startDocumentSAXFunc startDocument;
2280   endDocumentSAXFunc endDocument;
2281   startElementSAXFunc startElement;
2282   endElementSAXFunc endElement;
2283   referenceSAXFunc reference;
2284   charactersSAXFunc characters;
2285   ignorableWhitespaceSAXFunc ignorableWhitespace;
2286   processingInstructionSAXFunc processingInstruction;
2287   commentSAXFunc comment;
2288   warningSAXFunc warning;
2289   errorSAXFunc error;
2290   fatalErrorSAXFunc fatalError;
2291   getParameterEntitySAXFunc getParameterEntity;
2292   cdataBlockSAXFunc cdataBlock;
2293   externalSubsetSAXFunc externalSubset;
2294   unsigned int initialized;
2295 };
2296 typedef xmlParserInputPtr (*xmlExternalEntityLoader) (const char *URL,
2297                                                       const char *ID,
2298                                                       xmlParserCtxtPtr
2299                                                       context);
2300
2301 typedef void *iconv_t;
2302 extern iconv_t iconv_open (const char *__tocode, const char *__fromcode);
2303 extern size_t iconv (iconv_t __cd, char **__restrict __inbuf,
2304                      size_t * __restrict __inbytesleft,
2305                      char **__restrict __outbuf,
2306                      size_t * __restrict __outbytesleft);
2307
2308 extern int iconv_close (iconv_t __cd);
2309 typedef int8_t UBool;
2310 typedef short unsigned int UChar;
2311 typedef int32_t UChar32;
2312 typedef uint8_t UVersionInfo[4];
2313
2314 extern __attribute__ ((visibility ("default")))
2315 void u_versionFromString_52 (UVersionInfo versionArray,
2316                              const char *versionString);
2317 extern __attribute__ ((visibility ("default")))
2318 void u_versionFromUString_52 (UVersionInfo versionArray,
2319                               const UChar * versionString);
2320 extern __attribute__ ((visibility ("default")))
2321 void u_versionToString_52 (const UVersionInfo versionArray,
2322                            char *versionString);
2323 extern __attribute__ ((visibility ("default")))
2324 void u_getVersion_52 (UVersionInfo versionArray);
2325
2326 extern const uint8_t utf8_countTrailBytes_52[256];
2327 extern __attribute__ ((visibility ("default")))
2328 UChar32 utf8_nextCharSafeBody_52 (const uint8_t * s, int32_t * pi, int32_t length,
2329                                   UChar32 c, UBool strict);
2330 extern __attribute__ ((visibility ("default")))
2331 int32_t utf8_appendCharSafeBody_52 (uint8_t * s, int32_t i, int32_t length,
2332                                     UChar32 c, UBool * pIsError);
2333 extern __attribute__ ((visibility ("default")))
2334 UChar32   utf8_prevCharSafeBody_52 (const uint8_t * s, int32_t start, int32_t * pi,
2335                                     UChar32 c, UBool strict);
2336 extern __attribute__ ((visibility ("default"))) int32_t
2337 utf8_back1SafeBody_52 (const uint8_t * s, int32_t start, int32_t i);
2338
2339 typedef double UDate;
2340
2341 typedef enum UErrorCode {
2342   U_USING_FALLBACK_WARNING = -128,
2343   U_ERROR_WARNING_START = -128,
2344   U_USING_DEFAULT_WARNING = -127,
2345   U_SAFECLONE_ALLOCATED_WARNING = -126,
2346   U_STATE_OLD_WARNING = -125,
2347   U_STRING_NOT_TERMINATED_WARNING = -124,
2348   U_SORT_KEY_TOO_SHORT_WARNING = -123,
2349   U_AMBIGUOUS_ALIAS_WARNING = -122,
2350   U_DIFFERENT_UCA_VERSION = -121,
2351   U_PLUGIN_CHANGED_LEVEL_WARNING = -120,
2352   U_ERROR_WARNING_LIMIT,
2353   U_ZERO_ERROR = 0,
2354   U_ILLEGAL_ARGUMENT_ERROR = 1,
2355   U_MISSING_RESOURCE_ERROR = 2,
2356   U_INVALID_FORMAT_ERROR = 3,
2357   U_FILE_ACCESS_ERROR = 4,
2358   U_INTERNAL_PROGRAM_ERROR = 5,
2359   U_MESSAGE_PARSE_ERROR = 6,
2360   U_MEMORY_ALLOCATION_ERROR = 7,
2361   U_INDEX_OUTOFBOUNDS_ERROR = 8,
2362   U_PARSE_ERROR = 9,
2363   U_INVALID_CHAR_FOUND = 10,
2364   U_TRUNCATED_CHAR_FOUND = 11,
2365   U_ILLEGAL_CHAR_FOUND = 12,
2366   U_INVALID_TABLE_FORMAT = 13,
2367   U_INVALID_TABLE_FILE = 14,
2368   U_BUFFER_OVERFLOW_ERROR = 15,
2369   U_UNSUPPORTED_ERROR = 16,
2370   U_RESOURCE_TYPE_MISMATCH = 17,
2371   U_ILLEGAL_ESCAPE_SEQUENCE = 18,
2372   U_UNSUPPORTED_ESCAPE_SEQUENCE = 19,
2373   U_NO_SPACE_AVAILABLE = 20,
2374   U_CE_NOT_FOUND_ERROR = 21,
2375   U_PRIMARY_TOO_LONG_ERROR = 22,
2376   U_STATE_TOO_OLD_ERROR = 23,
2377   U_TOO_MANY_ALIASES_ERROR = 24,
2378   U_ENUM_OUT_OF_SYNC_ERROR = 25,
2379   U_INVARIANT_CONVERSION_ERROR = 26,
2380   U_INVALID_STATE_ERROR = 27,
2381   U_COLLATOR_VERSION_MISMATCH = 28,
2382   U_USELESS_COLLATOR_ERROR = 29,
2383   U_NO_WRITE_PERMISSION = 30,
2384   U_STANDARD_ERROR_LIMIT,
2385   U_BAD_VARIABLE_DEFINITION = 0x10000,
2386   U_PARSE_ERROR_START = 0x10000,
2387   U_MALFORMED_RULE,
2388   U_MALFORMED_SET,
2389   U_MALFORMED_SYMBOL_REFERENCE,
2390   U_MALFORMED_UNICODE_ESCAPE,
2391   U_MALFORMED_VARIABLE_DEFINITION,
2392   U_MALFORMED_VARIABLE_REFERENCE,
2393   U_MISMATCHED_SEGMENT_DELIMITERS,
2394   U_MISPLACED_ANCHOR_START,
2395   U_MISPLACED_CURSOR_OFFSET,
2396   U_MISPLACED_QUANTIFIER,
2397   U_MISSING_OPERATOR,
2398   U_MISSING_SEGMENT_CLOSE,
2399   U_MULTIPLE_ANTE_CONTEXTS,
2400   U_MULTIPLE_CURSORS,
2401   U_MULTIPLE_POST_CONTEXTS,
2402   U_TRAILING_BACKSLASH,
2403   U_UNDEFINED_SEGMENT_REFERENCE,
2404   U_UNDEFINED_VARIABLE,
2405   U_UNQUOTED_SPECIAL,
2406   U_UNTERMINATED_QUOTE,
2407   U_RULE_MASK_ERROR,
2408   U_MISPLACED_COMPOUND_FILTER,
2409   U_MULTIPLE_COMPOUND_FILTERS,
2410   U_INVALID_RBT_SYNTAX,
2411   U_INVALID_PROPERTY_PATTERN,
2412   U_MALFORMED_PRAGMA,
2413   U_UNCLOSED_SEGMENT,
2414   U_ILLEGAL_CHAR_IN_SEGMENT,
2415   U_VARIABLE_RANGE_EXHAUSTED,
2416   U_VARIABLE_RANGE_OVERLAP,
2417   U_ILLEGAL_CHARACTER,
2418   U_INTERNAL_TRANSLITERATOR_ERROR,
2419   U_INVALID_ID,
2420   U_INVALID_FUNCTION,
2421   U_PARSE_ERROR_LIMIT,
2422   U_UNEXPECTED_TOKEN = 0x10100,
2423   U_FMT_PARSE_ERROR_START = 0x10100,
2424   U_MULTIPLE_DECIMAL_SEPARATORS,
2425   U_MULTIPLE_DECIMAL_SEPERATORS = U_MULTIPLE_DECIMAL_SEPARATORS,
2426   U_MULTIPLE_EXPONENTIAL_SYMBOLS,
2427   U_MALFORMED_EXPONENTIAL_PATTERN,
2428   U_MULTIPLE_PERCENT_SYMBOLS,
2429   U_MULTIPLE_PERMILL_SYMBOLS,
2430   U_MULTIPLE_PAD_SPECIFIERS,
2431   U_PATTERN_SYNTAX_ERROR,
2432   U_ILLEGAL_PAD_POSITION,
2433   U_UNMATCHED_BRACES,
2434   U_UNSUPPORTED_PROPERTY,
2435   U_UNSUPPORTED_ATTRIBUTE,
2436   U_ARGUMENT_TYPE_MISMATCH,
2437   U_DUPLICATE_KEYWORD,
2438   U_UNDEFINED_KEYWORD,
2439   U_DEFAULT_KEYWORD_MISSING,
2440   U_DECIMAL_NUMBER_SYNTAX_ERROR,
2441   U_FORMAT_INEXACT_ERROR,
2442   U_FMT_PARSE_ERROR_LIMIT,
2443   U_BRK_INTERNAL_ERROR = 0x10200,
2444   U_BRK_ERROR_START = 0x10200,
2445   U_BRK_HEX_DIGITS_EXPECTED,
2446   U_BRK_SEMICOLON_EXPECTED,
2447   U_BRK_RULE_SYNTAX,
2448   U_BRK_UNCLOSED_SET,
2449   U_BRK_ASSIGN_ERROR,
2450   U_BRK_VARIABLE_REDFINITION,
2451   U_BRK_MISMATCHED_PAREN,
2452   U_BRK_NEW_LINE_IN_QUOTED_STRING,
2453   U_BRK_UNDEFINED_VARIABLE,
2454   U_BRK_INIT_ERROR,
2455   U_BRK_RULE_EMPTY_SET,
2456   U_BRK_UNRECOGNIZED_OPTION,
2457   U_BRK_MALFORMED_RULE_TAG,
2458   U_BRK_ERROR_LIMIT,
2459   U_REGEX_INTERNAL_ERROR = 0x10300,
2460   U_REGEX_ERROR_START = 0x10300,
2461   U_REGEX_RULE_SYNTAX,
2462   U_REGEX_INVALID_STATE,
2463   U_REGEX_BAD_ESCAPE_SEQUENCE,
2464   U_REGEX_PROPERTY_SYNTAX,
2465   U_REGEX_UNIMPLEMENTED,
2466   U_REGEX_MISMATCHED_PAREN,
2467   U_REGEX_NUMBER_TOO_BIG,
2468   U_REGEX_BAD_INTERVAL,
2469   U_REGEX_MAX_LT_MIN,
2470   U_REGEX_INVALID_BACK_REF,
2471   U_REGEX_INVALID_FLAG,
2472   U_REGEX_LOOK_BEHIND_LIMIT,
2473   U_REGEX_SET_CONTAINS_STRING,
2474   U_REGEX_OCTAL_TOO_BIG,
2475   U_REGEX_MISSING_CLOSE_BRACKET,
2476   U_REGEX_INVALID_RANGE,
2477   U_REGEX_STACK_OVERFLOW,
2478   U_REGEX_TIME_OUT,
2479   U_REGEX_STOPPED_BY_CALLER,
2480   U_REGEX_PATTERN_TOO_BIG,
2481   U_REGEX_ERROR_LIMIT,
2482   U_IDNA_PROHIBITED_ERROR = 0x10400,
2483   U_IDNA_ERROR_START = 0x10400,
2484   U_IDNA_UNASSIGNED_ERROR,
2485   U_IDNA_CHECK_BIDI_ERROR,
2486   U_IDNA_STD3_ASCII_RULES_ERROR,
2487   U_IDNA_ACE_PREFIX_ERROR,
2488   U_IDNA_VERIFICATION_ERROR,
2489   U_IDNA_LABEL_TOO_LONG_ERROR,
2490   U_IDNA_ZERO_LENGTH_LABEL_ERROR,
2491   U_IDNA_DOMAIN_NAME_TOO_LONG_ERROR,
2492   U_IDNA_ERROR_LIMIT,
2493   U_STRINGPREP_PROHIBITED_ERROR = U_IDNA_PROHIBITED_ERROR,
2494   U_STRINGPREP_UNASSIGNED_ERROR = U_IDNA_UNASSIGNED_ERROR,
2495   U_STRINGPREP_CHECK_BIDI_ERROR = U_IDNA_CHECK_BIDI_ERROR,
2496   U_PLUGIN_ERROR_START = 0x10500,
2497   U_PLUGIN_TOO_HIGH = 0x10500,
2498   U_PLUGIN_DIDNT_SET_LEVEL,
2499   U_PLUGIN_ERROR_LIMIT,
2500   U_ERROR_LIMIT = U_PLUGIN_ERROR_LIMIT
2501 } UErrorCode;
2502
2503 extern __attribute__ ((visibility ("default")))
2504 const char * u_errorName_52 (UErrorCode code);
2505
2506 struct UConverter;
2507
2508 typedef struct UConverter UConverter;
2509 typedef enum {
2510   UCNV_UNASSIGNED = 0,
2511   UCNV_ILLEGAL = 1,
2512   UCNV_IRREGULAR = 2,
2513   UCNV_RESET = 3,
2514   UCNV_CLOSE = 4,
2515   UCNV_CLONE = 5
2516 } UConverterCallbackReason;
2517
2518 typedef struct
2519 {
2520   uint16_t size;
2521   UBool flush;
2522   UConverter *converter;
2523   const UChar *source;
2524   const UChar *sourceLimit;
2525   char *target;
2526   const char *targetLimit;
2527   int32_t * offsets;
2528 } UConverterFromUnicodeArgs;
2529
2530 typedef struct
2531 {
2532   uint16_t size;
2533   UBool flush;
2534   UConverter *converter;
2535   const char *source;
2536   const char *sourceLimit;
2537   UChar *target;
2538   const UChar *targetLimit;
2539   int32_t *offsets;
2540 } UConverterToUnicodeArgs;
2541
2542 extern __attribute__ ((visibility ("default")))
2543 void UCNV_FROM_U_CALLBACK_STOP_52 (const void *context,
2544                                    UConverterFromUnicodeArgs * fromUArgs,
2545                                    const UChar * codeUnits,
2546                                    int32_t length,
2547                                    UChar32 codePoint,
2548                                    UConverterCallbackReason reason,
2549                                    UErrorCode * err);
2550
2551 extern __attribute__ ((visibility ("default")))
2552 void UCNV_TO_U_CALLBACK_STOP_52 (const void *context,
2553                                  UConverterToUnicodeArgs * toUArgs,
2554                                  const char *codeUnits,
2555                                  int32_t length,
2556                                  UConverterCallbackReason reason,
2557                                  UErrorCode * err);
2558
2559 extern __attribute__ ((visibility ("default")))
2560 void UCNV_FROM_U_CALLBACK_SKIP_52 (const void *context,
2561                                    UConverterFromUnicodeArgs * fromUArgs,
2562                                    const UChar * codeUnits,
2563                                    int32_t length,
2564                                    UChar32 codePoint,
2565                                    UConverterCallbackReason reason,
2566                                    UErrorCode * err);
2567
2568 extern __attribute__ ((visibility ("default")))
2569 void UCNV_FROM_U_CALLBACK_SUBSTITUTE_52 (const void *context,
2570                                          UConverterFromUnicodeArgs *
2571                                          fromUArgs, const UChar * codeUnits,
2572                                          int32_t length, UChar32 codePoint,
2573                                          UConverterCallbackReason reason,
2574                                          UErrorCode * err);
2575
2576 extern __attribute__ ((visibility ("default")))
2577 void UCNV_FROM_U_CALLBACK_ESCAPE_52 (const void *context,
2578                                      UConverterFromUnicodeArgs * fromUArgs,
2579                                      const UChar * codeUnits,
2580                                      int32_t length,
2581                                      UChar32 codePoint,
2582                                      UConverterCallbackReason reason,
2583                                      UErrorCode * err);
2584
2585 extern __attribute__ ((visibility ("default")))
2586 void UCNV_TO_U_CALLBACK_SKIP_52 (const void *context,
2587                                  UConverterToUnicodeArgs * toUArgs,
2588                                  const char *codeUnits,
2589                                  int32_t length,
2590                                  UConverterCallbackReason reason,
2591                                  UErrorCode * err);
2592
2593 extern __attribute__ ((visibility ("default")))
2594 void UCNV_TO_U_CALLBACK_SUBSTITUTE_52 (const void *context,
2595                                        UConverterToUnicodeArgs * toUArgs,
2596                                        const char *codeUnits,
2597                                        int32_t length,
2598                                        UConverterCallbackReason reason,
2599                                        UErrorCode * err);
2600
2601 extern __attribute__ ((visibility ("default")))
2602 void UCNV_TO_U_CALLBACK_ESCAPE_52 (const void *context,
2603                                    UConverterToUnicodeArgs * toUArgs,
2604                                    const char *codeUnits,
2605                                    int32_t length,
2606                                    UConverterCallbackReason reason,
2607                                    UErrorCode * err);
2608 struct UEnumeration;
2609
2610 typedef struct UEnumeration UEnumeration;
2611
2612 extern __attribute__ ((visibility ("default")))
2613 void uenum_close_52 (UEnumeration * en);
2614
2615 extern __attribute__ ((visibility ("default")))
2616 int32_t uenum_count_52 (UEnumeration * en, UErrorCode * status);
2617
2618 extern __attribute__ ((visibility ("default")))
2619 const UChar *uenum_unext_52 (UEnumeration * en,
2620                              int32_t * resultLength, UErrorCode * status);
2621
2622 extern __attribute__ ((visibility ("default")))
2623 const char *uenum_next_52 (UEnumeration * en,
2624                            int32_t * resultLength, UErrorCode * status);
2625
2626 extern __attribute__ ((visibility ("default")))
2627 void uenum_reset_52 (UEnumeration * en, UErrorCode * status);
2628
2629 extern __attribute__ ((visibility ("default")))
2630 UEnumeration *uenum_openUCharStringsEnumeration_52 (const UChar * const strings[],
2631                                                     int32_t count, UErrorCode * ec);
2632
2633 extern __attribute__ ((visibility ("default")))
2634 UEnumeration *uenum_openCharStringsEnumeration_52 (const char *const strings[],
2635                                                    int32_t count, UErrorCode * ec);
2636
2637 struct USet;
2638 typedef struct USet USet;
2639
2640 typedef enum {
2641   UCNV_UNSUPPORTED_CONVERTER = -1,
2642   UCNV_SBCS = 0,
2643   UCNV_DBCS = 1,
2644   UCNV_MBCS = 2,
2645   UCNV_LATIN_1 = 3,
2646   UCNV_UTF8 = 4,
2647   UCNV_UTF16_BigEndian = 5,
2648   UCNV_UTF16_LittleEndian = 6,
2649   UCNV_UTF32_BigEndian = 7,
2650   UCNV_UTF32_LittleEndian = 8,
2651   UCNV_EBCDIC_STATEFUL = 9,
2652   UCNV_ISO_2022 = 10,
2653   UCNV_LMBCS_1 = 11,
2654   UCNV_LMBCS_2,
2655   UCNV_LMBCS_3,
2656   UCNV_LMBCS_4,
2657   UCNV_LMBCS_5,
2658   UCNV_LMBCS_6,
2659   UCNV_LMBCS_8,
2660   UCNV_LMBCS_11,
2661   UCNV_LMBCS_16,
2662   UCNV_LMBCS_17,
2663   UCNV_LMBCS_18,
2664   UCNV_LMBCS_19,
2665   UCNV_LMBCS_LAST = UCNV_LMBCS_19,
2666   UCNV_HZ,
2667   UCNV_SCSU,
2668   UCNV_ISCII,
2669   UCNV_US_ASCII,
2670   UCNV_UTF7,
2671   UCNV_BOCU1,
2672   UCNV_UTF16,
2673   UCNV_UTF32,
2674   UCNV_CESU8,
2675   UCNV_IMAP_MAILBOX,
2676   UCNV_COMPOUND_TEXT,
2677   UCNV_NUMBER_OF_SUPPORTED_CONVERTER_TYPES
2678 } UConverterType;
2679
2680 typedef enum {
2681   UCNV_UNKNOWN = -1,
2682   UCNV_IBM = 0
2683 } UConverterPlatform;
2684
2685 typedef void (*UConverterToUCallback) (const void *context,
2686                                        UConverterToUnicodeArgs * args,
2687                                        const char *codeUnits,
2688                                        int32_t length,
2689                                        UConverterCallbackReason reason,
2690                                        UErrorCode * pErrorCode);
2691
2692 typedef void (*UConverterFromUCallback) (const void *context,
2693                                          UConverterFromUnicodeArgs *
2694                                          args, const UChar * codeUnits,
2695                                          int32_t length,
2696                                          UChar32 codePoint,
2697                                          UConverterCallbackReason reason,
2698                                          UErrorCode * pErrorCode);
2699
2700 extern __attribute__ ((visibility ("default")))
2701 int ucnv_compareNames_52 (const char *name1, const char *name2);
2702
2703 extern __attribute__ ((visibility ("default")))
2704 UConverter *ucnv_open_52 (const char *converterName, UErrorCode * err);
2705
2706 extern __attribute__ ((visibility ("default")))
2707 UConverter *ucnv_openU_52 (const UChar * name, UErrorCode * err);
2708
2709 extern __attribute__ ((visibility ("default")))
2710 UConverter *ucnv_openCCSID_52 (int32_t codepage,
2711                                UConverterPlatform platform, UErrorCode * err);
2712
2713 extern __attribute__ ((visibility ("default")))
2714 UConverter *ucnv_openPackage_52 (const char *packageName, const char *converterName,
2715                                  UErrorCode * err);
2716 extern __attribute__ ((visibility ("default")))
2717 UConverter *
2718 ucnv_safeClone_52 (const UConverter * cnv,
2719                    void *stackBuffer,
2720                    int32_t * pBufferSize, UErrorCode * status);
2721 extern __attribute__ ((visibility ("default")))
2722 void
2723 ucnv_close_52 (UConverter * converter);
2724 extern __attribute__ ((visibility ("default")))
2725 void
2726 ucnv_getSubstChars_52 (const UConverter * converter,
2727                        char *subChars, int8_t * len, UErrorCode * err);
2728 extern __attribute__ ((visibility ("default")))
2729 void
2730 ucnv_setSubstChars_52 (UConverter * converter,
2731                        const char *subChars,
2732                        int8_t len, UErrorCode * err);
2733 extern __attribute__ ((visibility ("default")))
2734 void
2735 ucnv_setSubstString_52 (UConverter * cnv,
2736                         const UChar * s,
2737                         int32_t length, UErrorCode * err);
2738 extern __attribute__ ((visibility ("default")))
2739 void
2740 ucnv_getInvalidChars_52 (const UConverter * converter,
2741                          char *errBytes, int8_t * len, UErrorCode * err);
2742 extern __attribute__ ((visibility ("default")))
2743 void
2744 ucnv_getInvalidUChars_52 (const UConverter * converter,
2745                           UChar * errUChars,
2746                           int8_t * len, UErrorCode * err);
2747 extern __attribute__ ((visibility ("default")))
2748 void
2749 ucnv_reset_52 (UConverter * converter);
2750 extern __attribute__ ((visibility ("default")))
2751 void
2752 ucnv_resetToUnicode_52 (UConverter * converter);
2753 extern __attribute__ ((visibility ("default")))
2754 void
2755 ucnv_resetFromUnicode_52 (UConverter * converter);
2756 extern __attribute__ ((visibility ("default"))) int8_t
2757 ucnv_getMaxCharSize_52 (const UConverter * converter);
2758 extern __attribute__ ((visibility ("default"))) int8_t
2759 ucnv_getMinCharSize_52 (const UConverter * converter);
2760 extern __attribute__ ((visibility ("default"))) int32_t
2761 ucnv_getDisplayName_52 (const UConverter * converter,
2762                         const char *displayLocale,
2763                         UChar * displayName,
2764                         int32_t displayNameCapacity, UErrorCode * err);
2765 extern __attribute__ ((visibility ("default")))
2766 const char *
2767 ucnv_getName_52 (const UConverter * converter, UErrorCode * err);
2768 extern __attribute__ ((visibility ("default"))) int32_t
2769 ucnv_getCCSID_52 (const UConverter * converter, UErrorCode * err);
2770 extern __attribute__ ((visibility ("default"))) UConverterPlatform
2771 ucnv_getPlatform_52 (const UConverter * converter, UErrorCode * err);
2772 extern __attribute__ ((visibility ("default"))) UConverterType
2773 ucnv_getType_52 (const UConverter * converter);
2774 extern __attribute__ ((visibility ("default")))
2775 void
2776 ucnv_getStarters_52 (const UConverter * converter,
2777                      UBool starters[256], UErrorCode * err);
2778
2779 typedef enum UConverterUnicodeSet {
2780
2781   UCNV_ROUNDTRIP_SET,
2782
2783   UCNV_ROUNDTRIP_AND_FALLBACK_SET,
2784
2785   UCNV_SET_COUNT
2786 } UConverterUnicodeSet;
2787 extern __attribute__ ((visibility ("default")))
2788 void
2789 ucnv_getUnicodeSet_52 (const UConverter * cnv,
2790                        USet * setFillIn,
2791                        UConverterUnicodeSet whichSet,
2792                        UErrorCode * pErrorCode);
2793 extern __attribute__ ((visibility ("default")))
2794 void
2795 ucnv_getToUCallBack_52 (const UConverter * converter,
2796                         UConverterToUCallback * action,
2797                         const void **context);
2798 extern __attribute__ ((visibility ("default")))
2799 void
2800 ucnv_getFromUCallBack_52 (const UConverter * converter,
2801                           UConverterFromUCallback * action,
2802                           const void **context);
2803 extern __attribute__ ((visibility ("default")))
2804 void
2805 ucnv_setToUCallBack_52 (UConverter * converter,
2806                         UConverterToUCallback newAction,
2807                         const void *newContext,
2808                         UConverterToUCallback * oldAction,
2809                         const void **oldContext, UErrorCode * err);
2810 extern __attribute__ ((visibility ("default")))
2811 void
2812 ucnv_setFromUCallBack_52 (UConverter * converter,
2813                           UConverterFromUCallback newAction,
2814                           const void *newContext,
2815                           UConverterFromUCallback * oldAction,
2816                           const void **oldContext, UErrorCode * err);
2817 extern __attribute__ ((visibility ("default")))
2818 void
2819 ucnv_fromUnicode_52 (UConverter * converter,
2820                      char **target,
2821                      const char *targetLimit,
2822                      const UChar ** source,
2823                      const UChar * sourceLimit,
2824                      int32_t * offsets, UBool flush, UErrorCode * err);
2825 extern __attribute__ ((visibility ("default")))
2826 void
2827 ucnv_toUnicode_52 (UConverter * converter,
2828                    UChar ** target,
2829                    const UChar * targetLimit,
2830                    const char **source,
2831                    const char *sourceLimit,
2832                    int32_t * offsets, UBool flush, UErrorCode * err);
2833 extern __attribute__ ((visibility ("default"))) int32_t
2834 ucnv_fromUChars_52 (UConverter * cnv,
2835                     char *dest, int32_t destCapacity,
2836                     const UChar * src, int32_t srcLength,
2837                     UErrorCode * pErrorCode);
2838 extern __attribute__ ((visibility ("default"))) int32_t
2839 ucnv_toUChars_52 (UConverter * cnv,
2840                   UChar * dest, int32_t destCapacity,
2841                   const char *src, int32_t srcLength,
2842                   UErrorCode * pErrorCode);
2843 extern __attribute__ ((visibility ("default"))) UChar32
2844 ucnv_getNextUChar_52 (UConverter * converter,
2845                       const char **source,
2846                       const char *sourceLimit, UErrorCode * err);
2847 extern __attribute__ ((visibility ("default")))
2848 void
2849 ucnv_convertEx_52 (UConverter * targetCnv, UConverter * sourceCnv,
2850                    char **target, const char *targetLimit,
2851                    const char **source, const char *sourceLimit,
2852                    UChar * pivotStart, UChar ** pivotSource,
2853                    UChar ** pivotTarget, const UChar * pivotLimit,
2854                    UBool reset, UBool flush, UErrorCode * pErrorCode);
2855 extern __attribute__ ((visibility ("default"))) int32_t
2856 ucnv_convert_52 (const char *toConverterName,
2857                  const char *fromConverterName,
2858                  char *target,
2859                  int32_t targetCapacity,
2860                  const char *source,
2861                  int32_t sourceLength, UErrorCode * pErrorCode);
2862 extern __attribute__ ((visibility ("default"))) int32_t
2863 ucnv_toAlgorithmic_52 (UConverterType algorithmicType,
2864                        UConverter * cnv,
2865                        char *target, int32_t targetCapacity,
2866                        const char *source, int32_t sourceLength,
2867                        UErrorCode * pErrorCode);
2868 extern __attribute__ ((visibility ("default"))) int32_t
2869 ucnv_fromAlgorithmic_52 (UConverter * cnv,
2870                          UConverterType algorithmicType,
2871                          char *target, int32_t targetCapacity,
2872                          const char *source, int32_t sourceLength,
2873                          UErrorCode * pErrorCode);
2874 extern __attribute__ ((visibility ("default"))) int32_t
2875 ucnv_flushCache_52 (void);
2876 extern __attribute__ ((visibility ("default"))) int32_t
2877 ucnv_countAvailable_52 (void);
2878 extern __attribute__ ((visibility ("default")))
2879 const char *
2880 ucnv_getAvailableName_52 (int32_t n);
2881 extern __attribute__ ((visibility ("default")))
2882 UEnumeration *
2883 ucnv_openAllNames_52 (UErrorCode * pErrorCode);
2884 extern __attribute__ ((visibility ("default"))) uint16_t
2885 ucnv_countAliases_52 (const char *alias, UErrorCode * pErrorCode);
2886 extern __attribute__ ((visibility ("default")))
2887 const char *
2888 ucnv_getAlias_52 (const char *alias, uint16_t n,
2889                   UErrorCode * pErrorCode);
2890 extern __attribute__ ((visibility ("default")))
2891 void
2892 ucnv_getAliases_52 (const char *alias, const char **aliases,
2893                     UErrorCode * pErrorCode);
2894 extern __attribute__ ((visibility ("default")))
2895 UEnumeration *
2896 ucnv_openStandardNames_52 (const char *convName,
2897                            const char *standard,
2898                            UErrorCode * pErrorCode);
2899
2900
2901
2902
2903
2904
2905 extern __attribute__ ((visibility ("default"))) uint16_t
2906 ucnv_countStandards_52 (void);
2907 extern __attribute__ ((visibility ("default")))
2908 const char *
2909 ucnv_getStandard_52 (uint16_t n, UErrorCode * pErrorCode);
2910 extern __attribute__ ((visibility ("default")))
2911 const char *
2912 ucnv_getStandardName_52 (const char *name, const char *standard,
2913                          UErrorCode * pErrorCode);
2914 extern __attribute__ ((visibility ("default")))
2915 const char *
2916 ucnv_getCanonicalName_52 (const char *alias, const char *standard,
2917                           UErrorCode * pErrorCode);
2918 extern __attribute__ ((visibility ("default")))
2919 const char *
2920 ucnv_getDefaultName_52 (void);
2921 extern __attribute__ ((visibility ("default")))
2922 void
2923 ucnv_setDefaultName_52 (const char *name);
2924 extern __attribute__ ((visibility ("default")))
2925 void
2926 ucnv_fixFileSeparator_52 (const UConverter * cnv, UChar * source,
2927                           int32_t sourceLen);
2928 extern
2929 __attribute__ ((visibility ("default"))) UBool
2930 ucnv_isAmbiguous_52 (const UConverter * cnv);
2931 extern __attribute__ ((visibility ("default")))
2932 void
2933 ucnv_setFallback_52 (UConverter * cnv, UBool usesFallback);
2934 extern __attribute__ ((visibility ("default"))) UBool
2935 ucnv_usesFallback_52 (const UConverter * cnv);
2936 extern __attribute__ ((visibility ("default")))
2937 const char *
2938 ucnv_detectUnicodeSignature_52 (const char *source,
2939                                 int32_t sourceLength,
2940                                 int32_t * signatureLength,
2941                                 UErrorCode * pErrorCode);
2942 extern __attribute__ ((visibility ("default"))) int32_t
2943 ucnv_fromUCountPending_52 (const UConverter * cnv, UErrorCode * status);
2944 extern __attribute__ ((visibility ("default"))) int32_t
2945 ucnv_toUCountPending_52 (const UConverter * cnv, UErrorCode * status);
2946 extern __attribute__ ((visibility ("default"))) UBool
2947 ucnv_isFixedWidth_52 (UConverter * cnv, UErrorCode * status);
2948
2949 typedef enum
2950   {
2951     XML_CHAR_ENCODING_ERROR = -1,
2952     XML_CHAR_ENCODING_NONE = 0,
2953     XML_CHAR_ENCODING_UTF8 = 1,
2954     XML_CHAR_ENCODING_UTF16LE = 2,
2955     XML_CHAR_ENCODING_UTF16BE = 3,
2956     XML_CHAR_ENCODING_UCS4LE = 4,
2957     XML_CHAR_ENCODING_UCS4BE = 5,
2958     XML_CHAR_ENCODING_EBCDIC = 6,
2959     XML_CHAR_ENCODING_UCS4_2143 = 7,
2960     XML_CHAR_ENCODING_UCS4_3412 = 8,
2961     XML_CHAR_ENCODING_UCS2 = 9,
2962     XML_CHAR_ENCODING_8859_1 = 10,
2963     XML_CHAR_ENCODING_8859_2 = 11,
2964     XML_CHAR_ENCODING_8859_3 = 12,
2965     XML_CHAR_ENCODING_8859_4 = 13,
2966     XML_CHAR_ENCODING_8859_5 = 14,
2967     XML_CHAR_ENCODING_8859_6 = 15,
2968     XML_CHAR_ENCODING_8859_7 = 16,
2969     XML_CHAR_ENCODING_8859_8 = 17,
2970     XML_CHAR_ENCODING_8859_9 = 18,
2971     XML_CHAR_ENCODING_2022_JP = 19,
2972     XML_CHAR_ENCODING_SHIFT_JIS = 20,
2973     XML_CHAR_ENCODING_EUC_JP = 21,
2974     XML_CHAR_ENCODING_ASCII = 22
2975   } xmlCharEncoding;
2976 typedef int (*xmlCharEncodingInputFunc) (unsigned char *out, int *outlen,
2977                                          const unsigned char *in,
2978                                          int *inlen);
2979 typedef int (*xmlCharEncodingOutputFunc) (unsigned char *out,
2980                                           int *outlen,
2981                                           const unsigned char *in,
2982                                           int *inlen);
2983
2984
2985
2986
2987
2988
2989
2990 struct _uconv_t
2991 {
2992   UConverter *
2993   uconv;
2994   UConverter *
2995   utf8;
2996 };
2997 typedef struct _uconv_t
2998 uconv_t;
2999
3000
3001 typedef struct _xmlCharEncodingHandler
3002 xmlCharEncodingHandler;
3003 typedef xmlCharEncodingHandler *
3004 xmlCharEncodingHandlerPtr;
3005 struct _xmlCharEncodingHandler
3006 {
3007   char *
3008   name;
3009   xmlCharEncodingInputFunc
3010   input;
3011   xmlCharEncodingOutputFunc
3012   output;
3013
3014   iconv_t
3015   iconv_in;
3016   iconv_t
3017   iconv_out;
3018
3019
3020   uconv_t *
3021   uconv_in;
3022   uconv_t *
3023   uconv_out;
3024
3025 };
3026 void
3027 xmlInitCharEncodingHandlers (void);
3028 void
3029 xmlCleanupCharEncodingHandlers (void);
3030 void
3031 xmlRegisterCharEncodingHandler (xmlCharEncodingHandlerPtr handler);
3032 xmlCharEncodingHandlerPtr
3033 xmlGetCharEncodingHandler (xmlCharEncoding enc);
3034 xmlCharEncodingHandlerPtr
3035 xmlFindCharEncodingHandler (const char *name);
3036 xmlCharEncodingHandlerPtr
3037 xmlNewCharEncodingHandler (const char *name,
3038                            xmlCharEncodingInputFunc input,
3039                            xmlCharEncodingOutputFunc output);
3040
3041
3042
3043
3044 int xmlAddEncodingAlias (const char *name, const char *alias);
3045 int xmlDelEncodingAlias (const char *alias);
3046 const char *xmlGetEncodingAlias (const char *alias);
3047 void xmlCleanupEncodingAliases (void);
3048 xmlCharEncoding
3049 xmlParseCharEncoding (const char *name);
3050 const char *xmlGetCharEncodingName (xmlCharEncoding enc);
3051
3052
3053
3054
3055 xmlCharEncoding
3056 xmlDetectCharEncoding (const unsigned char *in, int len);
3057
3058 int
3059 xmlCharEncOutFunc (xmlCharEncodingHandler * handler,
3060                    xmlBufferPtr out, xmlBufferPtr in);
3061
3062 int
3063 xmlCharEncInFunc (xmlCharEncodingHandler * handler,
3064                   xmlBufferPtr out, xmlBufferPtr in);
3065 int
3066 xmlCharEncFirstLine (xmlCharEncodingHandler * handler,
3067                      xmlBufferPtr out, xmlBufferPtr in);
3068 int xmlCharEncCloseFunc (xmlCharEncodingHandler * handler);
3069
3070
3071
3072
3073
3074 int
3075 UTF8Toisolat1 (unsigned char *out,
3076                int *outlen, const unsigned char *in, int *inlen);
3077
3078 int
3079 isolat1ToUTF8 (unsigned char *out,
3080                int *outlen, const unsigned char *in, int *inlen);
3081 typedef int (*xmlInputMatchCallback) (char const *filename);
3082 typedef void *(*xmlInputOpenCallback) (char const *filename);
3083 typedef int (*xmlInputReadCallback) (void *context, char *buffer,
3084                                      int len);
3085 typedef int (*xmlInputCloseCallback) (void *context);
3086 typedef int (*xmlOutputMatchCallback) (char const *filename);
3087 typedef void *(*xmlOutputOpenCallback) (char const *filename);
3088 typedef int (*xmlOutputWriteCallback) (void *context, const char *buffer,
3089                                        int len);
3090 typedef int (*xmlOutputCloseCallback) (void *context);
3091
3092
3093
3094
3095
3096
3097
3098 typedef xmlChar *xlinkHRef;
3099 typedef xmlChar *xlinkRole;
3100 typedef xmlChar *xlinkTitle;
3101
3102 typedef enum
3103   {
3104     XLINK_TYPE_NONE = 0,
3105     XLINK_TYPE_SIMPLE,
3106     XLINK_TYPE_EXTENDED,
3107     XLINK_TYPE_EXTENDED_SET
3108   } xlinkType;
3109
3110 typedef enum
3111   {
3112     XLINK_SHOW_NONE = 0,
3113     XLINK_SHOW_NEW,
3114     XLINK_SHOW_EMBED,
3115     XLINK_SHOW_REPLACE
3116   } xlinkShow;
3117
3118 typedef enum
3119   {
3120     XLINK_ACTUATE_NONE = 0,
3121     XLINK_ACTUATE_AUTO,
3122     XLINK_ACTUATE_ONREQUEST
3123   } xlinkActuate;
3124 typedef void (*xlinkNodeDetectFunc) (void *ctx, xmlNodePtr node);
3125 typedef void
3126 (*xlinkSimpleLinkFunk) (void *ctx,
3127                         xmlNodePtr node,
3128                         const xlinkHRef href,
3129                         const xlinkRole role, const xlinkTitle title);
3130 typedef void
3131 (*xlinkExtendedLinkFunk) (void *ctx,
3132                           xmlNodePtr node,
3133                           int nbLocators,
3134                           const xlinkHRef * hrefs,
3135                           const xlinkRole * roles,
3136                           int nbArcs,
3137                           const xlinkRole * from,
3138                           const xlinkRole * to,
3139                           xlinkShow * show,
3140                           xlinkActuate * actuate,
3141                           int nbTitles,
3142                           const xlinkTitle * titles,
3143                           const xmlChar ** langs);
3144 typedef void
3145 (*xlinkExtendedLinkSetFunk) (void *ctx,
3146                              xmlNodePtr node,
3147                              int nbLocators,
3148                              const xlinkHRef * hrefs,
3149                              const xlinkRole * roles,
3150                              int nbTitles,
3151                              const xlinkTitle * titles,
3152                              const xmlChar ** langs);
3153
3154
3155
3156
3157
3158
3159
3160 typedef struct _xlinkHandler xlinkHandler;
3161 typedef xlinkHandler *xlinkHandlerPtr;
3162 struct _xlinkHandler
3163 {
3164   xlinkSimpleLinkFunk simple;
3165   xlinkExtendedLinkFunk extended;
3166   xlinkExtendedLinkSetFunk set;
3167 };
3168
3169
3170
3171
3172
3173
3174 xlinkNodeDetectFunc
3175 xlinkGetDefaultDetect (void);
3176 void xlinkSetDefaultDetect (xlinkNodeDetectFunc func);
3177
3178
3179
3180
3181 xlinkHandlerPtr
3182 xlinkGetDefaultHandler (void);
3183 void xlinkSetDefaultHandler (xlinkHandlerPtr handler);
3184
3185
3186
3187
3188 xlinkType
3189 xlinkIsLink (xmlDocPtr doc, xmlNodePtr node);
3190
3191
3192
3193
3194
3195
3196 const xmlChar *getPublicId (void *ctx);
3197 const xmlChar *getSystemId (void *ctx);
3198 void setDocumentLocator (void *ctx, xmlSAXLocatorPtr loc);
3199
3200 int getLineNumber (void *ctx);
3201 int getColumnNumber (void *ctx);
3202
3203 int isStandalone (void *ctx);
3204 int hasInternalSubset (void *ctx);
3205 int hasExternalSubset (void *ctx);
3206
3207 void
3208 internalSubset (void *ctx,
3209                 const xmlChar * name,
3210                 const xmlChar * ExternalID, const xmlChar * SystemID);
3211 void
3212 externalSubset (void *ctx,
3213                 const xmlChar * name,
3214                 const xmlChar * ExternalID, const xmlChar * SystemID);
3215 xmlEntityPtr
3216 getEntity (void *ctx, const xmlChar * name);
3217 xmlEntityPtr
3218 getParameterEntity (void *ctx, const xmlChar * name);
3219 xmlParserInputPtr
3220 resolveEntity (void *ctx, const xmlChar * publicId, const xmlChar * systemId);
3221
3222 void
3223 entityDecl (void *ctx,
3224             const xmlChar * name,
3225             int type,
3226             const xmlChar * publicId,
3227             const xmlChar * systemId, xmlChar * content);
3228 void
3229 attributeDecl (void *ctx,
3230                const xmlChar * elem,
3231                const xmlChar * fullname,
3232                int type,
3233                int def,
3234                const xmlChar * defaultValue, xmlEnumerationPtr tree);
3235 void
3236 elementDecl (void *ctx,
3237              const xmlChar * name,
3238              int type, xmlElementContentPtr content);
3239 void
3240 notationDecl (void *ctx,
3241               const xmlChar * name,
3242               const xmlChar * publicId, const xmlChar * systemId);
3243 void
3244 unparsedEntityDecl (void *ctx,
3245                     const xmlChar * name,
3246                     const xmlChar * publicId,
3247                     const xmlChar * systemId,
3248                     const xmlChar * notationName);
3249
3250 void startDocument (void *ctx);
3251 void endDocument (void *ctx);
3252 void
3253 attribute (void *ctx, const xmlChar * fullname, const xmlChar * value);
3254 void
3255 startElement (void *ctx,
3256               const xmlChar * fullname, const xmlChar ** atts);
3257 void endElement (void *ctx, const xmlChar * name);
3258 void reference (void *ctx, const xmlChar * name);
3259 void characters (void *ctx, const xmlChar * ch, int len);
3260 void ignorableWhitespace (void *ctx, const xmlChar * ch, int len);
3261 void
3262 processingInstruction (void *ctx,
3263                        const xmlChar * target, const xmlChar * data);
3264 void
3265 globalNamespace (void *ctx,
3266                  const xmlChar * href, const xmlChar * prefix);
3267 void setNamespace (void *ctx, const xmlChar * name);
3268 xmlNsPtr
3269 getNamespace (void *ctx);
3270 int checkNamespace (void *ctx, xmlChar * nameSpace);
3271 void
3272 namespaceDecl (void *ctx,
3273                const xmlChar * href, const xmlChar * prefix);
3274 void comment (void *ctx, const xmlChar * value);
3275 void cdataBlock (void *ctx, const xmlChar * value, int len);
3276
3277
3278 void initxmlDefaultSAXHandler (xmlSAXHandlerV1 * hdlr, int warning);
3279
3280 void inithtmlDefaultSAXHandler (xmlSAXHandlerV1 * hdlr);
3281
3282
3283 void initdocbDefaultSAXHandler (xmlSAXHandlerV1 * hdlr);
3284 const xmlChar *xmlSAX2GetPublicId (void *ctx);
3285 const xmlChar *xmlSAX2GetSystemId (void *ctx);
3286 void xmlSAX2SetDocumentLocator (void *ctx, xmlSAXLocatorPtr loc);
3287
3288 int xmlSAX2GetLineNumber (void *ctx);
3289 int xmlSAX2GetColumnNumber (void *ctx);
3290
3291 int xmlSAX2IsStandalone (void *ctx);
3292 int xmlSAX2HasInternalSubset (void *ctx);
3293 int xmlSAX2HasExternalSubset (void *ctx);
3294
3295 void
3296 xmlSAX2InternalSubset (void *ctx,
3297                        const xmlChar * name,
3298                        const xmlChar * ExternalID,
3299                        const xmlChar * SystemID);
3300 void
3301 xmlSAX2ExternalSubset (void *ctx,
3302                        const xmlChar * name,
3303                        const xmlChar * ExternalID,
3304                        const xmlChar * SystemID);
3305 xmlEntityPtr
3306 xmlSAX2GetEntity (void *ctx, const xmlChar * name);
3307 xmlEntityPtr
3308 xmlSAX2GetParameterEntity (void *ctx, const xmlChar * name);
3309 xmlParserInputPtr
3310 xmlSAX2ResolveEntity (void *ctx,
3311                       const xmlChar * publicId, const xmlChar * systemId);
3312
3313 void
3314 xmlSAX2EntityDecl (void *ctx,
3315                    const xmlChar * name,
3316                    int type,
3317                    const xmlChar * publicId,
3318                    const xmlChar * systemId, xmlChar * content);
3319 void
3320 xmlSAX2AttributeDecl (void *ctx,
3321                       const xmlChar * elem,
3322                       const xmlChar * fullname,
3323                       int type,
3324                       int def,
3325                       const xmlChar * defaultValue,
3326                       xmlEnumerationPtr tree);
3327 void
3328 xmlSAX2ElementDecl (void *ctx,
3329                     const xmlChar * name,
3330                     int type, xmlElementContentPtr content);
3331 void
3332 xmlSAX2NotationDecl (void *ctx,
3333                      const xmlChar * name,
3334                      const xmlChar * publicId,
3335                      const xmlChar * systemId);
3336 void
3337 xmlSAX2UnparsedEntityDecl (void *ctx,
3338                            const xmlChar * name,
3339                            const xmlChar * publicId,
3340                            const xmlChar * systemId,
3341                            const xmlChar * notationName);
3342
3343 void xmlSAX2StartDocument (void *ctx);
3344 void xmlSAX2EndDocument (void *ctx);
3345
3346
3347
3348 void
3349 xmlSAX2StartElement (void *ctx,
3350                      const xmlChar * fullname, const xmlChar ** atts);
3351 void xmlSAX2EndElement (void *ctx, const xmlChar * name);
3352
3353 void
3354 xmlSAX2StartElementNs (void *ctx,
3355                        const xmlChar * localname,
3356                        const xmlChar * prefix,
3357                        const xmlChar * URI,
3358                        int nb_namespaces,
3359                        const xmlChar ** namespaces,
3360                        int nb_attributes,
3361                        int nb_defaulted, const xmlChar ** attributes);
3362 void
3363 xmlSAX2EndElementNs (void *ctx,
3364                      const xmlChar * localname,
3365                      const xmlChar * prefix, const xmlChar * URI);
3366 void xmlSAX2Reference (void *ctx, const xmlChar * name);
3367 void xmlSAX2Characters (void *ctx, const xmlChar * ch, int len);
3368 void xmlSAX2IgnorableWhitespace (void *ctx, const xmlChar * ch, int len);
3369 void
3370 xmlSAX2ProcessingInstruction (void *ctx,
3371                               const xmlChar * target,
3372                               const xmlChar * data);
3373 void xmlSAX2Comment (void *ctx, const xmlChar * value);
3374 void xmlSAX2CDataBlock (void *ctx, const xmlChar * value, int len);
3375
3376
3377 int xmlSAXDefaultVersion (int version);
3378
3379
3380 int xmlSAXVersion (xmlSAXHandler * hdlr, int version);
3381 void xmlSAX2InitDefaultSAXHandler (xmlSAXHandler * hdlr, int warning);
3382
3383 void xmlSAX2InitHtmlDefaultSAXHandler (xmlSAXHandler * hdlr);
3384 void htmlDefaultSAXHandlerInit (void);
3385
3386
3387 void xmlSAX2InitDocbDefaultSAXHandler (xmlSAXHandler * hdlr);
3388 void docbDefaultSAXHandlerInit (void);
3389
3390 void xmlDefaultSAXHandlerInit (void);
3391 typedef void (*xmlFreeFunc) (void *mem);
3392 typedef void *( __attribute__ ((alloc_size (1))) *
3393                 xmlMallocFunc) (size_t size);
3394 typedef void *(*xmlReallocFunc) (void *mem, size_t size);
3395 typedef char *(*xmlStrdupFunc) (const char *str);
3396 int
3397 xmlMemSetup (xmlFreeFunc freeFunc,
3398              xmlMallocFunc mallocFunc,
3399              xmlReallocFunc reallocFunc, xmlStrdupFunc strdupFunc);
3400 int
3401 xmlMemGet (xmlFreeFunc * freeFunc,
3402            xmlMallocFunc * mallocFunc,
3403            xmlReallocFunc * reallocFunc, xmlStrdupFunc * strdupFunc);
3404 int
3405 xmlGcMemSetup (xmlFreeFunc freeFunc,
3406                xmlMallocFunc mallocFunc,
3407                xmlMallocFunc mallocAtomicFunc,
3408                xmlReallocFunc reallocFunc, xmlStrdupFunc strdupFunc);
3409 int
3410 xmlGcMemGet (xmlFreeFunc * freeFunc,
3411              xmlMallocFunc * mallocFunc,
3412              xmlMallocFunc * mallocAtomicFunc,
3413              xmlReallocFunc * reallocFunc, xmlStrdupFunc * strdupFunc);
3414
3415
3416
3417
3418 int xmlInitMemory (void);
3419
3420
3421
3422
3423 void xmlCleanupMemory (void);
3424
3425
3426
3427 int xmlMemUsed (void);
3428 int xmlMemBlocks (void);
3429 void xmlMemDisplay (FILE * fp);
3430 void xmlMemDisplayLast (FILE * fp, long nbBytes);
3431 void xmlMemShow (FILE * fp, int nr);
3432 void xmlMemoryDump (void);
3433 void *xmlMemMalloc (size_t size) __attribute__ ((alloc_size (1)));
3434 void *xmlMemRealloc (void *ptr, size_t size);
3435 void xmlMemFree (void *ptr);
3436 char *xmlMemoryStrdup (const char *str);
3437 void *xmlMallocLoc (size_t size, const char *file, int line)
3438   __attribute__ ((alloc_size (1)));
3439 void *xmlReallocLoc (void *ptr, size_t size, const char *file, int line);
3440 void *xmlMallocAtomicLoc (size_t size, const char *file, int line)
3441   __attribute__ ((alloc_size (1)));
3442 char *xmlMemStrdupLoc (const char *str, const char *file, int line);
3443
3444
3445
3446
3447
3448 void xmlInitGlobals (void);
3449 void xmlCleanupGlobals (void);
3450 typedef
3451 xmlParserInputBufferPtr (*xmlParserInputBufferCreateFilenameFunc)
3452 (const char *URI, xmlCharEncoding enc);
3453 typedef xmlOutputBufferPtr (*xmlOutputBufferCreateFilenameFunc) (const
3454                                                                  char
3455                                                                  *URI,
3456                                                                  xmlCharEncodingHandlerPtr
3457                                                                  encoder,
3458                                                                  int
3459                                                                  compression);
3460
3461 xmlParserInputBufferCreateFilenameFunc
3462 xmlParserInputBufferCreateFilenameDefault
3463 (xmlParserInputBufferCreateFilenameFunc func);
3464 xmlOutputBufferCreateFilenameFunc
3465 xmlOutputBufferCreateFilenameDefault (xmlOutputBufferCreateFilenameFunc func);
3466 typedef void (*xmlRegisterNodeFunc) (xmlNodePtr node);
3467
3468
3469
3470
3471
3472
3473 typedef void (*xmlDeregisterNodeFunc) (xmlNodePtr node);
3474
3475 typedef struct _xmlGlobalState xmlGlobalState;
3476 typedef xmlGlobalState *xmlGlobalStatePtr;
3477 struct _xmlGlobalState
3478 {
3479   const char *xmlParserVersion;
3480
3481   xmlSAXLocator xmlDefaultSAXLocator;
3482   xmlSAXHandlerV1 xmlDefaultSAXHandler;
3483   xmlSAXHandlerV1 docbDefaultSAXHandler;
3484   xmlSAXHandlerV1 htmlDefaultSAXHandler;
3485
3486   xmlFreeFunc xmlFree;
3487   xmlMallocFunc xmlMalloc;
3488   xmlStrdupFunc xmlMemStrdup;
3489   xmlReallocFunc xmlRealloc;
3490
3491   xmlGenericErrorFunc xmlGenericError;
3492   xmlStructuredErrorFunc xmlStructuredError;
3493   void *xmlGenericErrorContext;
3494
3495   int oldXMLWDcompatibility;
3496
3497   xmlBufferAllocationScheme xmlBufferAllocScheme;
3498   int xmlDefaultBufferSize;
3499
3500   int xmlSubstituteEntitiesDefaultValue;
3501   int xmlDoValidityCheckingDefaultValue;
3502   int xmlGetWarningsDefaultValue;
3503   int xmlKeepBlanksDefaultValue;
3504   int xmlLineNumbersDefaultValue;
3505   int xmlLoadExtDtdDefaultValue;
3506   int xmlParserDebugEntities;
3507   int xmlPedanticParserDefaultValue;
3508
3509   int xmlSaveNoEmptyTags;
3510   int xmlIndentTreeOutput;
3511   const char *xmlTreeIndentString;
3512
3513   xmlRegisterNodeFunc xmlRegisterNodeDefaultValue;
3514   xmlDeregisterNodeFunc xmlDeregisterNodeDefaultValue;
3515
3516   xmlMallocFunc xmlMallocAtomic;
3517   xmlError xmlLastError;
3518
3519   xmlParserInputBufferCreateFilenameFunc
3520   xmlParserInputBufferCreateFilenameValue;
3521   xmlOutputBufferCreateFilenameFunc xmlOutputBufferCreateFilenameValue;
3522
3523   void *xmlStructuredErrorContext;
3524 };
3525
3526
3527
3528
3529 typedef struct _xmlMutex xmlMutex;
3530 typedef xmlMutex *xmlMutexPtr;
3531
3532
3533
3534
3535 typedef struct _xmlRMutex xmlRMutex;
3536 typedef xmlRMutex *xmlRMutexPtr;
3537
3538
3539
3540
3541
3542
3543
3544 xmlMutexPtr
3545 xmlNewMutex (void);
3546 void xmlMutexLock (xmlMutexPtr tok);
3547 void xmlMutexUnlock (xmlMutexPtr tok);
3548 void xmlFreeMutex (xmlMutexPtr tok);
3549
3550 xmlRMutexPtr
3551 xmlNewRMutex (void);
3552 void xmlRMutexLock (xmlRMutexPtr tok);
3553 void xmlRMutexUnlock (xmlRMutexPtr tok);
3554 void xmlFreeRMutex (xmlRMutexPtr tok);
3555
3556
3557
3558
3559 void xmlInitThreads (void);
3560 void xmlLockLibrary (void);
3561 void xmlUnlockLibrary (void);
3562 int xmlGetThreadId (void);
3563 int xmlIsMainThread (void);
3564 void xmlCleanupThreads (void);
3565 xmlGlobalStatePtr
3566 xmlGetGlobalState (void);
3567
3568
3569
3570
3571 void xmlInitializeGlobalState (xmlGlobalStatePtr gs);
3572
3573 void xmlThrDefSetGenericErrorFunc (void *ctx,
3574                                    xmlGenericErrorFunc handler);
3575
3576 void xmlThrDefSetStructuredErrorFunc (void *ctx,
3577                                       xmlStructuredErrorFunc handler);
3578
3579 xmlRegisterNodeFunc xmlRegisterNodeDefault (xmlRegisterNodeFunc func);
3580 xmlRegisterNodeFunc xmlThrDefRegisterNodeDefault (xmlRegisterNodeFunc
3581                                                   func);
3582 xmlDeregisterNodeFunc xmlDeregisterNodeDefault (xmlDeregisterNodeFunc
3583                                                 func);
3584 xmlDeregisterNodeFunc
3585 xmlThrDefDeregisterNodeDefault (xmlDeregisterNodeFunc func);
3586
3587 xmlOutputBufferCreateFilenameFunc
3588 xmlThrDefOutputBufferCreateFilenameDefault (xmlOutputBufferCreateFilenameFunc
3589                                             func);
3590 xmlParserInputBufferCreateFilenameFunc
3591 xmlThrDefParserInputBufferCreateFilenameDefault
3592 (xmlParserInputBufferCreateFilenameFunc func);
3593 extern xmlMallocFunc xmlMalloc;
3594 extern xmlMallocFunc xmlMallocAtomic;
3595 extern xmlReallocFunc xmlRealloc;
3596 extern xmlFreeFunc xmlFree;
3597 extern xmlStrdupFunc xmlMemStrdup;
3598
3599
3600
3601 xmlSAXHandlerV1 *__docbDefaultSAXHandler (void);
3602 xmlSAXHandlerV1 *__htmlDefaultSAXHandler (void);
3603 xmlError *__xmlLastError (void);
3604 int *__oldXMLWDcompatibility (void);
3605
3606
3607
3608
3609
3610
3611
3612 xmlBufferAllocationScheme *__xmlBufferAllocScheme (void);
3613
3614
3615
3616
3617
3618
3619 xmlBufferAllocationScheme
3620 xmlThrDefBufferAllocScheme (xmlBufferAllocationScheme v);
3621
3622 int *__xmlDefaultBufferSize (void);
3623
3624
3625
3626
3627
3628
3629 int xmlThrDefDefaultBufferSize (int v);
3630
3631 xmlSAXHandlerV1 *__xmlDefaultSAXHandler (void);
3632
3633
3634
3635
3636
3637
3638
3639 xmlSAXLocator *__xmlDefaultSAXLocator (void);
3640
3641
3642
3643
3644
3645
3646
3647 int *__xmlDoValidityCheckingDefaultValue (void);
3648
3649
3650
3651
3652
3653
3654 int xmlThrDefDoValidityCheckingDefaultValue (int v);
3655
3656 xmlGenericErrorFunc *__xmlGenericError (void);
3657
3658
3659
3660
3661
3662
3663
3664 xmlStructuredErrorFunc *__xmlStructuredError (void);
3665
3666
3667
3668
3669
3670
3671
3672 void **__xmlGenericErrorContext (void);
3673
3674
3675
3676
3677
3678
3679
3680 void **__xmlStructuredErrorContext (void);
3681
3682
3683
3684
3685
3686
3687
3688 int *__xmlGetWarningsDefaultValue (void);
3689
3690
3691
3692
3693
3694
3695 int xmlThrDefGetWarningsDefaultValue (int v);
3696
3697 int *__xmlIndentTreeOutput (void);
3698
3699
3700
3701
3702
3703
3704 int xmlThrDefIndentTreeOutput (int v);
3705
3706 const char **__xmlTreeIndentString (void);
3707
3708
3709
3710
3711
3712
3713 const char *xmlThrDefTreeIndentString (const char *v);
3714
3715 int *__xmlKeepBlanksDefaultValue (void);
3716
3717
3718
3719
3720
3721
3722 int xmlThrDefKeepBlanksDefaultValue (int v);
3723
3724 int *__xmlLineNumbersDefaultValue (void);
3725
3726
3727
3728
3729
3730
3731 int xmlThrDefLineNumbersDefaultValue (int v);
3732
3733 int *__xmlLoadExtDtdDefaultValue (void);
3734
3735
3736
3737
3738
3739
3740 int xmlThrDefLoadExtDtdDefaultValue (int v);
3741
3742 int *__xmlParserDebugEntities (void);
3743
3744
3745
3746
3747
3748
3749 int xmlThrDefParserDebugEntities (int v);
3750
3751 const char **__xmlParserVersion (void);
3752
3753
3754
3755
3756
3757
3758
3759 int *__xmlPedanticParserDefaultValue (void);
3760
3761
3762
3763
3764
3765
3766 int xmlThrDefPedanticParserDefaultValue (int v);
3767
3768 int *__xmlSaveNoEmptyTags (void);
3769
3770
3771
3772
3773
3774
3775 int xmlThrDefSaveNoEmptyTags (int v);
3776
3777 int *__xmlSubstituteEntitiesDefaultValue (void);
3778
3779
3780
3781
3782
3783
3784 int xmlThrDefSubstituteEntitiesDefaultValue (int v);
3785
3786 xmlRegisterNodeFunc *__xmlRegisterNodeDefaultValue (void);
3787
3788
3789
3790
3791
3792
3793
3794 xmlDeregisterNodeFunc *__xmlDeregisterNodeDefaultValue (void);
3795
3796
3797
3798
3799
3800
3801
3802 xmlParserInputBufferCreateFilenameFunc
3803 *__xmlParserInputBufferCreateFilenameValue (void);
3804
3805
3806
3807
3808
3809
3810
3811 xmlOutputBufferCreateFilenameFunc
3812 *__xmlOutputBufferCreateFilenameValue (void);
3813
3814
3815
3816
3817
3818
3819
3820 struct _xmlParserInputBuffer
3821 {
3822   void *context;
3823   xmlInputReadCallback readcallback;
3824   xmlInputCloseCallback closecallback;
3825
3826   xmlCharEncodingHandlerPtr encoder;
3827
3828   xmlBufPtr buffer;
3829   xmlBufPtr raw;
3830   int compressed;
3831   int error;
3832   unsigned long rawconsumed;
3833 };
3834
3835
3836
3837 struct _xmlOutputBuffer
3838 {
3839   void *context;
3840   xmlOutputWriteCallback writecallback;
3841   xmlOutputCloseCallback closecallback;
3842
3843   xmlCharEncodingHandlerPtr encoder;
3844
3845   xmlBufPtr buffer;
3846   xmlBufPtr conv;
3847   int written;
3848   int error;
3849 };
3850
3851
3852
3853
3854
3855 void xmlCleanupInputCallbacks (void);
3856
3857 int xmlPopInputCallbacks (void);
3858
3859 void xmlRegisterDefaultInputCallbacks (void);
3860 xmlParserInputBufferPtr
3861 xmlAllocParserInputBuffer (xmlCharEncoding enc);
3862
3863 xmlParserInputBufferPtr
3864 xmlParserInputBufferCreateFilename (const char *URI, xmlCharEncoding enc);
3865 xmlParserInputBufferPtr
3866 xmlParserInputBufferCreateFile (FILE * file, xmlCharEncoding enc);
3867 xmlParserInputBufferPtr
3868 xmlParserInputBufferCreateFd (int fd, xmlCharEncoding enc);
3869 xmlParserInputBufferPtr
3870 xmlParserInputBufferCreateMem (const char *mem, int size,
3871                                xmlCharEncoding enc);
3872 xmlParserInputBufferPtr
3873 xmlParserInputBufferCreateStatic (const char *mem, int size,
3874                                   xmlCharEncoding enc);
3875 xmlParserInputBufferPtr
3876 xmlParserInputBufferCreateIO (xmlInputReadCallback ioread,
3877                               xmlInputCloseCallback ioclose,
3878                               void *ioctx, xmlCharEncoding enc);
3879 int xmlParserInputBufferRead (xmlParserInputBufferPtr in, int len);
3880 int xmlParserInputBufferGrow (xmlParserInputBufferPtr in, int len);
3881 int
3882 xmlParserInputBufferPush (xmlParserInputBufferPtr in,
3883                           int len, const char *buf);
3884 void xmlFreeParserInputBuffer (xmlParserInputBufferPtr in);
3885 char *xmlParserGetDirectory (const char *filename);
3886
3887 int
3888 xmlRegisterInputCallbacks (xmlInputMatchCallback matchFunc,
3889                            xmlInputOpenCallback openFunc,
3890                            xmlInputReadCallback readFunc,
3891                            xmlInputCloseCallback closeFunc);
3892
3893 xmlParserInputBufferPtr
3894 __xmlParserInputBufferCreateFilename (const char *URI, xmlCharEncoding enc);
3895
3896
3897
3898
3899
3900 void xmlCleanupOutputCallbacks (void);
3901 void xmlRegisterDefaultOutputCallbacks (void);
3902 xmlOutputBufferPtr
3903 xmlAllocOutputBuffer (xmlCharEncodingHandlerPtr encoder);
3904
3905 xmlOutputBufferPtr
3906 xmlOutputBufferCreateFilename (const char *URI,
3907                                xmlCharEncodingHandlerPtr encoder,
3908                                int compression);
3909
3910 xmlOutputBufferPtr
3911 xmlOutputBufferCreateFile (FILE * file, xmlCharEncodingHandlerPtr encoder);
3912
3913 xmlOutputBufferPtr
3914 xmlOutputBufferCreateBuffer (xmlBufferPtr buffer,
3915                              xmlCharEncodingHandlerPtr encoder);
3916
3917 xmlOutputBufferPtr
3918 xmlOutputBufferCreateFd (int fd, xmlCharEncodingHandlerPtr encoder);
3919
3920 xmlOutputBufferPtr
3921 xmlOutputBufferCreateIO (xmlOutputWriteCallback iowrite,
3922                          xmlOutputCloseCallback ioclose,
3923                          void *ioctx, xmlCharEncodingHandlerPtr encoder);
3924
3925
3926 const xmlChar *xmlOutputBufferGetContent (xmlOutputBufferPtr out);
3927 size_t
3928 xmlOutputBufferGetSize (xmlOutputBufferPtr out);
3929
3930 int
3931 xmlOutputBufferWrite (xmlOutputBufferPtr out,
3932                       int len, const char *buf);
3933 int xmlOutputBufferWriteString (xmlOutputBufferPtr out, const char *str);
3934 int
3935 xmlOutputBufferWriteEscape (xmlOutputBufferPtr out,
3936                             const xmlChar * str,
3937                             xmlCharEncodingOutputFunc escaping);
3938
3939 int xmlOutputBufferFlush (xmlOutputBufferPtr out);
3940 int xmlOutputBufferClose (xmlOutputBufferPtr out);
3941
3942 int
3943 xmlRegisterOutputCallbacks (xmlOutputMatchCallback matchFunc,
3944                             xmlOutputOpenCallback openFunc,
3945                             xmlOutputWriteCallback writeFunc,
3946                             xmlOutputCloseCallback closeFunc);
3947
3948 xmlOutputBufferPtr
3949 __xmlOutputBufferCreateFilename (const char *URI,
3950                                  xmlCharEncodingHandlerPtr encoder,
3951                                  int compression);
3952
3953
3954
3955 void xmlRegisterHTTPPostCallbacks (void);
3956
3957
3958
3959
3960 xmlParserInputPtr
3961 xmlCheckHTTPInput (xmlParserCtxtPtr ctxt, xmlParserInputPtr ret);
3962
3963
3964
3965
3966 xmlParserInputPtr
3967 xmlNoNetExternalEntityLoader (const char *URL,
3968                               const char *ID, xmlParserCtxtPtr ctxt);
3969
3970
3971
3972
3973
3974 xmlChar *xmlNormalizeWindowsPath (const xmlChar * path);
3975
3976 int xmlCheckFilename (const char *path);
3977
3978
3979
3980 int xmlFileMatch (const char *filename);
3981 void *xmlFileOpen (const char *filename);
3982 int xmlFileRead (void *context, char *buffer, int len);
3983 int xmlFileClose (void *context);
3984
3985
3986
3987
3988
3989 int xmlIOHTTPMatch (const char *filename);
3990 void *xmlIOHTTPOpen (const char *filename);
3991
3992 void *xmlIOHTTPOpenW (const char *post_uri, int compression);
3993
3994 int xmlIOHTTPRead (void *context, char *buffer, int len);
3995 int xmlIOHTTPClose (void *context);
3996
3997
3998
3999
4000
4001
4002 int xmlIOFTPMatch (const char *filename);
4003 void *xmlIOFTPOpen (const char *filename);
4004 int xmlIOFTPRead (void *context, char *buffer, int len);
4005 int xmlIOFTPClose (void *context);
4006 void xmlInitParser (void);
4007 void xmlCleanupParser (void);
4008
4009
4010
4011
4012 int xmlParserInputRead (xmlParserInputPtr in, int len);
4013 int xmlParserInputGrow (xmlParserInputPtr in, int len);
4014
4015
4016
4017
4018
4019 xmlDocPtr
4020 xmlParseDoc (const xmlChar * cur);
4021 xmlDocPtr
4022 xmlParseFile (const char *filename);
4023 xmlDocPtr
4024 xmlParseMemory (const char *buffer, int size);
4025
4026 int xmlSubstituteEntitiesDefault (int val);
4027 int xmlKeepBlanksDefault (int val);
4028 void xmlStopParser (xmlParserCtxtPtr ctxt);
4029 int xmlPedanticParserDefault (int val);
4030 int xmlLineNumbersDefault (int val);
4031
4032
4033
4034
4035
4036 xmlDocPtr
4037 xmlRecoverDoc (const xmlChar * cur);
4038 xmlDocPtr
4039 xmlRecoverMemory (const char *buffer, int size);
4040 xmlDocPtr
4041 xmlRecoverFile (const char *filename);
4042
4043
4044
4045
4046
4047 int xmlParseDocument (xmlParserCtxtPtr ctxt);
4048 int xmlParseExtParsedEnt (xmlParserCtxtPtr ctxt);
4049
4050 int
4051 xmlSAXUserParseFile (xmlSAXHandlerPtr sax,
4052                      void *user_data, const char *filename);
4053 int
4054 xmlSAXUserParseMemory (xmlSAXHandlerPtr sax,
4055                        void *user_data, const char *buffer, int size);
4056 xmlDocPtr
4057 xmlSAXParseDoc (xmlSAXHandlerPtr sax, const xmlChar * cur, int recovery);
4058 xmlDocPtr
4059 xmlSAXParseMemory (xmlSAXHandlerPtr sax,
4060                    const char *buffer, int size, int recovery);
4061 xmlDocPtr
4062 xmlSAXParseMemoryWithData (xmlSAXHandlerPtr sax,
4063                            const char *buffer,
4064                            int size, int recovery, void *data);
4065 xmlDocPtr
4066 xmlSAXParseFile (xmlSAXHandlerPtr sax, const char *filename, int recovery);
4067 xmlDocPtr
4068 xmlSAXParseFileWithData (xmlSAXHandlerPtr sax,
4069                          const char *filename, int recovery, void *data);
4070 xmlDocPtr
4071 xmlSAXParseEntity (xmlSAXHandlerPtr sax, const char *filename);
4072 xmlDocPtr
4073 xmlParseEntity (const char *filename);
4074
4075
4076
4077 xmlDtdPtr
4078 xmlSAXParseDTD (xmlSAXHandlerPtr sax,
4079                 const xmlChar * ExternalID, const xmlChar * SystemID);
4080 xmlDtdPtr
4081 xmlParseDTD (const xmlChar * ExternalID, const xmlChar * SystemID);
4082 xmlDtdPtr
4083 xmlIOParseDTD (xmlSAXHandlerPtr sax,
4084                xmlParserInputBufferPtr input, xmlCharEncoding enc);
4085
4086
4087 int
4088 xmlParseBalancedChunkMemory (xmlDocPtr doc,
4089                              xmlSAXHandlerPtr sax,
4090                              void *user_data,
4091                              int depth,
4092                              const xmlChar * string, xmlNodePtr * lst);
4093
4094 xmlParserErrors
4095 xmlParseInNodeContext (xmlNodePtr node,
4096                        const char *data,
4097                        int datalen, int options, xmlNodePtr * lst);
4098
4099 int
4100 xmlParseBalancedChunkMemoryRecover (xmlDocPtr doc,
4101                                     xmlSAXHandlerPtr sax,
4102                                     void *user_data,
4103                                     int depth,
4104                                     const xmlChar * string,
4105                                     xmlNodePtr * lst, int recover);
4106 int
4107 xmlParseExternalEntity (xmlDocPtr doc,
4108                         xmlSAXHandlerPtr sax,
4109                         void *user_data,
4110                         int depth,
4111                         const xmlChar * URL,
4112                         const xmlChar * ID, xmlNodePtr * lst);
4113
4114 int
4115 xmlParseCtxtExternalEntity (xmlParserCtxtPtr ctx,
4116                             const xmlChar * URL,
4117                             const xmlChar * ID, xmlNodePtr * lst);
4118
4119
4120
4121
4122 xmlParserCtxtPtr
4123 xmlNewParserCtxt (void);
4124 int xmlInitParserCtxt (xmlParserCtxtPtr ctxt);
4125 void xmlClearParserCtxt (xmlParserCtxtPtr ctxt);
4126 void xmlFreeParserCtxt (xmlParserCtxtPtr ctxt);
4127
4128 void
4129 xmlSetupParserForBuffer (xmlParserCtxtPtr ctxt,
4130                          const xmlChar * buffer, const char *filename);
4131
4132 xmlParserCtxtPtr
4133 xmlCreateDocParserCtxt (const xmlChar * cur);
4134
4135
4136
4137
4138
4139 int xmlGetFeaturesList (int *len, const char **result);
4140 int
4141 xmlGetFeature (xmlParserCtxtPtr ctxt, const char *name, void *result);
4142 int xmlSetFeature (xmlParserCtxtPtr ctxt, const char *name, void *value);
4143
4144
4145
4146
4147
4148
4149 xmlParserCtxtPtr
4150 xmlCreatePushParserCtxt (xmlSAXHandlerPtr sax,
4151                          void *user_data,
4152                          const char *chunk, int size, const char *filename);
4153 int
4154 xmlParseChunk (xmlParserCtxtPtr ctxt,
4155                const char *chunk, int size, int terminate);
4156
4157
4158
4159
4160
4161
4162 xmlParserCtxtPtr
4163 xmlCreateIOParserCtxt (xmlSAXHandlerPtr sax,
4164                        void *user_data,
4165                        xmlInputReadCallback ioread,
4166                        xmlInputCloseCallback ioclose,
4167                        void *ioctx, xmlCharEncoding enc);
4168
4169 xmlParserInputPtr
4170 xmlNewIOInputStream (xmlParserCtxtPtr ctxt,
4171                      xmlParserInputBufferPtr input, xmlCharEncoding enc);
4172
4173
4174
4175
4176 const xmlParserNodeInfo *xmlParserFindNodeInfo (const xmlParserCtxtPtr
4177                                                 ctxt,
4178                                                 const xmlNodePtr node);
4179 void xmlInitNodeInfoSeq (xmlParserNodeInfoSeqPtr seq);
4180 void xmlClearNodeInfoSeq (xmlParserNodeInfoSeqPtr seq);
4181 unsigned long
4182 xmlParserFindNodeInfoIndex (const xmlParserNodeInfoSeqPtr seq,
4183                             const xmlNodePtr node);
4184 void
4185 xmlParserAddNodeInfo (xmlParserCtxtPtr ctxt,
4186                       const xmlParserNodeInfoPtr info);
4187
4188
4189
4190
4191
4192 void xmlSetExternalEntityLoader (xmlExternalEntityLoader f);
4193 xmlExternalEntityLoader
4194 xmlGetExternalEntityLoader (void);
4195 xmlParserInputPtr
4196 xmlLoadExternalEntity (const char *URL,
4197                        const char *ID, xmlParserCtxtPtr ctxt);
4198
4199
4200
4201
4202 long xmlByteConsumed (xmlParserCtxtPtr ctxt);
4203 typedef enum
4204   {
4205     XML_PARSE_RECOVER = 1 << 0,
4206     XML_PARSE_NOENT = 1 << 1,
4207     XML_PARSE_DTDLOAD = 1 << 2,
4208     XML_PARSE_DTDATTR = 1 << 3,
4209     XML_PARSE_DTDVALID = 1 << 4,
4210     XML_PARSE_NOERROR = 1 << 5,
4211     XML_PARSE_NOWARNING = 1 << 6,
4212     XML_PARSE_PEDANTIC = 1 << 7,
4213     XML_PARSE_NOBLANKS = 1 << 8,
4214     XML_PARSE_SAX1 = 1 << 9,
4215     XML_PARSE_XINCLUDE = 1 << 10,
4216     XML_PARSE_NONET = 1 << 11,
4217     XML_PARSE_NODICT = 1 << 12,
4218     XML_PARSE_NSCLEAN = 1 << 13,
4219     XML_PARSE_NOCDATA = 1 << 14,
4220     XML_PARSE_NOXINCNODE = 1 << 15,
4221     XML_PARSE_COMPACT = 1 << 16,
4222
4223
4224     XML_PARSE_OLD10 = 1 << 17,
4225     XML_PARSE_NOBASEFIX = 1 << 18,
4226     XML_PARSE_HUGE = 1 << 19,
4227     XML_PARSE_OLDSAX = 1 << 20,
4228     XML_PARSE_IGNORE_ENC = 1 << 21,
4229     XML_PARSE_BIG_LINES = 1 << 22
4230   } xmlParserOption;
4231
4232 void xmlCtxtReset (xmlParserCtxtPtr ctxt);
4233 int
4234 xmlCtxtResetPush (xmlParserCtxtPtr ctxt,
4235                   const char *chunk,
4236                   int size,
4237                   const char *filename, const char *encoding);
4238 int xmlCtxtUseOptions (xmlParserCtxtPtr ctxt, int options);
4239 xmlDocPtr
4240 xmlReadDoc (const xmlChar * cur,
4241             const char *URL, const char *encoding, int options);
4242 xmlDocPtr
4243 xmlReadFile (const char *URL, const char *encoding, int options);
4244 xmlDocPtr
4245 xmlReadMemory (const char *buffer,
4246                int size, const char *URL, const char *encoding, int options);
4247 xmlDocPtr
4248 xmlReadFd (int fd, const char *URL, const char *encoding, int options);
4249 xmlDocPtr
4250 xmlReadIO (xmlInputReadCallback ioread,
4251            xmlInputCloseCallback ioclose,
4252            void *ioctx, const char *URL, const char *encoding, int options);
4253 xmlDocPtr
4254 xmlCtxtReadDoc (xmlParserCtxtPtr ctxt,
4255                 const xmlChar * cur,
4256                 const char *URL, const char *encoding, int options);
4257 xmlDocPtr
4258 xmlCtxtReadFile (xmlParserCtxtPtr ctxt,
4259                  const char *filename, const char *encoding, int options);
4260 xmlDocPtr
4261 xmlCtxtReadMemory (xmlParserCtxtPtr ctxt,
4262                    const char *buffer,
4263                    int size,
4264                    const char *URL, const char *encoding, int options);
4265 xmlDocPtr
4266 xmlCtxtReadFd (xmlParserCtxtPtr ctxt,
4267                int fd, const char *URL, const char *encoding, int options);
4268 xmlDocPtr
4269 xmlCtxtReadIO (xmlParserCtxtPtr ctxt,
4270                xmlInputReadCallback ioread,
4271                xmlInputCloseCallback ioclose,
4272                void *ioctx,
4273                const char *URL, const char *encoding, int options);
4274 typedef enum
4275   {
4276     XML_WITH_THREAD = 1,
4277     XML_WITH_TREE = 2,
4278     XML_WITH_OUTPUT = 3,
4279     XML_WITH_PUSH = 4,
4280     XML_WITH_READER = 5,
4281     XML_WITH_PATTERN = 6,
4282     XML_WITH_WRITER = 7,
4283     XML_WITH_SAX1 = 8,
4284     XML_WITH_FTP = 9,
4285     XML_WITH_HTTP = 10,
4286     XML_WITH_VALID = 11,
4287     XML_WITH_HTML = 12,
4288     XML_WITH_LEGACY = 13,
4289     XML_WITH_C14N = 14,
4290     XML_WITH_CATALOG = 15,
4291     XML_WITH_XPATH = 16,
4292     XML_WITH_XPTR = 17,
4293     XML_WITH_XINCLUDE = 18,
4294     XML_WITH_ICONV = 19,
4295     XML_WITH_ISO8859X = 20,
4296     XML_WITH_UNICODE = 21,
4297     XML_WITH_REGEXP = 22,
4298     XML_WITH_AUTOMATA = 23,
4299     XML_WITH_EXPR = 24,
4300     XML_WITH_SCHEMAS = 25,
4301     XML_WITH_SCHEMATRON = 26,
4302     XML_WITH_MODULES = 27,
4303     XML_WITH_DEBUG = 28,
4304     XML_WITH_DEBUG_MEM = 29,
4305     XML_WITH_DEBUG_RUN = 30,
4306     XML_WITH_ZLIB = 31,
4307     XML_WITH_ICU = 32,
4308     XML_WITH_LZMA = 33,
4309     XML_WITH_NONE = 99999
4310   } xmlFeature;
4311
4312 int xmlHasFeature (xmlFeature feature);
4313 typedef unsigned long int ub4;
4314
4315
4316
4317 typedef signed long int sb4;
4318
4319
4320
4321 typedef unsigned short int ub2;
4322
4323
4324
4325 typedef signed short int sb2;
4326
4327
4328
4329 typedef unsigned char ub1;
4330
4331
4332
4333 typedef signed char sb1;
4334
4335
4336
4337 typedef int word;
4338 struct randctx
4339 {
4340   ub4 randcnt;
4341   ub4 randrsl[(1 << (4))];
4342   ub4 randmem[(1 << (4))];
4343   ub4 randa;
4344   ub4 randb;
4345   ub4 randc;
4346 };
4347 typedef struct randctx randctx;
4348
4349
4350
4351
4352
4353
4354 void irandinit (randctx * r, word flag);
4355
4356 void isaac (randctx * r);
4357 char *flam3_version ();
4358 typedef struct
4359 {
4360   double index;
4361   double color[4];
4362 } flam3_palette_entry;
4363
4364 typedef flam3_palette_entry flam3_palette[256];
4365
4366 int flam3_get_palette (int palette_index, flam3_palette p,
4367                        double hue_rotation);
4368
4369
4370
4371
4372 extern char *flam3_variation_names[];
4373 typedef struct
4374 {
4375
4376   double badvals;
4377   long int num_iters;
4378   int render_seconds;
4379
4380 } stat_struct;
4381
4382 typedef struct
4383 {
4384
4385   unsigned int width, height;
4386   int version;
4387   int id;
4388
4389
4390   double intensity_weight[256];
4391   unsigned int bin_size[256];
4392   unsigned int bin_offset[256];
4393
4394
4395
4396
4397
4398   unsigned short *rowcols;
4399
4400 } flam3_image_store;
4401
4402
4403 typedef struct xform
4404 {
4405   double var[98];
4406   double c[3][2];
4407   double post[3][2];
4408   double density;
4409   double color;
4410   double color_speed;
4411   double animate;
4412   double opacity;
4413   double vis_adjusted;
4414
4415   int padding;
4416   double wind[2];
4417
4418   int precalc_angles_flag;
4419   int precalc_atan_xy_flag;
4420   int precalc_atan_yx_flag;
4421   double has_preblur;
4422   int has_post;
4423
4424
4425
4426   double blob_low;
4427   double blob_high;
4428   double blob_waves;
4429
4430
4431   double pdj_a;
4432   double pdj_b;
4433   double pdj_c;
4434   double pdj_d;
4435
4436
4437   double fan2_x;
4438   double fan2_y;
4439
4440
4441   double rings2_val;
4442
4443
4444   double perspective_angle;
4445   double perspective_dist;
4446
4447
4448   double julian_power;
4449   double julian_dist;
4450
4451
4452   double juliascope_power;
4453   double juliascope_dist;
4454
4455
4456   double radial_blur_angle;
4457
4458
4459   double pie_slices;
4460   double pie_rotation;
4461   double pie_thickness;
4462
4463
4464   double ngon_sides;
4465   double ngon_power;
4466   double ngon_circle;
4467   double ngon_corners;
4468
4469
4470   double curl_c1;
4471   double curl_c2;
4472
4473
4474   double rectangles_x;
4475   double rectangles_y;
4476
4477
4478   double amw_amp;
4479
4480
4481   double disc2_rot;
4482   double disc2_twist;
4483
4484
4485   double super_shape_rnd;
4486   double super_shape_m;
4487   double super_shape_n1;
4488   double super_shape_n2;
4489   double super_shape_n3;
4490   double super_shape_holes;
4491
4492
4493   double flower_petals;
4494   double flower_holes;
4495
4496
4497   double conic_eccentricity;
4498   double conic_holes;
4499
4500
4501   double parabola_height;
4502   double parabola_width;
4503
4504
4505   double bent2_x;
4506   double bent2_y;
4507
4508
4509   double bipolar_shift;
4510
4511
4512   double cell_size;
4513
4514
4515   double cpow_r;
4516   double cpow_i;
4517   double cpow_power;
4518
4519
4520   double curve_xamp, curve_yamp;
4521   double curve_xlength, curve_ylength;
4522
4523
4524   double escher_beta;
4525
4526
4527   double lazysusan_spin;
4528   double lazysusan_space;
4529   double lazysusan_twist;
4530   double lazysusan_x, lazysusan_y;
4531
4532
4533   double modulus_x, modulus_y;
4534
4535
4536   double oscope_separation;
4537   double oscope_frequency;
4538   double oscope_amplitude;
4539   double oscope_damping;
4540
4541
4542   double popcorn2_x, popcorn2_y, popcorn2_c;
4543
4544
4545   double separation_x, separation_xinside;
4546   double separation_y, separation_yinside;
4547
4548
4549   double split_xsize;
4550   double split_ysize;
4551
4552
4553   double splits_x, splits_y;
4554
4555
4556   double stripes_space;
4557   double stripes_warp;
4558
4559
4560   double wedge_angle, wedge_hole;
4561   double wedge_count, wedge_swirl;
4562
4563
4564   double wedge_julia_angle;
4565   double wedge_julia_count;
4566   double wedge_julia_power;
4567   double wedge_julia_dist;
4568
4569
4570   double wedge_sph_angle, wedge_sph_count;
4571   double wedge_sph_hole, wedge_sph_swirl;
4572
4573
4574   double whorl_inside, whorl_outside;
4575
4576
4577   double waves2_freqx, waves2_scalex;
4578   double waves2_freqy, waves2_scaley;
4579
4580
4581   double auger_sym, auger_weight;
4582   double auger_freq, auger_scale;
4583
4584
4585   double flux_spread;
4586
4587
4588
4589   double persp_vsin;
4590   double persp_vfcos;
4591
4592
4593   double julian_rN;
4594   double julian_cn;
4595
4596
4597   double juliascope_rN;
4598   double juliascope_cn;
4599
4600
4601   double wedgeJulia_rN;
4602   double wedgeJulia_cn;
4603   double wedgeJulia_cf;
4604
4605
4606   double radialBlur_spinvar;
4607   double radialBlur_zoomvar;
4608
4609
4610   double waves_dx2;
4611   double waves_dy2;
4612
4613
4614   double disc2_sinadd;
4615   double disc2_cosadd;
4616   double disc2_timespi;
4617
4618
4619   double super_shape_pm_4;
4620   double super_shape_pneg1_n1;
4621
4622   int num_active_vars;
4623   double active_var_weights[98];
4624   int varFunc[98];
4625
4626   int motion_freq;
4627   int motion_func;
4628
4629   struct xform *motion;
4630   int num_motion;
4631
4632
4633 } flam3_xform;
4634
4635 typedef struct
4636 {
4637   char flame_name[64 + 1];
4638   double time;
4639   int interpolation;
4640   int interpolation_type;
4641   int palette_interpolation;
4642   int num_xforms;
4643   int final_xform_index;
4644   int final_xform_enable;
4645   flam3_xform *xform;
4646
4647
4648   double **chaos;
4649   int chaos_enable;
4650
4651   int genome_index;
4652   char parent_fname[30];
4653   int symmetry;
4654   flam3_palette palette;
4655   char *input_image;
4656   int palette_index;
4657   double brightness;
4658   double contrast;
4659   double gamma;
4660   double highlight_power;
4661   int width, height;
4662   int spatial_oversample;
4663   double center[2];
4664   double rot_center[2];
4665   double rotate;
4666   double vibrancy;
4667   double hue_rotation;
4668   double background[3];
4669   double zoom;
4670   double pixels_per_unit;
4671   double spatial_filter_radius;
4672   int spatial_filter_select;
4673
4674
4675   double sample_density;
4676
4677
4678
4679
4680
4681
4682   int nbatches;
4683   int ntemporal_samples;
4684
4685
4686   double estimator;
4687   double estimator_curve;
4688   double estimator_minimum;
4689
4690
4691
4692   xmlDocPtr edits;
4693
4694
4695   double gam_lin_thresh;
4696
4697
4698   int palette_index0;
4699   double hue_rotation0;
4700   int palette_index1;
4701   double hue_rotation1;
4702   double palette_blend;
4703
4704   int temporal_filter_type;
4705   double temporal_filter_width, temporal_filter_exp;
4706
4707   int palette_mode;
4708
4709
4710 } flam3_genome;
4711
4712 typedef struct
4713 {
4714   int from;
4715   int to;
4716   double scalar;
4717 } flam3_chaos_entry;
4718
4719
4720
4721 void flam3_add_motion_element (flam3_xform * xf);
4722 void flam3_add_xforms (flam3_genome * cp, int num_to_add,
4723                        int interp_padding, int final_flag);
4724 void flam3_delete_xform (flam3_genome * thiscp, int idx_to_delete);
4725 void flam3_copy_xform (flam3_xform * dest, flam3_xform * src);
4726 void flam3_copy (flam3_genome * dest, flam3_genome * src);
4727 void flam3_copyx (flam3_genome * dest, flam3_genome * src, int num_std,
4728                   int num_final);
4729 void flam3_copy_params (flam3_xform * dest, flam3_xform * src, int varn);
4730 void flam3_delete_motion_elements (flam3_xform * xf);
4731
4732 int flam3_xform_preview (flam3_genome * cp, int xi, double range,
4733                          int numvals, int depth, double *result,
4734                          randctx * rc);
4735 unsigned short *flam3_create_xform_distrib (flam3_genome * cp);
4736 int flam3_create_chaos_distrib (flam3_genome * cp, int xi,
4737                                 unsigned short *xform_distrib);
4738 int flam3_check_unity_chaos (flam3_genome * cp);
4739 void clear_cp (flam3_genome * cp, int def_flag);
4740
4741
4742
4743
4744
4745
4746 int flam3_iterate (flam3_genome * g, int nsamples, int fuse,
4747                    double *samples, unsigned short *xform_distrib,
4748                    randctx * rc);
4749
4750 void apply_motion_parameters (flam3_xform * xf, flam3_xform * addto,
4751                               double blend);
4752
4753
4754
4755 void flam3_interpolate (flam3_genome * genomes, int ngenomes,
4756                         double time, double stagger,
4757                         flam3_genome * result);
4758
4759
4760 void flam3_print (FILE * f, flam3_genome * g, char *extra_attributes,
4761                   int print_edits);
4762 void flam3_print_xform (FILE * f, flam3_xform * x, int final_flag,
4763                         int numstd, double *chaos_row, int motion_flag);
4764 char *flam3_print_to_string (flam3_genome * cp);
4765
4766
4767
4768
4769
4770 void flam3_random (flam3_genome * g, int *ivars, int ivars_n, int sym,
4771                    int spec_xforms);
4772
4773 void add_to_action (char *action, char *addtoaction);
4774
4775 void flam3_mutate (flam3_genome * cp, int mutate_mode, int *ivars,
4776                    int ivars_n, int sym, double speed, randctx * rc,
4777                    char *action);
4778 void flam3_cross (flam3_genome * cp0, flam3_genome * cp1,
4779                   flam3_genome * out, int cross_mode, randctx * rc,
4780                   char *action);
4781
4782
4783 flam3_genome *flam3_parse_xml2 (char *s, char *fn, int default_flag,
4784                                 int *ncps);
4785 flam3_genome *flam3_parse_from_file (FILE * f, char *fn,
4786                                      int default_flag, int *ncps);
4787
4788 void flam3_add_symmetry (flam3_genome * g, int sym);
4789
4790 void flam3_improve_colors (flam3_genome * g, int ntries,
4791                            int change_palette, int color_resolution);
4792 int flam3_colorhist (flam3_genome * cp, int num_batches, randctx * rc,
4793                      double *hist);
4794 int flam3_estimate_bounding_box (flam3_genome * g, double eps,
4795                                  int nsamples, double *bmin,
4796                                  double *bmax, randctx * rc);
4797 void flam3_rotate (flam3_genome * g, double angle, int interp_type);
4798
4799 double flam3_dimension (flam3_genome * g, int ntries,
4800                         int clip_to_camera);
4801 double flam3_lyapunov (flam3_genome * g, int ntries);
4802
4803 void flam3_apply_template (flam3_genome * cp, flam3_genome * templ);
4804
4805 int flam3_count_nthreads (void);
4806
4807 typedef struct
4808 {
4809
4810   double pixel_aspect_ratio;
4811   flam3_genome *genomes;
4812   int ngenomes;
4813   int verbose;
4814   int bits;
4815   int bytes_per_channel;
4816   int earlyclip;
4817   double time;
4818   int (*progress) (void *, double, int, double);
4819   void *progress_parameter;
4820   randctx rc;
4821   int nthreads;
4822   int sub_batch_size;
4823 } flam3_frame;
4824 int flam3_render (flam3_frame * f, void *out, int field, int nchan,
4825                   int transp, stat_struct * stats);
4826
4827 double flam3_render_memory_required (flam3_frame * f);
4828 int flam3_make_strip (flam3_genome * cp, int nstrips, int stripnum);
4829 void rotate_by (double *p, double *center, double by);
4830
4831
4832 double flam3_random01 ();
4833 double flam3_random11 ();
4834 int flam3_random_bit ();
4835
4836
4837 double flam3_random_isaac_01 (randctx *);
4838 double flam3_random_isaac_11 (randctx *);
4839 int flam3_random_isaac_bit (randctx *);
4840
4841 void flam3_init_frame (flam3_frame * f);
4842
4843
4844 void *flam3_malloc (size_t size);
4845 void flam3_free (void *ptr);
4846
4847 void flam3_srandom ();
4848
4849 flam3_genome *sheep_loop (flam3_genome * cp, double blend);
4850 flam3_genome *sheep_edge (flam3_genome * cp, double blend, int seqflag,
4851                           double stagger);
4852
4853
4854
4855
4856
4857 extern char *dirname (char *__path)
4858   __attribute__ ((__nothrow__, __leaf__));
4859
4860
4861
4862
4863
4864
4865
4866 extern char *__xpg_basename (char *__path)
4867   __attribute__ ((__nothrow__, __leaf__));
4868
4869
4870
4871
4872
4873
4874 void docstring ();
4875
4876
4877 typedef struct
4878 {
4879   unsigned short *xform_distrib;
4880   flam3_frame *spec;
4881   double bounds[4];
4882   double rot[2][2];
4883   double size[2];
4884   int width, height;
4885   double ws0, wb0s0, hs1, hb1s1;
4886   flam3_palette_entry *dmap;
4887   double color_scalar;
4888   void *buckets;
4889   double badvals;
4890   double batch_size;
4891   int temporal_sample_num, ntemporal_samples;
4892   int batch_num, nbatches, aborted;
4893   time_t *progress_timer;
4894   time_t *progress_timer_history;
4895   double *progress_history;
4896   int *progress_history_mark;
4897
4898
4899   pthread_mutex_t bucket_mutex;
4900
4901
4902 } flam3_iter_constants;
4903
4904 typedef struct
4905 {
4906
4907   double tx, ty;
4908
4909   double precalc_atan, precalc_sina;
4910   double precalc_cosa, precalc_sqrt;
4911   double precalc_sumsq, precalc_atanyx;
4912
4913   flam3_xform *xform;
4914
4915
4916
4917   double p0, p1;
4918
4919
4920   randctx *rc;
4921
4922 } flam3_iter_helper;
4923
4924 typedef struct
4925 {
4926   double *iter_storage;
4927   randctx rc;
4928   flam3_genome cp;
4929   int first_thread;
4930   int timer_initialize;
4931   flam3_iter_constants *fic;
4932 } flam3_thread_helper;
4933
4934 double flam3_sinc (double x);
4935
4936
4937 double flam3_gaussian_filter (double x);
4938 double flam3_hermite_filter (double t);
4939 double flam3_box_filter (double t);
4940 double flam3_triangle_filter (double t);
4941 double flam3_bell_filter (double t);
4942 double flam3_b_spline_filter (double t);
4943 double flam3_lanczos3_filter (double t);
4944 double flam3_lanczos2_filter (double t);
4945 double flam3_mitchell_filter (double t);
4946 double flam3_blackman_filter (double x);
4947 double flam3_catrom_filter (double x);
4948 double flam3_hamming_filter (double x);
4949 double flam3_hanning_filter (double x);
4950 double flam3_quadratic_filter (double x);
4951
4952 double flam3_spatial_filter (int knum, double x);
4953 typedef struct
4954 {
4955   int max_filtered_counts;
4956   int max_filter_index;
4957   int kernel_size;
4958   double *filter_widths;
4959   double *filter_coefs;
4960 } flam3_de_helper;
4961
4962 extern double flam3_spatial_support[14];
4963
4964 double flam3_spatial_filter (int knum, double x);
4965 int flam3_create_spatial_filter (flam3_frame * spec, int field,
4966                                  double **filter);
4967 flam3_de_helper flam3_create_de_filters (double max_rad, double min_rad,
4968                                          double curve, int ss);
4969 double flam3_create_temporal_filter (int numsteps, int filter_type,
4970                                      double filter_exp,
4971                                      double filter_width,
4972                                      double **temporal_filter,
4973                                      double **temporal_deltas);
4974
4975 double flam3_spatial_support[14] = {
4976   1.5,
4977   1.0,
4978   0.5,
4979   1.0,
4980   1.5,
4981   2.0,
4982   2.0,
4983   1.0,
4984   2.0,
4985   1.0,
4986   1.0,
4987   3.0,
4988   2.0,
4989   1.5
4990 };
4991
4992 double
4993 flam3_hermite_filter (double t)
4994 {
4995
4996   if (t < 0.0)
4997     t = -t;
4998   if (t < 1.0)
4999     return ((2.0 * t - 3.0) * t * t + 1.0);
5000   return (0.0);
5001 }
5002
5003 double
5004 flam3_box_filter (double t)
5005 {
5006   if ((t > -0.5) && (t <= 0.5))
5007     return (1.0);
5008   return (0.0);
5009 }
5010
5011 double
5012 flam3_triangle_filter (double t)
5013 {
5014   if (t < 0.0)
5015     t = -t;
5016   if (t < 1.0)
5017     return (1.0 - t);
5018   return (0.0);
5019 }
5020
5021 double
5022 flam3_bell_filter (double t)
5023 {
5024
5025   if (t < 0)
5026     t = -t;
5027   if (t < .5)
5028     return (.75 - (t * t));
5029   if (t < 1.5)
5030     {
5031       t = (t - 1.5);
5032       return (.5 * (t * t));
5033     }
5034   return (0.0);
5035 }
5036
5037 double
5038 flam3_b_spline_filter (double t)
5039 {
5040
5041
5042   double tt;
5043
5044   if (t < 0)
5045     t = -t;
5046   if (t < 1)
5047     {
5048       tt = t * t;
5049       return ((.5 * tt * t) - tt + (2.0 / 3.0));
5050     }
5051   else if (t < 2)
5052     {
5053       t = 2 - t;
5054       return ((1.0 / 6.0) * (t * t * t));
5055     }
5056   return (0.0);
5057 }
5058
5059 double
5060 flam3_sinc (double x)
5061 {
5062   x *= 3.14159265358979323846;
5063   if (x != 0)
5064     return (sin (x) / x);
5065   return (1.0);
5066 }
5067
5068 double
5069 flam3_blackman_filter (double x)
5070 {
5071   return (0.42 + 0.5 * cos (3.14159265358979323846 * x) + 0.08 * cos (2 * 3.14159265358979323846 * x));
5072 }
5073
5074 double
5075 flam3_catrom_filter (double x)
5076 {
5077   if (x < -2.0)
5078     return (0.0);
5079   if (x < -1.0)
5080     return (0.5 * (4.0 + x * (8.0 + x * (5.0 + x))));
5081   if (x < 0.0)
5082     return (0.5 * (2.0 + x * x * (-5.0 - 3.0 * x)));
5083   if (x < 1.0)
5084     return (0.5 * (2.0 + x * x * (-5.0 + 3.0 * x)));
5085   if (x < 2.0)
5086     return (0.5 * (4.0 + x * (-8.0 + x * (5.0 - x))));
5087   return (0.0);
5088 }
5089
5090 double
5091 flam3_mitchell_filter (double t)
5092 {
5093   double tt;
5094
5095   tt = t * t;
5096   if (t < 0)
5097     t = -t;
5098   if (t < 1.0)
5099     {
5100       t = (((12.0 - 9.0 * (1.0 / 3.0) - 6.0 * (1.0 / 3.0)) * (t * tt))
5101            + ((-18.0 + 12.0 * (1.0 / 3.0) + 6.0 * (1.0 / 3.0)) * tt)
5102            + (6.0 - 2 * (1.0 / 3.0)));
5103       return (t / 6.0);
5104     }
5105   else if (t < 2.0)
5106     {
5107       t = (((-1.0 * (1.0 / 3.0) - 6.0 * (1.0 / 3.0)) * (t * tt))
5108            + ((6.0 * (1.0 / 3.0) + 30.0 * (1.0 / 3.0)) * tt)
5109            + ((-12.0 * (1.0 / 3.0) - 48.0 * (1.0 / 3.0)) * t)
5110            + (8.0 * (1.0 / 3.0) + 24 * (1.0 / 3.0)));
5111       return (t / 6.0);
5112     }
5113   return (0.0);
5114 }
5115
5116 double
5117 flam3_hanning_filter (double x)
5118 {
5119   return (0.5 + 0.5 * cos (3.14159265358979323846 * x));
5120 }
5121
5122 double
5123 flam3_hamming_filter (double x)
5124 {
5125   return (0.54 + 0.46 * cos (3.14159265358979323846 * x));
5126 }
5127
5128 double
5129 flam3_lanczos3_filter (double t)
5130 {
5131   if (t < 0)
5132     t = -t;
5133   if (t < 3.0)
5134     return (flam3_sinc (t) * flam3_sinc (t / 3.0));
5135   return (0.0);
5136 }
5137
5138 double
5139 flam3_lanczos2_filter (double t)
5140 {
5141   if (t < 0)
5142     t = -t;
5143   if (t < 2.0)
5144     return (flam3_sinc (t) * flam3_sinc (t / 2.0));
5145   return (0.0);
5146 }
5147
5148 double
5149 flam3_gaussian_filter (double x)
5150 {
5151   return (exp ((-2.0 * x * x)) * sqrt (2.0 / 3.14159265358979323846));
5152 }
5153
5154 double
5155 flam3_quadratic_filter (double x)
5156 {
5157   if (x < -1.5)
5158     return (0.0);
5159   if (x < -0.5)
5160     return (0.5 * (x + 1.5) * (x + 1.5));
5161   if (x < 0.5)
5162     return (0.75 - x * x);
5163   if (x < 1.5)
5164     return (0.5 * (x - 1.5) * (x - 1.5));
5165   return (0.0);
5166 }
5167
5168 double
5169 flam3_spatial_filter (int knum, double x)
5170 {
5171
5172   if (knum == 0)
5173     return flam3_gaussian_filter (x);
5174   else if (knum == 1)
5175     return flam3_hermite_filter (x);
5176   else if (knum == 2)
5177     return flam3_box_filter (x);
5178   else if (knum == 3)
5179     return flam3_triangle_filter (x);
5180   else if (knum == 4)
5181     return flam3_bell_filter (x);
5182   else if (knum == 5)
5183     return flam3_b_spline_filter (x);
5184   else if (knum == 6)
5185     return flam3_mitchell_filter (x);
5186   else if (knum == 7)
5187     return flam3_sinc (x) * flam3_blackman_filter (x);
5188   else if (knum == 8)
5189     return flam3_catrom_filter (x);
5190   else if (knum == 9)
5191     return flam3_sinc (x) * flam3_hanning_filter (x);
5192   else if (knum == 10)
5193     return flam3_sinc (x) * flam3_hamming_filter (x);
5194   else if (knum == 11)
5195     return flam3_lanczos3_filter (x) * flam3_sinc (x / 3.0);
5196   else if (knum == 12)
5197     return flam3_lanczos2_filter (x) * flam3_sinc (x / 2.0);
5198   else if (knum == 13)
5199     return flam3_quadratic_filter (x);
5200 }
5201
5202 int
5203 normalize_vector (double *v, int n)
5204 {
5205   double t = 0.0;
5206   int i;
5207   for (i = 0; i < n; i++)
5208     t += v[i];
5209   if (0.0 == t)
5210     return 1;
5211   t = 1.0 / t;
5212   for (i = 0; i < n; i++)
5213     v[i] *= t;
5214   return 0;
5215 }
5216
5217
5218 int
5219 flam3_create_spatial_filter (flam3_frame * spec, int field, double **filter)
5220 {
5221
5222   int sf_kernel = spec->genomes[0].spatial_filter_select;
5223   int supersample = spec->genomes[0].spatial_oversample;
5224   double sf_radius = spec->genomes[0].spatial_filter_radius;
5225   double aspect_ratio = spec->pixel_aspect_ratio;
5226   double sf_supp = flam3_spatial_support[sf_kernel];
5227
5228   double fw = 2.0 * sf_supp * supersample * sf_radius / aspect_ratio;
5229   double adjust, ii, jj;
5230
5231   int fwidth = ((int) fw) + 1;
5232   int i, j;
5233
5234
5235
5236   if ((fwidth ^ supersample) & 1)
5237     fwidth++;
5238
5239
5240   if (fw > 0.0)
5241     adjust = sf_supp * fwidth / fw;
5242   else
5243     adjust = 1.0;
5244
5245
5246   (*filter) = (double *) calloc (fwidth * fwidth, sizeof (double));
5247
5248
5249   for (i = 0; i < fwidth; i++)
5250     for (j = 0; j < fwidth; j++)
5251       {
5252
5253
5254         ii = ((2.0 * i + 1.0) / (double) fwidth - 1.0) * adjust;
5255         jj = ((2.0 * j + 1.0) / (double) fwidth - 1.0) * adjust;
5256
5257
5258         if (field)
5259           jj *= 2.0;
5260
5261
5262         jj /= aspect_ratio;
5263
5264         (*filter)[i + j * fwidth] =
5265           flam3_spatial_filter (sf_kernel,
5266                                 ii) * flam3_spatial_filter (sf_kernel, jj);
5267       }
5268
5269
5270   if (normalize_vector ((*filter), fwidth * fwidth))
5271     {
5272       fprintf (stderr,
5273                "Spatial filter value is too small: %g.  Terminating.\n",
5274                sf_radius);
5275       return (-1);
5276     }
5277
5278   return (fwidth);
5279 }
5280
5281 flam3_de_helper
5282 flam3_create_de_filters (double max_rad, double min_rad, double curve, int ss)
5283 {
5284
5285   flam3_de_helper de;
5286   double comp_max_radius, comp_min_radius;
5287   double num_de_filters_d;
5288   int num_de_filters, de_max_ind;
5289   int de_row_size, de_half_size;
5290   int filtloop;
5291   int keep_thresh = 100;
5292
5293   de.kernel_size = -1;
5294
5295   if (curve <= 0.0)
5296     {
5297       fprintf (stderr, "estimator curve must be > 0\n");
5298       return (de);
5299     }
5300
5301   if (max_rad < min_rad)
5302     {
5303       fprintf (stderr, "estimator must be larger than estimator_minimum.\n");
5304       fprintf (stderr, "(%f > %f) ? \n", max_rad, min_rad);
5305       return (de);
5306     }
5307
5308
5309
5310   comp_max_radius = max_rad * ss + 1;
5311   comp_min_radius = min_rad * ss + 1;
5312
5313
5314
5315
5316
5317   num_de_filters_d = pow (comp_max_radius / comp_min_radius, 1.0 / curve);
5318   if (num_de_filters_d > 1e7)
5319     {
5320       fprintf (stderr,
5321                "too many filters required in this configuration (%g)\n",
5322                num_de_filters_d);
5323       return (de);
5324     }
5325   num_de_filters = (int) ceil (num_de_filters_d);
5326
5327
5328   if (num_de_filters > keep_thresh)
5329     {
5330       de_max_ind = (int) ceil (100 + pow (num_de_filters - 100, curve)) + 1;
5331       de.max_filtered_counts =
5332         (int) pow ((double) (de_max_ind - 100), 1.0 / curve) + 100;
5333     }
5334   else
5335     {
5336       de_max_ind = num_de_filters;
5337       de.max_filtered_counts = de_max_ind;
5338     }
5339
5340
5341
5342   de_row_size = (int) (2 * ceil (comp_max_radius) - 1);
5343   de_half_size = (de_row_size - 1) / 2;
5344   de.kernel_size = (de_half_size + 1) * (2 + de_half_size) / 2;
5345
5346   de.filter_coefs =
5347     (double *) calloc (de_max_ind * de.kernel_size, sizeof (double));
5348   de.filter_widths = (double *) calloc (de_max_ind, sizeof (double));
5349
5350
5351   de.max_filter_index = 0;
5352   for (filtloop = 0; filtloop < de_max_ind; filtloop++)
5353     {
5354
5355       double de_filt_sum = 0.0, de_filt_d;
5356       double de_filt_h;
5357       int dej, dek;
5358       double adjloop;
5359       int filter_coef_idx;
5360
5361
5362       if (filtloop < keep_thresh)
5363         de_filt_h = (comp_max_radius / pow (filtloop + 1, curve));
5364       else
5365         {
5366           adjloop = pow (filtloop - keep_thresh, (1.0 / curve)) + keep_thresh;
5367           de_filt_h = (comp_max_radius / pow (adjloop + 1, curve));
5368         }
5369
5370
5371       if (de_filt_h <= comp_min_radius)
5372         {
5373           de_filt_h = comp_min_radius;
5374           de.max_filter_index = filtloop;
5375         }
5376
5377       de.filter_widths[filtloop] = de_filt_h;
5378
5379
5380       for (dej = -de_half_size; dej <= de_half_size; dej++)
5381         {
5382           for (dek = -de_half_size; dek <= de_half_size; dek++)
5383             {
5384
5385               de_filt_d = sqrt ((double) (dej * dej + dek * dek)) / de_filt_h;
5386
5387
5388               if (de_filt_d <= 1.0)
5389                 {
5390                   de_filt_sum += flam3_spatial_filter (0, flam3_spatial_support [0] * de_filt_d);
5391                 }
5392             }
5393         }
5394
5395       filter_coef_idx = filtloop * de.kernel_size;
5396
5397
5398       for (dej = 0; dej <= de_half_size; dej++)
5399         {
5400           for (dek = 0; dek <= dej; dek++)
5401             {
5402               de_filt_d = sqrt ((double) (dej * dej + dek * dek)) / de_filt_h;
5403
5404
5405               if (de_filt_d > 1.0)
5406                 de.filter_coefs[filter_coef_idx] = 0.0;
5407               else
5408                 {
5409                   de.filter_coefs[filter_coef_idx] = flam3_spatial_filter (0, flam3_spatial_support[0] * de_filt_d) / de_filt_sum;
5410                 }
5411
5412               filter_coef_idx++;
5413             }
5414         }
5415
5416       if (de.max_filter_index > 0)
5417         break;
5418     }
5419
5420   if (de.max_filter_index == 0)
5421     de.max_filter_index = de_max_ind - 1;
5422
5423
5424   return (de);
5425 }
5426
5427 double
5428 flam3_create_temporal_filter (int numsteps, int filter_type,
5429                               double filter_exp, double filter_width,
5430                               double **temporal_filter,
5431                               double **temporal_deltas)
5432 {
5433
5434   double maxfilt = 0.0;
5435   double sumfilt = 0.0;
5436   double slpx, halfsteps;
5437   double *deltas, *filter;
5438
5439   int i;
5440
5441
5442   deltas = (double *) malloc (numsteps * sizeof (double));
5443   filter = (double *) malloc (numsteps * sizeof (double));
5444
5445
5446   if (numsteps == 1)
5447     {
5448       deltas[0] = 0;
5449       filter[0] = 1.0;
5450       *temporal_deltas = deltas;
5451       *temporal_filter = filter;
5452       return (1.0);
5453     }
5454
5455
5456   for (i = 0; i < numsteps; i++)
5457     deltas[i] = ((double) i / (double) (numsteps - 1) - 0.5) * filter_width;
5458
5459
5460   if (2 == filter_type)
5461     {
5462
5463       for (i = 0; i < numsteps; i++)
5464         {
5465
5466           if (filter_exp >= 0)
5467             slpx = ((double) i + 1.0) / numsteps;
5468           else
5469             slpx = (double) (numsteps - i) / numsteps;
5470
5471
5472           filter[i] = pow (slpx, fabs (filter_exp));
5473
5474
5475           if (filter[i] > maxfilt)
5476             maxfilt = filter[i];
5477         }
5478
5479     }
5480   else if (1 == filter_type)
5481     {
5482
5483       halfsteps = numsteps / 2.0;
5484       for (i = 0; i < numsteps; i++)
5485         {
5486
5487
5488           filter[i] = flam3_spatial_filter (0, flam3_spatial_support[0] * fabs (i - halfsteps) / halfsteps);
5489           if (filter[i] > maxfilt)
5490             maxfilt = filter[i];
5491         }
5492
5493     }
5494   else
5495     {
5496
5497       for (i = 0; i < numsteps; i++)
5498         filter[i] = 1.0;
5499
5500       maxfilt = 1.0;
5501
5502     }
5503
5504
5505
5506   for (i = 0; i < numsteps; i++)
5507     {
5508       filter[i] /= maxfilt;
5509       sumfilt += filter[i];
5510     }
5511
5512   sumfilt /= numsteps;
5513
5514   *temporal_deltas = deltas;
5515   *temporal_filter = filter;
5516
5517   return (sumfilt);
5518 }