diff options
Diffstat (limited to 'thirdparties/common/include/libxml2')
46 files changed, 3510 insertions, 3500 deletions
diff --git a/thirdparties/common/include/libxml2/libxml/DOCBparser.h b/thirdparties/common/include/libxml2/libxml/DOCBparser.h index 9394fa7..8fa4db3 100755 --- a/thirdparties/common/include/libxml2/libxml/DOCBparser.h +++ b/thirdparties/common/include/libxml2/libxml/DOCBparser.h @@ -42,50 +42,50 @@ typedef xmlDocPtr docbDocPtr; * There is only few public functions. */ XMLPUBFUN int XMLCALL - docbEncodeEntities(unsigned char *out, - int *outlen, - const unsigned char *in, - int *inlen, int quoteChar); +docbEncodeEntities(unsigned char *out, + int *outlen, + const unsigned char *in, + int *inlen, int quoteChar); XMLPUBFUN docbDocPtr XMLCALL - docbSAXParseDoc (xmlChar *cur, - const char *encoding, - docbSAXHandlerPtr sax, - void *userData); +docbSAXParseDoc (xmlChar *cur, + const char *encoding, + docbSAXHandlerPtr sax, + void *userData); XMLPUBFUN docbDocPtr XMLCALL - docbParseDoc (xmlChar *cur, - const char *encoding); +docbParseDoc (xmlChar *cur, + const char *encoding); XMLPUBFUN docbDocPtr XMLCALL - docbSAXParseFile (const char *filename, - const char *encoding, - docbSAXHandlerPtr sax, - void *userData); +docbSAXParseFile (const char *filename, + const char *encoding, + docbSAXHandlerPtr sax, + void *userData); XMLPUBFUN docbDocPtr XMLCALL - docbParseFile (const char *filename, - const char *encoding); +docbParseFile (const char *filename, + const char *encoding); /** * Interfaces for the Push mode. */ XMLPUBFUN void XMLCALL - docbFreeParserCtxt (docbParserCtxtPtr ctxt); +docbFreeParserCtxt (docbParserCtxtPtr ctxt); XMLPUBFUN docbParserCtxtPtr XMLCALL - docbCreatePushParserCtxt(docbSAXHandlerPtr sax, - void *user_data, - const char *chunk, - int size, - const char *filename, - xmlCharEncoding enc); +docbCreatePushParserCtxt(docbSAXHandlerPtr sax, + void *user_data, + const char *chunk, + int size, + const char *filename, + xmlCharEncoding enc); XMLPUBFUN int XMLCALL - docbParseChunk (docbParserCtxtPtr ctxt, - const char *chunk, - int size, - int terminate); +docbParseChunk (docbParserCtxtPtr ctxt, + const char *chunk, + int size, + int terminate); XMLPUBFUN docbParserCtxtPtr XMLCALL - docbCreateFileParserCtxt(const char *filename, - const char *encoding); +docbCreateFileParserCtxt(const char *filename, + const char *encoding); XMLPUBFUN int XMLCALL - docbParseDocument (docbParserCtxtPtr ctxt); +docbParseDocument (docbParserCtxtPtr ctxt); #ifdef __cplusplus } diff --git a/thirdparties/common/include/libxml2/libxml/HTMLparser.h b/thirdparties/common/include/libxml2/libxml/HTMLparser.h index 551186c..ec434f8 100755 --- a/thirdparties/common/include/libxml2/libxml/HTMLparser.h +++ b/thirdparties/common/include/libxml2/libxml/HTMLparser.h @@ -51,16 +51,16 @@ struct _htmlElemDesc { char isinline; /* is this a block 0 or inline 1 element */ const char *desc; /* the description */ -/* NRK Jan.2003 - * New fields encapsulating HTML structure - * - * Bugs: - * This is a very limited representation. It fails to tell us when - * an element *requires* subelements (we only have whether they're - * allowed or not), and it doesn't tell us where CDATA and PCDATA - * are allowed. Some element relationships are not fully represented: - * these are flagged with the word MODIFIER - */ + /* NRK Jan.2003 + * New fields encapsulating HTML structure + * + * Bugs: + * This is a very limited representation. It fails to tell us when + * an element *requires* subelements (we only have whether they're + * allowed or not), and it doesn't tell us where CDATA and PCDATA + * are allowed. Some element relationships are not fully represented: + * these are flagged with the word MODIFIER + */ const char** subelts; /* allowed sub-elements of this element */ const char* defaultsubelt; /* subelement for suggested auto-repair if necessary or NULL */ @@ -84,87 +84,87 @@ struct _htmlEntityDesc { * There is only few public functions. */ XMLPUBFUN const htmlElemDesc * XMLCALL - htmlTagLookup (const xmlChar *tag); +htmlTagLookup (const xmlChar *tag); XMLPUBFUN const htmlEntityDesc * XMLCALL - htmlEntityLookup(const xmlChar *name); +htmlEntityLookup(const xmlChar *name); XMLPUBFUN const htmlEntityDesc * XMLCALL - htmlEntityValueLookup(unsigned int value); +htmlEntityValueLookup(unsigned int value); XMLPUBFUN int XMLCALL - htmlIsAutoClosed(htmlDocPtr doc, - htmlNodePtr elem); +htmlIsAutoClosed(htmlDocPtr doc, + htmlNodePtr elem); XMLPUBFUN int XMLCALL - htmlAutoCloseTag(htmlDocPtr doc, - const xmlChar *name, - htmlNodePtr elem); +htmlAutoCloseTag(htmlDocPtr doc, + const xmlChar *name, + htmlNodePtr elem); XMLPUBFUN const htmlEntityDesc * XMLCALL - htmlParseEntityRef(htmlParserCtxtPtr ctxt, - const xmlChar **str); +htmlParseEntityRef(htmlParserCtxtPtr ctxt, + const xmlChar **str); XMLPUBFUN int XMLCALL - htmlParseCharRef(htmlParserCtxtPtr ctxt); +htmlParseCharRef(htmlParserCtxtPtr ctxt); XMLPUBFUN void XMLCALL - htmlParseElement(htmlParserCtxtPtr ctxt); +htmlParseElement(htmlParserCtxtPtr ctxt); XMLPUBFUN htmlParserCtxtPtr XMLCALL - htmlNewParserCtxt(void); +htmlNewParserCtxt(void); XMLPUBFUN htmlParserCtxtPtr XMLCALL - htmlCreateMemoryParserCtxt(const char *buffer, - int size); +htmlCreateMemoryParserCtxt(const char *buffer, + int size); XMLPUBFUN int XMLCALL - htmlParseDocument(htmlParserCtxtPtr ctxt); +htmlParseDocument(htmlParserCtxtPtr ctxt); XMLPUBFUN htmlDocPtr XMLCALL - htmlSAXParseDoc (xmlChar *cur, - const char *encoding, - htmlSAXHandlerPtr sax, - void *userData); +htmlSAXParseDoc (xmlChar *cur, + const char *encoding, + htmlSAXHandlerPtr sax, + void *userData); XMLPUBFUN htmlDocPtr XMLCALL - htmlParseDoc (xmlChar *cur, - const char *encoding); +htmlParseDoc (xmlChar *cur, + const char *encoding); XMLPUBFUN htmlDocPtr XMLCALL - htmlSAXParseFile(const char *filename, - const char *encoding, - htmlSAXHandlerPtr sax, - void *userData); +htmlSAXParseFile(const char *filename, + const char *encoding, + htmlSAXHandlerPtr sax, + void *userData); XMLPUBFUN htmlDocPtr XMLCALL - htmlParseFile (const char *filename, - const char *encoding); +htmlParseFile (const char *filename, + const char *encoding); XMLPUBFUN int XMLCALL - UTF8ToHtml (unsigned char *out, - int *outlen, - const unsigned char *in, - int *inlen); +UTF8ToHtml (unsigned char *out, + int *outlen, + const unsigned char *in, + int *inlen); XMLPUBFUN int XMLCALL - htmlEncodeEntities(unsigned char *out, - int *outlen, - const unsigned char *in, - int *inlen, int quoteChar); +htmlEncodeEntities(unsigned char *out, + int *outlen, + const unsigned char *in, + int *inlen, int quoteChar); XMLPUBFUN int XMLCALL - htmlIsScriptAttribute(const xmlChar *name); +htmlIsScriptAttribute(const xmlChar *name); XMLPUBFUN int XMLCALL - htmlHandleOmittedElem(int val); +htmlHandleOmittedElem(int val); #ifdef LIBXML_PUSH_ENABLED /** * Interfaces for the Push mode. */ XMLPUBFUN htmlParserCtxtPtr XMLCALL - htmlCreatePushParserCtxt(htmlSAXHandlerPtr sax, - void *user_data, - const char *chunk, - int size, - const char *filename, - xmlCharEncoding enc); +htmlCreatePushParserCtxt(htmlSAXHandlerPtr sax, + void *user_data, + const char *chunk, + int size, + const char *filename, + xmlCharEncoding enc); XMLPUBFUN int XMLCALL - htmlParseChunk (htmlParserCtxtPtr ctxt, - const char *chunk, - int size, - int terminate); +htmlParseChunk (htmlParserCtxtPtr ctxt, + const char *chunk, + int size, + int terminate); #endif /* LIBXML_PUSH_ENABLED */ XMLPUBFUN void XMLCALL - htmlFreeParserCtxt (htmlParserCtxtPtr ctxt); +htmlFreeParserCtxt (htmlParserCtxtPtr ctxt); /* * New set of simpler/more flexible APIs @@ -189,78 +189,78 @@ typedef enum { } htmlParserOption; XMLPUBFUN void XMLCALL - htmlCtxtReset (htmlParserCtxtPtr ctxt); +htmlCtxtReset (htmlParserCtxtPtr ctxt); XMLPUBFUN int XMLCALL - htmlCtxtUseOptions (htmlParserCtxtPtr ctxt, - int options); +htmlCtxtUseOptions (htmlParserCtxtPtr ctxt, + int options); XMLPUBFUN htmlDocPtr XMLCALL - htmlReadDoc (const xmlChar *cur, - const char *URL, - const char *encoding, - int options); +htmlReadDoc (const xmlChar *cur, + const char *URL, + const char *encoding, + int options); XMLPUBFUN htmlDocPtr XMLCALL - htmlReadFile (const char *URL, - const char *encoding, - int options); +htmlReadFile (const char *URL, + const char *encoding, + int options); XMLPUBFUN htmlDocPtr XMLCALL - htmlReadMemory (const char *buffer, - int size, - const char *URL, - const char *encoding, - int options); +htmlReadMemory (const char *buffer, + int size, + const char *URL, + const char *encoding, + int options); XMLPUBFUN htmlDocPtr XMLCALL - htmlReadFd (int fd, - const char *URL, - const char *encoding, - int options); +htmlReadFd (int fd, + const char *URL, + const char *encoding, + int options); XMLPUBFUN htmlDocPtr XMLCALL - htmlReadIO (xmlInputReadCallback ioread, - xmlInputCloseCallback ioclose, - void *ioctx, - const char *URL, - const char *encoding, - int options); +htmlReadIO (xmlInputReadCallback ioread, + xmlInputCloseCallback ioclose, + void *ioctx, + const char *URL, + const char *encoding, + int options); XMLPUBFUN htmlDocPtr XMLCALL - htmlCtxtReadDoc (xmlParserCtxtPtr ctxt, - const xmlChar *cur, - const char *URL, - const char *encoding, - int options); +htmlCtxtReadDoc (xmlParserCtxtPtr ctxt, + const xmlChar *cur, + const char *URL, + const char *encoding, + int options); XMLPUBFUN htmlDocPtr XMLCALL - htmlCtxtReadFile (xmlParserCtxtPtr ctxt, - const char *filename, - const char *encoding, - int options); +htmlCtxtReadFile (xmlParserCtxtPtr ctxt, + const char *filename, + const char *encoding, + int options); XMLPUBFUN htmlDocPtr XMLCALL - htmlCtxtReadMemory (xmlParserCtxtPtr ctxt, - const char *buffer, - int size, - const char *URL, - const char *encoding, - int options); +htmlCtxtReadMemory (xmlParserCtxtPtr ctxt, + const char *buffer, + int size, + const char *URL, + const char *encoding, + int options); XMLPUBFUN htmlDocPtr XMLCALL - htmlCtxtReadFd (xmlParserCtxtPtr ctxt, - int fd, - const char *URL, - const char *encoding, - int options); +htmlCtxtReadFd (xmlParserCtxtPtr ctxt, + int fd, + const char *URL, + const char *encoding, + int options); XMLPUBFUN htmlDocPtr XMLCALL - htmlCtxtReadIO (xmlParserCtxtPtr ctxt, - xmlInputReadCallback ioread, - xmlInputCloseCallback ioclose, - void *ioctx, - const char *URL, - const char *encoding, - int options); +htmlCtxtReadIO (xmlParserCtxtPtr ctxt, + xmlInputReadCallback ioread, + xmlInputCloseCallback ioclose, + void *ioctx, + const char *URL, + const char *encoding, + int options); /* NRK/Jan2003: further knowledge of HTML structure */ typedef enum { - HTML_NA = 0 , /* something we don't check at all */ - HTML_INVALID = 0x1 , - HTML_DEPRECATED = 0x2 , - HTML_VALID = 0x4 , - HTML_REQUIRED = 0xc /* VALID bit set so ( & HTML_VALID ) is TRUE */ + HTML_NA = 0 , /* something we don't check at all */ + HTML_INVALID = 0x1 , + HTML_DEPRECATED = 0x2 , + HTML_VALID = 0x4 , + HTML_REQUIRED = 0xc /* VALID bit set so ( & HTML_VALID ) is TRUE */ } htmlStatus ; /* Using htmlElemDesc rather than name here, to emphasise the fact diff --git a/thirdparties/common/include/libxml2/libxml/HTMLtree.h b/thirdparties/common/include/libxml2/libxml/HTMLtree.h index c0e1103..c5258ca 100755 --- a/thirdparties/common/include/libxml2/libxml/HTMLtree.h +++ b/thirdparties/common/include/libxml2/libxml/HTMLtree.h @@ -60,81 +60,81 @@ extern "C" { #define HTML_PI_NODE XML_PI_NODE XMLPUBFUN htmlDocPtr XMLCALL - htmlNewDoc (const xmlChar *URI, - const xmlChar *ExternalID); +htmlNewDoc (const xmlChar *URI, + const xmlChar *ExternalID); XMLPUBFUN htmlDocPtr XMLCALL - htmlNewDocNoDtD (const xmlChar *URI, - const xmlChar *ExternalID); +htmlNewDocNoDtD (const xmlChar *URI, + const xmlChar *ExternalID); XMLPUBFUN const xmlChar * XMLCALL - htmlGetMetaEncoding (htmlDocPtr doc); +htmlGetMetaEncoding (htmlDocPtr doc); XMLPUBFUN int XMLCALL - htmlSetMetaEncoding (htmlDocPtr doc, - const xmlChar *encoding); +htmlSetMetaEncoding (htmlDocPtr doc, + const xmlChar *encoding); #ifdef LIBXML_OUTPUT_ENABLED XMLPUBFUN void XMLCALL - htmlDocDumpMemory (xmlDocPtr cur, - xmlChar **mem, - int *size); +htmlDocDumpMemory (xmlDocPtr cur, + xmlChar **mem, + int *size); XMLPUBFUN void XMLCALL - htmlDocDumpMemoryFormat (xmlDocPtr cur, - xmlChar **mem, - int *size, - int format); +htmlDocDumpMemoryFormat (xmlDocPtr cur, + xmlChar **mem, + int *size, + int format); XMLPUBFUN int XMLCALL - htmlDocDump (FILE *f, - xmlDocPtr cur); +htmlDocDump (FILE *f, + xmlDocPtr cur); XMLPUBFUN int XMLCALL - htmlSaveFile (const char *filename, - xmlDocPtr cur); +htmlSaveFile (const char *filename, + xmlDocPtr cur); XMLPUBFUN int XMLCALL - htmlNodeDump (xmlBufferPtr buf, - xmlDocPtr doc, - xmlNodePtr cur); +htmlNodeDump (xmlBufferPtr buf, + xmlDocPtr doc, + xmlNodePtr cur); XMLPUBFUN void XMLCALL - htmlNodeDumpFile (FILE *out, - xmlDocPtr doc, - xmlNodePtr cur); +htmlNodeDumpFile (FILE *out, + xmlDocPtr doc, + xmlNodePtr cur); XMLPUBFUN int XMLCALL - htmlNodeDumpFileFormat (FILE *out, - xmlDocPtr doc, - xmlNodePtr cur, - const char *encoding, - int format); +htmlNodeDumpFileFormat (FILE *out, + xmlDocPtr doc, + xmlNodePtr cur, + const char *encoding, + int format); XMLPUBFUN int XMLCALL - htmlSaveFileEnc (const char *filename, - xmlDocPtr cur, - const char *encoding); +htmlSaveFileEnc (const char *filename, + xmlDocPtr cur, + const char *encoding); XMLPUBFUN int XMLCALL - htmlSaveFileFormat (const char *filename, - xmlDocPtr cur, - const char *encoding, - int format); +htmlSaveFileFormat (const char *filename, + xmlDocPtr cur, + const char *encoding, + int format); XMLPUBFUN void XMLCALL - htmlNodeDumpFormatOutput(xmlOutputBufferPtr buf, - xmlDocPtr doc, - xmlNodePtr cur, - const char *encoding, - int format); +htmlNodeDumpFormatOutput(xmlOutputBufferPtr buf, + xmlDocPtr doc, + xmlNodePtr cur, + const char *encoding, + int format); XMLPUBFUN void XMLCALL - htmlDocContentDumpOutput(xmlOutputBufferPtr buf, - xmlDocPtr cur, - const char *encoding); +htmlDocContentDumpOutput(xmlOutputBufferPtr buf, + xmlDocPtr cur, + const char *encoding); XMLPUBFUN void XMLCALL - htmlDocContentDumpFormatOutput(xmlOutputBufferPtr buf, - xmlDocPtr cur, - const char *encoding, - int format); +htmlDocContentDumpFormatOutput(xmlOutputBufferPtr buf, + xmlDocPtr cur, + const char *encoding, + int format); XMLPUBFUN void XMLCALL - htmlNodeDumpOutput (xmlOutputBufferPtr buf, - xmlDocPtr doc, - xmlNodePtr cur, - const char *encoding); +htmlNodeDumpOutput (xmlOutputBufferPtr buf, + xmlDocPtr doc, + xmlNodePtr cur, + const char *encoding); #endif /* LIBXML_OUTPUT_ENABLED */ XMLPUBFUN int XMLCALL - htmlIsBooleanAttr (const xmlChar *name); +htmlIsBooleanAttr (const xmlChar *name); #ifdef __cplusplus diff --git a/thirdparties/common/include/libxml2/libxml/SAX.h b/thirdparties/common/include/libxml2/libxml/SAX.h index 20093ce..e113753 100755 --- a/thirdparties/common/include/libxml2/libxml/SAX.h +++ b/thirdparties/common/include/libxml2/libxml/SAX.h @@ -24,143 +24,143 @@ extern "C" { #endif XMLPUBFUN const xmlChar * XMLCALL - getPublicId (void *ctx); +getPublicId (void *ctx); XMLPUBFUN const xmlChar * XMLCALL - getSystemId (void *ctx); +getSystemId (void *ctx); XMLPUBFUN void XMLCALL - setDocumentLocator (void *ctx, - xmlSAXLocatorPtr loc); +setDocumentLocator (void *ctx, + xmlSAXLocatorPtr loc); XMLPUBFUN int XMLCALL - getLineNumber (void *ctx); +getLineNumber (void *ctx); XMLPUBFUN int XMLCALL - getColumnNumber (void *ctx); +getColumnNumber (void *ctx); XMLPUBFUN int XMLCALL - isStandalone (void *ctx); +isStandalone (void *ctx); XMLPUBFUN int XMLCALL - hasInternalSubset (void *ctx); +hasInternalSubset (void *ctx); XMLPUBFUN int XMLCALL - hasExternalSubset (void *ctx); +hasExternalSubset (void *ctx); XMLPUBFUN void XMLCALL - internalSubset (void *ctx, - const xmlChar *name, - const xmlChar *ExternalID, - const xmlChar *SystemID); +internalSubset (void *ctx, + const xmlChar *name, + const xmlChar *ExternalID, + const xmlChar *SystemID); XMLPUBFUN void XMLCALL - externalSubset (void *ctx, - const xmlChar *name, - const xmlChar *ExternalID, - const xmlChar *SystemID); +externalSubset (void *ctx, + const xmlChar *name, + const xmlChar *ExternalID, + const xmlChar *SystemID); XMLPUBFUN xmlEntityPtr XMLCALL - getEntity (void *ctx, - const xmlChar *name); +getEntity (void *ctx, + const xmlChar *name); XMLPUBFUN xmlEntityPtr XMLCALL - getParameterEntity (void *ctx, - const xmlChar *name); +getParameterEntity (void *ctx, + const xmlChar *name); XMLPUBFUN xmlParserInputPtr XMLCALL - resolveEntity (void *ctx, - const xmlChar *publicId, - const xmlChar *systemId); +resolveEntity (void *ctx, + const xmlChar *publicId, + const xmlChar *systemId); XMLPUBFUN void XMLCALL - entityDecl (void *ctx, - const xmlChar *name, - int type, - const xmlChar *publicId, - const xmlChar *systemId, - xmlChar *content); -XMLPUBFUN void XMLCALL - attributeDecl (void *ctx, - const xmlChar *elem, - const xmlChar *fullname, - int type, - int def, - const xmlChar *defaultValue, - xmlEnumerationPtr tree); -XMLPUBFUN void XMLCALL - elementDecl (void *ctx, - const xmlChar *name, - int type, - xmlElementContentPtr content); -XMLPUBFUN void XMLCALL - notationDecl (void *ctx, - const xmlChar *name, - const xmlChar *publicId, - const xmlChar *systemId); -XMLPUBFUN void XMLCALL - unparsedEntityDecl (void *ctx, - const xmlChar *name, - const xmlChar *publicId, - const xmlChar *systemId, - const xmlChar *notationName); +entityDecl (void *ctx, + const xmlChar *name, + int type, + const xmlChar *publicId, + const xmlChar *systemId, + xmlChar *content); +XMLPUBFUN void XMLCALL +attributeDecl (void *ctx, + const xmlChar *elem, + const xmlChar *fullname, + int type, + int def, + const xmlChar *defaultValue, + xmlEnumerationPtr tree); +XMLPUBFUN void XMLCALL +elementDecl (void *ctx, + const xmlChar *name, + int type, + xmlElementContentPtr content); +XMLPUBFUN void XMLCALL +notationDecl (void *ctx, + const xmlChar *name, + const xmlChar *publicId, + const xmlChar *systemId); +XMLPUBFUN void XMLCALL +unparsedEntityDecl (void *ctx, + const xmlChar *name, + const xmlChar *publicId, + const xmlChar *systemId, + const xmlChar *notationName); XMLPUBFUN void XMLCALL - startDocument (void *ctx); +startDocument (void *ctx); XMLPUBFUN void XMLCALL - endDocument (void *ctx); +endDocument (void *ctx); XMLPUBFUN void XMLCALL - attribute (void *ctx, - const xmlChar *fullname, - const xmlChar *value); +attribute (void *ctx, + const xmlChar *fullname, + const xmlChar *value); XMLPUBFUN void XMLCALL - startElement (void *ctx, - const xmlChar *fullname, - const xmlChar **atts); +startElement (void *ctx, + const xmlChar *fullname, + const xmlChar **atts); XMLPUBFUN void XMLCALL - endElement (void *ctx, - const xmlChar *name); +endElement (void *ctx, + const xmlChar *name); XMLPUBFUN void XMLCALL - reference (void *ctx, - const xmlChar *name); +reference (void *ctx, + const xmlChar *name); XMLPUBFUN void XMLCALL - characters (void *ctx, - const xmlChar *ch, - int len); +characters (void *ctx, + const xmlChar *ch, + int len); XMLPUBFUN void XMLCALL - ignorableWhitespace (void *ctx, - const xmlChar *ch, - int len); +ignorableWhitespace (void *ctx, + const xmlChar *ch, + int len); XMLPUBFUN void XMLCALL - processingInstruction (void *ctx, - const xmlChar *target, - const xmlChar *data); +processingInstruction (void *ctx, + const xmlChar *target, + const xmlChar *data); XMLPUBFUN void XMLCALL - globalNamespace (void *ctx, - const xmlChar *href, - const xmlChar *prefix); +globalNamespace (void *ctx, + const xmlChar *href, + const xmlChar *prefix); XMLPUBFUN void XMLCALL - setNamespace (void *ctx, - const xmlChar *name); +setNamespace (void *ctx, + const xmlChar *name); XMLPUBFUN xmlNsPtr XMLCALL - getNamespace (void *ctx); +getNamespace (void *ctx); XMLPUBFUN int XMLCALL - checkNamespace (void *ctx, - xmlChar *nameSpace); +checkNamespace (void *ctx, + xmlChar *nameSpace); XMLPUBFUN void XMLCALL - namespaceDecl (void *ctx, - const xmlChar *href, - const xmlChar *prefix); +namespaceDecl (void *ctx, + const xmlChar *href, + const xmlChar *prefix); XMLPUBFUN void XMLCALL - comment (void *ctx, - const xmlChar *value); +comment (void *ctx, + const xmlChar *value); XMLPUBFUN void XMLCALL - cdataBlock (void *ctx, - const xmlChar *value, - int len); +cdataBlock (void *ctx, + const xmlChar *value, + int len); #ifdef LIBXML_SAX1_ENABLED XMLPUBFUN void XMLCALL - initxmlDefaultSAXHandler (xmlSAXHandlerV1 *hdlr, - int warning); +initxmlDefaultSAXHandler (xmlSAXHandlerV1 *hdlr, + int warning); #ifdef LIBXML_HTML_ENABLED XMLPUBFUN void XMLCALL - inithtmlDefaultSAXHandler (xmlSAXHandlerV1 *hdlr); +inithtmlDefaultSAXHandler (xmlSAXHandlerV1 *hdlr); #endif #ifdef LIBXML_DOCB_ENABLED XMLPUBFUN void XMLCALL - initdocbDefaultSAXHandler (xmlSAXHandlerV1 *hdlr); +initdocbDefaultSAXHandler (xmlSAXHandlerV1 *hdlr); #endif #endif /* LIBXML_SAX1_ENABLED */ diff --git a/thirdparties/common/include/libxml2/libxml/SAX2.h b/thirdparties/common/include/libxml2/libxml/SAX2.h index daafd17..722f0f9 100755 --- a/thirdparties/common/include/libxml2/libxml/SAX2.h +++ b/thirdparties/common/include/libxml2/libxml/SAX2.h @@ -22,154 +22,154 @@ extern "C" { #endif XMLPUBFUN const xmlChar * XMLCALL - xmlSAX2GetPublicId (void *ctx); +xmlSAX2GetPublicId (void *ctx); XMLPUBFUN const xmlChar * XMLCALL - xmlSAX2GetSystemId (void *ctx); +xmlSAX2GetSystemId (void *ctx); XMLPUBFUN void XMLCALL - xmlSAX2SetDocumentLocator (void *ctx, - xmlSAXLocatorPtr loc); +xmlSAX2SetDocumentLocator (void *ctx, + xmlSAXLocatorPtr loc); XMLPUBFUN int XMLCALL - xmlSAX2GetLineNumber (void *ctx); +xmlSAX2GetLineNumber (void *ctx); XMLPUBFUN int XMLCALL - xmlSAX2GetColumnNumber (void *ctx); +xmlSAX2GetColumnNumber (void *ctx); XMLPUBFUN int XMLCALL - xmlSAX2IsStandalone (void *ctx); +xmlSAX2IsStandalone (void *ctx); XMLPUBFUN int XMLCALL - xmlSAX2HasInternalSubset (void *ctx); +xmlSAX2HasInternalSubset (void *ctx); XMLPUBFUN int XMLCALL - xmlSAX2HasExternalSubset (void *ctx); +xmlSAX2HasExternalSubset (void *ctx); XMLPUBFUN void XMLCALL - xmlSAX2InternalSubset (void *ctx, - const xmlChar *name, - const xmlChar *ExternalID, - const xmlChar *SystemID); +xmlSAX2InternalSubset (void *ctx, + const xmlChar *name, + const xmlChar *ExternalID, + const xmlChar *SystemID); XMLPUBFUN void XMLCALL - xmlSAX2ExternalSubset (void *ctx, - const xmlChar *name, - const xmlChar *ExternalID, - const xmlChar *SystemID); +xmlSAX2ExternalSubset (void *ctx, + const xmlChar *name, + const xmlChar *ExternalID, + const xmlChar *SystemID); XMLPUBFUN xmlEntityPtr XMLCALL - xmlSAX2GetEntity (void *ctx, - const xmlChar *name); +xmlSAX2GetEntity (void *ctx, + const xmlChar *name); XMLPUBFUN xmlEntityPtr XMLCALL - xmlSAX2GetParameterEntity (void *ctx, - const xmlChar *name); +xmlSAX2GetParameterEntity (void *ctx, + const xmlChar *name); XMLPUBFUN xmlParserInputPtr XMLCALL - xmlSAX2ResolveEntity (void *ctx, - const xmlChar *publicId, - const xmlChar *systemId); +xmlSAX2ResolveEntity (void *ctx, + const xmlChar *publicId, + const xmlChar *systemId); XMLPUBFUN void XMLCALL - xmlSAX2EntityDecl (void *ctx, - const xmlChar *name, - int type, - const xmlChar *publicId, - const xmlChar *systemId, - xmlChar *content); -XMLPUBFUN void XMLCALL - xmlSAX2AttributeDecl (void *ctx, - const xmlChar *elem, - const xmlChar *fullname, - int type, - int def, - const xmlChar *defaultValue, - xmlEnumerationPtr tree); -XMLPUBFUN void XMLCALL - xmlSAX2ElementDecl (void *ctx, - const xmlChar *name, - int type, - xmlElementContentPtr content); -XMLPUBFUN void XMLCALL - xmlSAX2NotationDecl (void *ctx, - const xmlChar *name, - const xmlChar *publicId, - const xmlChar *systemId); -XMLPUBFUN void XMLCALL - xmlSAX2UnparsedEntityDecl (void *ctx, - const xmlChar *name, - const xmlChar *publicId, - const xmlChar *systemId, - const xmlChar *notationName); +xmlSAX2EntityDecl (void *ctx, + const xmlChar *name, + int type, + const xmlChar *publicId, + const xmlChar *systemId, + xmlChar *content); +XMLPUBFUN void XMLCALL +xmlSAX2AttributeDecl (void *ctx, + const xmlChar *elem, + const xmlChar *fullname, + int type, + int def, + const xmlChar *defaultValue, + xmlEnumerationPtr tree); +XMLPUBFUN void XMLCALL +xmlSAX2ElementDecl (void *ctx, + const xmlChar *name, + int type, + xmlElementContentPtr content); +XMLPUBFUN void XMLCALL +xmlSAX2NotationDecl (void *ctx, + const xmlChar *name, + const xmlChar *publicId, + const xmlChar *systemId); +XMLPUBFUN void XMLCALL +xmlSAX2UnparsedEntityDecl (void *ctx, + const xmlChar *name, + const xmlChar *publicId, + const xmlChar *systemId, + const xmlChar *notationName); XMLPUBFUN void XMLCALL - xmlSAX2StartDocument (void *ctx); +xmlSAX2StartDocument (void *ctx); XMLPUBFUN void XMLCALL - xmlSAX2EndDocument (void *ctx); +xmlSAX2EndDocument (void *ctx); #if defined(LIBXML_SAX1_ENABLED) || defined(LIBXML_HTML_ENABLED) || defined(LIBXML_WRITER_ENABLED) || defined(LIBXML_DOCB_ENABLED) XMLPUBFUN void XMLCALL - xmlSAX2StartElement (void *ctx, - const xmlChar *fullname, - const xmlChar **atts); +xmlSAX2StartElement (void *ctx, + const xmlChar *fullname, + const xmlChar **atts); XMLPUBFUN void XMLCALL - xmlSAX2EndElement (void *ctx, - const xmlChar *name); +xmlSAX2EndElement (void *ctx, + const xmlChar *name); #endif /* LIBXML_SAX1_ENABLED or LIBXML_HTML_ENABLED */ XMLPUBFUN void XMLCALL - xmlSAX2StartElementNs (void *ctx, - const xmlChar *localname, - const xmlChar *prefix, - const xmlChar *URI, - int nb_namespaces, - const xmlChar **namespaces, - int nb_attributes, - int nb_defaulted, - const xmlChar **attributes); -XMLPUBFUN void XMLCALL - xmlSAX2EndElementNs (void *ctx, - const xmlChar *localname, - const xmlChar *prefix, - const xmlChar *URI); -XMLPUBFUN void XMLCALL - xmlSAX2Reference (void *ctx, - const xmlChar *name); -XMLPUBFUN void XMLCALL - xmlSAX2Characters (void *ctx, - const xmlChar *ch, - int len); -XMLPUBFUN void XMLCALL - xmlSAX2IgnorableWhitespace (void *ctx, - const xmlChar *ch, - int len); -XMLPUBFUN void XMLCALL - xmlSAX2ProcessingInstruction (void *ctx, - const xmlChar *target, - const xmlChar *data); -XMLPUBFUN void XMLCALL - xmlSAX2Comment (void *ctx, - const xmlChar *value); -XMLPUBFUN void XMLCALL - xmlSAX2CDataBlock (void *ctx, - const xmlChar *value, - int len); +xmlSAX2StartElementNs (void *ctx, + const xmlChar *localname, + const xmlChar *prefix, + const xmlChar *URI, + int nb_namespaces, + const xmlChar **namespaces, + int nb_attributes, + int nb_defaulted, + const xmlChar **attributes); +XMLPUBFUN void XMLCALL +xmlSAX2EndElementNs (void *ctx, + const xmlChar *localname, + const xmlChar *prefix, + const xmlChar *URI); +XMLPUBFUN void XMLCALL +xmlSAX2Reference (void *ctx, + const xmlChar *name); +XMLPUBFUN void XMLCALL +xmlSAX2Characters (void *ctx, + const xmlChar *ch, + int len); +XMLPUBFUN void XMLCALL +xmlSAX2IgnorableWhitespace (void *ctx, + const xmlChar *ch, + int len); +XMLPUBFUN void XMLCALL +xmlSAX2ProcessingInstruction (void *ctx, + const xmlChar *target, + const xmlChar *data); +XMLPUBFUN void XMLCALL +xmlSAX2Comment (void *ctx, + const xmlChar *value); +XMLPUBFUN void XMLCALL +xmlSAX2CDataBlock (void *ctx, + const xmlChar *value, + int len); #ifdef LIBXML_SAX1_ENABLED XMLPUBFUN int XMLCALL - xmlSAXDefaultVersion (int version); +xmlSAXDefaultVersion (int version); #endif /* LIBXML_SAX1_ENABLED */ XMLPUBFUN int XMLCALL - xmlSAXVersion (xmlSAXHandler *hdlr, - int version); +xmlSAXVersion (xmlSAXHandler *hdlr, + int version); XMLPUBFUN void XMLCALL - xmlSAX2InitDefaultSAXHandler (xmlSAXHandler *hdlr, - int warning); +xmlSAX2InitDefaultSAXHandler (xmlSAXHandler *hdlr, + int warning); #ifdef LIBXML_HTML_ENABLED XMLPUBFUN void XMLCALL - xmlSAX2InitHtmlDefaultSAXHandler(xmlSAXHandler *hdlr); +xmlSAX2InitHtmlDefaultSAXHandler(xmlSAXHandler *hdlr); XMLPUBFUN void XMLCALL - htmlDefaultSAXHandlerInit (void); +htmlDefaultSAXHandlerInit (void); #endif #ifdef LIBXML_DOCB_ENABLED XMLPUBFUN void XMLCALL - xmlSAX2InitDocbDefaultSAXHandler(xmlSAXHandler *hdlr); +xmlSAX2InitDocbDefaultSAXHandler(xmlSAXHandler *hdlr); XMLPUBFUN void XMLCALL - docbDefaultSAXHandlerInit (void); +docbDefaultSAXHandlerInit (void); #endif XMLPUBFUN void XMLCALL - xmlDefaultSAXHandlerInit (void); +xmlDefaultSAXHandlerInit (void); #ifdef __cplusplus } #endif diff --git a/thirdparties/common/include/libxml2/libxml/c14n.h b/thirdparties/common/include/libxml2/libxml/c14n.h index b8971d9..ed14c94 100755 --- a/thirdparties/common/include/libxml2/libxml/c14n.h +++ b/thirdparties/common/include/libxml2/libxml/c14n.h @@ -62,32 +62,33 @@ typedef enum { XML_C14N_1_0 = 0, /* Origianal C14N 1.0 spec */ XML_C14N_EXCLUSIVE_1_0 = 1, /* Exclusive C14N 1.0 spec */ XML_C14N_1_1 = 2 /* C14N 1.1 spec */ -} xmlC14NMode; +} +xmlC14NMode; XMLPUBFUN int XMLCALL - xmlC14NDocSaveTo (xmlDocPtr doc, - xmlNodeSetPtr nodes, - int mode, /* a xmlC14NMode */ - xmlChar **inclusive_ns_prefixes, - int with_comments, - xmlOutputBufferPtr buf); +xmlC14NDocSaveTo (xmlDocPtr doc, + xmlNodeSetPtr nodes, + int mode, /* a xmlC14NMode */ + xmlChar **inclusive_ns_prefixes, + int with_comments, + xmlOutputBufferPtr buf); XMLPUBFUN int XMLCALL - xmlC14NDocDumpMemory (xmlDocPtr doc, - xmlNodeSetPtr nodes, - int mode, /* a xmlC14NMode */ - xmlChar **inclusive_ns_prefixes, - int with_comments, - xmlChar **doc_txt_ptr); +xmlC14NDocDumpMemory (xmlDocPtr doc, + xmlNodeSetPtr nodes, + int mode, /* a xmlC14NMode */ + xmlChar **inclusive_ns_prefixes, + int with_comments, + xmlChar **doc_txt_ptr); XMLPUBFUN int XMLCALL - xmlC14NDocSave (xmlDocPtr doc, - xmlNodeSetPtr nodes, - int mode, /* a xmlC14NMode */ - xmlChar **inclusive_ns_prefixes, - int with_comments, - const char* filename, - int compression); +xmlC14NDocSave (xmlDocPtr doc, + xmlNodeSetPtr nodes, + int mode, /* a xmlC14NMode */ + xmlChar **inclusive_ns_prefixes, + int with_comments, + const char* filename, + int compression); /** @@ -104,17 +105,17 @@ XMLPUBFUN int XMLCALL * Returns 1 if the node should be included */ typedef int (*xmlC14NIsVisibleCallback) (void* user_data, - xmlNodePtr node, - xmlNodePtr parent); + xmlNodePtr node, + xmlNodePtr parent); XMLPUBFUN int XMLCALL - xmlC14NExecute (xmlDocPtr doc, - xmlC14NIsVisibleCallback is_visible_callback, - void* user_data, - int mode, /* a xmlC14NMode */ - xmlChar **inclusive_ns_prefixes, - int with_comments, - xmlOutputBufferPtr buf); +xmlC14NExecute (xmlDocPtr doc, + xmlC14NIsVisibleCallback is_visible_callback, + void* user_data, + int mode, /* a xmlC14NMode */ + xmlChar **inclusive_ns_prefixes, + int with_comments, + xmlOutputBufferPtr buf); #ifdef __cplusplus } diff --git a/thirdparties/common/include/libxml2/libxml/catalog.h b/thirdparties/common/include/libxml2/libxml/catalog.h index 5a13f51..e3fa031 100755 --- a/thirdparties/common/include/libxml2/libxml/catalog.h +++ b/thirdparties/common/include/libxml2/libxml/catalog.h @@ -51,7 +51,8 @@ typedef enum { XML_CATA_PREFER_NONE = 0, XML_CATA_PREFER_PUBLIC = 1, XML_CATA_PREFER_SYSTEM -} xmlCatalogPrefer; +} +xmlCatalogPrefer; typedef enum { XML_CATA_ALLOW_NONE = 0, @@ -67,113 +68,113 @@ typedef xmlCatalog *xmlCatalogPtr; * Operations on a given catalog. */ XMLPUBFUN xmlCatalogPtr XMLCALL - xmlNewCatalog (int sgml); +xmlNewCatalog (int sgml); XMLPUBFUN xmlCatalogPtr XMLCALL - xmlLoadACatalog (const char *filename); +xmlLoadACatalog (const char *filename); XMLPUBFUN xmlCatalogPtr XMLCALL - xmlLoadSGMLSuperCatalog (const char *filename); +xmlLoadSGMLSuperCatalog (const char *filename); XMLPUBFUN int XMLCALL - xmlConvertSGMLCatalog (xmlCatalogPtr catal); +xmlConvertSGMLCatalog (xmlCatalogPtr catal); XMLPUBFUN int XMLCALL - xmlACatalogAdd (xmlCatalogPtr catal, - const xmlChar *type, - const xmlChar *orig, - const xmlChar *replace); +xmlACatalogAdd (xmlCatalogPtr catal, + const xmlChar *type, + const xmlChar *orig, + const xmlChar *replace); XMLPUBFUN int XMLCALL - xmlACatalogRemove (xmlCatalogPtr catal, - const xmlChar *value); +xmlACatalogRemove (xmlCatalogPtr catal, + const xmlChar *value); XMLPUBFUN xmlChar * XMLCALL - xmlACatalogResolve (xmlCatalogPtr catal, - const xmlChar *pubID, - const xmlChar *sysID); +xmlACatalogResolve (xmlCatalogPtr catal, + const xmlChar *pubID, + const xmlChar *sysID); XMLPUBFUN xmlChar * XMLCALL - xmlACatalogResolveSystem(xmlCatalogPtr catal, - const xmlChar *sysID); +xmlACatalogResolveSystem(xmlCatalogPtr catal, + const xmlChar *sysID); XMLPUBFUN xmlChar * XMLCALL - xmlACatalogResolvePublic(xmlCatalogPtr catal, - const xmlChar *pubID); +xmlACatalogResolvePublic(xmlCatalogPtr catal, + const xmlChar *pubID); XMLPUBFUN xmlChar * XMLCALL - xmlACatalogResolveURI (xmlCatalogPtr catal, - const xmlChar *URI); +xmlACatalogResolveURI (xmlCatalogPtr catal, + const xmlChar *URI); #ifdef LIBXML_OUTPUT_ENABLED XMLPUBFUN void XMLCALL - xmlACatalogDump (xmlCatalogPtr catal, - FILE *out); +xmlACatalogDump (xmlCatalogPtr catal, + FILE *out); #endif /* LIBXML_OUTPUT_ENABLED */ XMLPUBFUN void XMLCALL - xmlFreeCatalog (xmlCatalogPtr catal); +xmlFreeCatalog (xmlCatalogPtr catal); XMLPUBFUN int XMLCALL - xmlCatalogIsEmpty (xmlCatalogPtr catal); +xmlCatalogIsEmpty (xmlCatalogPtr catal); /* * Global operations. */ XMLPUBFUN void XMLCALL - xmlInitializeCatalog (void); +xmlInitializeCatalog (void); XMLPUBFUN int XMLCALL - xmlLoadCatalog (const char *filename); +xmlLoadCatalog (const char *filename); XMLPUBFUN void XMLCALL - xmlLoadCatalogs (const char *paths); +xmlLoadCatalogs (const char *paths); XMLPUBFUN void XMLCALL - xmlCatalogCleanup (void); +xmlCatalogCleanup (void); #ifdef LIBXML_OUTPUT_ENABLED XMLPUBFUN void XMLCALL - xmlCatalogDump (FILE *out); +xmlCatalogDump (FILE *out); #endif /* LIBXML_OUTPUT_ENABLED */ XMLPUBFUN xmlChar * XMLCALL - xmlCatalogResolve (const xmlChar *pubID, - const xmlChar *sysID); +xmlCatalogResolve (const xmlChar *pubID, + const xmlChar *sysID); XMLPUBFUN xmlChar * XMLCALL - xmlCatalogResolveSystem (const xmlChar *sysID); +xmlCatalogResolveSystem (const xmlChar *sysID); XMLPUBFUN xmlChar * XMLCALL - xmlCatalogResolvePublic (const xmlChar *pubID); +xmlCatalogResolvePublic (const xmlChar *pubID); XMLPUBFUN xmlChar * XMLCALL - xmlCatalogResolveURI (const xmlChar *URI); +xmlCatalogResolveURI (const xmlChar *URI); XMLPUBFUN int XMLCALL - xmlCatalogAdd (const xmlChar *type, - const xmlChar *orig, - const xmlChar *replace); +xmlCatalogAdd (const xmlChar *type, + const xmlChar *orig, + const xmlChar *replace); XMLPUBFUN int XMLCALL - xmlCatalogRemove (const xmlChar *value); +xmlCatalogRemove (const xmlChar *value); XMLPUBFUN xmlDocPtr XMLCALL - xmlParseCatalogFile (const char *filename); +xmlParseCatalogFile (const char *filename); XMLPUBFUN int XMLCALL - xmlCatalogConvert (void); +xmlCatalogConvert (void); /* * Strictly minimal interfaces for per-document catalogs used * by the parser. */ XMLPUBFUN void XMLCALL - xmlCatalogFreeLocal (void *catalogs); +xmlCatalogFreeLocal (void *catalogs); XMLPUBFUN void * XMLCALL - xmlCatalogAddLocal (void *catalogs, - const xmlChar *URL); +xmlCatalogAddLocal (void *catalogs, + const xmlChar *URL); XMLPUBFUN xmlChar * XMLCALL - xmlCatalogLocalResolve (void *catalogs, - const xmlChar *pubID, - const xmlChar *sysID); +xmlCatalogLocalResolve (void *catalogs, + const xmlChar *pubID, + const xmlChar *sysID); XMLPUBFUN xmlChar * XMLCALL - xmlCatalogLocalResolveURI(void *catalogs, - const xmlChar *URI); +xmlCatalogLocalResolveURI(void *catalogs, + const xmlChar *URI); /* * Preference settings. */ XMLPUBFUN int XMLCALL - xmlCatalogSetDebug (int level); +xmlCatalogSetDebug (int level); XMLPUBFUN xmlCatalogPrefer XMLCALL - xmlCatalogSetDefaultPrefer(xmlCatalogPrefer prefer); +xmlCatalogSetDefaultPrefer(xmlCatalogPrefer prefer); XMLPUBFUN void XMLCALL - xmlCatalogSetDefaults (xmlCatalogAllow allow); +xmlCatalogSetDefaults (xmlCatalogAllow allow); XMLPUBFUN xmlCatalogAllow XMLCALL - xmlCatalogGetDefaults (void); +xmlCatalogGetDefaults (void); /* DEPRECATED interfaces */ XMLPUBFUN const xmlChar * XMLCALL - xmlCatalogGetSystem (const xmlChar *sysID); +xmlCatalogGetSystem (const xmlChar *sysID); XMLPUBFUN const xmlChar * XMLCALL - xmlCatalogGetPublic (const xmlChar *pubID); +xmlCatalogGetPublic (const xmlChar *pubID); #ifdef __cplusplus } diff --git a/thirdparties/common/include/libxml2/libxml/chvalid.h b/thirdparties/common/include/libxml2/libxml/chvalid.h index fb43016..d650b0b 100755 --- a/thirdparties/common/include/libxml2/libxml/chvalid.h +++ b/thirdparties/common/include/libxml2/libxml/chvalid.h @@ -52,7 +52,7 @@ struct _xmlChRangeGroup { * Range checking routine */ XMLPUBFUN int XMLCALL - xmlCharInRange(unsigned int val, const xmlChRangeGroup *group); +xmlCharInRange(unsigned int val, const xmlChRangeGroup *group); /** @@ -208,21 +208,21 @@ XMLPUBVAR const unsigned char xmlIsPubidChar_tab[256]; xmlIsPubidChar_ch((c)) : 0) XMLPUBFUN int XMLCALL - xmlIsBaseChar(unsigned int ch); +xmlIsBaseChar(unsigned int ch); XMLPUBFUN int XMLCALL - xmlIsBlank(unsigned int ch); +xmlIsBlank(unsigned int ch); XMLPUBFUN int XMLCALL - xmlIsChar(unsigned int ch); +xmlIsChar(unsigned int ch); XMLPUBFUN int XMLCALL - xmlIsCombining(unsigned int ch); +xmlIsCombining(unsigned int ch); XMLPUBFUN int XMLCALL - xmlIsDigit(unsigned int ch); +xmlIsDigit(unsigned int ch); XMLPUBFUN int XMLCALL - xmlIsExtender(unsigned int ch); +xmlIsExtender(unsigned int ch); XMLPUBFUN int XMLCALL - xmlIsIdeographic(unsigned int ch); +xmlIsIdeographic(unsigned int ch); XMLPUBFUN int XMLCALL - xmlIsPubidChar(unsigned int ch); +xmlIsPubidChar(unsigned int ch); #ifdef __cplusplus } diff --git a/thirdparties/common/include/libxml2/libxml/debugXML.h b/thirdparties/common/include/libxml2/libxml/debugXML.h index 5b3be13..4de83a8 100755 --- a/thirdparties/common/include/libxml2/libxml/debugXML.h +++ b/thirdparties/common/include/libxml2/libxml/debugXML.h @@ -26,40 +26,40 @@ extern "C" { * The standard Dump routines. */ XMLPUBFUN void XMLCALL - xmlDebugDumpString (FILE *output, - const xmlChar *str); +xmlDebugDumpString (FILE *output, + const xmlChar *str); XMLPUBFUN void XMLCALL - xmlDebugDumpAttr (FILE *output, - xmlAttrPtr attr, - int depth); +xmlDebugDumpAttr (FILE *output, + xmlAttrPtr attr, + int depth); XMLPUBFUN void XMLCALL - xmlDebugDumpAttrList (FILE *output, - xmlAttrPtr attr, - int depth); +xmlDebugDumpAttrList (FILE *output, + xmlAttrPtr attr, + int depth); XMLPUBFUN void XMLCALL - xmlDebugDumpOneNode (FILE *output, - xmlNodePtr node, - int depth); +xmlDebugDumpOneNode (FILE *output, + xmlNodePtr node, + int depth); XMLPUBFUN void XMLCALL - xmlDebugDumpNode (FILE *output, - xmlNodePtr node, - int depth); +xmlDebugDumpNode (FILE *output, + xmlNodePtr node, + int depth); XMLPUBFUN void XMLCALL - xmlDebugDumpNodeList (FILE *output, - xmlNodePtr node, - int depth); +xmlDebugDumpNodeList (FILE *output, + xmlNodePtr node, + int depth); XMLPUBFUN void XMLCALL - xmlDebugDumpDocumentHead(FILE *output, - xmlDocPtr doc); +xmlDebugDumpDocumentHead(FILE *output, + xmlDocPtr doc); XMLPUBFUN void XMLCALL - xmlDebugDumpDocument (FILE *output, - xmlDocPtr doc); +xmlDebugDumpDocument (FILE *output, + xmlDocPtr doc); XMLPUBFUN void XMLCALL - xmlDebugDumpDTD (FILE *output, - xmlDtdPtr dtd); +xmlDebugDumpDTD (FILE *output, + xmlDtdPtr dtd); XMLPUBFUN void XMLCALL - xmlDebugDumpEntities (FILE *output, - xmlDocPtr doc); +xmlDebugDumpEntities (FILE *output, + xmlDocPtr doc); /**************************************************************** * * @@ -68,8 +68,8 @@ XMLPUBFUN void XMLCALL ****************************************************************/ XMLPUBFUN int XMLCALL - xmlDebugCheckDocument (FILE * output, - xmlDocPtr doc); +xmlDebugCheckDocument (FILE * output, + xmlDocPtr doc); /**************************************************************** * * @@ -78,12 +78,12 @@ XMLPUBFUN int XMLCALL ****************************************************************/ XMLPUBFUN void XMLCALL - xmlLsOneNode (FILE *output, xmlNodePtr node); +xmlLsOneNode (FILE *output, xmlNodePtr node); XMLPUBFUN int XMLCALL - xmlLsCountNode (xmlNodePtr node); +xmlLsCountNode (xmlNodePtr node); XMLPUBFUN const char * XMLCALL - xmlBoolToText (int boolval); +xmlBoolToText (int boolval); /**************************************************************** * * @@ -133,79 +133,79 @@ struct _xmlShellCtxt { */ typedef int (* xmlShellCmd) (xmlShellCtxtPtr ctxt, char *arg, - xmlNodePtr node, - xmlNodePtr node2); + xmlNodePtr node, + xmlNodePtr node2); XMLPUBFUN void XMLCALL - xmlShellPrintXPathError (int errorType, - const char *arg); +xmlShellPrintXPathError (int errorType, + const char *arg); XMLPUBFUN void XMLCALL - xmlShellPrintXPathResult(xmlXPathObjectPtr list); +xmlShellPrintXPathResult(xmlXPathObjectPtr list); XMLPUBFUN int XMLCALL - xmlShellList (xmlShellCtxtPtr ctxt, - char *arg, - xmlNodePtr node, - xmlNodePtr node2); +xmlShellList (xmlShellCtxtPtr ctxt, + char *arg, + xmlNodePtr node, + xmlNodePtr node2); XMLPUBFUN int XMLCALL - xmlShellBase (xmlShellCtxtPtr ctxt, - char *arg, - xmlNodePtr node, - xmlNodePtr node2); +xmlShellBase (xmlShellCtxtPtr ctxt, + char *arg, + xmlNodePtr node, + xmlNodePtr node2); XMLPUBFUN int XMLCALL - xmlShellDir (xmlShellCtxtPtr ctxt, - char *arg, - xmlNodePtr node, - xmlNodePtr node2); +xmlShellDir (xmlShellCtxtPtr ctxt, + char *arg, + xmlNodePtr node, + xmlNodePtr node2); XMLPUBFUN int XMLCALL - xmlShellLoad (xmlShellCtxtPtr ctxt, - char *filename, - xmlNodePtr node, - xmlNodePtr node2); +xmlShellLoad (xmlShellCtxtPtr ctxt, + char *filename, + xmlNodePtr node, + xmlNodePtr node2); #ifdef LIBXML_OUTPUT_ENABLED XMLPUBFUN void XMLCALL - xmlShellPrintNode (xmlNodePtr node); +xmlShellPrintNode (xmlNodePtr node); XMLPUBFUN int XMLCALL - xmlShellCat (xmlShellCtxtPtr ctxt, - char *arg, - xmlNodePtr node, - xmlNodePtr node2); +xmlShellCat (xmlShellCtxtPtr ctxt, + char *arg, + xmlNodePtr node, + xmlNodePtr node2); XMLPUBFUN int XMLCALL - xmlShellWrite (xmlShellCtxtPtr ctxt, - char *filename, - xmlNodePtr node, - xmlNodePtr node2); +xmlShellWrite (xmlShellCtxtPtr ctxt, + char *filename, + xmlNodePtr node, + xmlNodePtr node2); XMLPUBFUN int XMLCALL - xmlShellSave (xmlShellCtxtPtr ctxt, - char *filename, - xmlNodePtr node, - xmlNodePtr node2); +xmlShellSave (xmlShellCtxtPtr ctxt, + char *filename, + xmlNodePtr node, + xmlNodePtr node2); #endif /* LIBXML_OUTPUT_ENABLED */ #ifdef LIBXML_VALID_ENABLED XMLPUBFUN int XMLCALL - xmlShellValidate (xmlShellCtxtPtr ctxt, - char *dtd, - xmlNodePtr node, - xmlNodePtr node2); +xmlShellValidate (xmlShellCtxtPtr ctxt, + char *dtd, + xmlNodePtr node, + xmlNodePtr node2); #endif /* LIBXML_VALID_ENABLED */ XMLPUBFUN int XMLCALL - xmlShellDu (xmlShellCtxtPtr ctxt, - char *arg, - xmlNodePtr tree, - xmlNodePtr node2); +xmlShellDu (xmlShellCtxtPtr ctxt, + char *arg, + xmlNodePtr tree, + xmlNodePtr node2); XMLPUBFUN int XMLCALL - xmlShellPwd (xmlShellCtxtPtr ctxt, - char *buffer, - xmlNodePtr node, - xmlNodePtr node2); +xmlShellPwd (xmlShellCtxtPtr ctxt, + char *buffer, + xmlNodePtr node, + xmlNodePtr node2); /* * The Shell interface. */ XMLPUBFUN void XMLCALL - xmlShell (xmlDocPtr doc, - char *filename, - xmlShellReadlineFunc input, - FILE *output); +xmlShell (xmlDocPtr doc, + char *filename, + xmlShellReadlineFunc input, + FILE *output); #endif /* LIBXML_XPATH_ENABLED */ diff --git a/thirdparties/common/include/libxml2/libxml/dict.h b/thirdparties/common/include/libxml2/libxml/dict.h index 7022ec8..354ec6f 100755 --- a/thirdparties/common/include/libxml2/libxml/dict.h +++ b/thirdparties/common/include/libxml2/libxml/dict.h @@ -34,45 +34,45 @@ XMLPUBFUN int XMLCALL xmlInitializeDict(void); * Constructor and destructor. */ XMLPUBFUN xmlDictPtr XMLCALL - xmlDictCreate (void); +xmlDictCreate (void); XMLPUBFUN size_t XMLCALL - xmlDictSetLimit (xmlDictPtr dict, - size_t limit); +xmlDictSetLimit (xmlDictPtr dict, + size_t limit); XMLPUBFUN size_t XMLCALL - xmlDictGetUsage (xmlDictPtr dict); +xmlDictGetUsage (xmlDictPtr dict); XMLPUBFUN xmlDictPtr XMLCALL - xmlDictCreateSub(xmlDictPtr sub); +xmlDictCreateSub(xmlDictPtr sub); XMLPUBFUN int XMLCALL - xmlDictReference(xmlDictPtr dict); +xmlDictReference(xmlDictPtr dict); XMLPUBFUN void XMLCALL - xmlDictFree (xmlDictPtr dict); +xmlDictFree (xmlDictPtr dict); /* * Lookup of entry in the dictionnary. */ XMLPUBFUN const xmlChar * XMLCALL - xmlDictLookup (xmlDictPtr dict, - const xmlChar *name, - int len); +xmlDictLookup (xmlDictPtr dict, + const xmlChar *name, + int len); XMLPUBFUN const xmlChar * XMLCALL - xmlDictExists (xmlDictPtr dict, - const xmlChar *name, - int len); +xmlDictExists (xmlDictPtr dict, + const xmlChar *name, + int len); XMLPUBFUN const xmlChar * XMLCALL - xmlDictQLookup (xmlDictPtr dict, - const xmlChar *prefix, - const xmlChar *name); +xmlDictQLookup (xmlDictPtr dict, + const xmlChar *prefix, + const xmlChar *name); XMLPUBFUN int XMLCALL - xmlDictOwns (xmlDictPtr dict, - const xmlChar *str); +xmlDictOwns (xmlDictPtr dict, + const xmlChar *str); XMLPUBFUN int XMLCALL - xmlDictSize (xmlDictPtr dict); +xmlDictSize (xmlDictPtr dict); /* * Cleanup function */ XMLPUBFUN void XMLCALL - xmlDictCleanup (void); +xmlDictCleanup (void); #ifdef __cplusplus } diff --git a/thirdparties/common/include/libxml2/libxml/encoding.h b/thirdparties/common/include/libxml2/libxml/encoding.h index 7967cc6..93b7f06 100755 --- a/thirdparties/common/include/libxml2/libxml/encoding.h +++ b/thirdparties/common/include/libxml2/libxml/encoding.h @@ -80,7 +80,8 @@ typedef enum { XML_CHAR_ENCODING_SHIFT_JIS=20,/* Shift_JIS */ XML_CHAR_ENCODING_EUC_JP= 21,/* EUC-JP */ XML_CHAR_ENCODING_ASCII= 22 /* pure ASCII */ -} xmlCharEncoding; +} +xmlCharEncoding; /** * xmlCharEncodingInputFunc: @@ -99,7 +100,7 @@ typedef enum { * The value of @outlen after return is the number of octets consumed. */ typedef int (* xmlCharEncodingInputFunc)(unsigned char *out, int *outlen, - const unsigned char *in, int *inlen); + const unsigned char *in, int *inlen); /** @@ -121,7 +122,7 @@ typedef int (* xmlCharEncodingInputFunc)(unsigned char *out, int *outlen, * The value of @outlen after return is the number of octets produced. */ typedef int (* xmlCharEncodingOutputFunc)(unsigned char *out, int *outlen, - const unsigned char *in, int *inlen); + const unsigned char *in, int *inlen); /* @@ -130,8 +131,8 @@ typedef int (* xmlCharEncodingOutputFunc)(unsigned char *out, int *outlen, */ #ifdef LIBXML_ICU_ENABLED struct _uconv_t { - UConverter *uconv; /* for conversion between an encoding and UTF-16 */ - UConverter *utf8; /* for conversion between UTF-8 and UTF-16 */ + UConverter *uconv; /* for conversion between an encoding and UTF-16 */ + UConverter *utf8; /* for conversion between UTF-8 and UTF-16 */ }; typedef struct _uconv_t uconv_t; #endif @@ -164,75 +165,75 @@ extern "C" { * Interfaces for encoding handlers. */ XMLPUBFUN void XMLCALL - xmlInitCharEncodingHandlers (void); +xmlInitCharEncodingHandlers (void); XMLPUBFUN void XMLCALL - xmlCleanupCharEncodingHandlers (void); +xmlCleanupCharEncodingHandlers (void); XMLPUBFUN void XMLCALL - xmlRegisterCharEncodingHandler (xmlCharEncodingHandlerPtr handler); +xmlRegisterCharEncodingHandler (xmlCharEncodingHandlerPtr handler); XMLPUBFUN xmlCharEncodingHandlerPtr XMLCALL - xmlGetCharEncodingHandler (xmlCharEncoding enc); +xmlGetCharEncodingHandler (xmlCharEncoding enc); XMLPUBFUN xmlCharEncodingHandlerPtr XMLCALL - xmlFindCharEncodingHandler (const char *name); +xmlFindCharEncodingHandler (const char *name); XMLPUBFUN xmlCharEncodingHandlerPtr XMLCALL - xmlNewCharEncodingHandler (const char *name, - xmlCharEncodingInputFunc input, - xmlCharEncodingOutputFunc output); +xmlNewCharEncodingHandler (const char *name, + xmlCharEncodingInputFunc input, + xmlCharEncodingOutputFunc output); /* * Interfaces for encoding names and aliases. */ XMLPUBFUN int XMLCALL - xmlAddEncodingAlias (const char *name, - const char *alias); +xmlAddEncodingAlias (const char *name, + const char *alias); XMLPUBFUN int XMLCALL - xmlDelEncodingAlias (const char *alias); +xmlDelEncodingAlias (const char *alias); XMLPUBFUN const char * XMLCALL - xmlGetEncodingAlias (const char *alias); +xmlGetEncodingAlias (const char *alias); XMLPUBFUN void XMLCALL - xmlCleanupEncodingAliases (void); +xmlCleanupEncodingAliases (void); XMLPUBFUN xmlCharEncoding XMLCALL - xmlParseCharEncoding (const char *name); +xmlParseCharEncoding (const char *name); XMLPUBFUN const char * XMLCALL - xmlGetCharEncodingName (xmlCharEncoding enc); +xmlGetCharEncodingName (xmlCharEncoding enc); /* * Interfaces directly used by the parsers. */ XMLPUBFUN xmlCharEncoding XMLCALL - xmlDetectCharEncoding (const unsigned char *in, - int len); +xmlDetectCharEncoding (const unsigned char *in, + int len); XMLPUBFUN int XMLCALL - xmlCharEncOutFunc (xmlCharEncodingHandler *handler, - xmlBufferPtr out, - xmlBufferPtr in); +xmlCharEncOutFunc (xmlCharEncodingHandler *handler, + xmlBufferPtr out, + xmlBufferPtr in); XMLPUBFUN int XMLCALL - xmlCharEncInFunc (xmlCharEncodingHandler *handler, - xmlBufferPtr out, - xmlBufferPtr in); +xmlCharEncInFunc (xmlCharEncodingHandler *handler, + xmlBufferPtr out, + xmlBufferPtr in); XMLPUBFUN int XMLCALL - xmlCharEncFirstLine (xmlCharEncodingHandler *handler, - xmlBufferPtr out, - xmlBufferPtr in); +xmlCharEncFirstLine (xmlCharEncodingHandler *handler, + xmlBufferPtr out, + xmlBufferPtr in); XMLPUBFUN int XMLCALL - xmlCharEncCloseFunc (xmlCharEncodingHandler *handler); +xmlCharEncCloseFunc (xmlCharEncodingHandler *handler); /* * Export a few useful functions */ #ifdef LIBXML_OUTPUT_ENABLED XMLPUBFUN int XMLCALL - UTF8Toisolat1 (unsigned char *out, - int *outlen, - const unsigned char *in, - int *inlen); +UTF8Toisolat1 (unsigned char *out, + int *outlen, + const unsigned char *in, + int *inlen); #endif /* LIBXML_OUTPUT_ENABLED */ XMLPUBFUN int XMLCALL - isolat1ToUTF8 (unsigned char *out, - int *outlen, - const unsigned char *in, - int *inlen); +isolat1ToUTF8 (unsigned char *out, + int *outlen, + const unsigned char *in, + int *inlen); #ifdef __cplusplus } #endif diff --git a/thirdparties/common/include/libxml2/libxml/entities.h b/thirdparties/common/include/libxml2/libxml/entities.h index 1e91189..0e4ac33 100755 --- a/thirdparties/common/include/libxml2/libxml/entities.h +++ b/thirdparties/common/include/libxml2/libxml/entities.h @@ -28,7 +28,8 @@ typedef enum { XML_INTERNAL_PARAMETER_ENTITY = 4, XML_EXTERNAL_PARAMETER_ENTITY = 5, XML_INTERNAL_PREDEFINED_ENTITY = 6 -} xmlEntityType; +} +xmlEntityType; /* * An unit of storage for an entity, contains the string, the value @@ -57,9 +58,9 @@ struct _xmlEntity { const xmlChar *URI; /* the full URI as computed */ int owner; /* does the entity own the childrens */ int checked; /* was the entity content checked */ - /* this is also used to count entites - * references done from that entity - * and if it contains '<' */ + /* this is also used to count entites + * references done from that entity + * and if it contains '<' */ }; /* @@ -76,71 +77,71 @@ typedef xmlEntitiesTable *xmlEntitiesTablePtr; #ifdef LIBXML_LEGACY_ENABLED XMLPUBFUN void XMLCALL - xmlInitializePredefinedEntities (void); +xmlInitializePredefinedEntities (void); #endif /* LIBXML_LEGACY_ENABLED */ XMLPUBFUN xmlEntityPtr XMLCALL - xmlNewEntity (xmlDocPtr doc, - const xmlChar *name, - int type, - const xmlChar *ExternalID, - const xmlChar *SystemID, - const xmlChar *content); +xmlNewEntity (xmlDocPtr doc, + const xmlChar *name, + int type, + const xmlChar *ExternalID, + const xmlChar *SystemID, + const xmlChar *content); XMLPUBFUN xmlEntityPtr XMLCALL - xmlAddDocEntity (xmlDocPtr doc, - const xmlChar *name, - int type, - const xmlChar *ExternalID, - const xmlChar *SystemID, - const xmlChar *content); +xmlAddDocEntity (xmlDocPtr doc, + const xmlChar *name, + int type, + const xmlChar *ExternalID, + const xmlChar *SystemID, + const xmlChar *content); XMLPUBFUN xmlEntityPtr XMLCALL - xmlAddDtdEntity (xmlDocPtr doc, - const xmlChar *name, - int type, - const xmlChar *ExternalID, - const xmlChar *SystemID, - const xmlChar *content); +xmlAddDtdEntity (xmlDocPtr doc, + const xmlChar *name, + int type, + const xmlChar *ExternalID, + const xmlChar *SystemID, + const xmlChar *content); XMLPUBFUN xmlEntityPtr XMLCALL - xmlGetPredefinedEntity (const xmlChar *name); +xmlGetPredefinedEntity (const xmlChar *name); XMLPUBFUN xmlEntityPtr XMLCALL - xmlGetDocEntity (xmlDocPtr doc, - const xmlChar *name); +xmlGetDocEntity (xmlDocPtr doc, + const xmlChar *name); XMLPUBFUN xmlEntityPtr XMLCALL - xmlGetDtdEntity (xmlDocPtr doc, - const xmlChar *name); +xmlGetDtdEntity (xmlDocPtr doc, + const xmlChar *name); XMLPUBFUN xmlEntityPtr XMLCALL - xmlGetParameterEntity (xmlDocPtr doc, - const xmlChar *name); +xmlGetParameterEntity (xmlDocPtr doc, + const xmlChar *name); #ifdef LIBXML_LEGACY_ENABLED XMLPUBFUN const xmlChar * XMLCALL - xmlEncodeEntities (xmlDocPtr doc, - const xmlChar *input); +xmlEncodeEntities (xmlDocPtr doc, + const xmlChar *input); #endif /* LIBXML_LEGACY_ENABLED */ XMLPUBFUN xmlChar * XMLCALL - xmlEncodeEntitiesReentrant(xmlDocPtr doc, - const xmlChar *input); +xmlEncodeEntitiesReentrant(xmlDocPtr doc, + const xmlChar *input); XMLPUBFUN xmlChar * XMLCALL - xmlEncodeSpecialChars (xmlDocPtr doc, - const xmlChar *input); +xmlEncodeSpecialChars (xmlDocPtr doc, + const xmlChar *input); XMLPUBFUN xmlEntitiesTablePtr XMLCALL - xmlCreateEntitiesTable (void); +xmlCreateEntitiesTable (void); #ifdef LIBXML_TREE_ENABLED XMLPUBFUN xmlEntitiesTablePtr XMLCALL - xmlCopyEntitiesTable (xmlEntitiesTablePtr table); +xmlCopyEntitiesTable (xmlEntitiesTablePtr table); #endif /* LIBXML_TREE_ENABLED */ XMLPUBFUN void XMLCALL - xmlFreeEntitiesTable (xmlEntitiesTablePtr table); +xmlFreeEntitiesTable (xmlEntitiesTablePtr table); #ifdef LIBXML_OUTPUT_ENABLED XMLPUBFUN void XMLCALL - xmlDumpEntitiesTable (xmlBufferPtr buf, - xmlEntitiesTablePtr table); +xmlDumpEntitiesTable (xmlBufferPtr buf, + xmlEntitiesTablePtr table); XMLPUBFUN void XMLCALL - xmlDumpEntityDecl (xmlBufferPtr buf, - xmlEntityPtr ent); +xmlDumpEntityDecl (xmlBufferPtr buf, + xmlEntityPtr ent); #endif /* LIBXML_OUTPUT_ENABLED */ #ifdef LIBXML_LEGACY_ENABLED XMLPUBFUN void XMLCALL - xmlCleanupPredefinedEntities(void); +xmlCleanupPredefinedEntities(void); #endif /* LIBXML_LEGACY_ENABLED */ diff --git a/thirdparties/common/include/libxml2/libxml/globals.h b/thirdparties/common/include/libxml2/libxml/globals.h index 9d688e0..4803e85 100755 --- a/thirdparties/common/include/libxml2/libxml/globals.h +++ b/thirdparties/common/include/libxml2/libxml/globals.h @@ -115,52 +115,51 @@ typedef void (*xmlDeregisterNodeFunc) (xmlNodePtr node); typedef struct _xmlGlobalState xmlGlobalState; typedef xmlGlobalState *xmlGlobalStatePtr; -struct _xmlGlobalState -{ - const char *xmlParserVersion; +struct _xmlGlobalState { + const char *xmlParserVersion; - xmlSAXLocator xmlDefaultSAXLocator; - xmlSAXHandlerV1 xmlDefaultSAXHandler; - xmlSAXHandlerV1 docbDefaultSAXHandler; - xmlSAXHandlerV1 htmlDefaultSAXHandler; + xmlSAXLocator xmlDefaultSAXLocator; + xmlSAXHandlerV1 xmlDefaultSAXHandler; + xmlSAXHandlerV1 docbDefaultSAXHandler; + xmlSAXHandlerV1 htmlDefaultSAXHandler; - xmlFreeFunc xmlFree; - xmlMallocFunc xmlMalloc; - xmlStrdupFunc xmlMemStrdup; - xmlReallocFunc xmlRealloc; + xmlFreeFunc xmlFree; + xmlMallocFunc xmlMalloc; + xmlStrdupFunc xmlMemStrdup; + xmlReallocFunc xmlRealloc; - xmlGenericErrorFunc xmlGenericError; - xmlStructuredErrorFunc xmlStructuredError; - void *xmlGenericErrorContext; + xmlGenericErrorFunc xmlGenericError; + xmlStructuredErrorFunc xmlStructuredError; + void *xmlGenericErrorContext; - int oldXMLWDcompatibility; + int oldXMLWDcompatibility; - xmlBufferAllocationScheme xmlBufferAllocScheme; - int xmlDefaultBufferSize; + xmlBufferAllocationScheme xmlBufferAllocScheme; + int xmlDefaultBufferSize; - int xmlSubstituteEntitiesDefaultValue; - int xmlDoValidityCheckingDefaultValue; - int xmlGetWarningsDefaultValue; - int xmlKeepBlanksDefaultValue; - int xmlLineNumbersDefaultValue; - int xmlLoadExtDtdDefaultValue; - int xmlParserDebugEntities; - int xmlPedanticParserDefaultValue; + int xmlSubstituteEntitiesDefaultValue; + int xmlDoValidityCheckingDefaultValue; + int xmlGetWarningsDefaultValue; + int xmlKeepBlanksDefaultValue; + int xmlLineNumbersDefaultValue; + int xmlLoadExtDtdDefaultValue; + int xmlParserDebugEntities; + int xmlPedanticParserDefaultValue; - int xmlSaveNoEmptyTags; - int xmlIndentTreeOutput; - const char *xmlTreeIndentString; + int xmlSaveNoEmptyTags; + int xmlIndentTreeOutput; + const char *xmlTreeIndentString; - xmlRegisterNodeFunc xmlRegisterNodeDefaultValue; - xmlDeregisterNodeFunc xmlDeregisterNodeDefaultValue; + xmlRegisterNodeFunc xmlRegisterNodeDefaultValue; + xmlDeregisterNodeFunc xmlDeregisterNodeDefaultValue; - xmlMallocFunc xmlMallocAtomic; - xmlError xmlLastError; + xmlMallocFunc xmlMallocAtomic; + xmlError xmlLastError; - xmlParserInputBufferCreateFilenameFunc xmlParserInputBufferCreateFilenameValue; - xmlOutputBufferCreateFilenameFunc xmlOutputBufferCreateFilenameValue; + xmlParserInputBufferCreateFilenameFunc xmlParserInputBufferCreateFilenameValue; + xmlOutputBufferCreateFilenameFunc xmlOutputBufferCreateFilenameValue; - void *xmlStructuredErrorContext; + void *xmlStructuredErrorContext; }; #ifdef __cplusplus @@ -183,9 +182,9 @@ XMLPUBFUN xmlDeregisterNodeFunc XMLCALL xmlDeregisterNodeDefault(xmlDeregisterNo XMLPUBFUN xmlDeregisterNodeFunc XMLCALL xmlThrDefDeregisterNodeDefault(xmlDeregisterNodeFunc func); XMLPUBFUN xmlOutputBufferCreateFilenameFunc XMLCALL - xmlThrDefOutputBufferCreateFilenameDefault(xmlOutputBufferCreateFilenameFunc func); +xmlThrDefOutputBufferCreateFilenameDefault(xmlOutputBufferCreateFilenameFunc func); XMLPUBFUN xmlParserInputBufferCreateFilenameFunc XMLCALL - xmlThrDefParserInputBufferCreateFilenameDefault(xmlParserInputBufferCreateFilenameFunc func); +xmlThrDefParserInputBufferCreateFilenameDefault(xmlParserInputBufferCreateFilenameFunc func); /** DOC_DISABLE */ /* @@ -349,7 +348,7 @@ XMLPUBFUN xmlStructuredErrorFunc * XMLCALL __xmlStructuredError(void); XMLPUBVAR xmlStructuredErrorFunc xmlStructuredError; #endif -XMLPUBFUN void * * XMLCALL __xmlGenericErrorContext(void); +XMLPUBFUN void ** XMLCALL __xmlGenericErrorContext(void); #ifdef LIBXML_THREAD_ENABLED #define xmlGenericErrorContext \ (*(__xmlGenericErrorContext())) @@ -357,7 +356,7 @@ XMLPUBFUN void * * XMLCALL __xmlGenericErrorContext(void); XMLPUBVAR void * xmlGenericErrorContext; #endif -XMLPUBFUN void * * XMLCALL __xmlStructuredErrorContext(void); +XMLPUBFUN void ** XMLCALL __xmlStructuredErrorContext(void); #ifdef LIBXML_THREAD_ENABLED #define xmlStructuredErrorContext \ (*(__xmlStructuredErrorContext())) @@ -383,7 +382,7 @@ XMLPUBVAR int xmlIndentTreeOutput; #endif XMLPUBFUN int XMLCALL xmlThrDefIndentTreeOutput(int v); -XMLPUBFUN const char * * XMLCALL __xmlTreeIndentString(void); +XMLPUBFUN const char ** XMLCALL __xmlTreeIndentString(void); #ifdef LIBXML_THREAD_ENABLED #define xmlTreeIndentString \ (*(__xmlTreeIndentString())) @@ -428,7 +427,7 @@ XMLPUBVAR int xmlParserDebugEntities; #endif XMLPUBFUN int XMLCALL xmlThrDefParserDebugEntities(int v); -XMLPUBFUN const char * * XMLCALL __xmlParserVersion(void); +XMLPUBFUN const char ** XMLCALL __xmlParserVersion(void); #ifdef LIBXML_THREAD_ENABLED #define xmlParserVersion \ (*(__xmlParserVersion())) diff --git a/thirdparties/common/include/libxml2/libxml/hash.h b/thirdparties/common/include/libxml2/libxml/hash.h index dc8ab7e..0ecea8f 100755 --- a/thirdparties/common/include/libxml2/libxml/hash.h +++ b/thirdparties/common/include/libxml2/libxml/hash.h @@ -97,136 +97,136 @@ typedef void (*xmlHashScanner)(void *payload, void *data, xmlChar *name); * Callback when scanning data in a hash with the full scanner. */ typedef void (*xmlHashScannerFull)(void *payload, void *data, - const xmlChar *name, const xmlChar *name2, - const xmlChar *name3); + const xmlChar *name, const xmlChar *name2, + const xmlChar *name3); /* * Constructor and destructor. */ XMLPUBFUN xmlHashTablePtr XMLCALL - xmlHashCreate (int size); +xmlHashCreate (int size); XMLPUBFUN xmlHashTablePtr XMLCALL - xmlHashCreateDict(int size, - xmlDictPtr dict); +xmlHashCreateDict(int size, + xmlDictPtr dict); XMLPUBFUN void XMLCALL - xmlHashFree (xmlHashTablePtr table, - xmlHashDeallocator f); +xmlHashFree (xmlHashTablePtr table, + xmlHashDeallocator f); /* * Add a new entry to the hash table. */ XMLPUBFUN int XMLCALL - xmlHashAddEntry (xmlHashTablePtr table, - const xmlChar *name, - void *userdata); +xmlHashAddEntry (xmlHashTablePtr table, + const xmlChar *name, + void *userdata); XMLPUBFUN int XMLCALL - xmlHashUpdateEntry(xmlHashTablePtr table, - const xmlChar *name, - void *userdata, - xmlHashDeallocator f); +xmlHashUpdateEntry(xmlHashTablePtr table, + const xmlChar *name, + void *userdata, + xmlHashDeallocator f); XMLPUBFUN int XMLCALL - xmlHashAddEntry2(xmlHashTablePtr table, - const xmlChar *name, - const xmlChar *name2, - void *userdata); +xmlHashAddEntry2(xmlHashTablePtr table, + const xmlChar *name, + const xmlChar *name2, + void *userdata); XMLPUBFUN int XMLCALL - xmlHashUpdateEntry2(xmlHashTablePtr table, - const xmlChar *name, - const xmlChar *name2, - void *userdata, - xmlHashDeallocator f); +xmlHashUpdateEntry2(xmlHashTablePtr table, + const xmlChar *name, + const xmlChar *name2, + void *userdata, + xmlHashDeallocator f); XMLPUBFUN int XMLCALL - xmlHashAddEntry3(xmlHashTablePtr table, - const xmlChar *name, - const xmlChar *name2, - const xmlChar *name3, - void *userdata); +xmlHashAddEntry3(xmlHashTablePtr table, + const xmlChar *name, + const xmlChar *name2, + const xmlChar *name3, + void *userdata); XMLPUBFUN int XMLCALL - xmlHashUpdateEntry3(xmlHashTablePtr table, - const xmlChar *name, - const xmlChar *name2, - const xmlChar *name3, - void *userdata, - xmlHashDeallocator f); +xmlHashUpdateEntry3(xmlHashTablePtr table, + const xmlChar *name, + const xmlChar *name2, + const xmlChar *name3, + void *userdata, + xmlHashDeallocator f); /* * Remove an entry from the hash table. */ XMLPUBFUN int XMLCALL - xmlHashRemoveEntry(xmlHashTablePtr table, const xmlChar *name, - xmlHashDeallocator f); +xmlHashRemoveEntry(xmlHashTablePtr table, const xmlChar *name, + xmlHashDeallocator f); XMLPUBFUN int XMLCALL - xmlHashRemoveEntry2(xmlHashTablePtr table, const xmlChar *name, - const xmlChar *name2, xmlHashDeallocator f); +xmlHashRemoveEntry2(xmlHashTablePtr table, const xmlChar *name, + const xmlChar *name2, xmlHashDeallocator f); XMLPUBFUN int XMLCALL - xmlHashRemoveEntry3(xmlHashTablePtr table, const xmlChar *name, - const xmlChar *name2, const xmlChar *name3, - xmlHashDeallocator f); +xmlHashRemoveEntry3(xmlHashTablePtr table, const xmlChar *name, + const xmlChar *name2, const xmlChar *name3, + xmlHashDeallocator f); /* * Retrieve the userdata. */ XMLPUBFUN void * XMLCALL - xmlHashLookup (xmlHashTablePtr table, - const xmlChar *name); +xmlHashLookup (xmlHashTablePtr table, + const xmlChar *name); XMLPUBFUN void * XMLCALL - xmlHashLookup2 (xmlHashTablePtr table, - const xmlChar *name, - const xmlChar *name2); +xmlHashLookup2 (xmlHashTablePtr table, + const xmlChar *name, + const xmlChar *name2); XMLPUBFUN void * XMLCALL - xmlHashLookup3 (xmlHashTablePtr table, - const xmlChar *name, - const xmlChar *name2, - const xmlChar *name3); +xmlHashLookup3 (xmlHashTablePtr table, + const xmlChar *name, + const xmlChar *name2, + const xmlChar *name3); XMLPUBFUN void * XMLCALL - xmlHashQLookup (xmlHashTablePtr table, - const xmlChar *name, - const xmlChar *prefix); +xmlHashQLookup (xmlHashTablePtr table, + const xmlChar *name, + const xmlChar *prefix); XMLPUBFUN void * XMLCALL - xmlHashQLookup2 (xmlHashTablePtr table, - const xmlChar *name, - const xmlChar *prefix, - const xmlChar *name2, - const xmlChar *prefix2); +xmlHashQLookup2 (xmlHashTablePtr table, + const xmlChar *name, + const xmlChar *prefix, + const xmlChar *name2, + const xmlChar *prefix2); XMLPUBFUN void * XMLCALL - xmlHashQLookup3 (xmlHashTablePtr table, - const xmlChar *name, - const xmlChar *prefix, - const xmlChar *name2, - const xmlChar *prefix2, - const xmlChar *name3, - const xmlChar *prefix3); +xmlHashQLookup3 (xmlHashTablePtr table, + const xmlChar *name, + const xmlChar *prefix, + const xmlChar *name2, + const xmlChar *prefix2, + const xmlChar *name3, + const xmlChar *prefix3); /* * Helpers. */ XMLPUBFUN xmlHashTablePtr XMLCALL - xmlHashCopy (xmlHashTablePtr table, - xmlHashCopier f); +xmlHashCopy (xmlHashTablePtr table, + xmlHashCopier f); XMLPUBFUN int XMLCALL - xmlHashSize (xmlHashTablePtr table); +xmlHashSize (xmlHashTablePtr table); XMLPUBFUN void XMLCALL - xmlHashScan (xmlHashTablePtr table, - xmlHashScanner f, - void *data); +xmlHashScan (xmlHashTablePtr table, + xmlHashScanner f, + void *data); XMLPUBFUN void XMLCALL - xmlHashScan3 (xmlHashTablePtr table, - const xmlChar *name, - const xmlChar *name2, - const xmlChar *name3, - xmlHashScanner f, - void *data); +xmlHashScan3 (xmlHashTablePtr table, + const xmlChar *name, + const xmlChar *name2, + const xmlChar *name3, + xmlHashScanner f, + void *data); XMLPUBFUN void XMLCALL - xmlHashScanFull (xmlHashTablePtr table, - xmlHashScannerFull f, - void *data); +xmlHashScanFull (xmlHashTablePtr table, + xmlHashScannerFull f, + void *data); XMLPUBFUN void XMLCALL - xmlHashScanFull3(xmlHashTablePtr table, - const xmlChar *name, - const xmlChar *name2, - const xmlChar *name3, - xmlHashScannerFull f, - void *data); +xmlHashScanFull3(xmlHashTablePtr table, + const xmlChar *name, + const xmlChar *name2, + const xmlChar *name3, + xmlHashScannerFull f, + void *data); #ifdef __cplusplus } #endif diff --git a/thirdparties/common/include/libxml2/libxml/list.h b/thirdparties/common/include/libxml2/libxml/list.h index 0504e0c..7bd8e37 100755 --- a/thirdparties/common/include/libxml2/libxml/list.h +++ b/thirdparties/common/include/libxml2/libxml/list.h @@ -53,79 +53,79 @@ typedef int (*xmlListWalker) (const void *data, const void *user); /* Creation/Deletion */ XMLPUBFUN xmlListPtr XMLCALL - xmlListCreate (xmlListDeallocator deallocator, - xmlListDataCompare compare); +xmlListCreate (xmlListDeallocator deallocator, + xmlListDataCompare compare); XMLPUBFUN void XMLCALL - xmlListDelete (xmlListPtr l); +xmlListDelete (xmlListPtr l); /* Basic Operators */ XMLPUBFUN void * XMLCALL - xmlListSearch (xmlListPtr l, - void *data); +xmlListSearch (xmlListPtr l, + void *data); XMLPUBFUN void * XMLCALL - xmlListReverseSearch (xmlListPtr l, - void *data); +xmlListReverseSearch (xmlListPtr l, + void *data); XMLPUBFUN int XMLCALL - xmlListInsert (xmlListPtr l, - void *data) ; +xmlListInsert (xmlListPtr l, + void *data) ; XMLPUBFUN int XMLCALL - xmlListAppend (xmlListPtr l, - void *data) ; +xmlListAppend (xmlListPtr l, + void *data) ; XMLPUBFUN int XMLCALL - xmlListRemoveFirst (xmlListPtr l, - void *data); +xmlListRemoveFirst (xmlListPtr l, + void *data); XMLPUBFUN int XMLCALL - xmlListRemoveLast (xmlListPtr l, - void *data); +xmlListRemoveLast (xmlListPtr l, + void *data); XMLPUBFUN int XMLCALL - xmlListRemoveAll (xmlListPtr l, - void *data); +xmlListRemoveAll (xmlListPtr l, + void *data); XMLPUBFUN void XMLCALL - xmlListClear (xmlListPtr l); +xmlListClear (xmlListPtr l); XMLPUBFUN int XMLCALL - xmlListEmpty (xmlListPtr l); +xmlListEmpty (xmlListPtr l); XMLPUBFUN xmlLinkPtr XMLCALL - xmlListFront (xmlListPtr l); +xmlListFront (xmlListPtr l); XMLPUBFUN xmlLinkPtr XMLCALL - xmlListEnd (xmlListPtr l); +xmlListEnd (xmlListPtr l); XMLPUBFUN int XMLCALL - xmlListSize (xmlListPtr l); +xmlListSize (xmlListPtr l); XMLPUBFUN void XMLCALL - xmlListPopFront (xmlListPtr l); +xmlListPopFront (xmlListPtr l); XMLPUBFUN void XMLCALL - xmlListPopBack (xmlListPtr l); +xmlListPopBack (xmlListPtr l); XMLPUBFUN int XMLCALL - xmlListPushFront (xmlListPtr l, - void *data); +xmlListPushFront (xmlListPtr l, + void *data); XMLPUBFUN int XMLCALL - xmlListPushBack (xmlListPtr l, - void *data); +xmlListPushBack (xmlListPtr l, + void *data); /* Advanced Operators */ XMLPUBFUN void XMLCALL - xmlListReverse (xmlListPtr l); +xmlListReverse (xmlListPtr l); XMLPUBFUN void XMLCALL - xmlListSort (xmlListPtr l); +xmlListSort (xmlListPtr l); XMLPUBFUN void XMLCALL - xmlListWalk (xmlListPtr l, - xmlListWalker walker, - const void *user); +xmlListWalk (xmlListPtr l, + xmlListWalker walker, + const void *user); XMLPUBFUN void XMLCALL - xmlListReverseWalk (xmlListPtr l, - xmlListWalker walker, - const void *user); +xmlListReverseWalk (xmlListPtr l, + xmlListWalker walker, + const void *user); XMLPUBFUN void XMLCALL - xmlListMerge (xmlListPtr l1, - xmlListPtr l2); +xmlListMerge (xmlListPtr l1, + xmlListPtr l2); XMLPUBFUN xmlListPtr XMLCALL - xmlListDup (const xmlListPtr old); +xmlListDup (const xmlListPtr old); XMLPUBFUN int XMLCALL - xmlListCopy (xmlListPtr cur, - const xmlListPtr old); +xmlListCopy (xmlListPtr cur, + const xmlListPtr old); /* Link operators */ XMLPUBFUN void * XMLCALL - xmlLinkGetData (xmlLinkPtr lk); +xmlLinkGetData (xmlLinkPtr lk); /* xmlListUnique() */ /* xmlListSwap */ diff --git a/thirdparties/common/include/libxml2/libxml/nanoftp.h b/thirdparties/common/include/libxml2/libxml/nanoftp.h index abb4bf7..63581a5 100755 --- a/thirdparties/common/include/libxml2/libxml/nanoftp.h +++ b/thirdparties/common/include/libxml2/libxml/nanoftp.h @@ -58,11 +58,11 @@ extern "C" { * Note that only one of year and day:minute are specified. */ typedef void (*ftpListCallback) (void *userData, - const char *filename, const char *attrib, - const char *owner, const char *group, - unsigned long size, int links, int year, - const char *month, int day, int hour, - int minute); + const char *filename, const char *attrib, + const char *owner, const char *group, + unsigned long size, int links, int year, + const char *month, int day, int hour, + int minute); /** * ftpDataCallback: * @userData: the user provided context @@ -72,89 +72,89 @@ typedef void (*ftpListCallback) (void *userData, * A callback for the xmlNanoFTPGet command. */ typedef void (*ftpDataCallback) (void *userData, - const char *data, - int len); + const char *data, + int len); /* * Init */ XMLPUBFUN void XMLCALL - xmlNanoFTPInit (void); +xmlNanoFTPInit (void); XMLPUBFUN void XMLCALL - xmlNanoFTPCleanup (void); +xmlNanoFTPCleanup (void); /* * Creating/freeing contexts. */ XMLPUBFUN void * XMLCALL - xmlNanoFTPNewCtxt (const char *URL); +xmlNanoFTPNewCtxt (const char *URL); XMLPUBFUN void XMLCALL - xmlNanoFTPFreeCtxt (void * ctx); +xmlNanoFTPFreeCtxt (void * ctx); XMLPUBFUN void * XMLCALL - xmlNanoFTPConnectTo (const char *server, - int port); +xmlNanoFTPConnectTo (const char *server, + int port); /* * Opening/closing session connections. */ XMLPUBFUN void * XMLCALL - xmlNanoFTPOpen (const char *URL); +xmlNanoFTPOpen (const char *URL); XMLPUBFUN int XMLCALL - xmlNanoFTPConnect (void *ctx); +xmlNanoFTPConnect (void *ctx); XMLPUBFUN int XMLCALL - xmlNanoFTPClose (void *ctx); +xmlNanoFTPClose (void *ctx); XMLPUBFUN int XMLCALL - xmlNanoFTPQuit (void *ctx); +xmlNanoFTPQuit (void *ctx); XMLPUBFUN void XMLCALL - xmlNanoFTPScanProxy (const char *URL); +xmlNanoFTPScanProxy (const char *URL); XMLPUBFUN void XMLCALL - xmlNanoFTPProxy (const char *host, - int port, - const char *user, - const char *passwd, - int type); +xmlNanoFTPProxy (const char *host, + int port, + const char *user, + const char *passwd, + int type); XMLPUBFUN int XMLCALL - xmlNanoFTPUpdateURL (void *ctx, - const char *URL); +xmlNanoFTPUpdateURL (void *ctx, + const char *URL); /* * Rather internal commands. */ XMLPUBFUN int XMLCALL - xmlNanoFTPGetResponse (void *ctx); +xmlNanoFTPGetResponse (void *ctx); XMLPUBFUN int XMLCALL - xmlNanoFTPCheckResponse (void *ctx); +xmlNanoFTPCheckResponse (void *ctx); /* * CD/DIR/GET handlers. */ XMLPUBFUN int XMLCALL - xmlNanoFTPCwd (void *ctx, - const char *directory); +xmlNanoFTPCwd (void *ctx, + const char *directory); XMLPUBFUN int XMLCALL - xmlNanoFTPDele (void *ctx, - const char *file); +xmlNanoFTPDele (void *ctx, + const char *file); XMLPUBFUN SOCKET XMLCALL - xmlNanoFTPGetConnection (void *ctx); +xmlNanoFTPGetConnection (void *ctx); XMLPUBFUN int XMLCALL - xmlNanoFTPCloseConnection(void *ctx); +xmlNanoFTPCloseConnection(void *ctx); XMLPUBFUN int XMLCALL - xmlNanoFTPList (void *ctx, - ftpListCallback callback, - void *userData, - const char *filename); +xmlNanoFTPList (void *ctx, + ftpListCallback callback, + void *userData, + const char *filename); XMLPUBFUN SOCKET XMLCALL - xmlNanoFTPGetSocket (void *ctx, - const char *filename); +xmlNanoFTPGetSocket (void *ctx, + const char *filename); XMLPUBFUN int XMLCALL - xmlNanoFTPGet (void *ctx, - ftpDataCallback callback, - void *userData, - const char *filename); +xmlNanoFTPGet (void *ctx, + ftpDataCallback callback, + void *userData, + const char *filename); XMLPUBFUN int XMLCALL - xmlNanoFTPRead (void *ctx, - void *dest, - int len); +xmlNanoFTPRead (void *ctx, + void *dest, + int len); #ifdef __cplusplus } diff --git a/thirdparties/common/include/libxml2/libxml/nanohttp.h b/thirdparties/common/include/libxml2/libxml/nanohttp.h index 22b8fb4..8fca6e6 100755 --- a/thirdparties/common/include/libxml2/libxml/nanohttp.h +++ b/thirdparties/common/include/libxml2/libxml/nanohttp.h @@ -19,60 +19,60 @@ extern "C" { #endif XMLPUBFUN void XMLCALL - xmlNanoHTTPInit (void); +xmlNanoHTTPInit (void); XMLPUBFUN void XMLCALL - xmlNanoHTTPCleanup (void); +xmlNanoHTTPCleanup (void); XMLPUBFUN void XMLCALL - xmlNanoHTTPScanProxy (const char *URL); +xmlNanoHTTPScanProxy (const char *URL); XMLPUBFUN int XMLCALL - xmlNanoHTTPFetch (const char *URL, - const char *filename, - char **contentType); +xmlNanoHTTPFetch (const char *URL, + const char *filename, + char **contentType); XMLPUBFUN void * XMLCALL - xmlNanoHTTPMethod (const char *URL, - const char *method, - const char *input, - char **contentType, - const char *headers, - int ilen); +xmlNanoHTTPMethod (const char *URL, + const char *method, + const char *input, + char **contentType, + const char *headers, + int ilen); XMLPUBFUN void * XMLCALL - xmlNanoHTTPMethodRedir (const char *URL, - const char *method, - const char *input, - char **contentType, - char **redir, - const char *headers, - int ilen); +xmlNanoHTTPMethodRedir (const char *URL, + const char *method, + const char *input, + char **contentType, + char **redir, + const char *headers, + int ilen); XMLPUBFUN void * XMLCALL - xmlNanoHTTPOpen (const char *URL, - char **contentType); +xmlNanoHTTPOpen (const char *URL, + char **contentType); XMLPUBFUN void * XMLCALL - xmlNanoHTTPOpenRedir (const char *URL, - char **contentType, - char **redir); +xmlNanoHTTPOpenRedir (const char *URL, + char **contentType, + char **redir); XMLPUBFUN int XMLCALL - xmlNanoHTTPReturnCode (void *ctx); +xmlNanoHTTPReturnCode (void *ctx); XMLPUBFUN const char * XMLCALL - xmlNanoHTTPAuthHeader (void *ctx); +xmlNanoHTTPAuthHeader (void *ctx); XMLPUBFUN const char * XMLCALL - xmlNanoHTTPRedir (void *ctx); +xmlNanoHTTPRedir (void *ctx); XMLPUBFUN int XMLCALL - xmlNanoHTTPContentLength( void * ctx ); +xmlNanoHTTPContentLength( void * ctx ); XMLPUBFUN const char * XMLCALL - xmlNanoHTTPEncoding (void *ctx); +xmlNanoHTTPEncoding (void *ctx); XMLPUBFUN const char * XMLCALL - xmlNanoHTTPMimeType (void *ctx); +xmlNanoHTTPMimeType (void *ctx); XMLPUBFUN int XMLCALL - xmlNanoHTTPRead (void *ctx, - void *dest, - int len); +xmlNanoHTTPRead (void *ctx, + void *dest, + int len); #ifdef LIBXML_OUTPUT_ENABLED XMLPUBFUN int XMLCALL - xmlNanoHTTPSave (void *ctxt, - const char *filename); +xmlNanoHTTPSave (void *ctxt, + const char *filename); #endif /* LIBXML_OUTPUT_ENABLED */ XMLPUBFUN void XMLCALL - xmlNanoHTTPClose (void *ctx); +xmlNanoHTTPClose (void *ctx); #ifdef __cplusplus } #endif diff --git a/thirdparties/common/include/libxml2/libxml/parser.h b/thirdparties/common/include/libxml2/libxml/parser.h index 3f5730d..2df46fe 100755 --- a/thirdparties/common/include/libxml2/libxml/parser.h +++ b/thirdparties/common/include/libxml2/libxml/parser.h @@ -87,20 +87,20 @@ typedef struct _xmlParserNodeInfo xmlParserNodeInfo; typedef xmlParserNodeInfo *xmlParserNodeInfoPtr; struct _xmlParserNodeInfo { - const struct _xmlNode* node; - /* Position & line # that text that created the node begins & ends on */ - unsigned long begin_pos; - unsigned long begin_line; - unsigned long end_pos; - unsigned long end_line; + const struct _xmlNode* node; + /* Position & line # that text that created the node begins & ends on */ + unsigned long begin_pos; + unsigned long begin_line; + unsigned long end_pos; + unsigned long end_line; }; typedef struct _xmlParserNodeInfoSeq xmlParserNodeInfoSeq; typedef xmlParserNodeInfoSeq *xmlParserNodeInfoSeqPtr; struct _xmlParserNodeInfoSeq { - unsigned long maximum; - unsigned long length; - xmlParserNodeInfo* buffer; + unsigned long maximum; + unsigned long length; + xmlParserNodeInfo* buffer; }; /** @@ -229,7 +229,7 @@ struct _xmlParserCtxt { const xmlChar *name; /* Current parsed Node */ int nameNr; /* Depth of the parsing stack */ int nameMax; /* Max depth of the parsing stack */ - const xmlChar * *nameTab; /* array of nodes */ + const xmlChar **nameTab; /* array of nodes */ long nbChars; /* number of xmlChar processed */ long checkIndex; /* used by progressive parsing lookup */ @@ -261,7 +261,7 @@ struct _xmlParserCtxt { int recovery; /* run in recovery mode */ int progressive; /* is this a progressive parsing */ xmlDictPtr dict; /* dictionnary for the parser */ - const xmlChar * *atts; /* array for the attributes callbacks */ + const xmlChar **atts; /* array for the attributes callbacks */ int maxatts; /* the size of the array */ int docdict; /* use strings from dict to build tree */ @@ -278,9 +278,9 @@ struct _xmlParserCtxt { int sax2; /* operating in the new SAX mode */ int nsNr; /* the number of inherited namespaces */ int nsMax; /* the size of the arrays */ - const xmlChar * *nsTab; /* the array of prefix/namespace name */ + const xmlChar **nsTab; /* the array of prefix/namespace name */ int *attallocs; /* which attribute were allocated */ - void * *pushTab; /* array of data for push */ + void **pushTab; /* array of data for push */ xmlHashTablePtr attsDefault; /* defaulted attributes if any */ xmlHashTablePtr attsSpecial; /* non-CDATA attributes if any */ int nsWellFormed; /* is the document XML Nanespace okay */ @@ -348,8 +348,8 @@ struct _xmlSAXLocator { * Returns the xmlParserInputPtr if inlined or NULL for DOM behaviour. */ typedef xmlParserInputPtr (*resolveEntitySAXFunc) (void *ctx, - const xmlChar *publicId, - const xmlChar *systemId); + const xmlChar *publicId, + const xmlChar *systemId); /** * internalSubsetSAXFunc: * @ctx: the user data (XML parser context) @@ -360,9 +360,9 @@ typedef xmlParserInputPtr (*resolveEntitySAXFunc) (void *ctx, * Callback on internal subset declaration. */ typedef void (*internalSubsetSAXFunc) (void *ctx, - const xmlChar *name, - const xmlChar *ExternalID, - const xmlChar *SystemID); + const xmlChar *name, + const xmlChar *ExternalID, + const xmlChar *SystemID); /** * externalSubsetSAXFunc: * @ctx: the user data (XML parser context) @@ -373,9 +373,9 @@ typedef void (*internalSubsetSAXFunc) (void *ctx, * Callback on external subset declaration. */ typedef void (*externalSubsetSAXFunc) (void *ctx, - const xmlChar *name, - const xmlChar *ExternalID, - const xmlChar *SystemID); + const xmlChar *name, + const xmlChar *ExternalID, + const xmlChar *SystemID); /** * getEntitySAXFunc: * @ctx: the user data (XML parser context) @@ -386,7 +386,7 @@ typedef void (*externalSubsetSAXFunc) (void *ctx, * Returns the xmlEntityPtr if found. */ typedef xmlEntityPtr (*getEntitySAXFunc) (void *ctx, - const xmlChar *name); + const xmlChar *name); /** * getParameterEntitySAXFunc: * @ctx: the user data (XML parser context) @@ -397,7 +397,7 @@ typedef xmlEntityPtr (*getEntitySAXFunc) (void *ctx, * Returns the xmlEntityPtr if found. */ typedef xmlEntityPtr (*getParameterEntitySAXFunc) (void *ctx, - const xmlChar *name); + const xmlChar *name); /** * entityDeclSAXFunc: * @ctx: the user data (XML parser context) @@ -410,11 +410,11 @@ typedef xmlEntityPtr (*getParameterEntitySAXFunc) (void *ctx, * An entity definition has been parsed. */ typedef void (*entityDeclSAXFunc) (void *ctx, - const xmlChar *name, - int type, - const xmlChar *publicId, - const xmlChar *systemId, - xmlChar *content); + const xmlChar *name, + int type, + const xmlChar *publicId, + const xmlChar *systemId, + xmlChar *content); /** * notationDeclSAXFunc: * @ctx: the user data (XML parser context) @@ -425,9 +425,9 @@ typedef void (*entityDeclSAXFunc) (void *ctx, * What to do when a notation declaration has been parsed. */ typedef void (*notationDeclSAXFunc)(void *ctx, - const xmlChar *name, - const xmlChar *publicId, - const xmlChar *systemId); + const xmlChar *name, + const xmlChar *publicId, + const xmlChar *systemId); /** * attributeDeclSAXFunc: * @ctx: the user data (XML parser context) @@ -441,12 +441,12 @@ typedef void (*notationDeclSAXFunc)(void *ctx, * An attribute definition has been parsed. */ typedef void (*attributeDeclSAXFunc)(void *ctx, - const xmlChar *elem, - const xmlChar *fullname, - int type, - int def, - const xmlChar *defaultValue, - xmlEnumerationPtr tree); + const xmlChar *elem, + const xmlChar *fullname, + int type, + int def, + const xmlChar *defaultValue, + xmlEnumerationPtr tree); /** * elementDeclSAXFunc: * @ctx: the user data (XML parser context) @@ -457,9 +457,9 @@ typedef void (*attributeDeclSAXFunc)(void *ctx, * An element definition has been parsed. */ typedef void (*elementDeclSAXFunc)(void *ctx, - const xmlChar *name, - int type, - xmlElementContentPtr content); + const xmlChar *name, + int type, + xmlElementContentPtr content); /** * unparsedEntityDeclSAXFunc: * @ctx: the user data (XML parser context) @@ -471,10 +471,10 @@ typedef void (*elementDeclSAXFunc)(void *ctx, * What to do when an unparsed entity declaration is parsed. */ typedef void (*unparsedEntityDeclSAXFunc)(void *ctx, - const xmlChar *name, - const xmlChar *publicId, - const xmlChar *systemId, - const xmlChar *notationName); + const xmlChar *name, + const xmlChar *publicId, + const xmlChar *systemId, + const xmlChar *notationName); /** * setDocumentLocatorSAXFunc: * @ctx: the user data (XML parser context) @@ -484,7 +484,7 @@ typedef void (*unparsedEntityDeclSAXFunc)(void *ctx, * Everything is available on the context, so this is useless in our case. */ typedef void (*setDocumentLocatorSAXFunc) (void *ctx, - xmlSAXLocatorPtr loc); + xmlSAXLocatorPtr loc); /** * startDocumentSAXFunc: * @ctx: the user data (XML parser context) @@ -508,8 +508,8 @@ typedef void (*endDocumentSAXFunc) (void *ctx); * Called when an opening tag has been processed. */ typedef void (*startElementSAXFunc) (void *ctx, - const xmlChar *name, - const xmlChar **atts); + const xmlChar *name, + const xmlChar **atts); /** * endElementSAXFunc: * @ctx: the user data (XML parser context) @@ -518,7 +518,7 @@ typedef void (*startElementSAXFunc) (void *ctx, * Called when the end of an element has been detected. */ typedef void (*endElementSAXFunc) (void *ctx, - const xmlChar *name); + const xmlChar *name); /** * attributeSAXFunc: * @ctx: the user data (XML parser context) @@ -531,8 +531,8 @@ typedef void (*endElementSAXFunc) (void *ctx, * the element. */ typedef void (*attributeSAXFunc) (void *ctx, - const xmlChar *name, - const xmlChar *value); + const xmlChar *name, + const xmlChar *value); /** * referenceSAXFunc: * @ctx: the user data (XML parser context) @@ -541,7 +541,7 @@ typedef void (*attributeSAXFunc) (void *ctx, * Called when an entity reference is detected. */ typedef void (*referenceSAXFunc) (void *ctx, - const xmlChar *name); + const xmlChar *name); /** * charactersSAXFunc: * @ctx: the user data (XML parser context) @@ -551,8 +551,8 @@ typedef void (*referenceSAXFunc) (void *ctx, * Receiving some chars from the parser. */ typedef void (*charactersSAXFunc) (void *ctx, - const xmlChar *ch, - int len); + const xmlChar *ch, + int len); /** * ignorableWhitespaceSAXFunc: * @ctx: the user data (XML parser context) @@ -563,8 +563,8 @@ typedef void (*charactersSAXFunc) (void *ctx, * UNUSED: by default the DOM building will use characters. */ typedef void (*ignorableWhitespaceSAXFunc) (void *ctx, - const xmlChar *ch, - int len); + const xmlChar *ch, + int len); /** * processingInstructionSAXFunc: * @ctx: the user data (XML parser context) @@ -574,8 +574,8 @@ typedef void (*ignorableWhitespaceSAXFunc) (void *ctx, * A processing instruction has been parsed. */ typedef void (*processingInstructionSAXFunc) (void *ctx, - const xmlChar *target, - const xmlChar *data); + const xmlChar *target, + const xmlChar *data); /** * commentSAXFunc: * @ctx: the user data (XML parser context) @@ -584,7 +584,7 @@ typedef void (*processingInstructionSAXFunc) (void *ctx, * A comment has been parsed. */ typedef void (*commentSAXFunc) (void *ctx, - const xmlChar *value); + const xmlChar *value); /** * cdataBlockSAXFunc: * @ctx: the user data (XML parser context) @@ -594,9 +594,9 @@ typedef void (*commentSAXFunc) (void *ctx, * Called when a pcdata block has been parsed. */ typedef void (*cdataBlockSAXFunc) ( - void *ctx, - const xmlChar *value, - int len); + void *ctx, + const xmlChar *value, + int len); /** * warningSAXFunc: * @ctx: an XML parser context @@ -606,7 +606,7 @@ typedef void (*cdataBlockSAXFunc) ( * Display and format a warning messages, callback. */ typedef void (XMLCDECL *warningSAXFunc) (void *ctx, - const char *msg, ...) LIBXML_ATTR_FORMAT(2,3); + const char *msg, ...) LIBXML_ATTR_FORMAT(2,3); /** * errorSAXFunc: * @ctx: an XML parser context @@ -616,7 +616,7 @@ typedef void (XMLCDECL *warningSAXFunc) (void *ctx, * Display and format an error messages, callback. */ typedef void (XMLCDECL *errorSAXFunc) (void *ctx, - const char *msg, ...) LIBXML_ATTR_FORMAT(2,3); + const char *msg, ...) LIBXML_ATTR_FORMAT(2,3); /** * fatalErrorSAXFunc: * @ctx: an XML parser context @@ -628,7 +628,7 @@ typedef void (XMLCDECL *errorSAXFunc) (void *ctx, * get all the callbacks for errors. */ typedef void (XMLCDECL *fatalErrorSAXFunc) (void *ctx, - const char *msg, ...) LIBXML_ATTR_FORMAT(2,3); + const char *msg, ...) LIBXML_ATTR_FORMAT(2,3); /** * isStandaloneSAXFunc: * @ctx: the user data (XML parser context) @@ -690,14 +690,14 @@ typedef int (*hasExternalSubsetSAXFunc) (void *ctx); */ typedef void (*startElementNsSAX2Func) (void *ctx, - const xmlChar *localname, - const xmlChar *prefix, - const xmlChar *URI, - int nb_namespaces, - const xmlChar **namespaces, - int nb_attributes, - int nb_defaulted, - const xmlChar **attributes); + const xmlChar *localname, + const xmlChar *prefix, + const xmlChar *URI, + int nb_namespaces, + const xmlChar **namespaces, + int nb_attributes, + int nb_defaulted, + const xmlChar **attributes); /** * endElementNsSAX2Func: @@ -711,9 +711,9 @@ typedef void (*startElementNsSAX2Func) (void *ctx, */ typedef void (*endElementNsSAX2Func) (void *ctx, - const xmlChar *localname, - const xmlChar *prefix, - const xmlChar *URI); + const xmlChar *localname, + const xmlChar *prefix, + const xmlChar *URI); struct _xmlSAXHandler { @@ -800,8 +800,8 @@ struct _xmlSAXHandlerV1 { * Returns the entity input parser. */ typedef xmlParserInputPtr (*xmlExternalEntityLoader) (const char *URL, - const char *ID, - xmlParserCtxtPtr context); + const char *ID, + xmlParserCtxtPtr context); #ifdef __cplusplus } @@ -820,191 +820,191 @@ extern "C" { * Init/Cleanup */ XMLPUBFUN void XMLCALL - xmlInitParser (void); +xmlInitParser (void); XMLPUBFUN void XMLCALL - xmlCleanupParser (void); +xmlCleanupParser (void); /* * Input functions */ XMLPUBFUN int XMLCALL - xmlParserInputRead (xmlParserInputPtr in, - int len); +xmlParserInputRead (xmlParserInputPtr in, + int len); XMLPUBFUN int XMLCALL - xmlParserInputGrow (xmlParserInputPtr in, - int len); +xmlParserInputGrow (xmlParserInputPtr in, + int len); /* * Basic parsing Interfaces */ #ifdef LIBXML_SAX1_ENABLED XMLPUBFUN xmlDocPtr XMLCALL - xmlParseDoc (const xmlChar *cur); +xmlParseDoc (const xmlChar *cur); XMLPUBFUN xmlDocPtr XMLCALL - xmlParseFile (const char *filename); +xmlParseFile (const char *filename); XMLPUBFUN xmlDocPtr XMLCALL - xmlParseMemory (const char *buffer, - int size); +xmlParseMemory (const char *buffer, + int size); #endif /* LIBXML_SAX1_ENABLED */ XMLPUBFUN int XMLCALL - xmlSubstituteEntitiesDefault(int val); +xmlSubstituteEntitiesDefault(int val); XMLPUBFUN int XMLCALL - xmlKeepBlanksDefault (int val); +xmlKeepBlanksDefault (int val); XMLPUBFUN void XMLCALL - xmlStopParser (xmlParserCtxtPtr ctxt); +xmlStopParser (xmlParserCtxtPtr ctxt); XMLPUBFUN int XMLCALL - xmlPedanticParserDefault(int val); +xmlPedanticParserDefault(int val); XMLPUBFUN int XMLCALL - xmlLineNumbersDefault (int val); +xmlLineNumbersDefault (int val); #ifdef LIBXML_SAX1_ENABLED /* * Recovery mode */ XMLPUBFUN xmlDocPtr XMLCALL - xmlRecoverDoc (const xmlChar *cur); +xmlRecoverDoc (const xmlChar *cur); XMLPUBFUN xmlDocPtr XMLCALL - xmlRecoverMemory (const char *buffer, - int size); +xmlRecoverMemory (const char *buffer, + int size); XMLPUBFUN xmlDocPtr XMLCALL - xmlRecoverFile (const char *filename); +xmlRecoverFile (const char *filename); #endif /* LIBXML_SAX1_ENABLED */ /* * Less common routines and SAX interfaces */ XMLPUBFUN int XMLCALL - xmlParseDocument (xmlParserCtxtPtr ctxt); +xmlParseDocument (xmlParserCtxtPtr ctxt); XMLPUBFUN int XMLCALL - xmlParseExtParsedEnt (xmlParserCtxtPtr ctxt); +xmlParseExtParsedEnt (xmlParserCtxtPtr ctxt); #ifdef LIBXML_SAX1_ENABLED XMLPUBFUN int XMLCALL - xmlSAXUserParseFile (xmlSAXHandlerPtr sax, - void *user_data, - const char *filename); +xmlSAXUserParseFile (xmlSAXHandlerPtr sax, + void *user_data, + const char *filename); XMLPUBFUN int XMLCALL - xmlSAXUserParseMemory (xmlSAXHandlerPtr sax, - void *user_data, - const char *buffer, - int size); +xmlSAXUserParseMemory (xmlSAXHandlerPtr sax, + void *user_data, + const char *buffer, + int size); XMLPUBFUN xmlDocPtr XMLCALL - xmlSAXParseDoc (xmlSAXHandlerPtr sax, - const xmlChar *cur, - int recovery); +xmlSAXParseDoc (xmlSAXHandlerPtr sax, + const xmlChar *cur, + int recovery); XMLPUBFUN xmlDocPtr XMLCALL - xmlSAXParseMemory (xmlSAXHandlerPtr sax, - const char *buffer, - int size, - int recovery); +xmlSAXParseMemory (xmlSAXHandlerPtr sax, + const char *buffer, + int size, + int recovery); XMLPUBFUN xmlDocPtr XMLCALL - xmlSAXParseMemoryWithData (xmlSAXHandlerPtr sax, - const char *buffer, - int size, - int recovery, - void *data); +xmlSAXParseMemoryWithData (xmlSAXHandlerPtr sax, + const char *buffer, + int size, + int recovery, + void *data); XMLPUBFUN xmlDocPtr XMLCALL - xmlSAXParseFile (xmlSAXHandlerPtr sax, - const char *filename, - int recovery); +xmlSAXParseFile (xmlSAXHandlerPtr sax, + const char *filename, + int recovery); XMLPUBFUN xmlDocPtr XMLCALL - xmlSAXParseFileWithData (xmlSAXHandlerPtr sax, - const char *filename, - int recovery, - void *data); +xmlSAXParseFileWithData (xmlSAXHandlerPtr sax, + const char *filename, + int recovery, + void *data); XMLPUBFUN xmlDocPtr XMLCALL - xmlSAXParseEntity (xmlSAXHandlerPtr sax, - const char *filename); +xmlSAXParseEntity (xmlSAXHandlerPtr sax, + const char *filename); XMLPUBFUN xmlDocPtr XMLCALL - xmlParseEntity (const char *filename); +xmlParseEntity (const char *filename); #endif /* LIBXML_SAX1_ENABLED */ #ifdef LIBXML_VALID_ENABLED XMLPUBFUN xmlDtdPtr XMLCALL - xmlSAXParseDTD (xmlSAXHandlerPtr sax, - const xmlChar *ExternalID, - const xmlChar *SystemID); +xmlSAXParseDTD (xmlSAXHandlerPtr sax, + const xmlChar *ExternalID, + const xmlChar *SystemID); XMLPUBFUN xmlDtdPtr XMLCALL - xmlParseDTD (const xmlChar *ExternalID, - const xmlChar *SystemID); +xmlParseDTD (const xmlChar *ExternalID, + const xmlChar *SystemID); XMLPUBFUN xmlDtdPtr XMLCALL - xmlIOParseDTD (xmlSAXHandlerPtr sax, - xmlParserInputBufferPtr input, - xmlCharEncoding enc); +xmlIOParseDTD (xmlSAXHandlerPtr sax, + xmlParserInputBufferPtr input, + xmlCharEncoding enc); #endif /* LIBXML_VALID_ENABLE */ #ifdef LIBXML_SAX1_ENABLED XMLPUBFUN int XMLCALL - xmlParseBalancedChunkMemory(xmlDocPtr doc, - xmlSAXHandlerPtr sax, - void *user_data, - int depth, - const xmlChar *string, - xmlNodePtr *lst); +xmlParseBalancedChunkMemory(xmlDocPtr doc, + xmlSAXHandlerPtr sax, + void *user_data, + int depth, + const xmlChar *string, + xmlNodePtr *lst); #endif /* LIBXML_SAX1_ENABLED */ XMLPUBFUN xmlParserErrors XMLCALL - xmlParseInNodeContext (xmlNodePtr node, - const char *data, - int datalen, - int options, - xmlNodePtr *lst); +xmlParseInNodeContext (xmlNodePtr node, + const char *data, + int datalen, + int options, + xmlNodePtr *lst); #ifdef LIBXML_SAX1_ENABLED XMLPUBFUN int XMLCALL - xmlParseBalancedChunkMemoryRecover(xmlDocPtr doc, - xmlSAXHandlerPtr sax, - void *user_data, - int depth, - const xmlChar *string, - xmlNodePtr *lst, - int recover); +xmlParseBalancedChunkMemoryRecover(xmlDocPtr doc, + xmlSAXHandlerPtr sax, + void *user_data, + int depth, + const xmlChar *string, + xmlNodePtr *lst, + int recover); XMLPUBFUN int XMLCALL - xmlParseExternalEntity (xmlDocPtr doc, - xmlSAXHandlerPtr sax, - void *user_data, - int depth, - const xmlChar *URL, - const xmlChar *ID, - xmlNodePtr *lst); +xmlParseExternalEntity (xmlDocPtr doc, + xmlSAXHandlerPtr sax, + void *user_data, + int depth, + const xmlChar *URL, + const xmlChar *ID, + xmlNodePtr *lst); #endif /* LIBXML_SAX1_ENABLED */ XMLPUBFUN int XMLCALL - xmlParseCtxtExternalEntity(xmlParserCtxtPtr ctx, - const xmlChar *URL, - const xmlChar *ID, - xmlNodePtr *lst); +xmlParseCtxtExternalEntity(xmlParserCtxtPtr ctx, + const xmlChar *URL, + const xmlChar *ID, + xmlNodePtr *lst); /* * Parser contexts handling. */ XMLPUBFUN xmlParserCtxtPtr XMLCALL - xmlNewParserCtxt (void); +xmlNewParserCtxt (void); XMLPUBFUN int XMLCALL - xmlInitParserCtxt (xmlParserCtxtPtr ctxt); +xmlInitParserCtxt (xmlParserCtxtPtr ctxt); XMLPUBFUN void XMLCALL - xmlClearParserCtxt (xmlParserCtxtPtr ctxt); +xmlClearParserCtxt (xmlParserCtxtPtr ctxt); XMLPUBFUN void XMLCALL - xmlFreeParserCtxt (xmlParserCtxtPtr ctxt); +xmlFreeParserCtxt (xmlParserCtxtPtr ctxt); #ifdef LIBXML_SAX1_ENABLED XMLPUBFUN void XMLCALL - xmlSetupParserForBuffer (xmlParserCtxtPtr ctxt, - const xmlChar* buffer, - const char *filename); +xmlSetupParserForBuffer (xmlParserCtxtPtr ctxt, + const xmlChar* buffer, + const char *filename); #endif /* LIBXML_SAX1_ENABLED */ XMLPUBFUN xmlParserCtxtPtr XMLCALL - xmlCreateDocParserCtxt (const xmlChar *cur); +xmlCreateDocParserCtxt (const xmlChar *cur); #ifdef LIBXML_LEGACY_ENABLED /* * Reading/setting optional parsing features. */ XMLPUBFUN int XMLCALL - xmlGetFeaturesList (int *len, - const char **result); +xmlGetFeaturesList (int *len, + const char **result); XMLPUBFUN int XMLCALL - xmlGetFeature (xmlParserCtxtPtr ctxt, - const char *name, - void *result); +xmlGetFeature (xmlParserCtxtPtr ctxt, + const char *name, + void *result); XMLPUBFUN int XMLCALL - xmlSetFeature (xmlParserCtxtPtr ctxt, - const char *name, - void *value); +xmlSetFeature (xmlParserCtxtPtr ctxt, + const char *name, + void *value); #endif /* LIBXML_LEGACY_ENABLED */ #ifdef LIBXML_PUSH_ENABLED @@ -1012,16 +1012,16 @@ XMLPUBFUN int XMLCALL * Interfaces for the Push mode. */ XMLPUBFUN xmlParserCtxtPtr XMLCALL - xmlCreatePushParserCtxt(xmlSAXHandlerPtr sax, - void *user_data, - const char *chunk, - int size, - const char *filename); +xmlCreatePushParserCtxt(xmlSAXHandlerPtr sax, + void *user_data, + const char *chunk, + int size, + const char *filename); XMLPUBFUN int XMLCALL - xmlParseChunk (xmlParserCtxtPtr ctxt, - const char *chunk, - int size, - int terminate); +xmlParseChunk (xmlParserCtxtPtr ctxt, + const char *chunk, + int size, + int terminate); #endif /* LIBXML_PUSH_ENABLED */ /* @@ -1029,53 +1029,53 @@ XMLPUBFUN int XMLCALL */ XMLPUBFUN xmlParserCtxtPtr XMLCALL - xmlCreateIOParserCtxt (xmlSAXHandlerPtr sax, - void *user_data, - xmlInputReadCallback ioread, - xmlInputCloseCallback ioclose, - void *ioctx, - xmlCharEncoding enc); +xmlCreateIOParserCtxt (xmlSAXHandlerPtr sax, + void *user_data, + xmlInputReadCallback ioread, + xmlInputCloseCallback ioclose, + void *ioctx, + xmlCharEncoding enc); XMLPUBFUN xmlParserInputPtr XMLCALL - xmlNewIOInputStream (xmlParserCtxtPtr ctxt, - xmlParserInputBufferPtr input, - xmlCharEncoding enc); +xmlNewIOInputStream (xmlParserCtxtPtr ctxt, + xmlParserInputBufferPtr input, + xmlCharEncoding enc); /* * Node infos. */ XMLPUBFUN const xmlParserNodeInfo* XMLCALL - xmlParserFindNodeInfo (const xmlParserCtxtPtr ctxt, - const xmlNodePtr node); +xmlParserFindNodeInfo (const xmlParserCtxtPtr ctxt, + const xmlNodePtr node); XMLPUBFUN void XMLCALL - xmlInitNodeInfoSeq (xmlParserNodeInfoSeqPtr seq); +xmlInitNodeInfoSeq (xmlParserNodeInfoSeqPtr seq); XMLPUBFUN void XMLCALL - xmlClearNodeInfoSeq (xmlParserNodeInfoSeqPtr seq); +xmlClearNodeInfoSeq (xmlParserNodeInfoSeqPtr seq); XMLPUBFUN unsigned long XMLCALL - xmlParserFindNodeInfoIndex(const xmlParserNodeInfoSeqPtr seq, - const xmlNodePtr node); +xmlParserFindNodeInfoIndex(const xmlParserNodeInfoSeqPtr seq, + const xmlNodePtr node); XMLPUBFUN void XMLCALL - xmlParserAddNodeInfo (xmlParserCtxtPtr ctxt, - const xmlParserNodeInfoPtr info); +xmlParserAddNodeInfo (xmlParserCtxtPtr ctxt, + const xmlParserNodeInfoPtr info); /* * External entities handling actually implemented in xmlIO. */ XMLPUBFUN void XMLCALL - xmlSetExternalEntityLoader(xmlExternalEntityLoader f); +xmlSetExternalEntityLoader(xmlExternalEntityLoader f); XMLPUBFUN xmlExternalEntityLoader XMLCALL - xmlGetExternalEntityLoader(void); +xmlGetExternalEntityLoader(void); XMLPUBFUN xmlParserInputPtr XMLCALL - xmlLoadExternalEntity (const char *URL, - const char *ID, - xmlParserCtxtPtr ctxt); +xmlLoadExternalEntity (const char *URL, + const char *ID, + xmlParserCtxtPtr ctxt); /* * Index lookup, actually implemented in the encoding module */ XMLPUBFUN long XMLCALL - xmlByteConsumed (xmlParserCtxtPtr ctxt); +xmlByteConsumed (xmlParserCtxtPtr ctxt); /* * New set of simpler/more flexible APIs @@ -1115,75 +1115,75 @@ typedef enum { } xmlParserOption; XMLPUBFUN void XMLCALL - xmlCtxtReset (xmlParserCtxtPtr ctxt); +xmlCtxtReset (xmlParserCtxtPtr ctxt); XMLPUBFUN int XMLCALL - xmlCtxtResetPush (xmlParserCtxtPtr ctxt, - const char *chunk, - int size, - const char *filename, - const char *encoding); +xmlCtxtResetPush (xmlParserCtxtPtr ctxt, + const char *chunk, + int size, + const char *filename, + const char *encoding); XMLPUBFUN int XMLCALL - xmlCtxtUseOptions (xmlParserCtxtPtr ctxt, - int options); +xmlCtxtUseOptions (xmlParserCtxtPtr ctxt, + int options); XMLPUBFUN xmlDocPtr XMLCALL - xmlReadDoc (const xmlChar *cur, - const char *URL, - const char *encoding, - int options); +xmlReadDoc (const xmlChar *cur, + const char *URL, + const char *encoding, + int options); XMLPUBFUN xmlDocPtr XMLCALL - xmlReadFile (const char *URL, - const char *encoding, - int options); +xmlReadFile (const char *URL, + const char *encoding, + int options); XMLPUBFUN xmlDocPtr XMLCALL - xmlReadMemory (const char *buffer, - int size, - const char *URL, - const char *encoding, - int options); +xmlReadMemory (const char *buffer, + int size, + const char *URL, + const char *encoding, + int options); XMLPUBFUN xmlDocPtr XMLCALL - xmlReadFd (int fd, - const char *URL, - const char *encoding, - int options); +xmlReadFd (int fd, + const char *URL, + const char *encoding, + int options); XMLPUBFUN xmlDocPtr XMLCALL - xmlReadIO (xmlInputReadCallback ioread, - xmlInputCloseCallback ioclose, - void *ioctx, - const char *URL, - const char *encoding, - int options); +xmlReadIO (xmlInputReadCallback ioread, + xmlInputCloseCallback ioclose, + void *ioctx, + const char *URL, + const char *encoding, + int options); XMLPUBFUN xmlDocPtr XMLCALL - xmlCtxtReadDoc (xmlParserCtxtPtr ctxt, - const xmlChar *cur, - const char *URL, - const char *encoding, - int options); +xmlCtxtReadDoc (xmlParserCtxtPtr ctxt, + const xmlChar *cur, + const char *URL, + const char *encoding, + int options); XMLPUBFUN xmlDocPtr XMLCALL - xmlCtxtReadFile (xmlParserCtxtPtr ctxt, - const char *filename, - const char *encoding, - int options); +xmlCtxtReadFile (xmlParserCtxtPtr ctxt, + const char *filename, + const char *encoding, + int options); XMLPUBFUN xmlDocPtr XMLCALL - xmlCtxtReadMemory (xmlParserCtxtPtr ctxt, - const char *buffer, - int size, - const char *URL, - const char *encoding, - int options); +xmlCtxtReadMemory (xmlParserCtxtPtr ctxt, + const char *buffer, + int size, + const char *URL, + const char *encoding, + int options); XMLPUBFUN xmlDocPtr XMLCALL - xmlCtxtReadFd (xmlParserCtxtPtr ctxt, - int fd, - const char *URL, - const char *encoding, - int options); +xmlCtxtReadFd (xmlParserCtxtPtr ctxt, + int fd, + const char *URL, + const char *encoding, + int options); XMLPUBFUN xmlDocPtr XMLCALL - xmlCtxtReadIO (xmlParserCtxtPtr ctxt, - xmlInputReadCallback ioread, - xmlInputCloseCallback ioclose, - void *ioctx, - const char *URL, - const char *encoding, - int options); +xmlCtxtReadIO (xmlParserCtxtPtr ctxt, + xmlInputReadCallback ioread, + xmlInputCloseCallback ioclose, + void *ioctx, + const char *URL, + const char *encoding, + int options); /* * Library wide options @@ -1233,7 +1233,7 @@ typedef enum { } xmlFeature; XMLPUBFUN int XMLCALL - xmlHasFeature (xmlFeature feature); +xmlHasFeature (xmlFeature feature); #ifdef __cplusplus } diff --git a/thirdparties/common/include/libxml2/libxml/parserInternals.h b/thirdparties/common/include/libxml2/libxml/parserInternals.h index 6065320..0b05911 100755 --- a/thirdparties/common/include/libxml2/libxml/parserInternals.h +++ b/thirdparties/common/include/libxml2/libxml/parserInternals.h @@ -322,177 +322,177 @@ XMLPUBFUN int XMLCALL xmlIsLetter (int c); * Parser context. */ XMLPUBFUN xmlParserCtxtPtr XMLCALL - xmlCreateFileParserCtxt (const char *filename); +xmlCreateFileParserCtxt (const char *filename); XMLPUBFUN xmlParserCtxtPtr XMLCALL - xmlCreateURLParserCtxt (const char *filename, - int options); +xmlCreateURLParserCtxt (const char *filename, + int options); XMLPUBFUN xmlParserCtxtPtr XMLCALL - xmlCreateMemoryParserCtxt(const char *buffer, - int size); +xmlCreateMemoryParserCtxt(const char *buffer, + int size); XMLPUBFUN xmlParserCtxtPtr XMLCALL - xmlCreateEntityParserCtxt(const xmlChar *URL, - const xmlChar *ID, - const xmlChar *base); +xmlCreateEntityParserCtxt(const xmlChar *URL, + const xmlChar *ID, + const xmlChar *base); XMLPUBFUN int XMLCALL - xmlSwitchEncoding (xmlParserCtxtPtr ctxt, - xmlCharEncoding enc); +xmlSwitchEncoding (xmlParserCtxtPtr ctxt, + xmlCharEncoding enc); XMLPUBFUN int XMLCALL - xmlSwitchToEncoding (xmlParserCtxtPtr ctxt, - xmlCharEncodingHandlerPtr handler); +xmlSwitchToEncoding (xmlParserCtxtPtr ctxt, + xmlCharEncodingHandlerPtr handler); XMLPUBFUN int XMLCALL - xmlSwitchInputEncoding (xmlParserCtxtPtr ctxt, - xmlParserInputPtr input, - xmlCharEncodingHandlerPtr handler); +xmlSwitchInputEncoding (xmlParserCtxtPtr ctxt, + xmlParserInputPtr input, + xmlCharEncodingHandlerPtr handler); #ifdef IN_LIBXML /* internal error reporting */ XMLPUBFUN void XMLCALL - __xmlErrEncoding (xmlParserCtxtPtr ctxt, - xmlParserErrors xmlerr, - const char *msg, - const xmlChar * str1, - const xmlChar * str2); +__xmlErrEncoding (xmlParserCtxtPtr ctxt, + xmlParserErrors xmlerr, + const char *msg, + const xmlChar * str1, + const xmlChar * str2); #endif /** * Input Streams. */ XMLPUBFUN xmlParserInputPtr XMLCALL - xmlNewStringInputStream (xmlParserCtxtPtr ctxt, - const xmlChar *buffer); +xmlNewStringInputStream (xmlParserCtxtPtr ctxt, + const xmlChar *buffer); XMLPUBFUN xmlParserInputPtr XMLCALL - xmlNewEntityInputStream (xmlParserCtxtPtr ctxt, - xmlEntityPtr entity); +xmlNewEntityInputStream (xmlParserCtxtPtr ctxt, + xmlEntityPtr entity); XMLPUBFUN int XMLCALL - xmlPushInput (xmlParserCtxtPtr ctxt, - xmlParserInputPtr input); +xmlPushInput (xmlParserCtxtPtr ctxt, + xmlParserInputPtr input); XMLPUBFUN xmlChar XMLCALL - xmlPopInput (xmlParserCtxtPtr ctxt); +xmlPopInput (xmlParserCtxtPtr ctxt); XMLPUBFUN void XMLCALL - xmlFreeInputStream (xmlParserInputPtr input); +xmlFreeInputStream (xmlParserInputPtr input); XMLPUBFUN xmlParserInputPtr XMLCALL - xmlNewInputFromFile (xmlParserCtxtPtr ctxt, - const char *filename); +xmlNewInputFromFile (xmlParserCtxtPtr ctxt, + const char *filename); XMLPUBFUN xmlParserInputPtr XMLCALL - xmlNewInputStream (xmlParserCtxtPtr ctxt); +xmlNewInputStream (xmlParserCtxtPtr ctxt); /** * Namespaces. */ XMLPUBFUN xmlChar * XMLCALL - xmlSplitQName (xmlParserCtxtPtr ctxt, - const xmlChar *name, - xmlChar **prefix); +xmlSplitQName (xmlParserCtxtPtr ctxt, + const xmlChar *name, + xmlChar **prefix); /** * Generic production rules. */ XMLPUBFUN const xmlChar * XMLCALL - xmlParseName (xmlParserCtxtPtr ctxt); +xmlParseName (xmlParserCtxtPtr ctxt); XMLPUBFUN xmlChar * XMLCALL - xmlParseNmtoken (xmlParserCtxtPtr ctxt); +xmlParseNmtoken (xmlParserCtxtPtr ctxt); XMLPUBFUN xmlChar * XMLCALL - xmlParseEntityValue (xmlParserCtxtPtr ctxt, - xmlChar **orig); +xmlParseEntityValue (xmlParserCtxtPtr ctxt, + xmlChar **orig); XMLPUBFUN xmlChar * XMLCALL - xmlParseAttValue (xmlParserCtxtPtr ctxt); +xmlParseAttValue (xmlParserCtxtPtr ctxt); XMLPUBFUN xmlChar * XMLCALL - xmlParseSystemLiteral (xmlParserCtxtPtr ctxt); +xmlParseSystemLiteral (xmlParserCtxtPtr ctxt); XMLPUBFUN xmlChar * XMLCALL - xmlParsePubidLiteral (xmlParserCtxtPtr ctxt); +xmlParsePubidLiteral (xmlParserCtxtPtr ctxt); XMLPUBFUN void XMLCALL - xmlParseCharData (xmlParserCtxtPtr ctxt, - int cdata); +xmlParseCharData (xmlParserCtxtPtr ctxt, + int cdata); XMLPUBFUN xmlChar * XMLCALL - xmlParseExternalID (xmlParserCtxtPtr ctxt, - xmlChar **publicID, - int strict); +xmlParseExternalID (xmlParserCtxtPtr ctxt, + xmlChar **publicID, + int strict); XMLPUBFUN void XMLCALL - xmlParseComment (xmlParserCtxtPtr ctxt); +xmlParseComment (xmlParserCtxtPtr ctxt); XMLPUBFUN const xmlChar * XMLCALL - xmlParsePITarget (xmlParserCtxtPtr ctxt); +xmlParsePITarget (xmlParserCtxtPtr ctxt); XMLPUBFUN void XMLCALL - xmlParsePI (xmlParserCtxtPtr ctxt); +xmlParsePI (xmlParserCtxtPtr ctxt); XMLPUBFUN void XMLCALL - xmlParseNotationDecl (xmlParserCtxtPtr ctxt); +xmlParseNotationDecl (xmlParserCtxtPtr ctxt); XMLPUBFUN void XMLCALL - xmlParseEntityDecl (xmlParserCtxtPtr ctxt); +xmlParseEntityDecl (xmlParserCtxtPtr ctxt); XMLPUBFUN int XMLCALL - xmlParseDefaultDecl (xmlParserCtxtPtr ctxt, - xmlChar **value); +xmlParseDefaultDecl (xmlParserCtxtPtr ctxt, + xmlChar **value); XMLPUBFUN xmlEnumerationPtr XMLCALL - xmlParseNotationType (xmlParserCtxtPtr ctxt); +xmlParseNotationType (xmlParserCtxtPtr ctxt); XMLPUBFUN xmlEnumerationPtr XMLCALL - xmlParseEnumerationType (xmlParserCtxtPtr ctxt); +xmlParseEnumerationType (xmlParserCtxtPtr ctxt); XMLPUBFUN int XMLCALL - xmlParseEnumeratedType (xmlParserCtxtPtr ctxt, - xmlEnumerationPtr *tree); +xmlParseEnumeratedType (xmlParserCtxtPtr ctxt, + xmlEnumerationPtr *tree); XMLPUBFUN int XMLCALL - xmlParseAttributeType (xmlParserCtxtPtr ctxt, - xmlEnumerationPtr *tree); +xmlParseAttributeType (xmlParserCtxtPtr ctxt, + xmlEnumerationPtr *tree); XMLPUBFUN void XMLCALL - xmlParseAttributeListDecl(xmlParserCtxtPtr ctxt); +xmlParseAttributeListDecl(xmlParserCtxtPtr ctxt); XMLPUBFUN xmlElementContentPtr XMLCALL - xmlParseElementMixedContentDecl - (xmlParserCtxtPtr ctxt, - int inputchk); +xmlParseElementMixedContentDecl +(xmlParserCtxtPtr ctxt, + int inputchk); XMLPUBFUN xmlElementContentPtr XMLCALL - xmlParseElementChildrenContentDecl - (xmlParserCtxtPtr ctxt, - int inputchk); +xmlParseElementChildrenContentDecl +(xmlParserCtxtPtr ctxt, + int inputchk); XMLPUBFUN int XMLCALL - xmlParseElementContentDecl(xmlParserCtxtPtr ctxt, - const xmlChar *name, - xmlElementContentPtr *result); +xmlParseElementContentDecl(xmlParserCtxtPtr ctxt, + const xmlChar *name, + xmlElementContentPtr *result); XMLPUBFUN int XMLCALL - xmlParseElementDecl (xmlParserCtxtPtr ctxt); +xmlParseElementDecl (xmlParserCtxtPtr ctxt); XMLPUBFUN void XMLCALL - xmlParseMarkupDecl (xmlParserCtxtPtr ctxt); +xmlParseMarkupDecl (xmlParserCtxtPtr ctxt); XMLPUBFUN int XMLCALL - xmlParseCharRef (xmlParserCtxtPtr ctxt); +xmlParseCharRef (xmlParserCtxtPtr ctxt); XMLPUBFUN xmlEntityPtr XMLCALL - xmlParseEntityRef (xmlParserCtxtPtr ctxt); +xmlParseEntityRef (xmlParserCtxtPtr ctxt); XMLPUBFUN void XMLCALL - xmlParseReference (xmlParserCtxtPtr ctxt); +xmlParseReference (xmlParserCtxtPtr ctxt); XMLPUBFUN void XMLCALL - xmlParsePEReference (xmlParserCtxtPtr ctxt); +xmlParsePEReference (xmlParserCtxtPtr ctxt); XMLPUBFUN void XMLCALL - xmlParseDocTypeDecl (xmlParserCtxtPtr ctxt); +xmlParseDocTypeDecl (xmlParserCtxtPtr ctxt); #ifdef LIBXML_SAX1_ENABLED XMLPUBFUN const xmlChar * XMLCALL - xmlParseAttribute (xmlParserCtxtPtr ctxt, - xmlChar **value); +xmlParseAttribute (xmlParserCtxtPtr ctxt, + xmlChar **value); XMLPUBFUN const xmlChar * XMLCALL - xmlParseStartTag (xmlParserCtxtPtr ctxt); +xmlParseStartTag (xmlParserCtxtPtr ctxt); XMLPUBFUN void XMLCALL - xmlParseEndTag (xmlParserCtxtPtr ctxt); +xmlParseEndTag (xmlParserCtxtPtr ctxt); #endif /* LIBXML_SAX1_ENABLED */ XMLPUBFUN void XMLCALL - xmlParseCDSect (xmlParserCtxtPtr ctxt); +xmlParseCDSect (xmlParserCtxtPtr ctxt); XMLPUBFUN void XMLCALL - xmlParseContent (xmlParserCtxtPtr ctxt); +xmlParseContent (xmlParserCtxtPtr ctxt); XMLPUBFUN void XMLCALL - xmlParseElement (xmlParserCtxtPtr ctxt); +xmlParseElement (xmlParserCtxtPtr ctxt); XMLPUBFUN xmlChar * XMLCALL - xmlParseVersionNum (xmlParserCtxtPtr ctxt); +xmlParseVersionNum (xmlParserCtxtPtr ctxt); XMLPUBFUN xmlChar * XMLCALL - xmlParseVersionInfo (xmlParserCtxtPtr ctxt); +xmlParseVersionInfo (xmlParserCtxtPtr ctxt); XMLPUBFUN xmlChar * XMLCALL - xmlParseEncName (xmlParserCtxtPtr ctxt); +xmlParseEncName (xmlParserCtxtPtr ctxt); XMLPUBFUN const xmlChar * XMLCALL - xmlParseEncodingDecl (xmlParserCtxtPtr ctxt); +xmlParseEncodingDecl (xmlParserCtxtPtr ctxt); XMLPUBFUN int XMLCALL - xmlParseSDDecl (xmlParserCtxtPtr ctxt); +xmlParseSDDecl (xmlParserCtxtPtr ctxt); XMLPUBFUN void XMLCALL - xmlParseXMLDecl (xmlParserCtxtPtr ctxt); +xmlParseXMLDecl (xmlParserCtxtPtr ctxt); XMLPUBFUN void XMLCALL - xmlParseTextDecl (xmlParserCtxtPtr ctxt); +xmlParseTextDecl (xmlParserCtxtPtr ctxt); XMLPUBFUN void XMLCALL - xmlParseMisc (xmlParserCtxtPtr ctxt); +xmlParseMisc (xmlParserCtxtPtr ctxt); XMLPUBFUN void XMLCALL - xmlParseExternalSubset (xmlParserCtxtPtr ctxt, - const xmlChar *ExternalID, - const xmlChar *SystemID); +xmlParseExternalSubset (xmlParserCtxtPtr ctxt, + const xmlChar *ExternalID, + const xmlChar *SystemID); /** * XML_SUBSTITUTE_NONE: * @@ -519,41 +519,41 @@ XMLPUBFUN void XMLCALL #define XML_SUBSTITUTE_BOTH 3 XMLPUBFUN xmlChar * XMLCALL - xmlStringDecodeEntities (xmlParserCtxtPtr ctxt, - const xmlChar *str, - int what, - xmlChar end, - xmlChar end2, - xmlChar end3); +xmlStringDecodeEntities (xmlParserCtxtPtr ctxt, + const xmlChar *str, + int what, + xmlChar end, + xmlChar end2, + xmlChar end3); XMLPUBFUN xmlChar * XMLCALL - xmlStringLenDecodeEntities (xmlParserCtxtPtr ctxt, - const xmlChar *str, - int len, - int what, - xmlChar end, - xmlChar end2, - xmlChar end3); +xmlStringLenDecodeEntities (xmlParserCtxtPtr ctxt, + const xmlChar *str, + int len, + int what, + xmlChar end, + xmlChar end2, + xmlChar end3); /* * Generated by MACROS on top of parser.c c.f. PUSH_AND_POP. */ XMLPUBFUN int XMLCALL nodePush (xmlParserCtxtPtr ctxt, - xmlNodePtr value); + xmlNodePtr value); XMLPUBFUN xmlNodePtr XMLCALL nodePop (xmlParserCtxtPtr ctxt); XMLPUBFUN int XMLCALL inputPush (xmlParserCtxtPtr ctxt, - xmlParserInputPtr value); + xmlParserInputPtr value); XMLPUBFUN xmlParserInputPtr XMLCALL inputPop (xmlParserCtxtPtr ctxt); XMLPUBFUN const xmlChar * XMLCALL namePop (xmlParserCtxtPtr ctxt); XMLPUBFUN int XMLCALL namePush (xmlParserCtxtPtr ctxt, - const xmlChar *value); + const xmlChar *value); /* * other commodities shared between parser.c and parserInternals. */ XMLPUBFUN int XMLCALL xmlSkipBlankChars (xmlParserCtxtPtr ctxt); XMLPUBFUN int XMLCALL xmlStringCurrentChar (xmlParserCtxtPtr ctxt, - const xmlChar *cur, - int *len); + const xmlChar *cur, + int *len); XMLPUBFUN void XMLCALL xmlParserHandlePEReference(xmlParserCtxtPtr ctxt); XMLPUBFUN int XMLCALL xmlCheckLanguageID (const xmlChar *lang); @@ -561,12 +561,12 @@ XMLPUBFUN int XMLCALL xmlCheckLanguageID (const xmlChar *lang); * Really core function shared with HTML parser. */ XMLPUBFUN int XMLCALL xmlCurrentChar (xmlParserCtxtPtr ctxt, - int *len); + int *len); XMLPUBFUN int XMLCALL xmlCopyCharMultiByte (xmlChar *out, - int val); + int val); XMLPUBFUN int XMLCALL xmlCopyChar (int len, - xmlChar *out, - int val); + xmlChar *out, + int val); XMLPUBFUN void XMLCALL xmlNextChar (xmlParserCtxtPtr ctxt); XMLPUBFUN void XMLCALL xmlParserInputShrink (xmlParserInputPtr in); @@ -576,7 +576,7 @@ XMLPUBFUN void XMLCALL xmlParserInputShrink (xmlParserInputPtr in); */ XMLPUBFUN void XMLCALL htmlInitAutoClose (void); XMLPUBFUN htmlParserCtxtPtr XMLCALL htmlCreateFileParserCtxt(const char *filename, - const char *encoding); + const char *encoding); #endif /* @@ -594,38 +594,38 @@ XMLPUBFUN htmlParserCtxtPtr XMLCALL htmlCreateFileParserCtxt(const char *filenam * provenance of a chunk of nodes inherited from an entity replacement. */ typedef void (*xmlEntityReferenceFunc) (xmlEntityPtr ent, - xmlNodePtr firstNode, - xmlNodePtr lastNode); + xmlNodePtr firstNode, + xmlNodePtr lastNode); XMLPUBFUN void XMLCALL xmlSetEntityReferenceFunc (xmlEntityReferenceFunc func); XMLPUBFUN xmlChar * XMLCALL - xmlParseQuotedString (xmlParserCtxtPtr ctxt); +xmlParseQuotedString (xmlParserCtxtPtr ctxt); XMLPUBFUN void XMLCALL - xmlParseNamespace (xmlParserCtxtPtr ctxt); +xmlParseNamespace (xmlParserCtxtPtr ctxt); XMLPUBFUN xmlChar * XMLCALL - xmlNamespaceParseNSDef (xmlParserCtxtPtr ctxt); +xmlNamespaceParseNSDef (xmlParserCtxtPtr ctxt); XMLPUBFUN xmlChar * XMLCALL - xmlScanName (xmlParserCtxtPtr ctxt); +xmlScanName (xmlParserCtxtPtr ctxt); XMLPUBFUN xmlChar * XMLCALL - xmlNamespaceParseNCName (xmlParserCtxtPtr ctxt); +xmlNamespaceParseNCName (xmlParserCtxtPtr ctxt); XMLPUBFUN void XMLCALL xmlParserHandleReference(xmlParserCtxtPtr ctxt); XMLPUBFUN xmlChar * XMLCALL - xmlNamespaceParseQName (xmlParserCtxtPtr ctxt, - xmlChar **prefix); +xmlNamespaceParseQName (xmlParserCtxtPtr ctxt, + xmlChar **prefix); /** * Entities */ XMLPUBFUN xmlChar * XMLCALL - xmlDecodeEntities (xmlParserCtxtPtr ctxt, - int len, - int what, - xmlChar end, - xmlChar end2, - xmlChar end3); +xmlDecodeEntities (xmlParserCtxtPtr ctxt, + int len, + int what, + xmlChar end, + xmlChar end2, + xmlChar end3); XMLPUBFUN void XMLCALL - xmlHandleEntity (xmlParserCtxtPtr ctxt, - xmlEntityPtr entity); +xmlHandleEntity (xmlParserCtxtPtr ctxt, + xmlEntityPtr entity); #endif /* LIBXML_LEGACY_ENABLED */ @@ -634,8 +634,8 @@ XMLPUBFUN void XMLCALL * internal only */ XMLPUBFUN void XMLCALL - xmlErrMemory (xmlParserCtxtPtr ctxt, - const char *extra); +xmlErrMemory (xmlParserCtxtPtr ctxt, + const char *extra); #endif #ifdef __cplusplus diff --git a/thirdparties/common/include/libxml2/libxml/pattern.h b/thirdparties/common/include/libxml2/libxml/pattern.h index 97d2cd2..a697145 100755 --- a/thirdparties/common/include/libxml2/libxml/pattern.h +++ b/thirdparties/common/include/libxml2/libxml/pattern.h @@ -44,53 +44,53 @@ typedef enum { } xmlPatternFlags; XMLPUBFUN void XMLCALL - xmlFreePattern (xmlPatternPtr comp); +xmlFreePattern (xmlPatternPtr comp); XMLPUBFUN void XMLCALL - xmlFreePatternList (xmlPatternPtr comp); +xmlFreePatternList (xmlPatternPtr comp); XMLPUBFUN xmlPatternPtr XMLCALL - xmlPatterncompile (const xmlChar *pattern, - xmlDict *dict, - int flags, - const xmlChar **namespaces); +xmlPatterncompile (const xmlChar *pattern, + xmlDict *dict, + int flags, + const xmlChar **namespaces); XMLPUBFUN int XMLCALL - xmlPatternMatch (xmlPatternPtr comp, - xmlNodePtr node); +xmlPatternMatch (xmlPatternPtr comp, + xmlNodePtr node); /* streaming interfaces */ typedef struct _xmlStreamCtxt xmlStreamCtxt; typedef xmlStreamCtxt *xmlStreamCtxtPtr; XMLPUBFUN int XMLCALL - xmlPatternStreamable (xmlPatternPtr comp); +xmlPatternStreamable (xmlPatternPtr comp); XMLPUBFUN int XMLCALL - xmlPatternMaxDepth (xmlPatternPtr comp); +xmlPatternMaxDepth (xmlPatternPtr comp); XMLPUBFUN int XMLCALL - xmlPatternMinDepth (xmlPatternPtr comp); +xmlPatternMinDepth (xmlPatternPtr comp); XMLPUBFUN int XMLCALL - xmlPatternFromRoot (xmlPatternPtr comp); +xmlPatternFromRoot (xmlPatternPtr comp); XMLPUBFUN xmlStreamCtxtPtr XMLCALL - xmlPatternGetStreamCtxt (xmlPatternPtr comp); +xmlPatternGetStreamCtxt (xmlPatternPtr comp); XMLPUBFUN void XMLCALL - xmlFreeStreamCtxt (xmlStreamCtxtPtr stream); +xmlFreeStreamCtxt (xmlStreamCtxtPtr stream); XMLPUBFUN int XMLCALL - xmlStreamPushNode (xmlStreamCtxtPtr stream, - const xmlChar *name, - const xmlChar *ns, - int nodeType); +xmlStreamPushNode (xmlStreamCtxtPtr stream, + const xmlChar *name, + const xmlChar *ns, + int nodeType); XMLPUBFUN int XMLCALL - xmlStreamPush (xmlStreamCtxtPtr stream, - const xmlChar *name, - const xmlChar *ns); +xmlStreamPush (xmlStreamCtxtPtr stream, + const xmlChar *name, + const xmlChar *ns); XMLPUBFUN int XMLCALL - xmlStreamPushAttr (xmlStreamCtxtPtr stream, - const xmlChar *name, - const xmlChar *ns); +xmlStreamPushAttr (xmlStreamCtxtPtr stream, + const xmlChar *name, + const xmlChar *ns); XMLPUBFUN int XMLCALL - xmlStreamPop (xmlStreamCtxtPtr stream); +xmlStreamPop (xmlStreamCtxtPtr stream); XMLPUBFUN int XMLCALL - xmlStreamWantsAnyNode (xmlStreamCtxtPtr stream); +xmlStreamWantsAnyNode (xmlStreamCtxtPtr stream); #ifdef __cplusplus } #endif diff --git a/thirdparties/common/include/libxml2/libxml/relaxng.h b/thirdparties/common/include/libxml2/libxml/relaxng.h index bdb0a7d..59695c4 100755 --- a/thirdparties/common/include/libxml2/libxml/relaxng.h +++ b/thirdparties/common/include/libxml2/libxml/relaxng.h @@ -113,96 +113,96 @@ typedef enum { } xmlRelaxNGParserFlag; XMLPUBFUN int XMLCALL - xmlRelaxNGInitTypes (void); +xmlRelaxNGInitTypes (void); XMLPUBFUN void XMLCALL - xmlRelaxNGCleanupTypes (void); +xmlRelaxNGCleanupTypes (void); /* * Interfaces for parsing. */ XMLPUBFUN xmlRelaxNGParserCtxtPtr XMLCALL - xmlRelaxNGNewParserCtxt (const char *URL); +xmlRelaxNGNewParserCtxt (const char *URL); XMLPUBFUN xmlRelaxNGParserCtxtPtr XMLCALL - xmlRelaxNGNewMemParserCtxt (const char *buffer, - int size); +xmlRelaxNGNewMemParserCtxt (const char *buffer, + int size); XMLPUBFUN xmlRelaxNGParserCtxtPtr XMLCALL - xmlRelaxNGNewDocParserCtxt (xmlDocPtr doc); +xmlRelaxNGNewDocParserCtxt (xmlDocPtr doc); XMLPUBFUN int XMLCALL - xmlRelaxParserSetFlag (xmlRelaxNGParserCtxtPtr ctxt, - int flag); +xmlRelaxParserSetFlag (xmlRelaxNGParserCtxtPtr ctxt, + int flag); XMLPUBFUN void XMLCALL - xmlRelaxNGFreeParserCtxt (xmlRelaxNGParserCtxtPtr ctxt); +xmlRelaxNGFreeParserCtxt (xmlRelaxNGParserCtxtPtr ctxt); XMLPUBFUN void XMLCALL - xmlRelaxNGSetParserErrors(xmlRelaxNGParserCtxtPtr ctxt, - xmlRelaxNGValidityErrorFunc err, - xmlRelaxNGValidityWarningFunc warn, - void *ctx); +xmlRelaxNGSetParserErrors(xmlRelaxNGParserCtxtPtr ctxt, + xmlRelaxNGValidityErrorFunc err, + xmlRelaxNGValidityWarningFunc warn, + void *ctx); XMLPUBFUN int XMLCALL - xmlRelaxNGGetParserErrors(xmlRelaxNGParserCtxtPtr ctxt, - xmlRelaxNGValidityErrorFunc *err, - xmlRelaxNGValidityWarningFunc *warn, - void **ctx); +xmlRelaxNGGetParserErrors(xmlRelaxNGParserCtxtPtr ctxt, + xmlRelaxNGValidityErrorFunc *err, + xmlRelaxNGValidityWarningFunc *warn, + void **ctx); XMLPUBFUN void XMLCALL - xmlRelaxNGSetParserStructuredErrors( - xmlRelaxNGParserCtxtPtr ctxt, - xmlStructuredErrorFunc serror, - void *ctx); +xmlRelaxNGSetParserStructuredErrors( + xmlRelaxNGParserCtxtPtr ctxt, + xmlStructuredErrorFunc serror, + void *ctx); XMLPUBFUN xmlRelaxNGPtr XMLCALL - xmlRelaxNGParse (xmlRelaxNGParserCtxtPtr ctxt); +xmlRelaxNGParse (xmlRelaxNGParserCtxtPtr ctxt); XMLPUBFUN void XMLCALL - xmlRelaxNGFree (xmlRelaxNGPtr schema); +xmlRelaxNGFree (xmlRelaxNGPtr schema); #ifdef LIBXML_OUTPUT_ENABLED XMLPUBFUN void XMLCALL - xmlRelaxNGDump (FILE *output, - xmlRelaxNGPtr schema); +xmlRelaxNGDump (FILE *output, + xmlRelaxNGPtr schema); XMLPUBFUN void XMLCALL - xmlRelaxNGDumpTree (FILE * output, - xmlRelaxNGPtr schema); +xmlRelaxNGDumpTree (FILE * output, + xmlRelaxNGPtr schema); #endif /* LIBXML_OUTPUT_ENABLED */ /* * Interfaces for validating */ XMLPUBFUN void XMLCALL - xmlRelaxNGSetValidErrors(xmlRelaxNGValidCtxtPtr ctxt, - xmlRelaxNGValidityErrorFunc err, - xmlRelaxNGValidityWarningFunc warn, - void *ctx); +xmlRelaxNGSetValidErrors(xmlRelaxNGValidCtxtPtr ctxt, + xmlRelaxNGValidityErrorFunc err, + xmlRelaxNGValidityWarningFunc warn, + void *ctx); XMLPUBFUN int XMLCALL - xmlRelaxNGGetValidErrors(xmlRelaxNGValidCtxtPtr ctxt, - xmlRelaxNGValidityErrorFunc *err, - xmlRelaxNGValidityWarningFunc *warn, - void **ctx); +xmlRelaxNGGetValidErrors(xmlRelaxNGValidCtxtPtr ctxt, + xmlRelaxNGValidityErrorFunc *err, + xmlRelaxNGValidityWarningFunc *warn, + void **ctx); XMLPUBFUN void XMLCALL - xmlRelaxNGSetValidStructuredErrors(xmlRelaxNGValidCtxtPtr ctxt, - xmlStructuredErrorFunc serror, void *ctx); +xmlRelaxNGSetValidStructuredErrors(xmlRelaxNGValidCtxtPtr ctxt, + xmlStructuredErrorFunc serror, void *ctx); XMLPUBFUN xmlRelaxNGValidCtxtPtr XMLCALL - xmlRelaxNGNewValidCtxt (xmlRelaxNGPtr schema); +xmlRelaxNGNewValidCtxt (xmlRelaxNGPtr schema); XMLPUBFUN void XMLCALL - xmlRelaxNGFreeValidCtxt (xmlRelaxNGValidCtxtPtr ctxt); +xmlRelaxNGFreeValidCtxt (xmlRelaxNGValidCtxtPtr ctxt); XMLPUBFUN int XMLCALL - xmlRelaxNGValidateDoc (xmlRelaxNGValidCtxtPtr ctxt, - xmlDocPtr doc); +xmlRelaxNGValidateDoc (xmlRelaxNGValidCtxtPtr ctxt, + xmlDocPtr doc); /* * Interfaces for progressive validation when possible */ XMLPUBFUN int XMLCALL - xmlRelaxNGValidatePushElement (xmlRelaxNGValidCtxtPtr ctxt, - xmlDocPtr doc, - xmlNodePtr elem); +xmlRelaxNGValidatePushElement (xmlRelaxNGValidCtxtPtr ctxt, + xmlDocPtr doc, + xmlNodePtr elem); XMLPUBFUN int XMLCALL - xmlRelaxNGValidatePushCData (xmlRelaxNGValidCtxtPtr ctxt, - const xmlChar *data, - int len); +xmlRelaxNGValidatePushCData (xmlRelaxNGValidCtxtPtr ctxt, + const xmlChar *data, + int len); XMLPUBFUN int XMLCALL - xmlRelaxNGValidatePopElement (xmlRelaxNGValidCtxtPtr ctxt, - xmlDocPtr doc, - xmlNodePtr elem); +xmlRelaxNGValidatePopElement (xmlRelaxNGValidCtxtPtr ctxt, + xmlDocPtr doc, + xmlNodePtr elem); XMLPUBFUN int XMLCALL - xmlRelaxNGValidateFullElement (xmlRelaxNGValidCtxtPtr ctxt, - xmlDocPtr doc, - xmlNodePtr elem); +xmlRelaxNGValidateFullElement (xmlRelaxNGValidCtxtPtr ctxt, + xmlDocPtr doc, + xmlNodePtr elem); #ifdef __cplusplus } diff --git a/thirdparties/common/include/libxml2/libxml/schemasInternals.h b/thirdparties/common/include/libxml2/libxml/schemasInternals.h index 4f0ca9a..67dd50e 100755 --- a/thirdparties/common/include/libxml2/libxml/schemasInternals.h +++ b/thirdparties/common/include/libxml2/libxml/schemasInternals.h @@ -74,7 +74,8 @@ typedef enum { XML_SCHEMAS_BASE64BINARY, XML_SCHEMAS_ANYTYPE, XML_SCHEMAS_ANYSIMPLETYPE -} xmlSchemaValType; +} +xmlSchemaValType; /* * XML Schemas defines multiple type of types. @@ -698,11 +699,11 @@ struct _xmlSchemaType { * references have been resolved. */ #define XML_SCHEMAS_ELEM_INTERNAL_RESOLVED 1 << 8 - /** - * XML_SCHEMAS_ELEM_CIRCULAR: - * - * a helper flag for the search of circular references. - */ +/** +* XML_SCHEMAS_ELEM_CIRCULAR: +* +* a helper flag for the search of circular references. +*/ #define XML_SCHEMAS_ELEM_CIRCULAR 1 << 9 /** * XML_SCHEMAS_ELEM_BLOCK_ABSENT: diff --git a/thirdparties/common/include/libxml2/libxml/schematron.h b/thirdparties/common/include/libxml2/libxml/schematron.h index 364eaec..8c835ad 100755 --- a/thirdparties/common/include/libxml2/libxml/schematron.h +++ b/thirdparties/common/include/libxml2/libxml/schematron.h @@ -29,7 +29,8 @@ typedef enum { XML_SCHEMATRON_OUT_FILE = 1 << 8, /* output to a file descriptor */ XML_SCHEMATRON_OUT_BUFFER = 1 << 9, /* output to a buffer */ XML_SCHEMATRON_OUT_IO = 1 << 10 /* output to I/O mechanism */ -} xmlSchematronValidOptions; +} +xmlSchematronValidOptions; /** * The schemas related types are kept internal @@ -70,14 +71,14 @@ typedef xmlSchematronValidCtxt *xmlSchematronValidCtxtPtr; * Interfaces for parsing. */ XMLPUBFUN xmlSchematronParserCtxtPtr XMLCALL - xmlSchematronNewParserCtxt (const char *URL); +xmlSchematronNewParserCtxt (const char *URL); XMLPUBFUN xmlSchematronParserCtxtPtr XMLCALL - xmlSchematronNewMemParserCtxt(const char *buffer, - int size); +xmlSchematronNewMemParserCtxt(const char *buffer, + int size); XMLPUBFUN xmlSchematronParserCtxtPtr XMLCALL - xmlSchematronNewDocParserCtxt(xmlDocPtr doc); +xmlSchematronNewDocParserCtxt(xmlDocPtr doc); XMLPUBFUN void XMLCALL - xmlSchematronFreeParserCtxt (xmlSchematronParserCtxtPtr ctxt); +xmlSchematronFreeParserCtxt (xmlSchematronParserCtxtPtr ctxt); /***** XMLPUBFUN void XMLCALL xmlSchematronSetParserErrors(xmlSchematronParserCtxtPtr ctxt, @@ -93,17 +94,17 @@ XMLPUBFUN int XMLCALL xmlSchematronIsValid (xmlSchematronValidCtxtPtr ctxt); *****/ XMLPUBFUN xmlSchematronPtr XMLCALL - xmlSchematronParse (xmlSchematronParserCtxtPtr ctxt); +xmlSchematronParse (xmlSchematronParserCtxtPtr ctxt); XMLPUBFUN void XMLCALL - xmlSchematronFree (xmlSchematronPtr schema); +xmlSchematronFree (xmlSchematronPtr schema); /* * Interfaces for validating */ XMLPUBFUN void XMLCALL - xmlSchematronSetValidStructuredErrors( - xmlSchematronValidCtxtPtr ctxt, - xmlStructuredErrorFunc serror, - void *ctx); +xmlSchematronSetValidStructuredErrors( + xmlSchematronValidCtxtPtr ctxt, + xmlStructuredErrorFunc serror, + void *ctx); /****** XMLPUBFUN void XMLCALL xmlSchematronSetValidErrors (xmlSchematronValidCtxtPtr ctxt, @@ -126,13 +127,13 @@ XMLPUBFUN int XMLCALL *******/ XMLPUBFUN xmlSchematronValidCtxtPtr XMLCALL - xmlSchematronNewValidCtxt (xmlSchematronPtr schema, - int options); +xmlSchematronNewValidCtxt (xmlSchematronPtr schema, + int options); XMLPUBFUN void XMLCALL - xmlSchematronFreeValidCtxt (xmlSchematronValidCtxtPtr ctxt); +xmlSchematronFreeValidCtxt (xmlSchematronValidCtxtPtr ctxt); XMLPUBFUN int XMLCALL - xmlSchematronValidateDoc (xmlSchematronValidCtxtPtr ctxt, - xmlDocPtr instance); +xmlSchematronValidateDoc (xmlSchematronValidCtxtPtr ctxt, + xmlDocPtr instance); #ifdef __cplusplus } diff --git a/thirdparties/common/include/libxml2/libxml/threads.h b/thirdparties/common/include/libxml2/libxml/threads.h index d31f16a..b9db53e 100755 --- a/thirdparties/common/include/libxml2/libxml/threads.h +++ b/thirdparties/common/include/libxml2/libxml/threads.h @@ -37,40 +37,40 @@ typedef xmlRMutex *xmlRMutexPtr; extern "C" { #endif XMLPUBFUN xmlMutexPtr XMLCALL - xmlNewMutex (void); +xmlNewMutex (void); XMLPUBFUN void XMLCALL - xmlMutexLock (xmlMutexPtr tok); +xmlMutexLock (xmlMutexPtr tok); XMLPUBFUN void XMLCALL - xmlMutexUnlock (xmlMutexPtr tok); +xmlMutexUnlock (xmlMutexPtr tok); XMLPUBFUN void XMLCALL - xmlFreeMutex (xmlMutexPtr tok); +xmlFreeMutex (xmlMutexPtr tok); XMLPUBFUN xmlRMutexPtr XMLCALL - xmlNewRMutex (void); +xmlNewRMutex (void); XMLPUBFUN void XMLCALL - xmlRMutexLock (xmlRMutexPtr tok); +xmlRMutexLock (xmlRMutexPtr tok); XMLPUBFUN void XMLCALL - xmlRMutexUnlock (xmlRMutexPtr tok); +xmlRMutexUnlock (xmlRMutexPtr tok); XMLPUBFUN void XMLCALL - xmlFreeRMutex (xmlRMutexPtr tok); +xmlFreeRMutex (xmlRMutexPtr tok); /* * Library wide APIs. */ XMLPUBFUN void XMLCALL - xmlInitThreads (void); +xmlInitThreads (void); XMLPUBFUN void XMLCALL - xmlLockLibrary (void); +xmlLockLibrary (void); XMLPUBFUN void XMLCALL - xmlUnlockLibrary(void); +xmlUnlockLibrary(void); XMLPUBFUN int XMLCALL - xmlGetThreadId (void); +xmlGetThreadId (void); XMLPUBFUN int XMLCALL - xmlIsMainThread (void); +xmlIsMainThread (void); XMLPUBFUN void XMLCALL - xmlCleanupThreads(void); +xmlCleanupThreads(void); XMLPUBFUN xmlGlobalStatePtr XMLCALL - xmlGetGlobalState(void); +xmlGetGlobalState(void); #if defined(HAVE_WIN32_THREADS) && !defined(HAVE_COMPILER_TLS) && defined(LIBXML_STATIC_FOR_DLL) int XMLCALL xmlDllMain(void *hinstDLL, unsigned long fdwReason, void *lpvReserved); diff --git a/thirdparties/common/include/libxml2/libxml/tree.h b/thirdparties/common/include/libxml2/libxml/tree.h index 7e06686..b08d863 100755 --- a/thirdparties/common/include/libxml2/libxml/tree.h +++ b/thirdparties/common/include/libxml2/libxml/tree.h @@ -177,7 +177,7 @@ typedef enum { XML_XINCLUDE_START= 19, XML_XINCLUDE_END= 20 #ifdef LIBXML_DOCB_ENABLED - ,XML_DOCB_DOCUMENT_NODE= 21 + ,XML_DOCB_DOCUMENT_NODE= 21 #endif } xmlElementType; @@ -600,9 +600,9 @@ typedef xmlDOMWrapCtxt *xmlDOMWrapCtxtPtr; * Returns an xmlNsPtr or NULL in case of an error. */ typedef xmlNsPtr (*xmlDOMWrapAcquireNsFunction) (xmlDOMWrapCtxtPtr ctxt, - xmlNodePtr node, - const xmlChar *nsName, - const xmlChar *nsPrefix); + xmlNodePtr node, + const xmlChar *nsName, + const xmlChar *nsPrefix); /** * xmlDOMWrapCtxt: @@ -656,478 +656,478 @@ struct _xmlDOMWrapCtxt { */ #if defined(LIBXML_TREE_ENABLED) || defined(LIBXML_XPATH_ENABLED) || defined(LIBXML_SCHEMAS_ENABLED) || defined(LIBXML_DEBUG_ENABLED) || defined (LIBXML_HTML_ENABLED) || defined(LIBXML_SAX1_ENABLED) || defined(LIBXML_HTML_ENABLED) || defined(LIBXML_WRITER_ENABLED) || defined(LIBXML_DOCB_ENABLED) XMLPUBFUN int XMLCALL - xmlValidateNCName (const xmlChar *value, - int space); +xmlValidateNCName (const xmlChar *value, + int space); #endif #if defined(LIBXML_TREE_ENABLED) || defined(LIBXML_SCHEMAS_ENABLED) XMLPUBFUN int XMLCALL - xmlValidateQName (const xmlChar *value, - int space); +xmlValidateQName (const xmlChar *value, + int space); XMLPUBFUN int XMLCALL - xmlValidateName (const xmlChar *value, - int space); +xmlValidateName (const xmlChar *value, + int space); XMLPUBFUN int XMLCALL - xmlValidateNMToken (const xmlChar *value, - int space); +xmlValidateNMToken (const xmlChar *value, + int space); #endif XMLPUBFUN xmlChar * XMLCALL - xmlBuildQName (const xmlChar *ncname, - const xmlChar *prefix, - xmlChar *memory, - int len); +xmlBuildQName (const xmlChar *ncname, + const xmlChar *prefix, + xmlChar *memory, + int len); XMLPUBFUN xmlChar * XMLCALL - xmlSplitQName2 (const xmlChar *name, - xmlChar **prefix); +xmlSplitQName2 (const xmlChar *name, + xmlChar **prefix); XMLPUBFUN const xmlChar * XMLCALL - xmlSplitQName3 (const xmlChar *name, - int *len); +xmlSplitQName3 (const xmlChar *name, + int *len); /* * Handling Buffers, the old ones see @xmlBuf for the new ones. */ XMLPUBFUN void XMLCALL - xmlSetBufferAllocationScheme(xmlBufferAllocationScheme scheme); +xmlSetBufferAllocationScheme(xmlBufferAllocationScheme scheme); XMLPUBFUN xmlBufferAllocationScheme XMLCALL - xmlGetBufferAllocationScheme(void); +xmlGetBufferAllocationScheme(void); XMLPUBFUN xmlBufferPtr XMLCALL - xmlBufferCreate (void); +xmlBufferCreate (void); XMLPUBFUN xmlBufferPtr XMLCALL - xmlBufferCreateSize (size_t size); +xmlBufferCreateSize (size_t size); XMLPUBFUN xmlBufferPtr XMLCALL - xmlBufferCreateStatic (void *mem, - size_t size); +xmlBufferCreateStatic (void *mem, + size_t size); XMLPUBFUN int XMLCALL - xmlBufferResize (xmlBufferPtr buf, - unsigned int size); +xmlBufferResize (xmlBufferPtr buf, + unsigned int size); XMLPUBFUN void XMLCALL - xmlBufferFree (xmlBufferPtr buf); +xmlBufferFree (xmlBufferPtr buf); XMLPUBFUN int XMLCALL - xmlBufferDump (FILE *file, - xmlBufferPtr buf); +xmlBufferDump (FILE *file, + xmlBufferPtr buf); XMLPUBFUN int XMLCALL - xmlBufferAdd (xmlBufferPtr buf, - const xmlChar *str, - int len); +xmlBufferAdd (xmlBufferPtr buf, + const xmlChar *str, + int len); XMLPUBFUN int XMLCALL - xmlBufferAddHead (xmlBufferPtr buf, - const xmlChar *str, - int len); +xmlBufferAddHead (xmlBufferPtr buf, + const xmlChar *str, + int len); XMLPUBFUN int XMLCALL - xmlBufferCat (xmlBufferPtr buf, - const xmlChar *str); +xmlBufferCat (xmlBufferPtr buf, + const xmlChar *str); XMLPUBFUN int XMLCALL - xmlBufferCCat (xmlBufferPtr buf, - const char *str); +xmlBufferCCat (xmlBufferPtr buf, + const char *str); XMLPUBFUN int XMLCALL - xmlBufferShrink (xmlBufferPtr buf, - unsigned int len); +xmlBufferShrink (xmlBufferPtr buf, + unsigned int len); XMLPUBFUN int XMLCALL - xmlBufferGrow (xmlBufferPtr buf, - unsigned int len); +xmlBufferGrow (xmlBufferPtr buf, + unsigned int len); XMLPUBFUN void XMLCALL - xmlBufferEmpty (xmlBufferPtr buf); +xmlBufferEmpty (xmlBufferPtr buf); XMLPUBFUN const xmlChar* XMLCALL - xmlBufferContent (const xmlBufferPtr buf); +xmlBufferContent (const xmlBufferPtr buf); XMLPUBFUN xmlChar* XMLCALL - xmlBufferDetach (xmlBufferPtr buf); +xmlBufferDetach (xmlBufferPtr buf); XMLPUBFUN void XMLCALL - xmlBufferSetAllocationScheme(xmlBufferPtr buf, - xmlBufferAllocationScheme scheme); +xmlBufferSetAllocationScheme(xmlBufferPtr buf, + xmlBufferAllocationScheme scheme); XMLPUBFUN int XMLCALL - xmlBufferLength (const xmlBufferPtr buf); +xmlBufferLength (const xmlBufferPtr buf); /* * Creating/freeing new structures. */ XMLPUBFUN xmlDtdPtr XMLCALL - xmlCreateIntSubset (xmlDocPtr doc, - const xmlChar *name, - const xmlChar *ExternalID, - const xmlChar *SystemID); +xmlCreateIntSubset (xmlDocPtr doc, + const xmlChar *name, + const xmlChar *ExternalID, + const xmlChar *SystemID); XMLPUBFUN xmlDtdPtr XMLCALL - xmlNewDtd (xmlDocPtr doc, - const xmlChar *name, - const xmlChar *ExternalID, - const xmlChar *SystemID); +xmlNewDtd (xmlDocPtr doc, + const xmlChar *name, + const xmlChar *ExternalID, + const xmlChar *SystemID); XMLPUBFUN xmlDtdPtr XMLCALL - xmlGetIntSubset (xmlDocPtr doc); +xmlGetIntSubset (xmlDocPtr doc); XMLPUBFUN void XMLCALL - xmlFreeDtd (xmlDtdPtr cur); +xmlFreeDtd (xmlDtdPtr cur); #ifdef LIBXML_LEGACY_ENABLED XMLPUBFUN xmlNsPtr XMLCALL - xmlNewGlobalNs (xmlDocPtr doc, - const xmlChar *href, - const xmlChar *prefix); +xmlNewGlobalNs (xmlDocPtr doc, + const xmlChar *href, + const xmlChar *prefix); #endif /* LIBXML_LEGACY_ENABLED */ XMLPUBFUN xmlNsPtr XMLCALL - xmlNewNs (xmlNodePtr node, - const xmlChar *href, - const xmlChar *prefix); +xmlNewNs (xmlNodePtr node, + const xmlChar *href, + const xmlChar *prefix); XMLPUBFUN void XMLCALL - xmlFreeNs (xmlNsPtr cur); +xmlFreeNs (xmlNsPtr cur); XMLPUBFUN void XMLCALL - xmlFreeNsList (xmlNsPtr cur); +xmlFreeNsList (xmlNsPtr cur); XMLPUBFUN xmlDocPtr XMLCALL - xmlNewDoc (const xmlChar *version); +xmlNewDoc (const xmlChar *version); XMLPUBFUN void XMLCALL - xmlFreeDoc (xmlDocPtr cur); +xmlFreeDoc (xmlDocPtr cur); XMLPUBFUN xmlAttrPtr XMLCALL - xmlNewDocProp (xmlDocPtr doc, - const xmlChar *name, - const xmlChar *value); +xmlNewDocProp (xmlDocPtr doc, + const xmlChar *name, + const xmlChar *value); #if defined(LIBXML_TREE_ENABLED) || defined(LIBXML_HTML_ENABLED) || \ defined(LIBXML_SCHEMAS_ENABLED) XMLPUBFUN xmlAttrPtr XMLCALL - xmlNewProp (xmlNodePtr node, - const xmlChar *name, - const xmlChar *value); +xmlNewProp (xmlNodePtr node, + const xmlChar *name, + const xmlChar *value); #endif XMLPUBFUN xmlAttrPtr XMLCALL - xmlNewNsProp (xmlNodePtr node, - xmlNsPtr ns, - const xmlChar *name, - const xmlChar *value); +xmlNewNsProp (xmlNodePtr node, + xmlNsPtr ns, + const xmlChar *name, + const xmlChar *value); XMLPUBFUN xmlAttrPtr XMLCALL - xmlNewNsPropEatName (xmlNodePtr node, - xmlNsPtr ns, - xmlChar *name, - const xmlChar *value); +xmlNewNsPropEatName (xmlNodePtr node, + xmlNsPtr ns, + xmlChar *name, + const xmlChar *value); XMLPUBFUN void XMLCALL - xmlFreePropList (xmlAttrPtr cur); +xmlFreePropList (xmlAttrPtr cur); XMLPUBFUN void XMLCALL - xmlFreeProp (xmlAttrPtr cur); +xmlFreeProp (xmlAttrPtr cur); XMLPUBFUN xmlAttrPtr XMLCALL - xmlCopyProp (xmlNodePtr target, - xmlAttrPtr cur); +xmlCopyProp (xmlNodePtr target, + xmlAttrPtr cur); XMLPUBFUN xmlAttrPtr XMLCALL - xmlCopyPropList (xmlNodePtr target, - xmlAttrPtr cur); +xmlCopyPropList (xmlNodePtr target, + xmlAttrPtr cur); #ifdef LIBXML_TREE_ENABLED XMLPUBFUN xmlDtdPtr XMLCALL - xmlCopyDtd (xmlDtdPtr dtd); +xmlCopyDtd (xmlDtdPtr dtd); #endif /* LIBXML_TREE_ENABLED */ #if defined(LIBXML_TREE_ENABLED) || defined(LIBXML_SCHEMAS_ENABLED) XMLPUBFUN xmlDocPtr XMLCALL - xmlCopyDoc (xmlDocPtr doc, - int recursive); +xmlCopyDoc (xmlDocPtr doc, + int recursive); #endif /* defined(LIBXML_TREE_ENABLED) || defined(LIBXML_SCHEMAS_ENABLED) */ /* * Creating new nodes. */ XMLPUBFUN xmlNodePtr XMLCALL - xmlNewDocNode (xmlDocPtr doc, - xmlNsPtr ns, - const xmlChar *name, - const xmlChar *content); +xmlNewDocNode (xmlDocPtr doc, + xmlNsPtr ns, + const xmlChar *name, + const xmlChar *content); XMLPUBFUN xmlNodePtr XMLCALL - xmlNewDocNodeEatName (xmlDocPtr doc, - xmlNsPtr ns, - xmlChar *name, - const xmlChar *content); +xmlNewDocNodeEatName (xmlDocPtr doc, + xmlNsPtr ns, + xmlChar *name, + const xmlChar *content); XMLPUBFUN xmlNodePtr XMLCALL - xmlNewNode (xmlNsPtr ns, - const xmlChar *name); +xmlNewNode (xmlNsPtr ns, + const xmlChar *name); XMLPUBFUN xmlNodePtr XMLCALL - xmlNewNodeEatName (xmlNsPtr ns, - xmlChar *name); +xmlNewNodeEatName (xmlNsPtr ns, + xmlChar *name); #if defined(LIBXML_TREE_ENABLED) || defined(LIBXML_SCHEMAS_ENABLED) XMLPUBFUN xmlNodePtr XMLCALL - xmlNewChild (xmlNodePtr parent, - xmlNsPtr ns, - const xmlChar *name, - const xmlChar *content); +xmlNewChild (xmlNodePtr parent, + xmlNsPtr ns, + const xmlChar *name, + const xmlChar *content); #endif XMLPUBFUN xmlNodePtr XMLCALL - xmlNewDocText (xmlDocPtr doc, - const xmlChar *content); +xmlNewDocText (xmlDocPtr doc, + const xmlChar *content); XMLPUBFUN xmlNodePtr XMLCALL - xmlNewText (const xmlChar *content); +xmlNewText (const xmlChar *content); XMLPUBFUN xmlNodePtr XMLCALL - xmlNewDocPI (xmlDocPtr doc, - const xmlChar *name, - const xmlChar *content); +xmlNewDocPI (xmlDocPtr doc, + const xmlChar *name, + const xmlChar *content); XMLPUBFUN xmlNodePtr XMLCALL - xmlNewPI (const xmlChar *name, - const xmlChar *content); +xmlNewPI (const xmlChar *name, + const xmlChar *content); XMLPUBFUN xmlNodePtr XMLCALL - xmlNewDocTextLen (xmlDocPtr doc, - const xmlChar *content, - int len); +xmlNewDocTextLen (xmlDocPtr doc, + const xmlChar *content, + int len); XMLPUBFUN xmlNodePtr XMLCALL - xmlNewTextLen (const xmlChar *content, - int len); +xmlNewTextLen (const xmlChar *content, + int len); XMLPUBFUN xmlNodePtr XMLCALL - xmlNewDocComment (xmlDocPtr doc, - const xmlChar *content); +xmlNewDocComment (xmlDocPtr doc, + const xmlChar *content); XMLPUBFUN xmlNodePtr XMLCALL - xmlNewComment (const xmlChar *content); +xmlNewComment (const xmlChar *content); XMLPUBFUN xmlNodePtr XMLCALL - xmlNewCDataBlock (xmlDocPtr doc, - const xmlChar *content, - int len); +xmlNewCDataBlock (xmlDocPtr doc, + const xmlChar *content, + int len); XMLPUBFUN xmlNodePtr XMLCALL - xmlNewCharRef (xmlDocPtr doc, - const xmlChar *name); +xmlNewCharRef (xmlDocPtr doc, + const xmlChar *name); XMLPUBFUN xmlNodePtr XMLCALL - xmlNewReference (xmlDocPtr doc, - const xmlChar *name); +xmlNewReference (xmlDocPtr doc, + const xmlChar *name); XMLPUBFUN xmlNodePtr XMLCALL - xmlCopyNode (const xmlNodePtr node, - int recursive); +xmlCopyNode (const xmlNodePtr node, + int recursive); XMLPUBFUN xmlNodePtr XMLCALL - xmlDocCopyNode (const xmlNodePtr node, - xmlDocPtr doc, - int recursive); +xmlDocCopyNode (const xmlNodePtr node, + xmlDocPtr doc, + int recursive); XMLPUBFUN xmlNodePtr XMLCALL - xmlDocCopyNodeList (xmlDocPtr doc, - const xmlNodePtr node); +xmlDocCopyNodeList (xmlDocPtr doc, + const xmlNodePtr node); XMLPUBFUN xmlNodePtr XMLCALL - xmlCopyNodeList (const xmlNodePtr node); +xmlCopyNodeList (const xmlNodePtr node); #ifdef LIBXML_TREE_ENABLED XMLPUBFUN xmlNodePtr XMLCALL - xmlNewTextChild (xmlNodePtr parent, - xmlNsPtr ns, - const xmlChar *name, - const xmlChar *content); +xmlNewTextChild (xmlNodePtr parent, + xmlNsPtr ns, + const xmlChar *name, + const xmlChar *content); XMLPUBFUN xmlNodePtr XMLCALL - xmlNewDocRawNode (xmlDocPtr doc, - xmlNsPtr ns, - const xmlChar *name, - const xmlChar *content); +xmlNewDocRawNode (xmlDocPtr doc, + xmlNsPtr ns, + const xmlChar *name, + const xmlChar *content); XMLPUBFUN xmlNodePtr XMLCALL - xmlNewDocFragment (xmlDocPtr doc); +xmlNewDocFragment (xmlDocPtr doc); #endif /* LIBXML_TREE_ENABLED */ /* * Navigating. */ XMLPUBFUN long XMLCALL - xmlGetLineNo (xmlNodePtr node); +xmlGetLineNo (xmlNodePtr node); #if defined(LIBXML_TREE_ENABLED) || defined(LIBXML_DEBUG_ENABLED) XMLPUBFUN xmlChar * XMLCALL - xmlGetNodePath (xmlNodePtr node); +xmlGetNodePath (xmlNodePtr node); #endif /* defined(LIBXML_TREE_ENABLED) || defined(LIBXML_DEBUG_ENABLED) */ XMLPUBFUN xmlNodePtr XMLCALL - xmlDocGetRootElement (xmlDocPtr doc); +xmlDocGetRootElement (xmlDocPtr doc); XMLPUBFUN xmlNodePtr XMLCALL - xmlGetLastChild (xmlNodePtr parent); +xmlGetLastChild (xmlNodePtr parent); XMLPUBFUN int XMLCALL - xmlNodeIsText (xmlNodePtr node); +xmlNodeIsText (xmlNodePtr node); XMLPUBFUN int XMLCALL - xmlIsBlankNode (xmlNodePtr node); +xmlIsBlankNode (xmlNodePtr node); /* * Changing the structure. */ #if defined(LIBXML_TREE_ENABLED) || defined(LIBXML_WRITER_ENABLED) XMLPUBFUN xmlNodePtr XMLCALL - xmlDocSetRootElement (xmlDocPtr doc, - xmlNodePtr root); +xmlDocSetRootElement (xmlDocPtr doc, + xmlNodePtr root); #endif /* defined(LIBXML_TREE_ENABLED) || defined(LIBXML_WRITER_ENABLED) */ #ifdef LIBXML_TREE_ENABLED XMLPUBFUN void XMLCALL - xmlNodeSetName (xmlNodePtr cur, - const xmlChar *name); +xmlNodeSetName (xmlNodePtr cur, + const xmlChar *name); #endif /* LIBXML_TREE_ENABLED */ XMLPUBFUN xmlNodePtr XMLCALL - xmlAddChild (xmlNodePtr parent, - xmlNodePtr cur); +xmlAddChild (xmlNodePtr parent, + xmlNodePtr cur); XMLPUBFUN xmlNodePtr XMLCALL - xmlAddChildList (xmlNodePtr parent, - xmlNodePtr cur); +xmlAddChildList (xmlNodePtr parent, + xmlNodePtr cur); #if defined(LIBXML_TREE_ENABLED) || defined(LIBXML_WRITER_ENABLED) XMLPUBFUN xmlNodePtr XMLCALL - xmlReplaceNode (xmlNodePtr old, - xmlNodePtr cur); +xmlReplaceNode (xmlNodePtr old, + xmlNodePtr cur); #endif /* defined(LIBXML_TREE_ENABLED) || defined(LIBXML_WRITER_ENABLED) */ #if defined(LIBXML_TREE_ENABLED) || defined(LIBXML_HTML_ENABLED) || \ defined(LIBXML_SCHEMAS_ENABLED) XMLPUBFUN xmlNodePtr XMLCALL - xmlAddPrevSibling (xmlNodePtr cur, - xmlNodePtr elem); +xmlAddPrevSibling (xmlNodePtr cur, + xmlNodePtr elem); #endif /* LIBXML_TREE_ENABLED || LIBXML_HTML_ENABLED || LIBXML_SCHEMAS_ENABLED */ XMLPUBFUN xmlNodePtr XMLCALL - xmlAddSibling (xmlNodePtr cur, - xmlNodePtr elem); +xmlAddSibling (xmlNodePtr cur, + xmlNodePtr elem); XMLPUBFUN xmlNodePtr XMLCALL - xmlAddNextSibling (xmlNodePtr cur, - xmlNodePtr elem); +xmlAddNextSibling (xmlNodePtr cur, + xmlNodePtr elem); XMLPUBFUN void XMLCALL - xmlUnlinkNode (xmlNodePtr cur); +xmlUnlinkNode (xmlNodePtr cur); XMLPUBFUN xmlNodePtr XMLCALL - xmlTextMerge (xmlNodePtr first, - xmlNodePtr second); +xmlTextMerge (xmlNodePtr first, + xmlNodePtr second); XMLPUBFUN int XMLCALL - xmlTextConcat (xmlNodePtr node, - const xmlChar *content, - int len); +xmlTextConcat (xmlNodePtr node, + const xmlChar *content, + int len); XMLPUBFUN void XMLCALL - xmlFreeNodeList (xmlNodePtr cur); +xmlFreeNodeList (xmlNodePtr cur); XMLPUBFUN void XMLCALL - xmlFreeNode (xmlNodePtr cur); +xmlFreeNode (xmlNodePtr cur); XMLPUBFUN void XMLCALL - xmlSetTreeDoc (xmlNodePtr tree, - xmlDocPtr doc); +xmlSetTreeDoc (xmlNodePtr tree, + xmlDocPtr doc); XMLPUBFUN void XMLCALL - xmlSetListDoc (xmlNodePtr list, - xmlDocPtr doc); +xmlSetListDoc (xmlNodePtr list, + xmlDocPtr doc); /* * Namespaces. */ XMLPUBFUN xmlNsPtr XMLCALL - xmlSearchNs (xmlDocPtr doc, - xmlNodePtr node, - const xmlChar *nameSpace); +xmlSearchNs (xmlDocPtr doc, + xmlNodePtr node, + const xmlChar *nameSpace); XMLPUBFUN xmlNsPtr XMLCALL - xmlSearchNsByHref (xmlDocPtr doc, - xmlNodePtr node, - const xmlChar *href); +xmlSearchNsByHref (xmlDocPtr doc, + xmlNodePtr node, + const xmlChar *href); #if defined(LIBXML_TREE_ENABLED) || defined(LIBXML_XPATH_ENABLED) || defined(LIBXML_SCHEMAS_ENABLED) XMLPUBFUN xmlNsPtr * XMLCALL - xmlGetNsList (xmlDocPtr doc, - xmlNodePtr node); +xmlGetNsList (xmlDocPtr doc, + xmlNodePtr node); #endif /* defined(LIBXML_TREE_ENABLED) || defined(LIBXML_XPATH_ENABLED) */ XMLPUBFUN void XMLCALL - xmlSetNs (xmlNodePtr node, - xmlNsPtr ns); +xmlSetNs (xmlNodePtr node, + xmlNsPtr ns); XMLPUBFUN xmlNsPtr XMLCALL - xmlCopyNamespace (xmlNsPtr cur); +xmlCopyNamespace (xmlNsPtr cur); XMLPUBFUN xmlNsPtr XMLCALL - xmlCopyNamespaceList (xmlNsPtr cur); +xmlCopyNamespaceList (xmlNsPtr cur); /* * Changing the content. */ #if defined(LIBXML_TREE_ENABLED) || defined(LIBXML_XINCLUDE_ENABLED) || defined(LIBXML_SCHEMAS_ENABLED) || defined(LIBXML_HTML_ENABLED) XMLPUBFUN xmlAttrPtr XMLCALL - xmlSetProp (xmlNodePtr node, - const xmlChar *name, - const xmlChar *value); +xmlSetProp (xmlNodePtr node, + const xmlChar *name, + const xmlChar *value); XMLPUBFUN xmlAttrPtr XMLCALL - xmlSetNsProp (xmlNodePtr node, - xmlNsPtr ns, - const xmlChar *name, - const xmlChar *value); +xmlSetNsProp (xmlNodePtr node, + xmlNsPtr ns, + const xmlChar *name, + const xmlChar *value); #endif /* defined(LIBXML_TREE_ENABLED) || defined(LIBXML_XINCLUDE_ENABLED) || defined(LIBXML_SCHEMAS_ENABLED) || defined(LIBXML_HTML_ENABLED) */ XMLPUBFUN xmlChar * XMLCALL - xmlGetNoNsProp (xmlNodePtr node, - const xmlChar *name); +xmlGetNoNsProp (xmlNodePtr node, + const xmlChar *name); XMLPUBFUN xmlChar * XMLCALL - xmlGetProp (xmlNodePtr node, - const xmlChar *name); +xmlGetProp (xmlNodePtr node, + const xmlChar *name); XMLPUBFUN xmlAttrPtr XMLCALL - xmlHasProp (xmlNodePtr node, - const xmlChar *name); +xmlHasProp (xmlNodePtr node, + const xmlChar *name); XMLPUBFUN xmlAttrPtr XMLCALL - xmlHasNsProp (xmlNodePtr node, - const xmlChar *name, - const xmlChar *nameSpace); +xmlHasNsProp (xmlNodePtr node, + const xmlChar *name, + const xmlChar *nameSpace); XMLPUBFUN xmlChar * XMLCALL - xmlGetNsProp (xmlNodePtr node, - const xmlChar *name, - const xmlChar *nameSpace); +xmlGetNsProp (xmlNodePtr node, + const xmlChar *name, + const xmlChar *nameSpace); XMLPUBFUN xmlNodePtr XMLCALL - xmlStringGetNodeList (xmlDocPtr doc, - const xmlChar *value); +xmlStringGetNodeList (xmlDocPtr doc, + const xmlChar *value); XMLPUBFUN xmlNodePtr XMLCALL - xmlStringLenGetNodeList (xmlDocPtr doc, - const xmlChar *value, - int len); +xmlStringLenGetNodeList (xmlDocPtr doc, + const xmlChar *value, + int len); XMLPUBFUN xmlChar * XMLCALL - xmlNodeListGetString (xmlDocPtr doc, - xmlNodePtr list, - int inLine); +xmlNodeListGetString (xmlDocPtr doc, + xmlNodePtr list, + int inLine); #ifdef LIBXML_TREE_ENABLED XMLPUBFUN xmlChar * XMLCALL - xmlNodeListGetRawString (xmlDocPtr doc, - xmlNodePtr list, - int inLine); +xmlNodeListGetRawString (xmlDocPtr doc, + xmlNodePtr list, + int inLine); #endif /* LIBXML_TREE_ENABLED */ XMLPUBFUN void XMLCALL - xmlNodeSetContent (xmlNodePtr cur, - const xmlChar *content); +xmlNodeSetContent (xmlNodePtr cur, + const xmlChar *content); #ifdef LIBXML_TREE_ENABLED XMLPUBFUN void XMLCALL - xmlNodeSetContentLen (xmlNodePtr cur, - const xmlChar *content, - int len); +xmlNodeSetContentLen (xmlNodePtr cur, + const xmlChar *content, + int len); #endif /* LIBXML_TREE_ENABLED */ XMLPUBFUN void XMLCALL - xmlNodeAddContent (xmlNodePtr cur, - const xmlChar *content); +xmlNodeAddContent (xmlNodePtr cur, + const xmlChar *content); XMLPUBFUN void XMLCALL - xmlNodeAddContentLen (xmlNodePtr cur, - const xmlChar *content, - int len); +xmlNodeAddContentLen (xmlNodePtr cur, + const xmlChar *content, + int len); XMLPUBFUN xmlChar * XMLCALL - xmlNodeGetContent (xmlNodePtr cur); +xmlNodeGetContent (xmlNodePtr cur); XMLPUBFUN int XMLCALL - xmlNodeBufGetContent (xmlBufferPtr buffer, - xmlNodePtr cur); +xmlNodeBufGetContent (xmlBufferPtr buffer, + xmlNodePtr cur); XMLPUBFUN int XMLCALL - xmlBufGetNodeContent (xmlBufPtr buf, - xmlNodePtr cur); +xmlBufGetNodeContent (xmlBufPtr buf, + xmlNodePtr cur); XMLPUBFUN xmlChar * XMLCALL - xmlNodeGetLang (xmlNodePtr cur); +xmlNodeGetLang (xmlNodePtr cur); XMLPUBFUN int XMLCALL - xmlNodeGetSpacePreserve (xmlNodePtr cur); +xmlNodeGetSpacePreserve (xmlNodePtr cur); #ifdef LIBXML_TREE_ENABLED XMLPUBFUN void XMLCALL - xmlNodeSetLang (xmlNodePtr cur, - const xmlChar *lang); +xmlNodeSetLang (xmlNodePtr cur, + const xmlChar *lang); XMLPUBFUN void XMLCALL - xmlNodeSetSpacePreserve (xmlNodePtr cur, - int val); +xmlNodeSetSpacePreserve (xmlNodePtr cur, + int val); #endif /* LIBXML_TREE_ENABLED */ XMLPUBFUN xmlChar * XMLCALL - xmlNodeGetBase (xmlDocPtr doc, - xmlNodePtr cur); +xmlNodeGetBase (xmlDocPtr doc, + xmlNodePtr cur); #if defined(LIBXML_TREE_ENABLED) || defined(LIBXML_XINCLUDE_ENABLED) XMLPUBFUN void XMLCALL - xmlNodeSetBase (xmlNodePtr cur, - const xmlChar *uri); +xmlNodeSetBase (xmlNodePtr cur, + const xmlChar *uri); #endif /* * Removing content. */ XMLPUBFUN int XMLCALL - xmlRemoveProp (xmlAttrPtr cur); +xmlRemoveProp (xmlAttrPtr cur); #if defined(LIBXML_TREE_ENABLED) || defined(LIBXML_SCHEMAS_ENABLED) XMLPUBFUN int XMLCALL - xmlUnsetNsProp (xmlNodePtr node, - xmlNsPtr ns, - const xmlChar *name); +xmlUnsetNsProp (xmlNodePtr node, + xmlNsPtr ns, + const xmlChar *name); XMLPUBFUN int XMLCALL - xmlUnsetProp (xmlNodePtr node, - const xmlChar *name); +xmlUnsetProp (xmlNodePtr node, + const xmlChar *name); #endif /* defined(LIBXML_TREE_ENABLED) || defined(LIBXML_SCHEMAS_ENABLED) */ /* * Internal, don't use. */ XMLPUBFUN void XMLCALL - xmlBufferWriteCHAR (xmlBufferPtr buf, - const xmlChar *string); +xmlBufferWriteCHAR (xmlBufferPtr buf, + const xmlChar *string); XMLPUBFUN void XMLCALL - xmlBufferWriteChar (xmlBufferPtr buf, - const char *string); +xmlBufferWriteChar (xmlBufferPtr buf, + const char *string); XMLPUBFUN void XMLCALL - xmlBufferWriteQuotedString(xmlBufferPtr buf, - const xmlChar *string); +xmlBufferWriteQuotedString(xmlBufferPtr buf, + const xmlChar *string); #ifdef LIBXML_OUTPUT_ENABLED XMLPUBFUN void xmlAttrSerializeTxtContent(xmlBufferPtr buf, - xmlDocPtr doc, - xmlAttrPtr attr, - const xmlChar *string); + xmlDocPtr doc, + xmlAttrPtr attr, + const xmlChar *string); #endif /* LIBXML_OUTPUT_ENABLED */ #ifdef LIBXML_TREE_ENABLED @@ -1135,8 +1135,8 @@ XMLPUBFUN void xmlAttrSerializeTxtContent(xmlBufferPtr buf, * Namespace handling. */ XMLPUBFUN int XMLCALL - xmlReconciliateNs (xmlDocPtr doc, - xmlNodePtr tree); +xmlReconciliateNs (xmlDocPtr doc, + xmlNodePtr tree); #endif #ifdef LIBXML_OUTPUT_ENABLED @@ -1144,137 +1144,137 @@ XMLPUBFUN int XMLCALL * Saving. */ XMLPUBFUN void XMLCALL - xmlDocDumpFormatMemory (xmlDocPtr cur, - xmlChar **mem, - int *size, - int format); +xmlDocDumpFormatMemory (xmlDocPtr cur, + xmlChar **mem, + int *size, + int format); XMLPUBFUN void XMLCALL - xmlDocDumpMemory (xmlDocPtr cur, - xmlChar **mem, - int *size); +xmlDocDumpMemory (xmlDocPtr cur, + xmlChar **mem, + int *size); XMLPUBFUN void XMLCALL - xmlDocDumpMemoryEnc (xmlDocPtr out_doc, - xmlChar **doc_txt_ptr, - int * doc_txt_len, - const char *txt_encoding); +xmlDocDumpMemoryEnc (xmlDocPtr out_doc, + xmlChar **doc_txt_ptr, + int * doc_txt_len, + const char *txt_encoding); XMLPUBFUN void XMLCALL - xmlDocDumpFormatMemoryEnc(xmlDocPtr out_doc, - xmlChar **doc_txt_ptr, - int * doc_txt_len, - const char *txt_encoding, - int format); +xmlDocDumpFormatMemoryEnc(xmlDocPtr out_doc, + xmlChar **doc_txt_ptr, + int * doc_txt_len, + const char *txt_encoding, + int format); XMLPUBFUN int XMLCALL - xmlDocFormatDump (FILE *f, - xmlDocPtr cur, - int format); +xmlDocFormatDump (FILE *f, + xmlDocPtr cur, + int format); XMLPUBFUN int XMLCALL - xmlDocDump (FILE *f, - xmlDocPtr cur); +xmlDocDump (FILE *f, + xmlDocPtr cur); XMLPUBFUN void XMLCALL - xmlElemDump (FILE *f, - xmlDocPtr doc, - xmlNodePtr cur); +xmlElemDump (FILE *f, + xmlDocPtr doc, + xmlNodePtr cur); XMLPUBFUN int XMLCALL - xmlSaveFile (const char *filename, - xmlDocPtr cur); +xmlSaveFile (const char *filename, + xmlDocPtr cur); XMLPUBFUN int XMLCALL - xmlSaveFormatFile (const char *filename, - xmlDocPtr cur, - int format); +xmlSaveFormatFile (const char *filename, + xmlDocPtr cur, + int format); XMLPUBFUN size_t XMLCALL - xmlBufNodeDump (xmlBufPtr buf, - xmlDocPtr doc, - xmlNodePtr cur, - int level, - int format); +xmlBufNodeDump (xmlBufPtr buf, + xmlDocPtr doc, + xmlNodePtr cur, + int level, + int format); XMLPUBFUN int XMLCALL - xmlNodeDump (xmlBufferPtr buf, - xmlDocPtr doc, - xmlNodePtr cur, - int level, - int format); +xmlNodeDump (xmlBufferPtr buf, + xmlDocPtr doc, + xmlNodePtr cur, + int level, + int format); XMLPUBFUN int XMLCALL - xmlSaveFileTo (xmlOutputBufferPtr buf, - xmlDocPtr cur, - const char *encoding); +xmlSaveFileTo (xmlOutputBufferPtr buf, + xmlDocPtr cur, + const char *encoding); XMLPUBFUN int XMLCALL - xmlSaveFormatFileTo (xmlOutputBufferPtr buf, - xmlDocPtr cur, - const char *encoding, - int format); +xmlSaveFormatFileTo (xmlOutputBufferPtr buf, + xmlDocPtr cur, + const char *encoding, + int format); XMLPUBFUN void XMLCALL - xmlNodeDumpOutput (xmlOutputBufferPtr buf, - xmlDocPtr doc, - xmlNodePtr cur, - int level, - int format, - const char *encoding); +xmlNodeDumpOutput (xmlOutputBufferPtr buf, + xmlDocPtr doc, + xmlNodePtr cur, + int level, + int format, + const char *encoding); XMLPUBFUN int XMLCALL - xmlSaveFormatFileEnc (const char *filename, - xmlDocPtr cur, - const char *encoding, - int format); +xmlSaveFormatFileEnc (const char *filename, + xmlDocPtr cur, + const char *encoding, + int format); XMLPUBFUN int XMLCALL - xmlSaveFileEnc (const char *filename, - xmlDocPtr cur, - const char *encoding); +xmlSaveFileEnc (const char *filename, + xmlDocPtr cur, + const char *encoding); #endif /* LIBXML_OUTPUT_ENABLED */ /* * XHTML */ XMLPUBFUN int XMLCALL - xmlIsXHTML (const xmlChar *systemID, - const xmlChar *publicID); +xmlIsXHTML (const xmlChar *systemID, + const xmlChar *publicID); /* * Compression. */ XMLPUBFUN int XMLCALL - xmlGetDocCompressMode (xmlDocPtr doc); +xmlGetDocCompressMode (xmlDocPtr doc); XMLPUBFUN void XMLCALL - xmlSetDocCompressMode (xmlDocPtr doc, - int mode); +xmlSetDocCompressMode (xmlDocPtr doc, + int mode); XMLPUBFUN int XMLCALL - xmlGetCompressMode (void); +xmlGetCompressMode (void); XMLPUBFUN void XMLCALL - xmlSetCompressMode (int mode); +xmlSetCompressMode (int mode); /* * DOM-wrapper helper functions. */ XMLPUBFUN xmlDOMWrapCtxtPtr XMLCALL - xmlDOMWrapNewCtxt (void); +xmlDOMWrapNewCtxt (void); XMLPUBFUN void XMLCALL - xmlDOMWrapFreeCtxt (xmlDOMWrapCtxtPtr ctxt); +xmlDOMWrapFreeCtxt (xmlDOMWrapCtxtPtr ctxt); XMLPUBFUN int XMLCALL - xmlDOMWrapReconcileNamespaces(xmlDOMWrapCtxtPtr ctxt, - xmlNodePtr elem, - int options); +xmlDOMWrapReconcileNamespaces(xmlDOMWrapCtxtPtr ctxt, + xmlNodePtr elem, + int options); XMLPUBFUN int XMLCALL - xmlDOMWrapAdoptNode (xmlDOMWrapCtxtPtr ctxt, - xmlDocPtr sourceDoc, - xmlNodePtr node, - xmlDocPtr destDoc, - xmlNodePtr destParent, - int options); +xmlDOMWrapAdoptNode (xmlDOMWrapCtxtPtr ctxt, + xmlDocPtr sourceDoc, + xmlNodePtr node, + xmlDocPtr destDoc, + xmlNodePtr destParent, + int options); XMLPUBFUN int XMLCALL - xmlDOMWrapRemoveNode (xmlDOMWrapCtxtPtr ctxt, - xmlDocPtr doc, - xmlNodePtr node, - int options); +xmlDOMWrapRemoveNode (xmlDOMWrapCtxtPtr ctxt, + xmlDocPtr doc, + xmlNodePtr node, + int options); XMLPUBFUN int XMLCALL - xmlDOMWrapCloneNode (xmlDOMWrapCtxtPtr ctxt, - xmlDocPtr sourceDoc, - xmlNodePtr node, - xmlNodePtr *clonedNode, - xmlDocPtr destDoc, - xmlNodePtr destParent, - int deep, - int options); +xmlDOMWrapCloneNode (xmlDOMWrapCtxtPtr ctxt, + xmlDocPtr sourceDoc, + xmlNodePtr node, + xmlNodePtr *clonedNode, + xmlDocPtr destDoc, + xmlNodePtr destParent, + int deep, + int options); #ifdef LIBXML_TREE_ENABLED /* @@ -1282,15 +1282,15 @@ XMLPUBFUN int XMLCALL * traversal. */ XMLPUBFUN unsigned long XMLCALL - xmlChildElementCount (xmlNodePtr parent); +xmlChildElementCount (xmlNodePtr parent); XMLPUBFUN xmlNodePtr XMLCALL - xmlNextElementSibling (xmlNodePtr node); +xmlNextElementSibling (xmlNodePtr node); XMLPUBFUN xmlNodePtr XMLCALL - xmlFirstElementChild (xmlNodePtr parent); +xmlFirstElementChild (xmlNodePtr parent); XMLPUBFUN xmlNodePtr XMLCALL - xmlLastElementChild (xmlNodePtr parent); +xmlLastElementChild (xmlNodePtr parent); XMLPUBFUN xmlNodePtr XMLCALL - xmlPreviousElementSibling (xmlNodePtr node); +xmlPreviousElementSibling (xmlNodePtr node); #endif #ifdef __cplusplus } diff --git a/thirdparties/common/include/libxml2/libxml/uri.h b/thirdparties/common/include/libxml2/libxml/uri.h index db48262..599c3e3 100755 --- a/thirdparties/common/include/libxml2/libxml/uri.h +++ b/thirdparties/common/include/libxml2/libxml/uri.h @@ -50,43 +50,43 @@ struct _xmlURI { * xmlNodePtr cur); */ XMLPUBFUN xmlURIPtr XMLCALL - xmlCreateURI (void); +xmlCreateURI (void); XMLPUBFUN xmlChar * XMLCALL - xmlBuildURI (const xmlChar *URI, - const xmlChar *base); +xmlBuildURI (const xmlChar *URI, + const xmlChar *base); XMLPUBFUN xmlChar * XMLCALL - xmlBuildRelativeURI (const xmlChar *URI, - const xmlChar *base); +xmlBuildRelativeURI (const xmlChar *URI, + const xmlChar *base); XMLPUBFUN xmlURIPtr XMLCALL - xmlParseURI (const char *str); +xmlParseURI (const char *str); XMLPUBFUN xmlURIPtr XMLCALL - xmlParseURIRaw (const char *str, - int raw); +xmlParseURIRaw (const char *str, + int raw); XMLPUBFUN int XMLCALL - xmlParseURIReference (xmlURIPtr uri, - const char *str); +xmlParseURIReference (xmlURIPtr uri, + const char *str); XMLPUBFUN xmlChar * XMLCALL - xmlSaveUri (xmlURIPtr uri); +xmlSaveUri (xmlURIPtr uri); XMLPUBFUN void XMLCALL - xmlPrintURI (FILE *stream, - xmlURIPtr uri); +xmlPrintURI (FILE *stream, + xmlURIPtr uri); XMLPUBFUN xmlChar * XMLCALL - xmlURIEscapeStr (const xmlChar *str, - const xmlChar *list); +xmlURIEscapeStr (const xmlChar *str, + const xmlChar *list); XMLPUBFUN char * XMLCALL - xmlURIUnescapeString (const char *str, - int len, - char *target); +xmlURIUnescapeString (const char *str, + int len, + char *target); XMLPUBFUN int XMLCALL - xmlNormalizeURIPath (char *path); +xmlNormalizeURIPath (char *path); XMLPUBFUN xmlChar * XMLCALL - xmlURIEscape (const xmlChar *str); +xmlURIEscape (const xmlChar *str); XMLPUBFUN void XMLCALL - xmlFreeURI (xmlURIPtr uri); +xmlFreeURI (xmlURIPtr uri); XMLPUBFUN xmlChar* XMLCALL - xmlCanonicPath (const xmlChar *path); +xmlCanonicPath (const xmlChar *path); XMLPUBFUN xmlChar* XMLCALL - xmlPathToURI (const xmlChar *path); +xmlPathToURI (const xmlChar *path); #ifdef __cplusplus } diff --git a/thirdparties/common/include/libxml2/libxml/valid.h b/thirdparties/common/include/libxml2/libxml/valid.h index 2bc7b38..b67a9d6 100755 --- a/thirdparties/common/include/libxml2/libxml/valid.h +++ b/thirdparties/common/include/libxml2/libxml/valid.h @@ -40,8 +40,8 @@ typedef xmlValidState *xmlValidStatePtr; * oriented function similar to an *printf function. */ typedef void (XMLCDECL *xmlValidityErrorFunc) (void *ctx, - const char *msg, - ...) LIBXML_ATTR_FORMAT(2,3); + const char *msg, + ...) LIBXML_ATTR_FORMAT(2,3); /** * xmlValidityWarningFunc: @@ -55,8 +55,8 @@ typedef void (XMLCDECL *xmlValidityErrorFunc) (void *ctx, * oriented function similar to an *printf function. */ typedef void (XMLCDECL *xmlValidityWarningFunc) (void *ctx, - const char *msg, - ...) LIBXML_ATTR_FORMAT(2,3); + const char *msg, + ...) LIBXML_ATTR_FORMAT(2,3); #ifdef IN_LIBXML /** @@ -151,155 +151,155 @@ typedef xmlRefTable *xmlRefTablePtr; /* Notation */ XMLPUBFUN xmlNotationPtr XMLCALL - xmlAddNotationDecl (xmlValidCtxtPtr ctxt, - xmlDtdPtr dtd, - const xmlChar *name, - const xmlChar *PublicID, - const xmlChar *SystemID); +xmlAddNotationDecl (xmlValidCtxtPtr ctxt, + xmlDtdPtr dtd, + const xmlChar *name, + const xmlChar *PublicID, + const xmlChar *SystemID); #ifdef LIBXML_TREE_ENABLED XMLPUBFUN xmlNotationTablePtr XMLCALL - xmlCopyNotationTable (xmlNotationTablePtr table); +xmlCopyNotationTable (xmlNotationTablePtr table); #endif /* LIBXML_TREE_ENABLED */ XMLPUBFUN void XMLCALL - xmlFreeNotationTable (xmlNotationTablePtr table); +xmlFreeNotationTable (xmlNotationTablePtr table); #ifdef LIBXML_OUTPUT_ENABLED XMLPUBFUN void XMLCALL - xmlDumpNotationDecl (xmlBufferPtr buf, - xmlNotationPtr nota); +xmlDumpNotationDecl (xmlBufferPtr buf, + xmlNotationPtr nota); XMLPUBFUN void XMLCALL - xmlDumpNotationTable (xmlBufferPtr buf, - xmlNotationTablePtr table); +xmlDumpNotationTable (xmlBufferPtr buf, + xmlNotationTablePtr table); #endif /* LIBXML_OUTPUT_ENABLED */ /* Element Content */ /* the non Doc version are being deprecated */ XMLPUBFUN xmlElementContentPtr XMLCALL - xmlNewElementContent (const xmlChar *name, - xmlElementContentType type); +xmlNewElementContent (const xmlChar *name, + xmlElementContentType type); XMLPUBFUN xmlElementContentPtr XMLCALL - xmlCopyElementContent (xmlElementContentPtr content); +xmlCopyElementContent (xmlElementContentPtr content); XMLPUBFUN void XMLCALL - xmlFreeElementContent (xmlElementContentPtr cur); +xmlFreeElementContent (xmlElementContentPtr cur); /* the new versions with doc argument */ XMLPUBFUN xmlElementContentPtr XMLCALL - xmlNewDocElementContent (xmlDocPtr doc, - const xmlChar *name, - xmlElementContentType type); +xmlNewDocElementContent (xmlDocPtr doc, + const xmlChar *name, + xmlElementContentType type); XMLPUBFUN xmlElementContentPtr XMLCALL - xmlCopyDocElementContent(xmlDocPtr doc, - xmlElementContentPtr content); +xmlCopyDocElementContent(xmlDocPtr doc, + xmlElementContentPtr content); XMLPUBFUN void XMLCALL - xmlFreeDocElementContent(xmlDocPtr doc, - xmlElementContentPtr cur); +xmlFreeDocElementContent(xmlDocPtr doc, + xmlElementContentPtr cur); XMLPUBFUN void XMLCALL - xmlSnprintfElementContent(char *buf, - int size, - xmlElementContentPtr content, - int englob); +xmlSnprintfElementContent(char *buf, + int size, + xmlElementContentPtr content, + int englob); #ifdef LIBXML_OUTPUT_ENABLED /* DEPRECATED */ XMLPUBFUN void XMLCALL - xmlSprintfElementContent(char *buf, - xmlElementContentPtr content, - int englob); +xmlSprintfElementContent(char *buf, + xmlElementContentPtr content, + int englob); #endif /* LIBXML_OUTPUT_ENABLED */ /* DEPRECATED */ /* Element */ XMLPUBFUN xmlElementPtr XMLCALL - xmlAddElementDecl (xmlValidCtxtPtr ctxt, - xmlDtdPtr dtd, - const xmlChar *name, - xmlElementTypeVal type, - xmlElementContentPtr content); +xmlAddElementDecl (xmlValidCtxtPtr ctxt, + xmlDtdPtr dtd, + const xmlChar *name, + xmlElementTypeVal type, + xmlElementContentPtr content); #ifdef LIBXML_TREE_ENABLED XMLPUBFUN xmlElementTablePtr XMLCALL - xmlCopyElementTable (xmlElementTablePtr table); +xmlCopyElementTable (xmlElementTablePtr table); #endif /* LIBXML_TREE_ENABLED */ XMLPUBFUN void XMLCALL - xmlFreeElementTable (xmlElementTablePtr table); +xmlFreeElementTable (xmlElementTablePtr table); #ifdef LIBXML_OUTPUT_ENABLED XMLPUBFUN void XMLCALL - xmlDumpElementTable (xmlBufferPtr buf, - xmlElementTablePtr table); +xmlDumpElementTable (xmlBufferPtr buf, + xmlElementTablePtr table); XMLPUBFUN void XMLCALL - xmlDumpElementDecl (xmlBufferPtr buf, - xmlElementPtr elem); +xmlDumpElementDecl (xmlBufferPtr buf, + xmlElementPtr elem); #endif /* LIBXML_OUTPUT_ENABLED */ /* Enumeration */ XMLPUBFUN xmlEnumerationPtr XMLCALL - xmlCreateEnumeration (const xmlChar *name); +xmlCreateEnumeration (const xmlChar *name); XMLPUBFUN void XMLCALL - xmlFreeEnumeration (xmlEnumerationPtr cur); +xmlFreeEnumeration (xmlEnumerationPtr cur); #ifdef LIBXML_TREE_ENABLED XMLPUBFUN xmlEnumerationPtr XMLCALL - xmlCopyEnumeration (xmlEnumerationPtr cur); +xmlCopyEnumeration (xmlEnumerationPtr cur); #endif /* LIBXML_TREE_ENABLED */ /* Attribute */ XMLPUBFUN xmlAttributePtr XMLCALL - xmlAddAttributeDecl (xmlValidCtxtPtr ctxt, - xmlDtdPtr dtd, - const xmlChar *elem, - const xmlChar *name, - const xmlChar *ns, - xmlAttributeType type, - xmlAttributeDefault def, - const xmlChar *defaultValue, - xmlEnumerationPtr tree); +xmlAddAttributeDecl (xmlValidCtxtPtr ctxt, + xmlDtdPtr dtd, + const xmlChar *elem, + const xmlChar *name, + const xmlChar *ns, + xmlAttributeType type, + xmlAttributeDefault def, + const xmlChar *defaultValue, + xmlEnumerationPtr tree); #ifdef LIBXML_TREE_ENABLED XMLPUBFUN xmlAttributeTablePtr XMLCALL - xmlCopyAttributeTable (xmlAttributeTablePtr table); +xmlCopyAttributeTable (xmlAttributeTablePtr table); #endif /* LIBXML_TREE_ENABLED */ XMLPUBFUN void XMLCALL - xmlFreeAttributeTable (xmlAttributeTablePtr table); +xmlFreeAttributeTable (xmlAttributeTablePtr table); #ifdef LIBXML_OUTPUT_ENABLED XMLPUBFUN void XMLCALL - xmlDumpAttributeTable (xmlBufferPtr buf, - xmlAttributeTablePtr table); +xmlDumpAttributeTable (xmlBufferPtr buf, + xmlAttributeTablePtr table); XMLPUBFUN void XMLCALL - xmlDumpAttributeDecl (xmlBufferPtr buf, - xmlAttributePtr attr); +xmlDumpAttributeDecl (xmlBufferPtr buf, + xmlAttributePtr attr); #endif /* LIBXML_OUTPUT_ENABLED */ /* IDs */ XMLPUBFUN xmlIDPtr XMLCALL - xmlAddID (xmlValidCtxtPtr ctxt, - xmlDocPtr doc, - const xmlChar *value, - xmlAttrPtr attr); +xmlAddID (xmlValidCtxtPtr ctxt, + xmlDocPtr doc, + const xmlChar *value, + xmlAttrPtr attr); XMLPUBFUN void XMLCALL - xmlFreeIDTable (xmlIDTablePtr table); +xmlFreeIDTable (xmlIDTablePtr table); XMLPUBFUN xmlAttrPtr XMLCALL - xmlGetID (xmlDocPtr doc, - const xmlChar *ID); +xmlGetID (xmlDocPtr doc, + const xmlChar *ID); XMLPUBFUN int XMLCALL - xmlIsID (xmlDocPtr doc, - xmlNodePtr elem, - xmlAttrPtr attr); +xmlIsID (xmlDocPtr doc, + xmlNodePtr elem, + xmlAttrPtr attr); XMLPUBFUN int XMLCALL - xmlRemoveID (xmlDocPtr doc, - xmlAttrPtr attr); +xmlRemoveID (xmlDocPtr doc, + xmlAttrPtr attr); /* IDREFs */ XMLPUBFUN xmlRefPtr XMLCALL - xmlAddRef (xmlValidCtxtPtr ctxt, - xmlDocPtr doc, - const xmlChar *value, - xmlAttrPtr attr); +xmlAddRef (xmlValidCtxtPtr ctxt, + xmlDocPtr doc, + const xmlChar *value, + xmlAttrPtr attr); XMLPUBFUN void XMLCALL - xmlFreeRefTable (xmlRefTablePtr table); +xmlFreeRefTable (xmlRefTablePtr table); XMLPUBFUN int XMLCALL - xmlIsRef (xmlDocPtr doc, - xmlNodePtr elem, - xmlAttrPtr attr); +xmlIsRef (xmlDocPtr doc, + xmlNodePtr elem, + xmlAttrPtr attr); XMLPUBFUN int XMLCALL - xmlRemoveRef (xmlDocPtr doc, - xmlAttrPtr attr); +xmlRemoveRef (xmlDocPtr doc, + xmlAttrPtr attr); XMLPUBFUN xmlListPtr XMLCALL - xmlGetRefs (xmlDocPtr doc, - const xmlChar *ID); +xmlGetRefs (xmlDocPtr doc, + const xmlChar *ID); /** * The public function calls related to validity checking. @@ -307,149 +307,149 @@ XMLPUBFUN xmlListPtr XMLCALL #ifdef LIBXML_VALID_ENABLED /* Allocate/Release Validation Contexts */ XMLPUBFUN xmlValidCtxtPtr XMLCALL - xmlNewValidCtxt(void); +xmlNewValidCtxt(void); XMLPUBFUN void XMLCALL - xmlFreeValidCtxt(xmlValidCtxtPtr); +xmlFreeValidCtxt(xmlValidCtxtPtr); XMLPUBFUN int XMLCALL - xmlValidateRoot (xmlValidCtxtPtr ctxt, - xmlDocPtr doc); +xmlValidateRoot (xmlValidCtxtPtr ctxt, + xmlDocPtr doc); XMLPUBFUN int XMLCALL - xmlValidateElementDecl (xmlValidCtxtPtr ctxt, - xmlDocPtr doc, - xmlElementPtr elem); +xmlValidateElementDecl (xmlValidCtxtPtr ctxt, + xmlDocPtr doc, + xmlElementPtr elem); XMLPUBFUN xmlChar * XMLCALL - xmlValidNormalizeAttributeValue(xmlDocPtr doc, - xmlNodePtr elem, - const xmlChar *name, - const xmlChar *value); +xmlValidNormalizeAttributeValue(xmlDocPtr doc, + xmlNodePtr elem, + const xmlChar *name, + const xmlChar *value); XMLPUBFUN xmlChar * XMLCALL - xmlValidCtxtNormalizeAttributeValue(xmlValidCtxtPtr ctxt, - xmlDocPtr doc, - xmlNodePtr elem, - const xmlChar *name, - const xmlChar *value); +xmlValidCtxtNormalizeAttributeValue(xmlValidCtxtPtr ctxt, + xmlDocPtr doc, + xmlNodePtr elem, + const xmlChar *name, + const xmlChar *value); XMLPUBFUN int XMLCALL - xmlValidateAttributeDecl(xmlValidCtxtPtr ctxt, - xmlDocPtr doc, - xmlAttributePtr attr); +xmlValidateAttributeDecl(xmlValidCtxtPtr ctxt, + xmlDocPtr doc, + xmlAttributePtr attr); XMLPUBFUN int XMLCALL - xmlValidateAttributeValue(xmlAttributeType type, - const xmlChar *value); +xmlValidateAttributeValue(xmlAttributeType type, + const xmlChar *value); XMLPUBFUN int XMLCALL - xmlValidateNotationDecl (xmlValidCtxtPtr ctxt, - xmlDocPtr doc, - xmlNotationPtr nota); +xmlValidateNotationDecl (xmlValidCtxtPtr ctxt, + xmlDocPtr doc, + xmlNotationPtr nota); XMLPUBFUN int XMLCALL - xmlValidateDtd (xmlValidCtxtPtr ctxt, - xmlDocPtr doc, - xmlDtdPtr dtd); +xmlValidateDtd (xmlValidCtxtPtr ctxt, + xmlDocPtr doc, + xmlDtdPtr dtd); XMLPUBFUN int XMLCALL - xmlValidateDtdFinal (xmlValidCtxtPtr ctxt, - xmlDocPtr doc); +xmlValidateDtdFinal (xmlValidCtxtPtr ctxt, + xmlDocPtr doc); XMLPUBFUN int XMLCALL - xmlValidateDocument (xmlValidCtxtPtr ctxt, - xmlDocPtr doc); +xmlValidateDocument (xmlValidCtxtPtr ctxt, + xmlDocPtr doc); XMLPUBFUN int XMLCALL - xmlValidateElement (xmlValidCtxtPtr ctxt, - xmlDocPtr doc, - xmlNodePtr elem); +xmlValidateElement (xmlValidCtxtPtr ctxt, + xmlDocPtr doc, + xmlNodePtr elem); XMLPUBFUN int XMLCALL - xmlValidateOneElement (xmlValidCtxtPtr ctxt, - xmlDocPtr doc, - xmlNodePtr elem); +xmlValidateOneElement (xmlValidCtxtPtr ctxt, + xmlDocPtr doc, + xmlNodePtr elem); XMLPUBFUN int XMLCALL - xmlValidateOneAttribute (xmlValidCtxtPtr ctxt, - xmlDocPtr doc, - xmlNodePtr elem, - xmlAttrPtr attr, - const xmlChar *value); +xmlValidateOneAttribute (xmlValidCtxtPtr ctxt, + xmlDocPtr doc, + xmlNodePtr elem, + xmlAttrPtr attr, + const xmlChar *value); XMLPUBFUN int XMLCALL - xmlValidateOneNamespace (xmlValidCtxtPtr ctxt, - xmlDocPtr doc, - xmlNodePtr elem, - const xmlChar *prefix, - xmlNsPtr ns, - const xmlChar *value); +xmlValidateOneNamespace (xmlValidCtxtPtr ctxt, + xmlDocPtr doc, + xmlNodePtr elem, + const xmlChar *prefix, + xmlNsPtr ns, + const xmlChar *value); XMLPUBFUN int XMLCALL - xmlValidateDocumentFinal(xmlValidCtxtPtr ctxt, - xmlDocPtr doc); +xmlValidateDocumentFinal(xmlValidCtxtPtr ctxt, + xmlDocPtr doc); #endif /* LIBXML_VALID_ENABLED */ #if defined(LIBXML_VALID_ENABLED) || defined(LIBXML_SCHEMAS_ENABLED) XMLPUBFUN int XMLCALL - xmlValidateNotationUse (xmlValidCtxtPtr ctxt, - xmlDocPtr doc, - const xmlChar *notationName); +xmlValidateNotationUse (xmlValidCtxtPtr ctxt, + xmlDocPtr doc, + const xmlChar *notationName); #endif /* LIBXML_VALID_ENABLED or LIBXML_SCHEMAS_ENABLED */ XMLPUBFUN int XMLCALL - xmlIsMixedElement (xmlDocPtr doc, - const xmlChar *name); +xmlIsMixedElement (xmlDocPtr doc, + const xmlChar *name); XMLPUBFUN xmlAttributePtr XMLCALL - xmlGetDtdAttrDesc (xmlDtdPtr dtd, - const xmlChar *elem, - const xmlChar *name); +xmlGetDtdAttrDesc (xmlDtdPtr dtd, + const xmlChar *elem, + const xmlChar *name); XMLPUBFUN xmlAttributePtr XMLCALL - xmlGetDtdQAttrDesc (xmlDtdPtr dtd, - const xmlChar *elem, - const xmlChar *name, - const xmlChar *prefix); +xmlGetDtdQAttrDesc (xmlDtdPtr dtd, + const xmlChar *elem, + const xmlChar *name, + const xmlChar *prefix); XMLPUBFUN xmlNotationPtr XMLCALL - xmlGetDtdNotationDesc (xmlDtdPtr dtd, - const xmlChar *name); +xmlGetDtdNotationDesc (xmlDtdPtr dtd, + const xmlChar *name); XMLPUBFUN xmlElementPtr XMLCALL - xmlGetDtdQElementDesc (xmlDtdPtr dtd, - const xmlChar *name, - const xmlChar *prefix); +xmlGetDtdQElementDesc (xmlDtdPtr dtd, + const xmlChar *name, + const xmlChar *prefix); XMLPUBFUN xmlElementPtr XMLCALL - xmlGetDtdElementDesc (xmlDtdPtr dtd, - const xmlChar *name); +xmlGetDtdElementDesc (xmlDtdPtr dtd, + const xmlChar *name); #ifdef LIBXML_VALID_ENABLED XMLPUBFUN int XMLCALL - xmlValidGetPotentialChildren(xmlElementContent *ctree, - const xmlChar **names, - int *len, - int max); +xmlValidGetPotentialChildren(xmlElementContent *ctree, + const xmlChar **names, + int *len, + int max); XMLPUBFUN int XMLCALL - xmlValidGetValidElements(xmlNode *prev, - xmlNode *next, - const xmlChar **names, - int max); +xmlValidGetValidElements(xmlNode *prev, + xmlNode *next, + const xmlChar **names, + int max); XMLPUBFUN int XMLCALL - xmlValidateNameValue (const xmlChar *value); +xmlValidateNameValue (const xmlChar *value); XMLPUBFUN int XMLCALL - xmlValidateNamesValue (const xmlChar *value); +xmlValidateNamesValue (const xmlChar *value); XMLPUBFUN int XMLCALL - xmlValidateNmtokenValue (const xmlChar *value); +xmlValidateNmtokenValue (const xmlChar *value); XMLPUBFUN int XMLCALL - xmlValidateNmtokensValue(const xmlChar *value); +xmlValidateNmtokensValue(const xmlChar *value); #ifdef LIBXML_REGEXP_ENABLED /* * Validation based on the regexp support */ XMLPUBFUN int XMLCALL - xmlValidBuildContentModel(xmlValidCtxtPtr ctxt, - xmlElementPtr elem); +xmlValidBuildContentModel(xmlValidCtxtPtr ctxt, + xmlElementPtr elem); XMLPUBFUN int XMLCALL - xmlValidatePushElement (xmlValidCtxtPtr ctxt, - xmlDocPtr doc, - xmlNodePtr elem, - const xmlChar *qname); +xmlValidatePushElement (xmlValidCtxtPtr ctxt, + xmlDocPtr doc, + xmlNodePtr elem, + const xmlChar *qname); XMLPUBFUN int XMLCALL - xmlValidatePushCData (xmlValidCtxtPtr ctxt, - const xmlChar *data, - int len); +xmlValidatePushCData (xmlValidCtxtPtr ctxt, + const xmlChar *data, + int len); XMLPUBFUN int XMLCALL - xmlValidatePopElement (xmlValidCtxtPtr ctxt, - xmlDocPtr doc, - xmlNodePtr elem, - const xmlChar *qname); +xmlValidatePopElement (xmlValidCtxtPtr ctxt, + xmlDocPtr doc, + xmlNodePtr elem, + const xmlChar *qname); #endif /* LIBXML_REGEXP_ENABLED */ #endif /* LIBXML_VALID_ENABLED */ #ifdef __cplusplus diff --git a/thirdparties/common/include/libxml2/libxml/xinclude.h b/thirdparties/common/include/libxml2/libxml/xinclude.h index 863ab25..e6b79cb 100755 --- a/thirdparties/common/include/libxml2/libxml/xinclude.h +++ b/thirdparties/common/include/libxml2/libxml/xinclude.h @@ -90,36 +90,36 @@ typedef xmlXIncludeCtxt *xmlXIncludeCtxtPtr; * standalone processing */ XMLPUBFUN int XMLCALL - xmlXIncludeProcess (xmlDocPtr doc); +xmlXIncludeProcess (xmlDocPtr doc); XMLPUBFUN int XMLCALL - xmlXIncludeProcessFlags (xmlDocPtr doc, - int flags); +xmlXIncludeProcessFlags (xmlDocPtr doc, + int flags); XMLPUBFUN int XMLCALL - xmlXIncludeProcessFlagsData(xmlDocPtr doc, - int flags, - void *data); +xmlXIncludeProcessFlagsData(xmlDocPtr doc, + int flags, + void *data); XMLPUBFUN int XMLCALL - xmlXIncludeProcessTreeFlagsData(xmlNodePtr tree, - int flags, - void *data); +xmlXIncludeProcessTreeFlagsData(xmlNodePtr tree, + int flags, + void *data); XMLPUBFUN int XMLCALL - xmlXIncludeProcessTree (xmlNodePtr tree); +xmlXIncludeProcessTree (xmlNodePtr tree); XMLPUBFUN int XMLCALL - xmlXIncludeProcessTreeFlags(xmlNodePtr tree, - int flags); +xmlXIncludeProcessTreeFlags(xmlNodePtr tree, + int flags); /* * contextual processing */ XMLPUBFUN xmlXIncludeCtxtPtr XMLCALL - xmlXIncludeNewContext (xmlDocPtr doc); +xmlXIncludeNewContext (xmlDocPtr doc); XMLPUBFUN int XMLCALL - xmlXIncludeSetFlags (xmlXIncludeCtxtPtr ctxt, - int flags); +xmlXIncludeSetFlags (xmlXIncludeCtxtPtr ctxt, + int flags); XMLPUBFUN void XMLCALL - xmlXIncludeFreeContext (xmlXIncludeCtxtPtr ctxt); +xmlXIncludeFreeContext (xmlXIncludeCtxtPtr ctxt); XMLPUBFUN int XMLCALL - xmlXIncludeProcessNode (xmlXIncludeCtxtPtr ctxt, - xmlNodePtr tree); +xmlXIncludeProcessNode (xmlXIncludeCtxtPtr ctxt, + xmlNodePtr tree); #ifdef __cplusplus } #endif diff --git a/thirdparties/common/include/libxml2/libxml/xlink.h b/thirdparties/common/include/libxml2/libxml/xlink.h index a209a99..adf3fc5 100755 --- a/thirdparties/common/include/libxml2/libxml/xlink.h +++ b/thirdparties/common/include/libxml2/libxml/xlink.h @@ -80,10 +80,10 @@ typedef void (*xlinkNodeDetectFunc) (void *ctx, xmlNodePtr node); */ typedef void (*xlinkSimpleLinkFunk) (void *ctx, - xmlNodePtr node, - const xlinkHRef href, - const xlinkRole role, - const xlinkTitle title); + xmlNodePtr node, + const xlinkHRef href, + const xlinkRole role, + const xlinkTitle title); /** * xlinkExtendedLinkFunk: @@ -105,18 +105,18 @@ typedef void */ typedef void (*xlinkExtendedLinkFunk)(void *ctx, - xmlNodePtr node, - int nbLocators, - const xlinkHRef *hrefs, - const xlinkRole *roles, - int nbArcs, - const xlinkRole *from, - const xlinkRole *to, - xlinkShow *show, - xlinkActuate *actuate, - int nbTitles, - const xlinkTitle *titles, - const xmlChar **langs); + xmlNodePtr node, + int nbLocators, + const xlinkHRef *hrefs, + const xlinkRole *roles, + int nbArcs, + const xlinkRole *from, + const xlinkRole *to, + xlinkShow *show, + xlinkActuate *actuate, + int nbTitles, + const xlinkTitle *titles, + const xmlChar **langs); /** * xlinkExtendedLinkSetFunk: @@ -133,13 +133,13 @@ typedef void */ typedef void (*xlinkExtendedLinkSetFunk) (void *ctx, - xmlNodePtr node, - int nbLocators, - const xlinkHRef *hrefs, - const xlinkRole *roles, - int nbTitles, - const xlinkTitle *titles, - const xmlChar **langs); + xmlNodePtr node, + int nbLocators, + const xlinkHRef *hrefs, + const xlinkRole *roles, + int nbTitles, + const xlinkTitle *titles, + const xmlChar **langs); /** * This is the structure containing a set of Links detection callbacks. @@ -161,24 +161,24 @@ struct _xlinkHandler { */ XMLPUBFUN xlinkNodeDetectFunc XMLCALL - xlinkGetDefaultDetect (void); +xlinkGetDefaultDetect (void); XMLPUBFUN void XMLCALL - xlinkSetDefaultDetect (xlinkNodeDetectFunc func); +xlinkSetDefaultDetect (xlinkNodeDetectFunc func); /* * Routines to set/get the default handlers. */ XMLPUBFUN xlinkHandlerPtr XMLCALL - xlinkGetDefaultHandler (void); +xlinkGetDefaultHandler (void); XMLPUBFUN void XMLCALL - xlinkSetDefaultHandler (xlinkHandlerPtr handler); +xlinkSetDefaultHandler (xlinkHandlerPtr handler); /* * Link detection module itself. */ XMLPUBFUN xlinkType XMLCALL - xlinkIsLink (xmlDocPtr doc, - xmlNodePtr node); +xlinkIsLink (xmlDocPtr doc, + xmlNodePtr node); #ifdef __cplusplus } diff --git a/thirdparties/common/include/libxml2/libxml/xmlIO.h b/thirdparties/common/include/libxml2/libxml/xmlIO.h index 6c241a8..7ddba9a 100755 --- a/thirdparties/common/include/libxml2/libxml/xmlIO.h +++ b/thirdparties/common/include/libxml2/libxml/xmlIO.h @@ -98,7 +98,7 @@ typedef void * (XMLCALL *xmlOutputOpenCallback) (char const *filename); * Returns the number of bytes written or -1 in case of error */ typedef int (XMLCALL *xmlOutputWriteCallback) (void * context, const char * buffer, - int len); + int len); /** * xmlOutputCloseCallback: * @context: an Output context @@ -156,191 +156,191 @@ struct _xmlOutputBuffer { * Interfaces for input */ XMLPUBFUN void XMLCALL - xmlCleanupInputCallbacks (void); +xmlCleanupInputCallbacks (void); XMLPUBFUN int XMLCALL - xmlPopInputCallbacks (void); +xmlPopInputCallbacks (void); XMLPUBFUN void XMLCALL - xmlRegisterDefaultInputCallbacks (void); +xmlRegisterDefaultInputCallbacks (void); XMLPUBFUN xmlParserInputBufferPtr XMLCALL - xmlAllocParserInputBuffer (xmlCharEncoding enc); +xmlAllocParserInputBuffer (xmlCharEncoding enc); XMLPUBFUN xmlParserInputBufferPtr XMLCALL - xmlParserInputBufferCreateFilename (const char *URI, - xmlCharEncoding enc); +xmlParserInputBufferCreateFilename (const char *URI, + xmlCharEncoding enc); XMLPUBFUN xmlParserInputBufferPtr XMLCALL - xmlParserInputBufferCreateFile (FILE *file, - xmlCharEncoding enc); +xmlParserInputBufferCreateFile (FILE *file, + xmlCharEncoding enc); XMLPUBFUN xmlParserInputBufferPtr XMLCALL - xmlParserInputBufferCreateFd (int fd, - xmlCharEncoding enc); +xmlParserInputBufferCreateFd (int fd, + xmlCharEncoding enc); XMLPUBFUN xmlParserInputBufferPtr XMLCALL - xmlParserInputBufferCreateMem (const char *mem, int size, - xmlCharEncoding enc); +xmlParserInputBufferCreateMem (const char *mem, int size, + xmlCharEncoding enc); XMLPUBFUN xmlParserInputBufferPtr XMLCALL - xmlParserInputBufferCreateStatic (const char *mem, int size, - xmlCharEncoding enc); +xmlParserInputBufferCreateStatic (const char *mem, int size, + xmlCharEncoding enc); XMLPUBFUN xmlParserInputBufferPtr XMLCALL - xmlParserInputBufferCreateIO (xmlInputReadCallback ioread, - xmlInputCloseCallback ioclose, - void *ioctx, - xmlCharEncoding enc); +xmlParserInputBufferCreateIO (xmlInputReadCallback ioread, + xmlInputCloseCallback ioclose, + void *ioctx, + xmlCharEncoding enc); XMLPUBFUN int XMLCALL - xmlParserInputBufferRead (xmlParserInputBufferPtr in, - int len); +xmlParserInputBufferRead (xmlParserInputBufferPtr in, + int len); XMLPUBFUN int XMLCALL - xmlParserInputBufferGrow (xmlParserInputBufferPtr in, - int len); +xmlParserInputBufferGrow (xmlParserInputBufferPtr in, + int len); XMLPUBFUN int XMLCALL - xmlParserInputBufferPush (xmlParserInputBufferPtr in, - int len, - const char *buf); +xmlParserInputBufferPush (xmlParserInputBufferPtr in, + int len, + const char *buf); XMLPUBFUN void XMLCALL - xmlFreeParserInputBuffer (xmlParserInputBufferPtr in); +xmlFreeParserInputBuffer (xmlParserInputBufferPtr in); XMLPUBFUN char * XMLCALL - xmlParserGetDirectory (const char *filename); +xmlParserGetDirectory (const char *filename); XMLPUBFUN int XMLCALL - xmlRegisterInputCallbacks (xmlInputMatchCallback matchFunc, - xmlInputOpenCallback openFunc, - xmlInputReadCallback readFunc, - xmlInputCloseCallback closeFunc); +xmlRegisterInputCallbacks (xmlInputMatchCallback matchFunc, + xmlInputOpenCallback openFunc, + xmlInputReadCallback readFunc, + xmlInputCloseCallback closeFunc); xmlParserInputBufferPtr - __xmlParserInputBufferCreateFilename(const char *URI, - xmlCharEncoding enc); +__xmlParserInputBufferCreateFilename(const char *URI, + xmlCharEncoding enc); #ifdef LIBXML_OUTPUT_ENABLED /* * Interfaces for output */ XMLPUBFUN void XMLCALL - xmlCleanupOutputCallbacks (void); +xmlCleanupOutputCallbacks (void); XMLPUBFUN void XMLCALL - xmlRegisterDefaultOutputCallbacks(void); +xmlRegisterDefaultOutputCallbacks(void); XMLPUBFUN xmlOutputBufferPtr XMLCALL - xmlAllocOutputBuffer (xmlCharEncodingHandlerPtr encoder); +xmlAllocOutputBuffer (xmlCharEncodingHandlerPtr encoder); XMLPUBFUN xmlOutputBufferPtr XMLCALL - xmlOutputBufferCreateFilename (const char *URI, - xmlCharEncodingHandlerPtr encoder, - int compression); +xmlOutputBufferCreateFilename (const char *URI, + xmlCharEncodingHandlerPtr encoder, + int compression); XMLPUBFUN xmlOutputBufferPtr XMLCALL - xmlOutputBufferCreateFile (FILE *file, - xmlCharEncodingHandlerPtr encoder); +xmlOutputBufferCreateFile (FILE *file, + xmlCharEncodingHandlerPtr encoder); XMLPUBFUN xmlOutputBufferPtr XMLCALL - xmlOutputBufferCreateBuffer (xmlBufferPtr buffer, - xmlCharEncodingHandlerPtr encoder); +xmlOutputBufferCreateBuffer (xmlBufferPtr buffer, + xmlCharEncodingHandlerPtr encoder); XMLPUBFUN xmlOutputBufferPtr XMLCALL - xmlOutputBufferCreateFd (int fd, - xmlCharEncodingHandlerPtr encoder); +xmlOutputBufferCreateFd (int fd, + xmlCharEncodingHandlerPtr encoder); XMLPUBFUN xmlOutputBufferPtr XMLCALL - xmlOutputBufferCreateIO (xmlOutputWriteCallback iowrite, - xmlOutputCloseCallback ioclose, - void *ioctx, - xmlCharEncodingHandlerPtr encoder); +xmlOutputBufferCreateIO (xmlOutputWriteCallback iowrite, + xmlOutputCloseCallback ioclose, + void *ioctx, + xmlCharEncodingHandlerPtr encoder); /* Couple of APIs to get the output without digging into the buffers */ XMLPUBFUN const xmlChar * XMLCALL - xmlOutputBufferGetContent (xmlOutputBufferPtr out); +xmlOutputBufferGetContent (xmlOutputBufferPtr out); XMLPUBFUN size_t XMLCALL - xmlOutputBufferGetSize (xmlOutputBufferPtr out); +xmlOutputBufferGetSize (xmlOutputBufferPtr out); XMLPUBFUN int XMLCALL - xmlOutputBufferWrite (xmlOutputBufferPtr out, - int len, - const char *buf); +xmlOutputBufferWrite (xmlOutputBufferPtr out, + int len, + const char *buf); XMLPUBFUN int XMLCALL - xmlOutputBufferWriteString (xmlOutputBufferPtr out, - const char *str); +xmlOutputBufferWriteString (xmlOutputBufferPtr out, + const char *str); XMLPUBFUN int XMLCALL - xmlOutputBufferWriteEscape (xmlOutputBufferPtr out, - const xmlChar *str, - xmlCharEncodingOutputFunc escaping); +xmlOutputBufferWriteEscape (xmlOutputBufferPtr out, + const xmlChar *str, + xmlCharEncodingOutputFunc escaping); XMLPUBFUN int XMLCALL - xmlOutputBufferFlush (xmlOutputBufferPtr out); +xmlOutputBufferFlush (xmlOutputBufferPtr out); XMLPUBFUN int XMLCALL - xmlOutputBufferClose (xmlOutputBufferPtr out); +xmlOutputBufferClose (xmlOutputBufferPtr out); XMLPUBFUN int XMLCALL - xmlRegisterOutputCallbacks (xmlOutputMatchCallback matchFunc, - xmlOutputOpenCallback openFunc, - xmlOutputWriteCallback writeFunc, - xmlOutputCloseCallback closeFunc); +xmlRegisterOutputCallbacks (xmlOutputMatchCallback matchFunc, + xmlOutputOpenCallback openFunc, + xmlOutputWriteCallback writeFunc, + xmlOutputCloseCallback closeFunc); xmlOutputBufferPtr - __xmlOutputBufferCreateFilename(const char *URI, - xmlCharEncodingHandlerPtr encoder, - int compression); +__xmlOutputBufferCreateFilename(const char *URI, + xmlCharEncodingHandlerPtr encoder, + int compression); #ifdef LIBXML_HTTP_ENABLED /* This function only exists if HTTP support built into the library */ XMLPUBFUN void XMLCALL - xmlRegisterHTTPPostCallbacks (void ); +xmlRegisterHTTPPostCallbacks (void ); #endif /* LIBXML_HTTP_ENABLED */ #endif /* LIBXML_OUTPUT_ENABLED */ XMLPUBFUN xmlParserInputPtr XMLCALL - xmlCheckHTTPInput (xmlParserCtxtPtr ctxt, - xmlParserInputPtr ret); +xmlCheckHTTPInput (xmlParserCtxtPtr ctxt, + xmlParserInputPtr ret); /* * A predefined entity loader disabling network accesses */ XMLPUBFUN xmlParserInputPtr XMLCALL - xmlNoNetExternalEntityLoader (const char *URL, - const char *ID, - xmlParserCtxtPtr ctxt); +xmlNoNetExternalEntityLoader (const char *URL, + const char *ID, + xmlParserCtxtPtr ctxt); /* * xmlNormalizeWindowsPath is obsolete, don't use it. * Check xmlCanonicPath in uri.h for a better alternative. */ XMLPUBFUN xmlChar * XMLCALL - xmlNormalizeWindowsPath (const xmlChar *path); +xmlNormalizeWindowsPath (const xmlChar *path); XMLPUBFUN int XMLCALL - xmlCheckFilename (const char *path); +xmlCheckFilename (const char *path); /** * Default 'file://' protocol callbacks */ XMLPUBFUN int XMLCALL - xmlFileMatch (const char *filename); +xmlFileMatch (const char *filename); XMLPUBFUN void * XMLCALL - xmlFileOpen (const char *filename); +xmlFileOpen (const char *filename); XMLPUBFUN int XMLCALL - xmlFileRead (void * context, - char * buffer, - int len); +xmlFileRead (void * context, + char * buffer, + int len); XMLPUBFUN int XMLCALL - xmlFileClose (void * context); +xmlFileClose (void * context); /** * Default 'http://' protocol callbacks */ #ifdef LIBXML_HTTP_ENABLED XMLPUBFUN int XMLCALL - xmlIOHTTPMatch (const char *filename); +xmlIOHTTPMatch (const char *filename); XMLPUBFUN void * XMLCALL - xmlIOHTTPOpen (const char *filename); +xmlIOHTTPOpen (const char *filename); #ifdef LIBXML_OUTPUT_ENABLED XMLPUBFUN void * XMLCALL - xmlIOHTTPOpenW (const char * post_uri, - int compression ); +xmlIOHTTPOpenW (const char * post_uri, + int compression ); #endif /* LIBXML_OUTPUT_ENABLED */ XMLPUBFUN int XMLCALL - xmlIOHTTPRead (void * context, - char * buffer, - int len); +xmlIOHTTPRead (void * context, + char * buffer, + int len); XMLPUBFUN int XMLCALL - xmlIOHTTPClose (void * context); +xmlIOHTTPClose (void * context); #endif /* LIBXML_HTTP_ENABLED */ /** @@ -348,15 +348,15 @@ XMLPUBFUN int XMLCALL */ #ifdef LIBXML_FTP_ENABLED XMLPUBFUN int XMLCALL - xmlIOFTPMatch (const char *filename); +xmlIOFTPMatch (const char *filename); XMLPUBFUN void * XMLCALL - xmlIOFTPOpen (const char *filename); +xmlIOFTPOpen (const char *filename); XMLPUBFUN int XMLCALL - xmlIOFTPRead (void * context, - char * buffer, - int len); +xmlIOFTPRead (void * context, + char * buffer, + int len); XMLPUBFUN int XMLCALL - xmlIOFTPClose (void * context); +xmlIOFTPClose (void * context); #endif /* LIBXML_FTP_ENABLED */ #ifdef __cplusplus diff --git a/thirdparties/common/include/libxml2/libxml/xmlautomata.h b/thirdparties/common/include/libxml2/libxml/xmlautomata.h index bf1b131..1a49117 100755 --- a/thirdparties/common/include/libxml2/libxml/xmlautomata.h +++ b/thirdparties/common/include/libxml2/libxml/xmlautomata.h @@ -41,100 +41,100 @@ typedef xmlAutomataState *xmlAutomataStatePtr; * Building API */ XMLPUBFUN xmlAutomataPtr XMLCALL - xmlNewAutomata (void); +xmlNewAutomata (void); XMLPUBFUN void XMLCALL - xmlFreeAutomata (xmlAutomataPtr am); +xmlFreeAutomata (xmlAutomataPtr am); XMLPUBFUN xmlAutomataStatePtr XMLCALL - xmlAutomataGetInitState (xmlAutomataPtr am); +xmlAutomataGetInitState (xmlAutomataPtr am); XMLPUBFUN int XMLCALL - xmlAutomataSetFinalState (xmlAutomataPtr am, - xmlAutomataStatePtr state); +xmlAutomataSetFinalState (xmlAutomataPtr am, + xmlAutomataStatePtr state); XMLPUBFUN xmlAutomataStatePtr XMLCALL - xmlAutomataNewState (xmlAutomataPtr am); +xmlAutomataNewState (xmlAutomataPtr am); XMLPUBFUN xmlAutomataStatePtr XMLCALL - xmlAutomataNewTransition (xmlAutomataPtr am, - xmlAutomataStatePtr from, - xmlAutomataStatePtr to, - const xmlChar *token, - void *data); +xmlAutomataNewTransition (xmlAutomataPtr am, + xmlAutomataStatePtr from, + xmlAutomataStatePtr to, + const xmlChar *token, + void *data); XMLPUBFUN xmlAutomataStatePtr XMLCALL - xmlAutomataNewTransition2 (xmlAutomataPtr am, - xmlAutomataStatePtr from, - xmlAutomataStatePtr to, - const xmlChar *token, - const xmlChar *token2, - void *data); +xmlAutomataNewTransition2 (xmlAutomataPtr am, + xmlAutomataStatePtr from, + xmlAutomataStatePtr to, + const xmlChar *token, + const xmlChar *token2, + void *data); XMLPUBFUN xmlAutomataStatePtr XMLCALL - xmlAutomataNewNegTrans (xmlAutomataPtr am, - xmlAutomataStatePtr from, - xmlAutomataStatePtr to, - const xmlChar *token, - const xmlChar *token2, - void *data); +xmlAutomataNewNegTrans (xmlAutomataPtr am, + xmlAutomataStatePtr from, + xmlAutomataStatePtr to, + const xmlChar *token, + const xmlChar *token2, + void *data); XMLPUBFUN xmlAutomataStatePtr XMLCALL - xmlAutomataNewCountTrans (xmlAutomataPtr am, - xmlAutomataStatePtr from, - xmlAutomataStatePtr to, - const xmlChar *token, - int min, - int max, - void *data); +xmlAutomataNewCountTrans (xmlAutomataPtr am, + xmlAutomataStatePtr from, + xmlAutomataStatePtr to, + const xmlChar *token, + int min, + int max, + void *data); XMLPUBFUN xmlAutomataStatePtr XMLCALL - xmlAutomataNewCountTrans2 (xmlAutomataPtr am, - xmlAutomataStatePtr from, - xmlAutomataStatePtr to, - const xmlChar *token, - const xmlChar *token2, - int min, - int max, - void *data); +xmlAutomataNewCountTrans2 (xmlAutomataPtr am, + xmlAutomataStatePtr from, + xmlAutomataStatePtr to, + const xmlChar *token, + const xmlChar *token2, + int min, + int max, + void *data); XMLPUBFUN xmlAutomataStatePtr XMLCALL - xmlAutomataNewOnceTrans (xmlAutomataPtr am, - xmlAutomataStatePtr from, - xmlAutomataStatePtr to, - const xmlChar *token, - int min, - int max, - void *data); +xmlAutomataNewOnceTrans (xmlAutomataPtr am, + xmlAutomataStatePtr from, + xmlAutomataStatePtr to, + const xmlChar *token, + int min, + int max, + void *data); XMLPUBFUN xmlAutomataStatePtr XMLCALL - xmlAutomataNewOnceTrans2 (xmlAutomataPtr am, - xmlAutomataStatePtr from, - xmlAutomataStatePtr to, - const xmlChar *token, - const xmlChar *token2, - int min, - int max, - void *data); +xmlAutomataNewOnceTrans2 (xmlAutomataPtr am, + xmlAutomataStatePtr from, + xmlAutomataStatePtr to, + const xmlChar *token, + const xmlChar *token2, + int min, + int max, + void *data); XMLPUBFUN xmlAutomataStatePtr XMLCALL - xmlAutomataNewAllTrans (xmlAutomataPtr am, - xmlAutomataStatePtr from, - xmlAutomataStatePtr to, - int lax); +xmlAutomataNewAllTrans (xmlAutomataPtr am, + xmlAutomataStatePtr from, + xmlAutomataStatePtr to, + int lax); XMLPUBFUN xmlAutomataStatePtr XMLCALL - xmlAutomataNewEpsilon (xmlAutomataPtr am, - xmlAutomataStatePtr from, - xmlAutomataStatePtr to); +xmlAutomataNewEpsilon (xmlAutomataPtr am, + xmlAutomataStatePtr from, + xmlAutomataStatePtr to); XMLPUBFUN xmlAutomataStatePtr XMLCALL - xmlAutomataNewCountedTrans (xmlAutomataPtr am, - xmlAutomataStatePtr from, - xmlAutomataStatePtr to, - int counter); +xmlAutomataNewCountedTrans (xmlAutomataPtr am, + xmlAutomataStatePtr from, + xmlAutomataStatePtr to, + int counter); XMLPUBFUN xmlAutomataStatePtr XMLCALL - xmlAutomataNewCounterTrans (xmlAutomataPtr am, - xmlAutomataStatePtr from, - xmlAutomataStatePtr to, - int counter); +xmlAutomataNewCounterTrans (xmlAutomataPtr am, + xmlAutomataStatePtr from, + xmlAutomataStatePtr to, + int counter); XMLPUBFUN int XMLCALL - xmlAutomataNewCounter (xmlAutomataPtr am, - int min, - int max); +xmlAutomataNewCounter (xmlAutomataPtr am, + int min, + int max); XMLPUBFUN xmlRegexpPtr XMLCALL - xmlAutomataCompile (xmlAutomataPtr am); +xmlAutomataCompile (xmlAutomataPtr am); XMLPUBFUN int XMLCALL - xmlAutomataIsDeterminist (xmlAutomataPtr am); +xmlAutomataIsDeterminist (xmlAutomataPtr am); #ifdef __cplusplus } diff --git a/thirdparties/common/include/libxml2/libxml/xmlerror.h b/thirdparties/common/include/libxml2/libxml/xmlerror.h index 537a396..48fd444 100755 --- a/thirdparties/common/include/libxml2/libxml/xmlerror.h +++ b/thirdparties/common/include/libxml2/libxml/xmlerror.h @@ -26,7 +26,8 @@ typedef enum { XML_ERR_WARNING = 1, /* A simple warning */ XML_ERR_ERROR = 2, /* A recoverable error */ XML_ERR_FATAL = 3 /* A fatal error */ -} xmlErrorLevel; +} +xmlErrorLevel; /** * xmlErrorDomain: @@ -843,8 +844,8 @@ typedef enum { * no parsing or validity context available . */ typedef void (XMLCDECL *xmlGenericErrorFunc) (void *ctx, - const char *msg, - ...) LIBXML_ATTR_FORMAT(2,3); + const char *msg, + ...) LIBXML_ATTR_FORMAT(2,3); /** * xmlStructuredErrorFunc: * @userData: user provided data for the error callback @@ -860,84 +861,84 @@ typedef void (XMLCALL *xmlStructuredErrorFunc) (void *userData, xmlErrorPtr erro * xmlGenericError and xmlGenericErrorContext. */ XMLPUBFUN void XMLCALL - xmlSetGenericErrorFunc (void *ctx, - xmlGenericErrorFunc handler); +xmlSetGenericErrorFunc (void *ctx, + xmlGenericErrorFunc handler); XMLPUBFUN void XMLCALL - initGenericErrorDefaultFunc (xmlGenericErrorFunc *handler); +initGenericErrorDefaultFunc (xmlGenericErrorFunc *handler); XMLPUBFUN void XMLCALL - xmlSetStructuredErrorFunc (void *ctx, - xmlStructuredErrorFunc handler); +xmlSetStructuredErrorFunc (void *ctx, + xmlStructuredErrorFunc handler); /* * Default message routines used by SAX and Valid context for error * and warning reporting. */ XMLPUBFUN void XMLCDECL - xmlParserError (void *ctx, - const char *msg, - ...) LIBXML_ATTR_FORMAT(2,3); +xmlParserError (void *ctx, + const char *msg, + ...) LIBXML_ATTR_FORMAT(2,3); XMLPUBFUN void XMLCDECL - xmlParserWarning (void *ctx, - const char *msg, - ...) LIBXML_ATTR_FORMAT(2,3); +xmlParserWarning (void *ctx, + const char *msg, + ...) LIBXML_ATTR_FORMAT(2,3); XMLPUBFUN void XMLCDECL - xmlParserValidityError (void *ctx, - const char *msg, - ...) LIBXML_ATTR_FORMAT(2,3); +xmlParserValidityError (void *ctx, + const char *msg, + ...) LIBXML_ATTR_FORMAT(2,3); XMLPUBFUN void XMLCDECL - xmlParserValidityWarning (void *ctx, - const char *msg, - ...) LIBXML_ATTR_FORMAT(2,3); +xmlParserValidityWarning (void *ctx, + const char *msg, + ...) LIBXML_ATTR_FORMAT(2,3); XMLPUBFUN void XMLCALL - xmlParserPrintFileInfo (xmlParserInputPtr input); +xmlParserPrintFileInfo (xmlParserInputPtr input); XMLPUBFUN void XMLCALL - xmlParserPrintFileContext (xmlParserInputPtr input); +xmlParserPrintFileContext (xmlParserInputPtr input); /* * Extended error information routines */ XMLPUBFUN xmlErrorPtr XMLCALL - xmlGetLastError (void); +xmlGetLastError (void); XMLPUBFUN void XMLCALL - xmlResetLastError (void); +xmlResetLastError (void); XMLPUBFUN xmlErrorPtr XMLCALL - xmlCtxtGetLastError (void *ctx); +xmlCtxtGetLastError (void *ctx); XMLPUBFUN void XMLCALL - xmlCtxtResetLastError (void *ctx); +xmlCtxtResetLastError (void *ctx); XMLPUBFUN void XMLCALL - xmlResetError (xmlErrorPtr err); +xmlResetError (xmlErrorPtr err); XMLPUBFUN int XMLCALL - xmlCopyError (xmlErrorPtr from, - xmlErrorPtr to); +xmlCopyError (xmlErrorPtr from, + xmlErrorPtr to); #ifdef IN_LIBXML /* * Internal callback reporting routine */ XMLPUBFUN void XMLCALL - __xmlRaiseError (xmlStructuredErrorFunc schannel, - xmlGenericErrorFunc channel, - void *data, - void *ctx, - void *node, - int domain, - int code, - xmlErrorLevel level, - const char *file, - int line, - const char *str1, - const char *str2, - const char *str3, - int int1, - int col, - const char *msg, - ...) LIBXML_ATTR_FORMAT(16,17); +__xmlRaiseError (xmlStructuredErrorFunc schannel, + xmlGenericErrorFunc channel, + void *data, + void *ctx, + void *node, + int domain, + int code, + xmlErrorLevel level, + const char *file, + int line, + const char *str1, + const char *str2, + const char *str3, + int int1, + int col, + const char *msg, + ...) LIBXML_ATTR_FORMAT(16,17); XMLPUBFUN void XMLCALL - __xmlSimpleError (int domain, - int code, - xmlNodePtr node, - const char *msg, - const char *extra); +__xmlSimpleError (int domain, + int code, + xmlNodePtr node, + const char *msg, + const char *extra); #endif #ifdef __cplusplus } diff --git a/thirdparties/common/include/libxml2/libxml/xmlexports.h b/thirdparties/common/include/libxml2/libxml/xmlexports.h index 2c79f81..864c3d9 100755 --- a/thirdparties/common/include/libxml2/libxml/xmlexports.h +++ b/thirdparties/common/include/libxml2/libxml/xmlexports.h @@ -52,104 +52,104 @@ /* Windows platform with MS compiler */ #if defined(_WIN32) && defined(_MSC_VER) - #undef XMLPUBFUN - #undef XMLPUBVAR - #undef XMLCALL - #undef XMLCDECL - #if defined(IN_LIBXML) && !defined(LIBXML_STATIC) - #define XMLPUBFUN __declspec(dllexport) - #define XMLPUBVAR __declspec(dllexport) - #else - #define XMLPUBFUN - #if !defined(LIBXML_STATIC) - #define XMLPUBVAR __declspec(dllimport) extern - #else - #define XMLPUBVAR extern - #endif - #endif - #if defined(LIBXML_FASTCALL) - #define XMLCALL __fastcall - #else - #define XMLCALL __cdecl - #endif - #define XMLCDECL __cdecl - #if !defined _REENTRANT - #define _REENTRANT - #endif +#undef XMLPUBFUN +#undef XMLPUBVAR +#undef XMLCALL +#undef XMLCDECL +#if defined(IN_LIBXML) && !defined(LIBXML_STATIC) +#define XMLPUBFUN __declspec(dllexport) +#define XMLPUBVAR __declspec(dllexport) +#else +#define XMLPUBFUN +#if !defined(LIBXML_STATIC) +#define XMLPUBVAR __declspec(dllimport) extern +#else +#define XMLPUBVAR extern +#endif +#endif +#if defined(LIBXML_FASTCALL) +#define XMLCALL __fastcall +#else +#define XMLCALL __cdecl +#endif +#define XMLCDECL __cdecl +#if !defined _REENTRANT +#define _REENTRANT +#endif #endif /* Windows platform with Borland compiler */ #if defined(_WIN32) && defined(__BORLANDC__) - #undef XMLPUBFUN - #undef XMLPUBVAR - #undef XMLCALL - #undef XMLCDECL - #if defined(IN_LIBXML) && !defined(LIBXML_STATIC) - #define XMLPUBFUN __declspec(dllexport) - #define XMLPUBVAR __declspec(dllexport) extern - #else - #define XMLPUBFUN - #if !defined(LIBXML_STATIC) - #define XMLPUBVAR __declspec(dllimport) extern - #else - #define XMLPUBVAR extern - #endif - #endif - #define XMLCALL __cdecl - #define XMLCDECL __cdecl - #if !defined _REENTRANT - #define _REENTRANT - #endif +#undef XMLPUBFUN +#undef XMLPUBVAR +#undef XMLCALL +#undef XMLCDECL +#if defined(IN_LIBXML) && !defined(LIBXML_STATIC) +#define XMLPUBFUN __declspec(dllexport) +#define XMLPUBVAR __declspec(dllexport) extern +#else +#define XMLPUBFUN +#if !defined(LIBXML_STATIC) +#define XMLPUBVAR __declspec(dllimport) extern +#else +#define XMLPUBVAR extern +#endif +#endif +#define XMLCALL __cdecl +#define XMLCDECL __cdecl +#if !defined _REENTRANT +#define _REENTRANT +#endif #endif /* Windows platform with GNU compiler (Mingw) */ #if defined(_WIN32) && defined(__MINGW32__) - #undef XMLPUBFUN - #undef XMLPUBVAR - #undef XMLCALL - #undef XMLCDECL - /* - * if defined(IN_LIBXML) this raises problems on mingw with msys - * _imp__xmlFree listed as missing. Try to workaround the problem - * by also making that declaration when compiling client code. - */ - #if defined(IN_LIBXML) && !defined(LIBXML_STATIC) - #define XMLPUBFUN __declspec(dllexport) - #define XMLPUBVAR __declspec(dllexport) extern - #else - #define XMLPUBFUN - #if !defined(LIBXML_STATIC) - #define XMLPUBVAR __declspec(dllimport) extern - #else - #define XMLPUBVAR extern - #endif - #endif - #define XMLCALL __cdecl - #define XMLCDECL __cdecl - #if !defined _REENTRANT - #define _REENTRANT - #endif +#undef XMLPUBFUN +#undef XMLPUBVAR +#undef XMLCALL +#undef XMLCDECL +/* + * if defined(IN_LIBXML) this raises problems on mingw with msys + * _imp__xmlFree listed as missing. Try to workaround the problem + * by also making that declaration when compiling client code. + */ +#if defined(IN_LIBXML) && !defined(LIBXML_STATIC) +#define XMLPUBFUN __declspec(dllexport) +#define XMLPUBVAR __declspec(dllexport) extern +#else +#define XMLPUBFUN +#if !defined(LIBXML_STATIC) +#define XMLPUBVAR __declspec(dllimport) extern +#else +#define XMLPUBVAR extern +#endif +#endif +#define XMLCALL __cdecl +#define XMLCDECL __cdecl +#if !defined _REENTRANT +#define _REENTRANT +#endif #endif /* Cygwin platform, GNU compiler */ #if defined(_WIN32) && defined(__CYGWIN__) - #undef XMLPUBFUN - #undef XMLPUBVAR - #undef XMLCALL - #undef XMLCDECL - #if defined(IN_LIBXML) && !defined(LIBXML_STATIC) - #define XMLPUBFUN __declspec(dllexport) - #define XMLPUBVAR __declspec(dllexport) - #else - #define XMLPUBFUN - #if !defined(LIBXML_STATIC) - #define XMLPUBVAR __declspec(dllimport) extern - #else - #define XMLPUBVAR - #endif - #endif - #define XMLCALL __cdecl - #define XMLCDECL __cdecl +#undef XMLPUBFUN +#undef XMLPUBVAR +#undef XMLCALL +#undef XMLCDECL +#if defined(IN_LIBXML) && !defined(LIBXML_STATIC) +#define XMLPUBFUN __declspec(dllexport) +#define XMLPUBVAR __declspec(dllexport) +#else +#define XMLPUBFUN +#if !defined(LIBXML_STATIC) +#define XMLPUBVAR __declspec(dllimport) extern +#else +#define XMLPUBVAR +#endif +#endif +#define XMLCALL __cdecl +#define XMLCDECL __cdecl #endif /* Compatibility */ diff --git a/thirdparties/common/include/libxml2/libxml/xmlmemory.h b/thirdparties/common/include/libxml2/libxml/xmlmemory.h index 17e375a..58e6e5c 100755 --- a/thirdparties/common/include/libxml2/libxml/xmlmemory.h +++ b/thirdparties/common/include/libxml2/libxml/xmlmemory.h @@ -101,70 +101,70 @@ LIBXML_DLL_IMPORT xmlStrdupFunc xmlMemStrdup; * allocations useful for garbage collected memory allocators */ XMLPUBFUN int XMLCALL - xmlMemSetup (xmlFreeFunc freeFunc, - xmlMallocFunc mallocFunc, - xmlReallocFunc reallocFunc, - xmlStrdupFunc strdupFunc); +xmlMemSetup (xmlFreeFunc freeFunc, + xmlMallocFunc mallocFunc, + xmlReallocFunc reallocFunc, + xmlStrdupFunc strdupFunc); XMLPUBFUN int XMLCALL - xmlMemGet (xmlFreeFunc *freeFunc, - xmlMallocFunc *mallocFunc, - xmlReallocFunc *reallocFunc, - xmlStrdupFunc *strdupFunc); +xmlMemGet (xmlFreeFunc *freeFunc, + xmlMallocFunc *mallocFunc, + xmlReallocFunc *reallocFunc, + xmlStrdupFunc *strdupFunc); XMLPUBFUN int XMLCALL - xmlGcMemSetup (xmlFreeFunc freeFunc, - xmlMallocFunc mallocFunc, - xmlMallocFunc mallocAtomicFunc, - xmlReallocFunc reallocFunc, - xmlStrdupFunc strdupFunc); +xmlGcMemSetup (xmlFreeFunc freeFunc, + xmlMallocFunc mallocFunc, + xmlMallocFunc mallocAtomicFunc, + xmlReallocFunc reallocFunc, + xmlStrdupFunc strdupFunc); XMLPUBFUN int XMLCALL - xmlGcMemGet (xmlFreeFunc *freeFunc, - xmlMallocFunc *mallocFunc, - xmlMallocFunc *mallocAtomicFunc, - xmlReallocFunc *reallocFunc, - xmlStrdupFunc *strdupFunc); +xmlGcMemGet (xmlFreeFunc *freeFunc, + xmlMallocFunc *mallocFunc, + xmlMallocFunc *mallocAtomicFunc, + xmlReallocFunc *reallocFunc, + xmlStrdupFunc *strdupFunc); /* * Initialization of the memory layer. */ XMLPUBFUN int XMLCALL - xmlInitMemory (void); +xmlInitMemory (void); /* * Cleanup of the memory layer. */ XMLPUBFUN void XMLCALL - xmlCleanupMemory (void); +xmlCleanupMemory (void); /* * These are specific to the XML debug memory wrapper. */ XMLPUBFUN int XMLCALL - xmlMemUsed (void); +xmlMemUsed (void); XMLPUBFUN int XMLCALL - xmlMemBlocks (void); +xmlMemBlocks (void); XMLPUBFUN void XMLCALL - xmlMemDisplay (FILE *fp); +xmlMemDisplay (FILE *fp); XMLPUBFUN void XMLCALL - xmlMemDisplayLast(FILE *fp, long nbBytes); +xmlMemDisplayLast(FILE *fp, long nbBytes); XMLPUBFUN void XMLCALL - xmlMemShow (FILE *fp, int nr); +xmlMemShow (FILE *fp, int nr); XMLPUBFUN void XMLCALL - xmlMemoryDump (void); +xmlMemoryDump (void); XMLPUBFUN void * XMLCALL - xmlMemMalloc (size_t size) LIBXML_ATTR_ALLOC_SIZE(1); +xmlMemMalloc (size_t size) LIBXML_ATTR_ALLOC_SIZE(1); XMLPUBFUN void * XMLCALL - xmlMemRealloc (void *ptr,size_t size); +xmlMemRealloc (void *ptr,size_t size); XMLPUBFUN void XMLCALL - xmlMemFree (void *ptr); +xmlMemFree (void *ptr); XMLPUBFUN char * XMLCALL - xmlMemoryStrdup (const char *str); +xmlMemoryStrdup (const char *str); XMLPUBFUN void * XMLCALL - xmlMallocLoc (size_t size, const char *file, int line) LIBXML_ATTR_ALLOC_SIZE(1); +xmlMallocLoc (size_t size, const char *file, int line) LIBXML_ATTR_ALLOC_SIZE(1); XMLPUBFUN void * XMLCALL - xmlReallocLoc (void *ptr, size_t size, const char *file, int line); +xmlReallocLoc (void *ptr, size_t size, const char *file, int line); XMLPUBFUN void * XMLCALL - xmlMallocAtomicLoc (size_t size, const char *file, int line) LIBXML_ATTR_ALLOC_SIZE(1); +xmlMallocAtomicLoc (size_t size, const char *file, int line) LIBXML_ATTR_ALLOC_SIZE(1); XMLPUBFUN char * XMLCALL - xmlMemStrdupLoc (const char *str, const char *file, int line); +xmlMemStrdupLoc (const char *str, const char *file, int line); #ifdef DEBUG_MEMORY_LOCATION diff --git a/thirdparties/common/include/libxml2/libxml/xmlmodule.h b/thirdparties/common/include/libxml2/libxml/xmlmodule.h index 9667820..ef4720c 100755 --- a/thirdparties/common/include/libxml2/libxml/xmlmodule.h +++ b/thirdparties/common/include/libxml2/libxml/xmlmodule.h @@ -38,11 +38,11 @@ typedef enum { } xmlModuleOption; XMLPUBFUN xmlModulePtr XMLCALL xmlModuleOpen (const char *filename, - int options); + int options); XMLPUBFUN int XMLCALL xmlModuleSymbol (xmlModulePtr module, - const char* name, - void **result); + const char* name, + void **result); XMLPUBFUN int XMLCALL xmlModuleClose (xmlModulePtr module); diff --git a/thirdparties/common/include/libxml2/libxml/xmlreader.h b/thirdparties/common/include/libxml2/libxml/xmlreader.h index 2c99e3a..1c87e82 100755 --- a/thirdparties/common/include/libxml2/libxml/xmlreader.h +++ b/thirdparties/common/include/libxml2/libxml/xmlreader.h @@ -33,7 +33,8 @@ typedef enum { XML_PARSER_SEVERITY_VALIDITY_ERROR = 2, XML_PARSER_SEVERITY_WARNING = 3, XML_PARSER_SEVERITY_ERROR = 4 -} xmlParserSeverities; +} +xmlParserSeverities; #ifdef LIBXML_READER_ENABLED @@ -109,16 +110,16 @@ typedef xmlTextReader *xmlTextReaderPtr; * Constructors & Destructor */ XMLPUBFUN xmlTextReaderPtr XMLCALL - xmlNewTextReader (xmlParserInputBufferPtr input, - const char *URI); +xmlNewTextReader (xmlParserInputBufferPtr input, + const char *URI); XMLPUBFUN xmlTextReaderPtr XMLCALL - xmlNewTextReaderFilename(const char *URI); +xmlNewTextReaderFilename(const char *URI); XMLPUBFUN void XMLCALL - xmlFreeTextReader (xmlTextReaderPtr reader); +xmlFreeTextReader (xmlTextReaderPtr reader); XMLPUBFUN int XMLCALL - xmlTextReaderSetup(xmlTextReaderPtr reader, +xmlTextReaderSetup(xmlTextReaderPtr reader, xmlParserInputBufferPtr input, const char *URL, const char *encoding, int options); @@ -126,263 +127,263 @@ XMLPUBFUN int XMLCALL * Iterators */ XMLPUBFUN int XMLCALL - xmlTextReaderRead (xmlTextReaderPtr reader); +xmlTextReaderRead (xmlTextReaderPtr reader); #ifdef LIBXML_WRITER_ENABLED XMLPUBFUN xmlChar * XMLCALL - xmlTextReaderReadInnerXml(xmlTextReaderPtr reader); +xmlTextReaderReadInnerXml(xmlTextReaderPtr reader); XMLPUBFUN xmlChar * XMLCALL - xmlTextReaderReadOuterXml(xmlTextReaderPtr reader); +xmlTextReaderReadOuterXml(xmlTextReaderPtr reader); #endif XMLPUBFUN xmlChar * XMLCALL - xmlTextReaderReadString (xmlTextReaderPtr reader); +xmlTextReaderReadString (xmlTextReaderPtr reader); XMLPUBFUN int XMLCALL - xmlTextReaderReadAttributeValue(xmlTextReaderPtr reader); +xmlTextReaderReadAttributeValue(xmlTextReaderPtr reader); /* * Attributes of the node */ XMLPUBFUN int XMLCALL - xmlTextReaderAttributeCount(xmlTextReaderPtr reader); +xmlTextReaderAttributeCount(xmlTextReaderPtr reader); XMLPUBFUN int XMLCALL - xmlTextReaderDepth (xmlTextReaderPtr reader); +xmlTextReaderDepth (xmlTextReaderPtr reader); XMLPUBFUN int XMLCALL - xmlTextReaderHasAttributes(xmlTextReaderPtr reader); +xmlTextReaderHasAttributes(xmlTextReaderPtr reader); XMLPUBFUN int XMLCALL - xmlTextReaderHasValue(xmlTextReaderPtr reader); +xmlTextReaderHasValue(xmlTextReaderPtr reader); XMLPUBFUN int XMLCALL - xmlTextReaderIsDefault (xmlTextReaderPtr reader); +xmlTextReaderIsDefault (xmlTextReaderPtr reader); XMLPUBFUN int XMLCALL - xmlTextReaderIsEmptyElement(xmlTextReaderPtr reader); +xmlTextReaderIsEmptyElement(xmlTextReaderPtr reader); XMLPUBFUN int XMLCALL - xmlTextReaderNodeType (xmlTextReaderPtr reader); +xmlTextReaderNodeType (xmlTextReaderPtr reader); XMLPUBFUN int XMLCALL - xmlTextReaderQuoteChar (xmlTextReaderPtr reader); +xmlTextReaderQuoteChar (xmlTextReaderPtr reader); XMLPUBFUN int XMLCALL - xmlTextReaderReadState (xmlTextReaderPtr reader); +xmlTextReaderReadState (xmlTextReaderPtr reader); XMLPUBFUN int XMLCALL - xmlTextReaderIsNamespaceDecl(xmlTextReaderPtr reader); +xmlTextReaderIsNamespaceDecl(xmlTextReaderPtr reader); XMLPUBFUN const xmlChar * XMLCALL - xmlTextReaderConstBaseUri (xmlTextReaderPtr reader); +xmlTextReaderConstBaseUri (xmlTextReaderPtr reader); XMLPUBFUN const xmlChar * XMLCALL - xmlTextReaderConstLocalName (xmlTextReaderPtr reader); +xmlTextReaderConstLocalName (xmlTextReaderPtr reader); XMLPUBFUN const xmlChar * XMLCALL - xmlTextReaderConstName (xmlTextReaderPtr reader); +xmlTextReaderConstName (xmlTextReaderPtr reader); XMLPUBFUN const xmlChar * XMLCALL - xmlTextReaderConstNamespaceUri(xmlTextReaderPtr reader); +xmlTextReaderConstNamespaceUri(xmlTextReaderPtr reader); XMLPUBFUN const xmlChar * XMLCALL - xmlTextReaderConstPrefix (xmlTextReaderPtr reader); +xmlTextReaderConstPrefix (xmlTextReaderPtr reader); XMLPUBFUN const xmlChar * XMLCALL - xmlTextReaderConstXmlLang (xmlTextReaderPtr reader); +xmlTextReaderConstXmlLang (xmlTextReaderPtr reader); XMLPUBFUN const xmlChar * XMLCALL - xmlTextReaderConstString (xmlTextReaderPtr reader, - const xmlChar *str); +xmlTextReaderConstString (xmlTextReaderPtr reader, + const xmlChar *str); XMLPUBFUN const xmlChar * XMLCALL - xmlTextReaderConstValue (xmlTextReaderPtr reader); +xmlTextReaderConstValue (xmlTextReaderPtr reader); /* * use the Const version of the routine for * better performance and simpler code */ XMLPUBFUN xmlChar * XMLCALL - xmlTextReaderBaseUri (xmlTextReaderPtr reader); +xmlTextReaderBaseUri (xmlTextReaderPtr reader); XMLPUBFUN xmlChar * XMLCALL - xmlTextReaderLocalName (xmlTextReaderPtr reader); +xmlTextReaderLocalName (xmlTextReaderPtr reader); XMLPUBFUN xmlChar * XMLCALL - xmlTextReaderName (xmlTextReaderPtr reader); +xmlTextReaderName (xmlTextReaderPtr reader); XMLPUBFUN xmlChar * XMLCALL - xmlTextReaderNamespaceUri(xmlTextReaderPtr reader); +xmlTextReaderNamespaceUri(xmlTextReaderPtr reader); XMLPUBFUN xmlChar * XMLCALL - xmlTextReaderPrefix (xmlTextReaderPtr reader); +xmlTextReaderPrefix (xmlTextReaderPtr reader); XMLPUBFUN xmlChar * XMLCALL - xmlTextReaderXmlLang (xmlTextReaderPtr reader); +xmlTextReaderXmlLang (xmlTextReaderPtr reader); XMLPUBFUN xmlChar * XMLCALL - xmlTextReaderValue (xmlTextReaderPtr reader); +xmlTextReaderValue (xmlTextReaderPtr reader); /* * Methods of the XmlTextReader */ XMLPUBFUN int XMLCALL - xmlTextReaderClose (xmlTextReaderPtr reader); +xmlTextReaderClose (xmlTextReaderPtr reader); XMLPUBFUN xmlChar * XMLCALL - xmlTextReaderGetAttributeNo (xmlTextReaderPtr reader, - int no); +xmlTextReaderGetAttributeNo (xmlTextReaderPtr reader, + int no); XMLPUBFUN xmlChar * XMLCALL - xmlTextReaderGetAttribute (xmlTextReaderPtr reader, - const xmlChar *name); +xmlTextReaderGetAttribute (xmlTextReaderPtr reader, + const xmlChar *name); XMLPUBFUN xmlChar * XMLCALL - xmlTextReaderGetAttributeNs (xmlTextReaderPtr reader, - const xmlChar *localName, - const xmlChar *namespaceURI); +xmlTextReaderGetAttributeNs (xmlTextReaderPtr reader, + const xmlChar *localName, + const xmlChar *namespaceURI); XMLPUBFUN xmlParserInputBufferPtr XMLCALL - xmlTextReaderGetRemainder (xmlTextReaderPtr reader); +xmlTextReaderGetRemainder (xmlTextReaderPtr reader); XMLPUBFUN xmlChar * XMLCALL - xmlTextReaderLookupNamespace(xmlTextReaderPtr reader, - const xmlChar *prefix); +xmlTextReaderLookupNamespace(xmlTextReaderPtr reader, + const xmlChar *prefix); XMLPUBFUN int XMLCALL - xmlTextReaderMoveToAttributeNo(xmlTextReaderPtr reader, - int no); +xmlTextReaderMoveToAttributeNo(xmlTextReaderPtr reader, + int no); XMLPUBFUN int XMLCALL - xmlTextReaderMoveToAttribute(xmlTextReaderPtr reader, - const xmlChar *name); +xmlTextReaderMoveToAttribute(xmlTextReaderPtr reader, + const xmlChar *name); XMLPUBFUN int XMLCALL - xmlTextReaderMoveToAttributeNs(xmlTextReaderPtr reader, - const xmlChar *localName, - const xmlChar *namespaceURI); +xmlTextReaderMoveToAttributeNs(xmlTextReaderPtr reader, + const xmlChar *localName, + const xmlChar *namespaceURI); XMLPUBFUN int XMLCALL - xmlTextReaderMoveToFirstAttribute(xmlTextReaderPtr reader); +xmlTextReaderMoveToFirstAttribute(xmlTextReaderPtr reader); XMLPUBFUN int XMLCALL - xmlTextReaderMoveToNextAttribute(xmlTextReaderPtr reader); +xmlTextReaderMoveToNextAttribute(xmlTextReaderPtr reader); XMLPUBFUN int XMLCALL - xmlTextReaderMoveToElement (xmlTextReaderPtr reader); +xmlTextReaderMoveToElement (xmlTextReaderPtr reader); XMLPUBFUN int XMLCALL - xmlTextReaderNormalization (xmlTextReaderPtr reader); +xmlTextReaderNormalization (xmlTextReaderPtr reader); XMLPUBFUN const xmlChar * XMLCALL - xmlTextReaderConstEncoding (xmlTextReaderPtr reader); +xmlTextReaderConstEncoding (xmlTextReaderPtr reader); /* * Extensions */ XMLPUBFUN int XMLCALL - xmlTextReaderSetParserProp (xmlTextReaderPtr reader, - int prop, - int value); +xmlTextReaderSetParserProp (xmlTextReaderPtr reader, + int prop, + int value); XMLPUBFUN int XMLCALL - xmlTextReaderGetParserProp (xmlTextReaderPtr reader, - int prop); +xmlTextReaderGetParserProp (xmlTextReaderPtr reader, + int prop); XMLPUBFUN xmlNodePtr XMLCALL - xmlTextReaderCurrentNode (xmlTextReaderPtr reader); +xmlTextReaderCurrentNode (xmlTextReaderPtr reader); XMLPUBFUN int XMLCALL - xmlTextReaderGetParserLineNumber(xmlTextReaderPtr reader); +xmlTextReaderGetParserLineNumber(xmlTextReaderPtr reader); XMLPUBFUN int XMLCALL - xmlTextReaderGetParserColumnNumber(xmlTextReaderPtr reader); +xmlTextReaderGetParserColumnNumber(xmlTextReaderPtr reader); XMLPUBFUN xmlNodePtr XMLCALL - xmlTextReaderPreserve (xmlTextReaderPtr reader); +xmlTextReaderPreserve (xmlTextReaderPtr reader); #ifdef LIBXML_PATTERN_ENABLED XMLPUBFUN int XMLCALL - xmlTextReaderPreservePattern(xmlTextReaderPtr reader, - const xmlChar *pattern, - const xmlChar **namespaces); +xmlTextReaderPreservePattern(xmlTextReaderPtr reader, + const xmlChar *pattern, + const xmlChar **namespaces); #endif /* LIBXML_PATTERN_ENABLED */ XMLPUBFUN xmlDocPtr XMLCALL - xmlTextReaderCurrentDoc (xmlTextReaderPtr reader); +xmlTextReaderCurrentDoc (xmlTextReaderPtr reader); XMLPUBFUN xmlNodePtr XMLCALL - xmlTextReaderExpand (xmlTextReaderPtr reader); +xmlTextReaderExpand (xmlTextReaderPtr reader); XMLPUBFUN int XMLCALL - xmlTextReaderNext (xmlTextReaderPtr reader); +xmlTextReaderNext (xmlTextReaderPtr reader); XMLPUBFUN int XMLCALL - xmlTextReaderNextSibling (xmlTextReaderPtr reader); +xmlTextReaderNextSibling (xmlTextReaderPtr reader); XMLPUBFUN int XMLCALL - xmlTextReaderIsValid (xmlTextReaderPtr reader); +xmlTextReaderIsValid (xmlTextReaderPtr reader); #ifdef LIBXML_SCHEMAS_ENABLED XMLPUBFUN int XMLCALL - xmlTextReaderRelaxNGValidate(xmlTextReaderPtr reader, - const char *rng); +xmlTextReaderRelaxNGValidate(xmlTextReaderPtr reader, + const char *rng); XMLPUBFUN int XMLCALL - xmlTextReaderRelaxNGValidateCtxt(xmlTextReaderPtr reader, - xmlRelaxNGValidCtxtPtr ctxt, - int options); +xmlTextReaderRelaxNGValidateCtxt(xmlTextReaderPtr reader, + xmlRelaxNGValidCtxtPtr ctxt, + int options); XMLPUBFUN int XMLCALL - xmlTextReaderRelaxNGSetSchema(xmlTextReaderPtr reader, - xmlRelaxNGPtr schema); +xmlTextReaderRelaxNGSetSchema(xmlTextReaderPtr reader, + xmlRelaxNGPtr schema); XMLPUBFUN int XMLCALL - xmlTextReaderSchemaValidate (xmlTextReaderPtr reader, - const char *xsd); +xmlTextReaderSchemaValidate (xmlTextReaderPtr reader, + const char *xsd); XMLPUBFUN int XMLCALL - xmlTextReaderSchemaValidateCtxt(xmlTextReaderPtr reader, - xmlSchemaValidCtxtPtr ctxt, - int options); +xmlTextReaderSchemaValidateCtxt(xmlTextReaderPtr reader, + xmlSchemaValidCtxtPtr ctxt, + int options); XMLPUBFUN int XMLCALL - xmlTextReaderSetSchema (xmlTextReaderPtr reader, - xmlSchemaPtr schema); +xmlTextReaderSetSchema (xmlTextReaderPtr reader, + xmlSchemaPtr schema); #endif XMLPUBFUN const xmlChar * XMLCALL - xmlTextReaderConstXmlVersion(xmlTextReaderPtr reader); +xmlTextReaderConstXmlVersion(xmlTextReaderPtr reader); XMLPUBFUN int XMLCALL - xmlTextReaderStandalone (xmlTextReaderPtr reader); +xmlTextReaderStandalone (xmlTextReaderPtr reader); /* * Index lookup */ XMLPUBFUN long XMLCALL - xmlTextReaderByteConsumed (xmlTextReaderPtr reader); +xmlTextReaderByteConsumed (xmlTextReaderPtr reader); /* * New more complete APIs for simpler creation and reuse of readers */ XMLPUBFUN xmlTextReaderPtr XMLCALL - xmlReaderWalker (xmlDocPtr doc); +xmlReaderWalker (xmlDocPtr doc); XMLPUBFUN xmlTextReaderPtr XMLCALL - xmlReaderForDoc (const xmlChar * cur, - const char *URL, - const char *encoding, - int options); +xmlReaderForDoc (const xmlChar * cur, + const char *URL, + const char *encoding, + int options); XMLPUBFUN xmlTextReaderPtr XMLCALL - xmlReaderForFile (const char *filename, - const char *encoding, - int options); +xmlReaderForFile (const char *filename, + const char *encoding, + int options); XMLPUBFUN xmlTextReaderPtr XMLCALL - xmlReaderForMemory (const char *buffer, - int size, - const char *URL, - const char *encoding, - int options); +xmlReaderForMemory (const char *buffer, + int size, + const char *URL, + const char *encoding, + int options); XMLPUBFUN xmlTextReaderPtr XMLCALL - xmlReaderForFd (int fd, - const char *URL, - const char *encoding, - int options); +xmlReaderForFd (int fd, + const char *URL, + const char *encoding, + int options); XMLPUBFUN xmlTextReaderPtr XMLCALL - xmlReaderForIO (xmlInputReadCallback ioread, - xmlInputCloseCallback ioclose, - void *ioctx, - const char *URL, - const char *encoding, - int options); - -XMLPUBFUN int XMLCALL - xmlReaderNewWalker (xmlTextReaderPtr reader, - xmlDocPtr doc); -XMLPUBFUN int XMLCALL - xmlReaderNewDoc (xmlTextReaderPtr reader, - const xmlChar * cur, - const char *URL, - const char *encoding, - int options); -XMLPUBFUN int XMLCALL - xmlReaderNewFile (xmlTextReaderPtr reader, - const char *filename, - const char *encoding, - int options); -XMLPUBFUN int XMLCALL - xmlReaderNewMemory (xmlTextReaderPtr reader, - const char *buffer, - int size, - const char *URL, - const char *encoding, - int options); -XMLPUBFUN int XMLCALL - xmlReaderNewFd (xmlTextReaderPtr reader, - int fd, - const char *URL, - const char *encoding, - int options); -XMLPUBFUN int XMLCALL - xmlReaderNewIO (xmlTextReaderPtr reader, - xmlInputReadCallback ioread, - xmlInputCloseCallback ioclose, - void *ioctx, - const char *URL, - const char *encoding, - int options); +xmlReaderForIO (xmlInputReadCallback ioread, + xmlInputCloseCallback ioclose, + void *ioctx, + const char *URL, + const char *encoding, + int options); + +XMLPUBFUN int XMLCALL +xmlReaderNewWalker (xmlTextReaderPtr reader, + xmlDocPtr doc); +XMLPUBFUN int XMLCALL +xmlReaderNewDoc (xmlTextReaderPtr reader, + const xmlChar * cur, + const char *URL, + const char *encoding, + int options); +XMLPUBFUN int XMLCALL +xmlReaderNewFile (xmlTextReaderPtr reader, + const char *filename, + const char *encoding, + int options); +XMLPUBFUN int XMLCALL +xmlReaderNewMemory (xmlTextReaderPtr reader, + const char *buffer, + int size, + const char *URL, + const char *encoding, + int options); +XMLPUBFUN int XMLCALL +xmlReaderNewFd (xmlTextReaderPtr reader, + int fd, + const char *URL, + const char *encoding, + int options); +XMLPUBFUN int XMLCALL +xmlReaderNewIO (xmlTextReaderPtr reader, + xmlInputReadCallback ioread, + xmlInputCloseCallback ioclose, + void *ioctx, + const char *URL, + const char *encoding, + int options); /* * Error handling extensions */ @@ -398,25 +399,25 @@ typedef void * xmlTextReaderLocatorPtr; * Signature of an error callback from a reader parser */ typedef void (XMLCALL *xmlTextReaderErrorFunc)(void *arg, - const char *msg, - xmlParserSeverities severity, - xmlTextReaderLocatorPtr locator); + const char *msg, + xmlParserSeverities severity, + xmlTextReaderLocatorPtr locator); XMLPUBFUN int XMLCALL - xmlTextReaderLocatorLineNumber(xmlTextReaderLocatorPtr locator); +xmlTextReaderLocatorLineNumber(xmlTextReaderLocatorPtr locator); XMLPUBFUN xmlChar * XMLCALL - xmlTextReaderLocatorBaseURI (xmlTextReaderLocatorPtr locator); +xmlTextReaderLocatorBaseURI (xmlTextReaderLocatorPtr locator); XMLPUBFUN void XMLCALL - xmlTextReaderSetErrorHandler(xmlTextReaderPtr reader, - xmlTextReaderErrorFunc f, - void *arg); +xmlTextReaderSetErrorHandler(xmlTextReaderPtr reader, + xmlTextReaderErrorFunc f, + void *arg); XMLPUBFUN void XMLCALL - xmlTextReaderSetStructuredErrorHandler(xmlTextReaderPtr reader, - xmlStructuredErrorFunc f, - void *arg); +xmlTextReaderSetStructuredErrorHandler(xmlTextReaderPtr reader, + xmlStructuredErrorFunc f, + void *arg); XMLPUBFUN void XMLCALL - xmlTextReaderGetErrorHandler(xmlTextReaderPtr reader, - xmlTextReaderErrorFunc *f, - void **arg); +xmlTextReaderGetErrorHandler(xmlTextReaderPtr reader, + xmlTextReaderErrorFunc *f, + void **arg); #endif /* LIBXML_READER_ENABLED */ diff --git a/thirdparties/common/include/libxml2/libxml/xmlregexp.h b/thirdparties/common/include/libxml2/libxml/xmlregexp.h index 7009645..f81664d 100755 --- a/thirdparties/common/include/libxml2/libxml/xmlregexp.h +++ b/thirdparties/common/include/libxml2/libxml/xmlregexp.h @@ -49,16 +49,16 @@ extern "C" { * The POSIX like API */ XMLPUBFUN xmlRegexpPtr XMLCALL - xmlRegexpCompile (const xmlChar *regexp); +xmlRegexpCompile (const xmlChar *regexp); XMLPUBFUN void XMLCALL xmlRegFreeRegexp(xmlRegexpPtr regexp); XMLPUBFUN int XMLCALL - xmlRegexpExec (xmlRegexpPtr comp, - const xmlChar *value); +xmlRegexpExec (xmlRegexpPtr comp, + const xmlChar *value); XMLPUBFUN void XMLCALL - xmlRegexpPrint (FILE *output, - xmlRegexpPtr regexp); +xmlRegexpPrint (FILE *output, + xmlRegexpPtr regexp); XMLPUBFUN int XMLCALL - xmlRegexpIsDeterminist(xmlRegexpPtr comp); +xmlRegexpIsDeterminist(xmlRegexpPtr comp); /** * xmlRegExecCallbacks: @@ -70,42 +70,42 @@ XMLPUBFUN int XMLCALL * Callback function when doing a transition in the automata */ typedef void (*xmlRegExecCallbacks) (xmlRegExecCtxtPtr exec, - const xmlChar *token, - void *transdata, - void *inputdata); + const xmlChar *token, + void *transdata, + void *inputdata); /* * The progressive API */ XMLPUBFUN xmlRegExecCtxtPtr XMLCALL - xmlRegNewExecCtxt (xmlRegexpPtr comp, - xmlRegExecCallbacks callback, - void *data); +xmlRegNewExecCtxt (xmlRegexpPtr comp, + xmlRegExecCallbacks callback, + void *data); XMLPUBFUN void XMLCALL - xmlRegFreeExecCtxt (xmlRegExecCtxtPtr exec); +xmlRegFreeExecCtxt (xmlRegExecCtxtPtr exec); XMLPUBFUN int XMLCALL - xmlRegExecPushString(xmlRegExecCtxtPtr exec, - const xmlChar *value, - void *data); +xmlRegExecPushString(xmlRegExecCtxtPtr exec, + const xmlChar *value, + void *data); XMLPUBFUN int XMLCALL - xmlRegExecPushString2(xmlRegExecCtxtPtr exec, - const xmlChar *value, - const xmlChar *value2, - void *data); +xmlRegExecPushString2(xmlRegExecCtxtPtr exec, + const xmlChar *value, + const xmlChar *value2, + void *data); XMLPUBFUN int XMLCALL - xmlRegExecNextValues(xmlRegExecCtxtPtr exec, - int *nbval, - int *nbneg, - xmlChar **values, - int *terminal); +xmlRegExecNextValues(xmlRegExecCtxtPtr exec, + int *nbval, + int *nbneg, + xmlChar **values, + int *terminal); XMLPUBFUN int XMLCALL - xmlRegExecErrInfo (xmlRegExecCtxtPtr exec, - const xmlChar **string, - int *nbval, - int *nbneg, - xmlChar **values, - int *terminal); +xmlRegExecErrInfo (xmlRegExecCtxtPtr exec, + const xmlChar **string, + int *nbval, + int *nbneg, + xmlChar **values, + int *terminal); #ifdef LIBXML_EXPR_ENABLED /* * Formal regular expression handling @@ -117,15 +117,15 @@ typedef struct _xmlExpCtxt xmlExpCtxt; typedef xmlExpCtxt *xmlExpCtxtPtr; XMLPUBFUN void XMLCALL - xmlExpFreeCtxt (xmlExpCtxtPtr ctxt); +xmlExpFreeCtxt (xmlExpCtxtPtr ctxt); XMLPUBFUN xmlExpCtxtPtr XMLCALL - xmlExpNewCtxt (int maxNodes, - xmlDictPtr dict); +xmlExpNewCtxt (int maxNodes, + xmlDictPtr dict); XMLPUBFUN int XMLCALL - xmlExpCtxtNbNodes(xmlExpCtxtPtr ctxt); +xmlExpCtxtNbNodes(xmlExpCtxtPtr ctxt); XMLPUBFUN int XMLCALL - xmlExpCtxtNbCons(xmlExpCtxtPtr ctxt); +xmlExpCtxtNbCons(xmlExpCtxtPtr ctxt); /* Expressions are trees but the tree is opaque */ typedef struct _xmlExpNode xmlExpNode; @@ -151,67 +151,67 @@ XMLPUBVAR xmlExpNodePtr emptyExp; * Expressions are reference counted internally */ XMLPUBFUN void XMLCALL - xmlExpFree (xmlExpCtxtPtr ctxt, - xmlExpNodePtr expr); +xmlExpFree (xmlExpCtxtPtr ctxt, + xmlExpNodePtr expr); XMLPUBFUN void XMLCALL - xmlExpRef (xmlExpNodePtr expr); +xmlExpRef (xmlExpNodePtr expr); /* * constructors can be either manual or from a string */ XMLPUBFUN xmlExpNodePtr XMLCALL - xmlExpParse (xmlExpCtxtPtr ctxt, - const char *expr); +xmlExpParse (xmlExpCtxtPtr ctxt, + const char *expr); XMLPUBFUN xmlExpNodePtr XMLCALL - xmlExpNewAtom (xmlExpCtxtPtr ctxt, - const xmlChar *name, - int len); +xmlExpNewAtom (xmlExpCtxtPtr ctxt, + const xmlChar *name, + int len); XMLPUBFUN xmlExpNodePtr XMLCALL - xmlExpNewOr (xmlExpCtxtPtr ctxt, - xmlExpNodePtr left, - xmlExpNodePtr right); +xmlExpNewOr (xmlExpCtxtPtr ctxt, + xmlExpNodePtr left, + xmlExpNodePtr right); XMLPUBFUN xmlExpNodePtr XMLCALL - xmlExpNewSeq (xmlExpCtxtPtr ctxt, - xmlExpNodePtr left, - xmlExpNodePtr right); +xmlExpNewSeq (xmlExpCtxtPtr ctxt, + xmlExpNodePtr left, + xmlExpNodePtr right); XMLPUBFUN xmlExpNodePtr XMLCALL - xmlExpNewRange (xmlExpCtxtPtr ctxt, - xmlExpNodePtr subset, - int min, - int max); +xmlExpNewRange (xmlExpCtxtPtr ctxt, + xmlExpNodePtr subset, + int min, + int max); /* * The really interesting APIs */ XMLPUBFUN int XMLCALL - xmlExpIsNillable(xmlExpNodePtr expr); +xmlExpIsNillable(xmlExpNodePtr expr); XMLPUBFUN int XMLCALL - xmlExpMaxToken (xmlExpNodePtr expr); +xmlExpMaxToken (xmlExpNodePtr expr); XMLPUBFUN int XMLCALL - xmlExpGetLanguage(xmlExpCtxtPtr ctxt, - xmlExpNodePtr expr, - const xmlChar**langList, - int len); +xmlExpGetLanguage(xmlExpCtxtPtr ctxt, + xmlExpNodePtr expr, + const xmlChar**langList, + int len); XMLPUBFUN int XMLCALL - xmlExpGetStart (xmlExpCtxtPtr ctxt, - xmlExpNodePtr expr, - const xmlChar**tokList, - int len); +xmlExpGetStart (xmlExpCtxtPtr ctxt, + xmlExpNodePtr expr, + const xmlChar**tokList, + int len); XMLPUBFUN xmlExpNodePtr XMLCALL - xmlExpStringDerive(xmlExpCtxtPtr ctxt, - xmlExpNodePtr expr, - const xmlChar *str, - int len); +xmlExpStringDerive(xmlExpCtxtPtr ctxt, + xmlExpNodePtr expr, + const xmlChar *str, + int len); XMLPUBFUN xmlExpNodePtr XMLCALL - xmlExpExpDerive (xmlExpCtxtPtr ctxt, - xmlExpNodePtr expr, - xmlExpNodePtr sub); +xmlExpExpDerive (xmlExpCtxtPtr ctxt, + xmlExpNodePtr expr, + xmlExpNodePtr sub); XMLPUBFUN int XMLCALL - xmlExpSubsume (xmlExpCtxtPtr ctxt, - xmlExpNodePtr expr, - xmlExpNodePtr sub); +xmlExpSubsume (xmlExpCtxtPtr ctxt, + xmlExpNodePtr expr, + xmlExpNodePtr sub); XMLPUBFUN void XMLCALL - xmlExpDump (xmlBufferPtr buf, - xmlExpNodePtr expr); +xmlExpDump (xmlBufferPtr buf, + xmlExpNodePtr expr); #endif /* LIBXML_EXPR_ENABLED */ #ifdef __cplusplus } diff --git a/thirdparties/common/include/libxml2/libxml/xmlsave.h b/thirdparties/common/include/libxml2/libxml/xmlsave.h index fb329b2..5f5407b 100755 --- a/thirdparties/common/include/libxml2/libxml/xmlsave.h +++ b/thirdparties/common/include/libxml2/libxml/xmlsave.h @@ -30,55 +30,56 @@ typedef enum { XML_SAVE_FORMAT = 1<<0, /* format save output */ XML_SAVE_NO_DECL = 1<<1, /* drop the xml declaration */ XML_SAVE_NO_EMPTY = 1<<2, /* no empty tags */ - XML_SAVE_NO_XHTML = 1<<3, /* disable XHTML1 specific rules */ - XML_SAVE_XHTML = 1<<4, /* force XHTML1 specific rules */ - XML_SAVE_AS_XML = 1<<5, /* force XML serialization on HTML doc */ - XML_SAVE_AS_HTML = 1<<6, /* force HTML serialization on XML doc */ - XML_SAVE_WSNONSIG = 1<<7 /* format with non-significant whitespace */ -} xmlSaveOption; + XML_SAVE_NO_XHTML = 1<<3, /* disable XHTML1 specific rules */ + XML_SAVE_XHTML = 1<<4, /* force XHTML1 specific rules */ + XML_SAVE_AS_XML = 1<<5, /* force XML serialization on HTML doc */ + XML_SAVE_AS_HTML = 1<<6, /* force HTML serialization on XML doc */ + XML_SAVE_WSNONSIG = 1<<7 /* format with non-significant whitespace */ +} +xmlSaveOption; typedef struct _xmlSaveCtxt xmlSaveCtxt; typedef xmlSaveCtxt *xmlSaveCtxtPtr; XMLPUBFUN xmlSaveCtxtPtr XMLCALL - xmlSaveToFd (int fd, - const char *encoding, - int options); +xmlSaveToFd (int fd, + const char *encoding, + int options); XMLPUBFUN xmlSaveCtxtPtr XMLCALL - xmlSaveToFilename (const char *filename, - const char *encoding, - int options); +xmlSaveToFilename (const char *filename, + const char *encoding, + int options); XMLPUBFUN xmlSaveCtxtPtr XMLCALL - xmlSaveToBuffer (xmlBufferPtr buffer, - const char *encoding, - int options); +xmlSaveToBuffer (xmlBufferPtr buffer, + const char *encoding, + int options); XMLPUBFUN xmlSaveCtxtPtr XMLCALL - xmlSaveToIO (xmlOutputWriteCallback iowrite, - xmlOutputCloseCallback ioclose, - void *ioctx, - const char *encoding, - int options); +xmlSaveToIO (xmlOutputWriteCallback iowrite, + xmlOutputCloseCallback ioclose, + void *ioctx, + const char *encoding, + int options); XMLPUBFUN long XMLCALL - xmlSaveDoc (xmlSaveCtxtPtr ctxt, - xmlDocPtr doc); +xmlSaveDoc (xmlSaveCtxtPtr ctxt, + xmlDocPtr doc); XMLPUBFUN long XMLCALL - xmlSaveTree (xmlSaveCtxtPtr ctxt, - xmlNodePtr node); +xmlSaveTree (xmlSaveCtxtPtr ctxt, + xmlNodePtr node); XMLPUBFUN int XMLCALL - xmlSaveFlush (xmlSaveCtxtPtr ctxt); +xmlSaveFlush (xmlSaveCtxtPtr ctxt); XMLPUBFUN int XMLCALL - xmlSaveClose (xmlSaveCtxtPtr ctxt); +xmlSaveClose (xmlSaveCtxtPtr ctxt); XMLPUBFUN int XMLCALL - xmlSaveSetEscape (xmlSaveCtxtPtr ctxt, - xmlCharEncodingOutputFunc escape); +xmlSaveSetEscape (xmlSaveCtxtPtr ctxt, + xmlCharEncodingOutputFunc escape); XMLPUBFUN int XMLCALL - xmlSaveSetAttrEscape (xmlSaveCtxtPtr ctxt, - xmlCharEncodingOutputFunc escape); +xmlSaveSetAttrEscape (xmlSaveCtxtPtr ctxt, + xmlCharEncodingOutputFunc escape); #ifdef __cplusplus } #endif diff --git a/thirdparties/common/include/libxml2/libxml/xmlschemas.h b/thirdparties/common/include/libxml2/libxml/xmlschemas.h index 97930c7..2fc2b30 100755 --- a/thirdparties/common/include/libxml2/libxml/xmlschemas.h +++ b/thirdparties/common/include/libxml2/libxml/xmlschemas.h @@ -27,32 +27,33 @@ extern "C" { */ typedef enum { XML_SCHEMAS_ERR_OK = 0, - XML_SCHEMAS_ERR_NOROOT = 1, - XML_SCHEMAS_ERR_UNDECLAREDELEM, - XML_SCHEMAS_ERR_NOTTOPLEVEL, - XML_SCHEMAS_ERR_MISSING, - XML_SCHEMAS_ERR_WRONGELEM, - XML_SCHEMAS_ERR_NOTYPE, - XML_SCHEMAS_ERR_NOROLLBACK, - XML_SCHEMAS_ERR_ISABSTRACT, - XML_SCHEMAS_ERR_NOTEMPTY, - XML_SCHEMAS_ERR_ELEMCONT, - XML_SCHEMAS_ERR_HAVEDEFAULT, - XML_SCHEMAS_ERR_NOTNILLABLE, - XML_SCHEMAS_ERR_EXTRACONTENT, - XML_SCHEMAS_ERR_INVALIDATTR, - XML_SCHEMAS_ERR_INVALIDELEM, - XML_SCHEMAS_ERR_NOTDETERMINIST, - XML_SCHEMAS_ERR_CONSTRUCT, - XML_SCHEMAS_ERR_INTERNAL, - XML_SCHEMAS_ERR_NOTSIMPLE, - XML_SCHEMAS_ERR_ATTRUNKNOWN, - XML_SCHEMAS_ERR_ATTRINVALID, - XML_SCHEMAS_ERR_VALUE, - XML_SCHEMAS_ERR_FACET, - XML_SCHEMAS_ERR_, - XML_SCHEMAS_ERR_XXX -} xmlSchemaValidError; + XML_SCHEMAS_ERR_NOROOT = 1, + XML_SCHEMAS_ERR_UNDECLAREDELEM, + XML_SCHEMAS_ERR_NOTTOPLEVEL, + XML_SCHEMAS_ERR_MISSING, + XML_SCHEMAS_ERR_WRONGELEM, + XML_SCHEMAS_ERR_NOTYPE, + XML_SCHEMAS_ERR_NOROLLBACK, + XML_SCHEMAS_ERR_ISABSTRACT, + XML_SCHEMAS_ERR_NOTEMPTY, + XML_SCHEMAS_ERR_ELEMCONT, + XML_SCHEMAS_ERR_HAVEDEFAULT, + XML_SCHEMAS_ERR_NOTNILLABLE, + XML_SCHEMAS_ERR_EXTRACONTENT, + XML_SCHEMAS_ERR_INVALIDATTR, + XML_SCHEMAS_ERR_INVALIDELEM, + XML_SCHEMAS_ERR_NOTDETERMINIST, + XML_SCHEMAS_ERR_CONSTRUCT, + XML_SCHEMAS_ERR_INTERNAL, + XML_SCHEMAS_ERR_NOTSIMPLE, + XML_SCHEMAS_ERR_ATTRUNKNOWN, + XML_SCHEMAS_ERR_ATTRINVALID, + XML_SCHEMAS_ERR_VALUE, + XML_SCHEMAS_ERR_FACET, + XML_SCHEMAS_ERR_, + XML_SCHEMAS_ERR_XXX +} +xmlSchemaValidError; /* * ATTENTION: Change xmlSchemaSetValidOptions's check @@ -66,9 +67,9 @@ typedef enum { */ typedef enum { XML_SCHEMA_VAL_VC_I_CREATE = 1<<0 - /* Default/fixed: create an attribute node - * or an element's text node on the instance. - */ + /* Default/fixed: create an attribute node + * or an element's text node on the instance. + */ } xmlSchemaValidOption; /* @@ -93,7 +94,7 @@ typedef xmlSchema *xmlSchemaPtr; * Signature of an error callback from an XSD validation */ typedef void (XMLCDECL *xmlSchemaValidityErrorFunc) - (void *ctx, const char *msg, ...) LIBXML_ATTR_FORMAT(2,3); +(void *ctx, const char *msg, ...) LIBXML_ATTR_FORMAT(2,3); /** * xmlSchemaValidityWarningFunc: @@ -104,7 +105,7 @@ typedef void (XMLCDECL *xmlSchemaValidityErrorFunc) * Signature of a warning callback from an XSD validation */ typedef void (XMLCDECL *xmlSchemaValidityWarningFunc) - (void *ctx, const char *msg, ...) LIBXML_ATTR_FORMAT(2,3); +(void *ctx, const char *msg, ...) LIBXML_ATTR_FORMAT(2,3); /** * A schemas validation context @@ -129,95 +130,95 @@ typedef xmlSchemaValidCtxt *xmlSchemaValidCtxtPtr; */ typedef int (XMLCDECL *xmlSchemaValidityLocatorFunc) (void *ctx, - const char **file, unsigned long *line); + const char **file, unsigned long *line); /* * Interfaces for parsing. */ XMLPUBFUN xmlSchemaParserCtxtPtr XMLCALL - xmlSchemaNewParserCtxt (const char *URL); +xmlSchemaNewParserCtxt (const char *URL); XMLPUBFUN xmlSchemaParserCtxtPtr XMLCALL - xmlSchemaNewMemParserCtxt (const char *buffer, - int size); +xmlSchemaNewMemParserCtxt (const char *buffer, + int size); XMLPUBFUN xmlSchemaParserCtxtPtr XMLCALL - xmlSchemaNewDocParserCtxt (xmlDocPtr doc); +xmlSchemaNewDocParserCtxt (xmlDocPtr doc); XMLPUBFUN void XMLCALL - xmlSchemaFreeParserCtxt (xmlSchemaParserCtxtPtr ctxt); +xmlSchemaFreeParserCtxt (xmlSchemaParserCtxtPtr ctxt); XMLPUBFUN void XMLCALL - xmlSchemaSetParserErrors (xmlSchemaParserCtxtPtr ctxt, - xmlSchemaValidityErrorFunc err, - xmlSchemaValidityWarningFunc warn, - void *ctx); +xmlSchemaSetParserErrors (xmlSchemaParserCtxtPtr ctxt, + xmlSchemaValidityErrorFunc err, + xmlSchemaValidityWarningFunc warn, + void *ctx); XMLPUBFUN void XMLCALL - xmlSchemaSetParserStructuredErrors(xmlSchemaParserCtxtPtr ctxt, - xmlStructuredErrorFunc serror, - void *ctx); +xmlSchemaSetParserStructuredErrors(xmlSchemaParserCtxtPtr ctxt, + xmlStructuredErrorFunc serror, + void *ctx); XMLPUBFUN int XMLCALL - xmlSchemaGetParserErrors(xmlSchemaParserCtxtPtr ctxt, - xmlSchemaValidityErrorFunc * err, - xmlSchemaValidityWarningFunc * warn, - void **ctx); +xmlSchemaGetParserErrors(xmlSchemaParserCtxtPtr ctxt, + xmlSchemaValidityErrorFunc * err, + xmlSchemaValidityWarningFunc * warn, + void **ctx); XMLPUBFUN int XMLCALL - xmlSchemaIsValid (xmlSchemaValidCtxtPtr ctxt); +xmlSchemaIsValid (xmlSchemaValidCtxtPtr ctxt); XMLPUBFUN xmlSchemaPtr XMLCALL - xmlSchemaParse (xmlSchemaParserCtxtPtr ctxt); +xmlSchemaParse (xmlSchemaParserCtxtPtr ctxt); XMLPUBFUN void XMLCALL - xmlSchemaFree (xmlSchemaPtr schema); +xmlSchemaFree (xmlSchemaPtr schema); #ifdef LIBXML_OUTPUT_ENABLED XMLPUBFUN void XMLCALL - xmlSchemaDump (FILE *output, - xmlSchemaPtr schema); +xmlSchemaDump (FILE *output, + xmlSchemaPtr schema); #endif /* LIBXML_OUTPUT_ENABLED */ /* * Interfaces for validating */ XMLPUBFUN void XMLCALL - xmlSchemaSetValidErrors (xmlSchemaValidCtxtPtr ctxt, - xmlSchemaValidityErrorFunc err, - xmlSchemaValidityWarningFunc warn, - void *ctx); +xmlSchemaSetValidErrors (xmlSchemaValidCtxtPtr ctxt, + xmlSchemaValidityErrorFunc err, + xmlSchemaValidityWarningFunc warn, + void *ctx); XMLPUBFUN void XMLCALL - xmlSchemaSetValidStructuredErrors(xmlSchemaValidCtxtPtr ctxt, - xmlStructuredErrorFunc serror, - void *ctx); +xmlSchemaSetValidStructuredErrors(xmlSchemaValidCtxtPtr ctxt, + xmlStructuredErrorFunc serror, + void *ctx); XMLPUBFUN int XMLCALL - xmlSchemaGetValidErrors (xmlSchemaValidCtxtPtr ctxt, - xmlSchemaValidityErrorFunc *err, - xmlSchemaValidityWarningFunc *warn, - void **ctx); +xmlSchemaGetValidErrors (xmlSchemaValidCtxtPtr ctxt, + xmlSchemaValidityErrorFunc *err, + xmlSchemaValidityWarningFunc *warn, + void **ctx); XMLPUBFUN int XMLCALL - xmlSchemaSetValidOptions (xmlSchemaValidCtxtPtr ctxt, - int options); +xmlSchemaSetValidOptions (xmlSchemaValidCtxtPtr ctxt, + int options); XMLPUBFUN void XMLCALL - xmlSchemaValidateSetFilename(xmlSchemaValidCtxtPtr vctxt, - const char *filename); +xmlSchemaValidateSetFilename(xmlSchemaValidCtxtPtr vctxt, + const char *filename); XMLPUBFUN int XMLCALL - xmlSchemaValidCtxtGetOptions(xmlSchemaValidCtxtPtr ctxt); +xmlSchemaValidCtxtGetOptions(xmlSchemaValidCtxtPtr ctxt); XMLPUBFUN xmlSchemaValidCtxtPtr XMLCALL - xmlSchemaNewValidCtxt (xmlSchemaPtr schema); +xmlSchemaNewValidCtxt (xmlSchemaPtr schema); XMLPUBFUN void XMLCALL - xmlSchemaFreeValidCtxt (xmlSchemaValidCtxtPtr ctxt); +xmlSchemaFreeValidCtxt (xmlSchemaValidCtxtPtr ctxt); XMLPUBFUN int XMLCALL - xmlSchemaValidateDoc (xmlSchemaValidCtxtPtr ctxt, - xmlDocPtr instance); +xmlSchemaValidateDoc (xmlSchemaValidCtxtPtr ctxt, + xmlDocPtr instance); XMLPUBFUN int XMLCALL - xmlSchemaValidateOneElement (xmlSchemaValidCtxtPtr ctxt, - xmlNodePtr elem); +xmlSchemaValidateOneElement (xmlSchemaValidCtxtPtr ctxt, + xmlNodePtr elem); XMLPUBFUN int XMLCALL - xmlSchemaValidateStream (xmlSchemaValidCtxtPtr ctxt, - xmlParserInputBufferPtr input, - xmlCharEncoding enc, - xmlSAXHandlerPtr sax, - void *user_data); +xmlSchemaValidateStream (xmlSchemaValidCtxtPtr ctxt, + xmlParserInputBufferPtr input, + xmlCharEncoding enc, + xmlSAXHandlerPtr sax, + void *user_data); XMLPUBFUN int XMLCALL - xmlSchemaValidateFile (xmlSchemaValidCtxtPtr ctxt, - const char * filename, - int options); +xmlSchemaValidateFile (xmlSchemaValidCtxtPtr ctxt, + const char * filename, + int options); XMLPUBFUN xmlParserCtxtPtr XMLCALL - xmlSchemaValidCtxtGetParserCtxt(xmlSchemaValidCtxtPtr ctxt); +xmlSchemaValidCtxtGetParserCtxt(xmlSchemaValidCtxtPtr ctxt); /* * Interface to insert Schemas SAX validation in a SAX stream @@ -226,17 +227,17 @@ typedef struct _xmlSchemaSAXPlug xmlSchemaSAXPlugStruct; typedef xmlSchemaSAXPlugStruct *xmlSchemaSAXPlugPtr; XMLPUBFUN xmlSchemaSAXPlugPtr XMLCALL - xmlSchemaSAXPlug (xmlSchemaValidCtxtPtr ctxt, - xmlSAXHandlerPtr *sax, - void **user_data); +xmlSchemaSAXPlug (xmlSchemaValidCtxtPtr ctxt, + xmlSAXHandlerPtr *sax, + void **user_data); XMLPUBFUN int XMLCALL - xmlSchemaSAXUnplug (xmlSchemaSAXPlugPtr plug); +xmlSchemaSAXUnplug (xmlSchemaSAXPlugPtr plug); XMLPUBFUN void XMLCALL - xmlSchemaValidateSetLocator (xmlSchemaValidCtxtPtr vctxt, - xmlSchemaValidityLocatorFunc f, - void *ctxt); +xmlSchemaValidateSetLocator (xmlSchemaValidCtxtPtr vctxt, + xmlSchemaValidityLocatorFunc f, + void *ctxt); #ifdef __cplusplus } diff --git a/thirdparties/common/include/libxml2/libxml/xmlschemastypes.h b/thirdparties/common/include/libxml2/libxml/xmlschemastypes.h index 35d48d4..4c94162 100755 --- a/thirdparties/common/include/libxml2/libxml/xmlschemastypes.h +++ b/thirdparties/common/include/libxml2/libxml/xmlschemastypes.h @@ -28,120 +28,121 @@ typedef enum { XML_SCHEMA_WHITESPACE_PRESERVE = 1, XML_SCHEMA_WHITESPACE_REPLACE = 2, XML_SCHEMA_WHITESPACE_COLLAPSE = 3 -} xmlSchemaWhitespaceValueType; +} +xmlSchemaWhitespaceValueType; XMLPUBFUN void XMLCALL - xmlSchemaInitTypes (void); +xmlSchemaInitTypes (void); XMLPUBFUN void XMLCALL - xmlSchemaCleanupTypes (void); +xmlSchemaCleanupTypes (void); XMLPUBFUN xmlSchemaTypePtr XMLCALL - xmlSchemaGetPredefinedType (const xmlChar *name, - const xmlChar *ns); -XMLPUBFUN int XMLCALL - xmlSchemaValidatePredefinedType (xmlSchemaTypePtr type, - const xmlChar *value, - xmlSchemaValPtr *val); -XMLPUBFUN int XMLCALL - xmlSchemaValPredefTypeNode (xmlSchemaTypePtr type, - const xmlChar *value, - xmlSchemaValPtr *val, - xmlNodePtr node); -XMLPUBFUN int XMLCALL - xmlSchemaValidateFacet (xmlSchemaTypePtr base, - xmlSchemaFacetPtr facet, - const xmlChar *value, - xmlSchemaValPtr val); -XMLPUBFUN int XMLCALL - xmlSchemaValidateFacetWhtsp (xmlSchemaFacetPtr facet, - xmlSchemaWhitespaceValueType fws, - xmlSchemaValType valType, - const xmlChar *value, - xmlSchemaValPtr val, - xmlSchemaWhitespaceValueType ws); +xmlSchemaGetPredefinedType (const xmlChar *name, + const xmlChar *ns); +XMLPUBFUN int XMLCALL +xmlSchemaValidatePredefinedType (xmlSchemaTypePtr type, + const xmlChar *value, + xmlSchemaValPtr *val); +XMLPUBFUN int XMLCALL +xmlSchemaValPredefTypeNode (xmlSchemaTypePtr type, + const xmlChar *value, + xmlSchemaValPtr *val, + xmlNodePtr node); +XMLPUBFUN int XMLCALL +xmlSchemaValidateFacet (xmlSchemaTypePtr base, + xmlSchemaFacetPtr facet, + const xmlChar *value, + xmlSchemaValPtr val); +XMLPUBFUN int XMLCALL +xmlSchemaValidateFacetWhtsp (xmlSchemaFacetPtr facet, + xmlSchemaWhitespaceValueType fws, + xmlSchemaValType valType, + const xmlChar *value, + xmlSchemaValPtr val, + xmlSchemaWhitespaceValueType ws); XMLPUBFUN void XMLCALL - xmlSchemaFreeValue (xmlSchemaValPtr val); +xmlSchemaFreeValue (xmlSchemaValPtr val); XMLPUBFUN xmlSchemaFacetPtr XMLCALL - xmlSchemaNewFacet (void); +xmlSchemaNewFacet (void); XMLPUBFUN int XMLCALL - xmlSchemaCheckFacet (xmlSchemaFacetPtr facet, - xmlSchemaTypePtr typeDecl, - xmlSchemaParserCtxtPtr ctxt, - const xmlChar *name); +xmlSchemaCheckFacet (xmlSchemaFacetPtr facet, + xmlSchemaTypePtr typeDecl, + xmlSchemaParserCtxtPtr ctxt, + const xmlChar *name); XMLPUBFUN void XMLCALL - xmlSchemaFreeFacet (xmlSchemaFacetPtr facet); +xmlSchemaFreeFacet (xmlSchemaFacetPtr facet); XMLPUBFUN int XMLCALL - xmlSchemaCompareValues (xmlSchemaValPtr x, - xmlSchemaValPtr y); +xmlSchemaCompareValues (xmlSchemaValPtr x, + xmlSchemaValPtr y); XMLPUBFUN xmlSchemaTypePtr XMLCALL - xmlSchemaGetBuiltInListSimpleTypeItemType (xmlSchemaTypePtr type); +xmlSchemaGetBuiltInListSimpleTypeItemType (xmlSchemaTypePtr type); XMLPUBFUN int XMLCALL - xmlSchemaValidateListSimpleTypeFacet (xmlSchemaFacetPtr facet, - const xmlChar *value, - unsigned long actualLen, - unsigned long *expectedLen); +xmlSchemaValidateListSimpleTypeFacet (xmlSchemaFacetPtr facet, + const xmlChar *value, + unsigned long actualLen, + unsigned long *expectedLen); XMLPUBFUN xmlSchemaTypePtr XMLCALL - xmlSchemaGetBuiltInType (xmlSchemaValType type); +xmlSchemaGetBuiltInType (xmlSchemaValType type); XMLPUBFUN int XMLCALL - xmlSchemaIsBuiltInTypeFacet (xmlSchemaTypePtr type, - int facetType); +xmlSchemaIsBuiltInTypeFacet (xmlSchemaTypePtr type, + int facetType); XMLPUBFUN xmlChar * XMLCALL - xmlSchemaCollapseString (const xmlChar *value); +xmlSchemaCollapseString (const xmlChar *value); XMLPUBFUN xmlChar * XMLCALL - xmlSchemaWhiteSpaceReplace (const xmlChar *value); +xmlSchemaWhiteSpaceReplace (const xmlChar *value); XMLPUBFUN unsigned long XMLCALL - xmlSchemaGetFacetValueAsULong (xmlSchemaFacetPtr facet); -XMLPUBFUN int XMLCALL - xmlSchemaValidateLengthFacet (xmlSchemaTypePtr type, - xmlSchemaFacetPtr facet, - const xmlChar *value, - xmlSchemaValPtr val, - unsigned long *length); -XMLPUBFUN int XMLCALL - xmlSchemaValidateLengthFacetWhtsp(xmlSchemaFacetPtr facet, - xmlSchemaValType valType, - const xmlChar *value, - xmlSchemaValPtr val, - unsigned long *length, - xmlSchemaWhitespaceValueType ws); -XMLPUBFUN int XMLCALL - xmlSchemaValPredefTypeNodeNoNorm(xmlSchemaTypePtr type, - const xmlChar *value, - xmlSchemaValPtr *val, - xmlNodePtr node); -XMLPUBFUN int XMLCALL - xmlSchemaGetCanonValue (xmlSchemaValPtr val, - const xmlChar **retValue); -XMLPUBFUN int XMLCALL - xmlSchemaGetCanonValueWhtsp (xmlSchemaValPtr val, - const xmlChar **retValue, - xmlSchemaWhitespaceValueType ws); -XMLPUBFUN int XMLCALL - xmlSchemaValueAppend (xmlSchemaValPtr prev, - xmlSchemaValPtr cur); +xmlSchemaGetFacetValueAsULong (xmlSchemaFacetPtr facet); +XMLPUBFUN int XMLCALL +xmlSchemaValidateLengthFacet (xmlSchemaTypePtr type, + xmlSchemaFacetPtr facet, + const xmlChar *value, + xmlSchemaValPtr val, + unsigned long *length); +XMLPUBFUN int XMLCALL +xmlSchemaValidateLengthFacetWhtsp(xmlSchemaFacetPtr facet, + xmlSchemaValType valType, + const xmlChar *value, + xmlSchemaValPtr val, + unsigned long *length, + xmlSchemaWhitespaceValueType ws); +XMLPUBFUN int XMLCALL +xmlSchemaValPredefTypeNodeNoNorm(xmlSchemaTypePtr type, + const xmlChar *value, + xmlSchemaValPtr *val, + xmlNodePtr node); +XMLPUBFUN int XMLCALL +xmlSchemaGetCanonValue (xmlSchemaValPtr val, + const xmlChar **retValue); +XMLPUBFUN int XMLCALL +xmlSchemaGetCanonValueWhtsp (xmlSchemaValPtr val, + const xmlChar **retValue, + xmlSchemaWhitespaceValueType ws); +XMLPUBFUN int XMLCALL +xmlSchemaValueAppend (xmlSchemaValPtr prev, + xmlSchemaValPtr cur); XMLPUBFUN xmlSchemaValPtr XMLCALL - xmlSchemaValueGetNext (xmlSchemaValPtr cur); +xmlSchemaValueGetNext (xmlSchemaValPtr cur); XMLPUBFUN const xmlChar * XMLCALL - xmlSchemaValueGetAsString (xmlSchemaValPtr val); +xmlSchemaValueGetAsString (xmlSchemaValPtr val); XMLPUBFUN int XMLCALL - xmlSchemaValueGetAsBoolean (xmlSchemaValPtr val); +xmlSchemaValueGetAsBoolean (xmlSchemaValPtr val); XMLPUBFUN xmlSchemaValPtr XMLCALL - xmlSchemaNewStringValue (xmlSchemaValType type, - const xmlChar *value); +xmlSchemaNewStringValue (xmlSchemaValType type, + const xmlChar *value); XMLPUBFUN xmlSchemaValPtr XMLCALL - xmlSchemaNewNOTATIONValue (const xmlChar *name, - const xmlChar *ns); +xmlSchemaNewNOTATIONValue (const xmlChar *name, + const xmlChar *ns); XMLPUBFUN xmlSchemaValPtr XMLCALL - xmlSchemaNewQNameValue (const xmlChar *namespaceName, - const xmlChar *localName); +xmlSchemaNewQNameValue (const xmlChar *namespaceName, + const xmlChar *localName); XMLPUBFUN int XMLCALL - xmlSchemaCompareValuesWhtsp (xmlSchemaValPtr x, - xmlSchemaWhitespaceValueType xws, - xmlSchemaValPtr y, - xmlSchemaWhitespaceValueType yws); +xmlSchemaCompareValuesWhtsp (xmlSchemaValPtr x, + xmlSchemaWhitespaceValueType xws, + xmlSchemaValPtr y, + xmlSchemaWhitespaceValueType yws); XMLPUBFUN xmlSchemaValPtr XMLCALL - xmlSchemaCopyValue (xmlSchemaValPtr val); +xmlSchemaCopyValue (xmlSchemaValPtr val); XMLPUBFUN xmlSchemaValType XMLCALL - xmlSchemaGetValType (xmlSchemaValPtr val); +xmlSchemaGetValType (xmlSchemaValPtr val); #ifdef __cplusplus } diff --git a/thirdparties/common/include/libxml2/libxml/xmlstring.h b/thirdparties/common/include/libxml2/libxml/xmlstring.h index 2036236..60508f9 100755 --- a/thirdparties/common/include/libxml2/libxml/xmlstring.h +++ b/thirdparties/common/include/libxml2/libxml/xmlstring.h @@ -38,101 +38,101 @@ typedef unsigned char xmlChar; * xmlChar handling */ XMLPUBFUN xmlChar * XMLCALL - xmlStrdup (const xmlChar *cur); +xmlStrdup (const xmlChar *cur); XMLPUBFUN xmlChar * XMLCALL - xmlStrndup (const xmlChar *cur, - int len); +xmlStrndup (const xmlChar *cur, + int len); XMLPUBFUN xmlChar * XMLCALL - xmlCharStrndup (const char *cur, - int len); +xmlCharStrndup (const char *cur, + int len); XMLPUBFUN xmlChar * XMLCALL - xmlCharStrdup (const char *cur); +xmlCharStrdup (const char *cur); XMLPUBFUN xmlChar * XMLCALL - xmlStrsub (const xmlChar *str, - int start, - int len); +xmlStrsub (const xmlChar *str, + int start, + int len); XMLPUBFUN const xmlChar * XMLCALL - xmlStrchr (const xmlChar *str, - xmlChar val); +xmlStrchr (const xmlChar *str, + xmlChar val); XMLPUBFUN const xmlChar * XMLCALL - xmlStrstr (const xmlChar *str, - const xmlChar *val); +xmlStrstr (const xmlChar *str, + const xmlChar *val); XMLPUBFUN const xmlChar * XMLCALL - xmlStrcasestr (const xmlChar *str, - const xmlChar *val); +xmlStrcasestr (const xmlChar *str, + const xmlChar *val); XMLPUBFUN int XMLCALL - xmlStrcmp (const xmlChar *str1, - const xmlChar *str2); +xmlStrcmp (const xmlChar *str1, + const xmlChar *str2); XMLPUBFUN int XMLCALL - xmlStrncmp (const xmlChar *str1, - const xmlChar *str2, - int len); +xmlStrncmp (const xmlChar *str1, + const xmlChar *str2, + int len); XMLPUBFUN int XMLCALL - xmlStrcasecmp (const xmlChar *str1, - const xmlChar *str2); +xmlStrcasecmp (const xmlChar *str1, + const xmlChar *str2); XMLPUBFUN int XMLCALL - xmlStrncasecmp (const xmlChar *str1, - const xmlChar *str2, - int len); +xmlStrncasecmp (const xmlChar *str1, + const xmlChar *str2, + int len); XMLPUBFUN int XMLCALL - xmlStrEqual (const xmlChar *str1, - const xmlChar *str2); +xmlStrEqual (const xmlChar *str1, + const xmlChar *str2); XMLPUBFUN int XMLCALL - xmlStrQEqual (const xmlChar *pref, - const xmlChar *name, - const xmlChar *str); +xmlStrQEqual (const xmlChar *pref, + const xmlChar *name, + const xmlChar *str); XMLPUBFUN int XMLCALL - xmlStrlen (const xmlChar *str); +xmlStrlen (const xmlChar *str); XMLPUBFUN xmlChar * XMLCALL - xmlStrcat (xmlChar *cur, - const xmlChar *add); +xmlStrcat (xmlChar *cur, + const xmlChar *add); XMLPUBFUN xmlChar * XMLCALL - xmlStrncat (xmlChar *cur, - const xmlChar *add, - int len); +xmlStrncat (xmlChar *cur, + const xmlChar *add, + int len); XMLPUBFUN xmlChar * XMLCALL - xmlStrncatNew (const xmlChar *str1, - const xmlChar *str2, - int len); -XMLPUBFUN int XMLCALL - xmlStrPrintf (xmlChar *buf, - int len, - const xmlChar *msg, - ...); -XMLPUBFUN int XMLCALL - xmlStrVPrintf (xmlChar *buf, - int len, - const xmlChar *msg, - va_list ap); +xmlStrncatNew (const xmlChar *str1, + const xmlChar *str2, + int len); +XMLPUBFUN int XMLCALL +xmlStrPrintf (xmlChar *buf, + int len, + const xmlChar *msg, + ...); +XMLPUBFUN int XMLCALL +xmlStrVPrintf (xmlChar *buf, + int len, + const xmlChar *msg, + va_list ap); XMLPUBFUN int XMLCALL - xmlGetUTF8Char (const unsigned char *utf, - int *len); +xmlGetUTF8Char (const unsigned char *utf, + int *len); XMLPUBFUN int XMLCALL - xmlCheckUTF8 (const unsigned char *utf); +xmlCheckUTF8 (const unsigned char *utf); XMLPUBFUN int XMLCALL - xmlUTF8Strsize (const xmlChar *utf, - int len); +xmlUTF8Strsize (const xmlChar *utf, + int len); XMLPUBFUN xmlChar * XMLCALL - xmlUTF8Strndup (const xmlChar *utf, - int len); +xmlUTF8Strndup (const xmlChar *utf, + int len); XMLPUBFUN const xmlChar * XMLCALL - xmlUTF8Strpos (const xmlChar *utf, - int pos); +xmlUTF8Strpos (const xmlChar *utf, + int pos); XMLPUBFUN int XMLCALL - xmlUTF8Strloc (const xmlChar *utf, - const xmlChar *utfchar); +xmlUTF8Strloc (const xmlChar *utf, + const xmlChar *utfchar); XMLPUBFUN xmlChar * XMLCALL - xmlUTF8Strsub (const xmlChar *utf, - int start, - int len); +xmlUTF8Strsub (const xmlChar *utf, + int start, + int len); XMLPUBFUN int XMLCALL - xmlUTF8Strlen (const xmlChar *utf); +xmlUTF8Strlen (const xmlChar *utf); XMLPUBFUN int XMLCALL - xmlUTF8Size (const xmlChar *utf); +xmlUTF8Size (const xmlChar *utf); XMLPUBFUN int XMLCALL - xmlUTF8Charcmp (const xmlChar *utf1, - const xmlChar *utf2); +xmlUTF8Charcmp (const xmlChar *utf1, + const xmlChar *utf2); #ifdef __cplusplus } diff --git a/thirdparties/common/include/libxml2/libxml/xmlversion.h b/thirdparties/common/include/libxml2/libxml/xmlversion.h index 456b44a..c63299b 100755 --- a/thirdparties/common/include/libxml2/libxml/xmlversion.h +++ b/thirdparties/common/include/libxml2/libxml/xmlversion.h @@ -388,7 +388,7 @@ XMLPUBFUN void XMLCALL xmlCheckVersion(int version); * * the string suffix used by dynamic modules (usually shared libraries) */ -#define LIBXML_MODULE_EXTENSION ".dll" +#define LIBXML_MODULE_EXTENSION ".dll" #endif /** diff --git a/thirdparties/common/include/libxml2/libxml/xmlwriter.h b/thirdparties/common/include/libxml2/libxml/xmlwriter.h index dd5add3..b568a1d 100755 --- a/thirdparties/common/include/libxml2/libxml/xmlwriter.h +++ b/thirdparties/common/include/libxml2/libxml/xmlwriter.h @@ -23,26 +23,26 @@ extern "C" { #endif - typedef struct _xmlTextWriter xmlTextWriter; - typedef xmlTextWriter *xmlTextWriterPtr; +typedef struct _xmlTextWriter xmlTextWriter; +typedef xmlTextWriter *xmlTextWriterPtr; /* * Constructors & Destructor */ - XMLPUBFUN xmlTextWriterPtr XMLCALL - xmlNewTextWriter(xmlOutputBufferPtr out); - XMLPUBFUN xmlTextWriterPtr XMLCALL - xmlNewTextWriterFilename(const char *uri, int compression); - XMLPUBFUN xmlTextWriterPtr XMLCALL - xmlNewTextWriterMemory(xmlBufferPtr buf, int compression); - XMLPUBFUN xmlTextWriterPtr XMLCALL - xmlNewTextWriterPushParser(xmlParserCtxtPtr ctxt, int compression); - XMLPUBFUN xmlTextWriterPtr XMLCALL - xmlNewTextWriterDoc(xmlDocPtr * doc, int compression); - XMLPUBFUN xmlTextWriterPtr XMLCALL - xmlNewTextWriterTree(xmlDocPtr doc, xmlNodePtr node, - int compression); - XMLPUBFUN void XMLCALL xmlFreeTextWriter(xmlTextWriterPtr writer); +XMLPUBFUN xmlTextWriterPtr XMLCALL +xmlNewTextWriter(xmlOutputBufferPtr out); +XMLPUBFUN xmlTextWriterPtr XMLCALL +xmlNewTextWriterFilename(const char *uri, int compression); +XMLPUBFUN xmlTextWriterPtr XMLCALL +xmlNewTextWriterMemory(xmlBufferPtr buf, int compression); +XMLPUBFUN xmlTextWriterPtr XMLCALL +xmlNewTextWriterPushParser(xmlParserCtxtPtr ctxt, int compression); +XMLPUBFUN xmlTextWriterPtr XMLCALL +xmlNewTextWriterDoc(xmlDocPtr * doc, int compression); +XMLPUBFUN xmlTextWriterPtr XMLCALL +xmlNewTextWriterTree(xmlDocPtr doc, xmlNodePtr node, + int compression); +XMLPUBFUN void XMLCALL xmlFreeTextWriter(xmlTextWriterPtr writer); /* * Functions @@ -52,220 +52,220 @@ extern "C" { /* * Document */ - XMLPUBFUN int XMLCALL - xmlTextWriterStartDocument(xmlTextWriterPtr writer, - const char *version, - const char *encoding, - const char *standalone); - XMLPUBFUN int XMLCALL xmlTextWriterEndDocument(xmlTextWriterPtr - writer); +XMLPUBFUN int XMLCALL +xmlTextWriterStartDocument(xmlTextWriterPtr writer, + const char *version, + const char *encoding, + const char *standalone); +XMLPUBFUN int XMLCALL xmlTextWriterEndDocument(xmlTextWriterPtr + writer); /* * Comments */ - XMLPUBFUN int XMLCALL xmlTextWriterStartComment(xmlTextWriterPtr - writer); - XMLPUBFUN int XMLCALL xmlTextWriterEndComment(xmlTextWriterPtr writer); - XMLPUBFUN int XMLCALL - xmlTextWriterWriteFormatComment(xmlTextWriterPtr writer, - const char *format, ...) - LIBXML_ATTR_FORMAT(2,3); - XMLPUBFUN int XMLCALL - xmlTextWriterWriteVFormatComment(xmlTextWriterPtr writer, - const char *format, - va_list argptr) - LIBXML_ATTR_FORMAT(2,0); - XMLPUBFUN int XMLCALL xmlTextWriterWriteComment(xmlTextWriterPtr - writer, - const xmlChar * - content); +XMLPUBFUN int XMLCALL xmlTextWriterStartComment(xmlTextWriterPtr + writer); +XMLPUBFUN int XMLCALL xmlTextWriterEndComment(xmlTextWriterPtr writer); +XMLPUBFUN int XMLCALL +xmlTextWriterWriteFormatComment(xmlTextWriterPtr writer, + const char *format, ...) +LIBXML_ATTR_FORMAT(2,3); +XMLPUBFUN int XMLCALL +xmlTextWriterWriteVFormatComment(xmlTextWriterPtr writer, + const char *format, + va_list argptr) +LIBXML_ATTR_FORMAT(2,0); +XMLPUBFUN int XMLCALL xmlTextWriterWriteComment(xmlTextWriterPtr + writer, + const xmlChar * + content); /* * Elements */ - XMLPUBFUN int XMLCALL - xmlTextWriterStartElement(xmlTextWriterPtr writer, - const xmlChar * name); - XMLPUBFUN int XMLCALL xmlTextWriterStartElementNS(xmlTextWriterPtr - writer, - const xmlChar * - prefix, - const xmlChar * name, - const xmlChar * - namespaceURI); - XMLPUBFUN int XMLCALL xmlTextWriterEndElement(xmlTextWriterPtr writer); - XMLPUBFUN int XMLCALL xmlTextWriterFullEndElement(xmlTextWriterPtr - writer); +XMLPUBFUN int XMLCALL +xmlTextWriterStartElement(xmlTextWriterPtr writer, + const xmlChar * name); +XMLPUBFUN int XMLCALL xmlTextWriterStartElementNS(xmlTextWriterPtr + writer, + const xmlChar * + prefix, + const xmlChar * name, + const xmlChar * + namespaceURI); +XMLPUBFUN int XMLCALL xmlTextWriterEndElement(xmlTextWriterPtr writer); +XMLPUBFUN int XMLCALL xmlTextWriterFullEndElement(xmlTextWriterPtr + writer); /* * Elements conveniency functions */ - XMLPUBFUN int XMLCALL - xmlTextWriterWriteFormatElement(xmlTextWriterPtr writer, - const xmlChar * name, - const char *format, ...) - LIBXML_ATTR_FORMAT(3,4); - XMLPUBFUN int XMLCALL - xmlTextWriterWriteVFormatElement(xmlTextWriterPtr writer, - const xmlChar * name, - const char *format, - va_list argptr) - LIBXML_ATTR_FORMAT(3,0); - XMLPUBFUN int XMLCALL xmlTextWriterWriteElement(xmlTextWriterPtr - writer, - const xmlChar * name, - const xmlChar * - content); - XMLPUBFUN int XMLCALL - xmlTextWriterWriteFormatElementNS(xmlTextWriterPtr writer, - const xmlChar * prefix, - const xmlChar * name, - const xmlChar * namespaceURI, - const char *format, ...) - LIBXML_ATTR_FORMAT(5,6); - XMLPUBFUN int XMLCALL - xmlTextWriterWriteVFormatElementNS(xmlTextWriterPtr writer, - const xmlChar * prefix, - const xmlChar * name, - const xmlChar * namespaceURI, - const char *format, - va_list argptr) - LIBXML_ATTR_FORMAT(5,0); - XMLPUBFUN int XMLCALL xmlTextWriterWriteElementNS(xmlTextWriterPtr - writer, - const xmlChar * - prefix, - const xmlChar * name, - const xmlChar * - namespaceURI, - const xmlChar * - content); +XMLPUBFUN int XMLCALL +xmlTextWriterWriteFormatElement(xmlTextWriterPtr writer, + const xmlChar * name, + const char *format, ...) +LIBXML_ATTR_FORMAT(3,4); +XMLPUBFUN int XMLCALL +xmlTextWriterWriteVFormatElement(xmlTextWriterPtr writer, + const xmlChar * name, + const char *format, + va_list argptr) +LIBXML_ATTR_FORMAT(3,0); +XMLPUBFUN int XMLCALL xmlTextWriterWriteElement(xmlTextWriterPtr + writer, + const xmlChar * name, + const xmlChar * + content); +XMLPUBFUN int XMLCALL +xmlTextWriterWriteFormatElementNS(xmlTextWriterPtr writer, + const xmlChar * prefix, + const xmlChar * name, + const xmlChar * namespaceURI, + const char *format, ...) +LIBXML_ATTR_FORMAT(5,6); +XMLPUBFUN int XMLCALL +xmlTextWriterWriteVFormatElementNS(xmlTextWriterPtr writer, + const xmlChar * prefix, + const xmlChar * name, + const xmlChar * namespaceURI, + const char *format, + va_list argptr) +LIBXML_ATTR_FORMAT(5,0); +XMLPUBFUN int XMLCALL xmlTextWriterWriteElementNS(xmlTextWriterPtr + writer, + const xmlChar * + prefix, + const xmlChar * name, + const xmlChar * + namespaceURI, + const xmlChar * + content); /* * Text */ - XMLPUBFUN int XMLCALL - xmlTextWriterWriteFormatRaw(xmlTextWriterPtr writer, - const char *format, ...) - LIBXML_ATTR_FORMAT(2,3); - XMLPUBFUN int XMLCALL - xmlTextWriterWriteVFormatRaw(xmlTextWriterPtr writer, - const char *format, va_list argptr) - LIBXML_ATTR_FORMAT(2,0); - XMLPUBFUN int XMLCALL - xmlTextWriterWriteRawLen(xmlTextWriterPtr writer, - const xmlChar * content, int len); - XMLPUBFUN int XMLCALL - xmlTextWriterWriteRaw(xmlTextWriterPtr writer, - const xmlChar * content); - XMLPUBFUN int XMLCALL xmlTextWriterWriteFormatString(xmlTextWriterPtr - writer, - const char - *format, ...) - LIBXML_ATTR_FORMAT(2,3); - XMLPUBFUN int XMLCALL xmlTextWriterWriteVFormatString(xmlTextWriterPtr - writer, - const char - *format, - va_list argptr) - LIBXML_ATTR_FORMAT(2,0); - XMLPUBFUN int XMLCALL xmlTextWriterWriteString(xmlTextWriterPtr writer, - const xmlChar * - content); - XMLPUBFUN int XMLCALL xmlTextWriterWriteBase64(xmlTextWriterPtr writer, - const char *data, - int start, int len); - XMLPUBFUN int XMLCALL xmlTextWriterWriteBinHex(xmlTextWriterPtr writer, - const char *data, - int start, int len); +XMLPUBFUN int XMLCALL +xmlTextWriterWriteFormatRaw(xmlTextWriterPtr writer, + const char *format, ...) +LIBXML_ATTR_FORMAT(2,3); +XMLPUBFUN int XMLCALL +xmlTextWriterWriteVFormatRaw(xmlTextWriterPtr writer, + const char *format, va_list argptr) +LIBXML_ATTR_FORMAT(2,0); +XMLPUBFUN int XMLCALL +xmlTextWriterWriteRawLen(xmlTextWriterPtr writer, + const xmlChar * content, int len); +XMLPUBFUN int XMLCALL +xmlTextWriterWriteRaw(xmlTextWriterPtr writer, + const xmlChar * content); +XMLPUBFUN int XMLCALL xmlTextWriterWriteFormatString(xmlTextWriterPtr + writer, + const char + *format, ...) +LIBXML_ATTR_FORMAT(2,3); +XMLPUBFUN int XMLCALL xmlTextWriterWriteVFormatString(xmlTextWriterPtr + writer, + const char + *format, + va_list argptr) +LIBXML_ATTR_FORMAT(2,0); +XMLPUBFUN int XMLCALL xmlTextWriterWriteString(xmlTextWriterPtr writer, + const xmlChar * + content); +XMLPUBFUN int XMLCALL xmlTextWriterWriteBase64(xmlTextWriterPtr writer, + const char *data, + int start, int len); +XMLPUBFUN int XMLCALL xmlTextWriterWriteBinHex(xmlTextWriterPtr writer, + const char *data, + int start, int len); /* * Attributes */ - XMLPUBFUN int XMLCALL - xmlTextWriterStartAttribute(xmlTextWriterPtr writer, - const xmlChar * name); - XMLPUBFUN int XMLCALL xmlTextWriterStartAttributeNS(xmlTextWriterPtr - writer, - const xmlChar * - prefix, - const xmlChar * - name, - const xmlChar * - namespaceURI); - XMLPUBFUN int XMLCALL xmlTextWriterEndAttribute(xmlTextWriterPtr - writer); +XMLPUBFUN int XMLCALL +xmlTextWriterStartAttribute(xmlTextWriterPtr writer, + const xmlChar * name); +XMLPUBFUN int XMLCALL xmlTextWriterStartAttributeNS(xmlTextWriterPtr + writer, + const xmlChar * + prefix, + const xmlChar * + name, + const xmlChar * + namespaceURI); +XMLPUBFUN int XMLCALL xmlTextWriterEndAttribute(xmlTextWriterPtr + writer); /* * Attributes conveniency functions */ - XMLPUBFUN int XMLCALL - xmlTextWriterWriteFormatAttribute(xmlTextWriterPtr writer, - const xmlChar * name, - const char *format, ...) - LIBXML_ATTR_FORMAT(3,4); - XMLPUBFUN int XMLCALL - xmlTextWriterWriteVFormatAttribute(xmlTextWriterPtr writer, - const xmlChar * name, - const char *format, - va_list argptr) - LIBXML_ATTR_FORMAT(3,0); - XMLPUBFUN int XMLCALL xmlTextWriterWriteAttribute(xmlTextWriterPtr - writer, - const xmlChar * name, - const xmlChar * - content); - XMLPUBFUN int XMLCALL - xmlTextWriterWriteFormatAttributeNS(xmlTextWriterPtr writer, - const xmlChar * prefix, - const xmlChar * name, - const xmlChar * namespaceURI, - const char *format, ...) - LIBXML_ATTR_FORMAT(5,6); - XMLPUBFUN int XMLCALL - xmlTextWriterWriteVFormatAttributeNS(xmlTextWriterPtr writer, - const xmlChar * prefix, - const xmlChar * name, - const xmlChar * namespaceURI, - const char *format, - va_list argptr) - LIBXML_ATTR_FORMAT(5,0); - XMLPUBFUN int XMLCALL xmlTextWriterWriteAttributeNS(xmlTextWriterPtr - writer, - const xmlChar * - prefix, - const xmlChar * - name, - const xmlChar * - namespaceURI, - const xmlChar * - content); +XMLPUBFUN int XMLCALL +xmlTextWriterWriteFormatAttribute(xmlTextWriterPtr writer, + const xmlChar * name, + const char *format, ...) +LIBXML_ATTR_FORMAT(3,4); +XMLPUBFUN int XMLCALL +xmlTextWriterWriteVFormatAttribute(xmlTextWriterPtr writer, + const xmlChar * name, + const char *format, + va_list argptr) +LIBXML_ATTR_FORMAT(3,0); +XMLPUBFUN int XMLCALL xmlTextWriterWriteAttribute(xmlTextWriterPtr + writer, + const xmlChar * name, + const xmlChar * + content); +XMLPUBFUN int XMLCALL +xmlTextWriterWriteFormatAttributeNS(xmlTextWriterPtr writer, + const xmlChar * prefix, + const xmlChar * name, + const xmlChar * namespaceURI, + const char *format, ...) +LIBXML_ATTR_FORMAT(5,6); +XMLPUBFUN int XMLCALL +xmlTextWriterWriteVFormatAttributeNS(xmlTextWriterPtr writer, + const xmlChar * prefix, + const xmlChar * name, + const xmlChar * namespaceURI, + const char *format, + va_list argptr) +LIBXML_ATTR_FORMAT(5,0); +XMLPUBFUN int XMLCALL xmlTextWriterWriteAttributeNS(xmlTextWriterPtr + writer, + const xmlChar * + prefix, + const xmlChar * + name, + const xmlChar * + namespaceURI, + const xmlChar * + content); /* * PI's */ - XMLPUBFUN int XMLCALL - xmlTextWriterStartPI(xmlTextWriterPtr writer, - const xmlChar * target); - XMLPUBFUN int XMLCALL xmlTextWriterEndPI(xmlTextWriterPtr writer); +XMLPUBFUN int XMLCALL +xmlTextWriterStartPI(xmlTextWriterPtr writer, + const xmlChar * target); +XMLPUBFUN int XMLCALL xmlTextWriterEndPI(xmlTextWriterPtr writer); /* * PI conveniency functions */ - XMLPUBFUN int XMLCALL - xmlTextWriterWriteFormatPI(xmlTextWriterPtr writer, - const xmlChar * target, - const char *format, ...) - LIBXML_ATTR_FORMAT(3,4); - XMLPUBFUN int XMLCALL - xmlTextWriterWriteVFormatPI(xmlTextWriterPtr writer, - const xmlChar * target, - const char *format, va_list argptr) - LIBXML_ATTR_FORMAT(3,0); - XMLPUBFUN int XMLCALL - xmlTextWriterWritePI(xmlTextWriterPtr writer, - const xmlChar * target, - const xmlChar * content); +XMLPUBFUN int XMLCALL +xmlTextWriterWriteFormatPI(xmlTextWriterPtr writer, + const xmlChar * target, + const char *format, ...) +LIBXML_ATTR_FORMAT(3,4); +XMLPUBFUN int XMLCALL +xmlTextWriterWriteVFormatPI(xmlTextWriterPtr writer, + const xmlChar * target, + const char *format, va_list argptr) +LIBXML_ATTR_FORMAT(3,0); +XMLPUBFUN int XMLCALL +xmlTextWriterWritePI(xmlTextWriterPtr writer, + const xmlChar * target, + const xmlChar * content); /** * xmlTextWriterWriteProcessingInstruction: @@ -277,57 +277,57 @@ extern "C" { /* * CDATA */ - XMLPUBFUN int XMLCALL xmlTextWriterStartCDATA(xmlTextWriterPtr writer); - XMLPUBFUN int XMLCALL xmlTextWriterEndCDATA(xmlTextWriterPtr writer); +XMLPUBFUN int XMLCALL xmlTextWriterStartCDATA(xmlTextWriterPtr writer); +XMLPUBFUN int XMLCALL xmlTextWriterEndCDATA(xmlTextWriterPtr writer); /* * CDATA conveniency functions */ - XMLPUBFUN int XMLCALL - xmlTextWriterWriteFormatCDATA(xmlTextWriterPtr writer, - const char *format, ...) - LIBXML_ATTR_FORMAT(2,3); - XMLPUBFUN int XMLCALL - xmlTextWriterWriteVFormatCDATA(xmlTextWriterPtr writer, - const char *format, va_list argptr) - LIBXML_ATTR_FORMAT(2,0); - XMLPUBFUN int XMLCALL - xmlTextWriterWriteCDATA(xmlTextWriterPtr writer, - const xmlChar * content); +XMLPUBFUN int XMLCALL +xmlTextWriterWriteFormatCDATA(xmlTextWriterPtr writer, + const char *format, ...) +LIBXML_ATTR_FORMAT(2,3); +XMLPUBFUN int XMLCALL +xmlTextWriterWriteVFormatCDATA(xmlTextWriterPtr writer, + const char *format, va_list argptr) +LIBXML_ATTR_FORMAT(2,0); +XMLPUBFUN int XMLCALL +xmlTextWriterWriteCDATA(xmlTextWriterPtr writer, + const xmlChar * content); /* * DTD */ - XMLPUBFUN int XMLCALL - xmlTextWriterStartDTD(xmlTextWriterPtr writer, - const xmlChar * name, - const xmlChar * pubid, - const xmlChar * sysid); - XMLPUBFUN int XMLCALL xmlTextWriterEndDTD(xmlTextWriterPtr writer); +XMLPUBFUN int XMLCALL +xmlTextWriterStartDTD(xmlTextWriterPtr writer, + const xmlChar * name, + const xmlChar * pubid, + const xmlChar * sysid); +XMLPUBFUN int XMLCALL xmlTextWriterEndDTD(xmlTextWriterPtr writer); /* * DTD conveniency functions */ - XMLPUBFUN int XMLCALL - xmlTextWriterWriteFormatDTD(xmlTextWriterPtr writer, - const xmlChar * name, - const xmlChar * pubid, - const xmlChar * sysid, - const char *format, ...) - LIBXML_ATTR_FORMAT(5,6); - XMLPUBFUN int XMLCALL - xmlTextWriterWriteVFormatDTD(xmlTextWriterPtr writer, - const xmlChar * name, - const xmlChar * pubid, - const xmlChar * sysid, - const char *format, va_list argptr) - LIBXML_ATTR_FORMAT(5,0); - XMLPUBFUN int XMLCALL - xmlTextWriterWriteDTD(xmlTextWriterPtr writer, - const xmlChar * name, - const xmlChar * pubid, - const xmlChar * sysid, - const xmlChar * subset); +XMLPUBFUN int XMLCALL +xmlTextWriterWriteFormatDTD(xmlTextWriterPtr writer, + const xmlChar * name, + const xmlChar * pubid, + const xmlChar * sysid, + const char *format, ...) +LIBXML_ATTR_FORMAT(5,6); +XMLPUBFUN int XMLCALL +xmlTextWriterWriteVFormatDTD(xmlTextWriterPtr writer, + const xmlChar * name, + const xmlChar * pubid, + const xmlChar * sysid, + const char *format, va_list argptr) +LIBXML_ATTR_FORMAT(5,0); +XMLPUBFUN int XMLCALL +xmlTextWriterWriteDTD(xmlTextWriterPtr writer, + const xmlChar * name, + const xmlChar * pubid, + const xmlChar * sysid, + const xmlChar * subset); /** * xmlTextWriterWriteDocType: @@ -339,145 +339,145 @@ extern "C" { /* * DTD element definition */ - XMLPUBFUN int XMLCALL - xmlTextWriterStartDTDElement(xmlTextWriterPtr writer, - const xmlChar * name); - XMLPUBFUN int XMLCALL xmlTextWriterEndDTDElement(xmlTextWriterPtr - writer); +XMLPUBFUN int XMLCALL +xmlTextWriterStartDTDElement(xmlTextWriterPtr writer, + const xmlChar * name); +XMLPUBFUN int XMLCALL xmlTextWriterEndDTDElement(xmlTextWriterPtr + writer); /* * DTD element definition conveniency functions */ - XMLPUBFUN int XMLCALL - xmlTextWriterWriteFormatDTDElement(xmlTextWriterPtr writer, - const xmlChar * name, - const char *format, ...) - LIBXML_ATTR_FORMAT(3,4); - XMLPUBFUN int XMLCALL - xmlTextWriterWriteVFormatDTDElement(xmlTextWriterPtr writer, - const xmlChar * name, - const char *format, - va_list argptr) - LIBXML_ATTR_FORMAT(3,0); - XMLPUBFUN int XMLCALL xmlTextWriterWriteDTDElement(xmlTextWriterPtr - writer, - const xmlChar * - name, - const xmlChar * - content); +XMLPUBFUN int XMLCALL +xmlTextWriterWriteFormatDTDElement(xmlTextWriterPtr writer, + const xmlChar * name, + const char *format, ...) +LIBXML_ATTR_FORMAT(3,4); +XMLPUBFUN int XMLCALL +xmlTextWriterWriteVFormatDTDElement(xmlTextWriterPtr writer, + const xmlChar * name, + const char *format, + va_list argptr) +LIBXML_ATTR_FORMAT(3,0); +XMLPUBFUN int XMLCALL xmlTextWriterWriteDTDElement(xmlTextWriterPtr + writer, + const xmlChar * + name, + const xmlChar * + content); /* * DTD attribute list definition */ - XMLPUBFUN int XMLCALL - xmlTextWriterStartDTDAttlist(xmlTextWriterPtr writer, - const xmlChar * name); - XMLPUBFUN int XMLCALL xmlTextWriterEndDTDAttlist(xmlTextWriterPtr - writer); +XMLPUBFUN int XMLCALL +xmlTextWriterStartDTDAttlist(xmlTextWriterPtr writer, + const xmlChar * name); +XMLPUBFUN int XMLCALL xmlTextWriterEndDTDAttlist(xmlTextWriterPtr + writer); /* * DTD attribute list definition conveniency functions */ - XMLPUBFUN int XMLCALL - xmlTextWriterWriteFormatDTDAttlist(xmlTextWriterPtr writer, - const xmlChar * name, - const char *format, ...) - LIBXML_ATTR_FORMAT(3,4); - XMLPUBFUN int XMLCALL - xmlTextWriterWriteVFormatDTDAttlist(xmlTextWriterPtr writer, - const xmlChar * name, - const char *format, - va_list argptr) - LIBXML_ATTR_FORMAT(3,0); - XMLPUBFUN int XMLCALL xmlTextWriterWriteDTDAttlist(xmlTextWriterPtr - writer, - const xmlChar * - name, - const xmlChar * - content); +XMLPUBFUN int XMLCALL +xmlTextWriterWriteFormatDTDAttlist(xmlTextWriterPtr writer, + const xmlChar * name, + const char *format, ...) +LIBXML_ATTR_FORMAT(3,4); +XMLPUBFUN int XMLCALL +xmlTextWriterWriteVFormatDTDAttlist(xmlTextWriterPtr writer, + const xmlChar * name, + const char *format, + va_list argptr) +LIBXML_ATTR_FORMAT(3,0); +XMLPUBFUN int XMLCALL xmlTextWriterWriteDTDAttlist(xmlTextWriterPtr + writer, + const xmlChar * + name, + const xmlChar * + content); /* * DTD entity definition */ - XMLPUBFUN int XMLCALL - xmlTextWriterStartDTDEntity(xmlTextWriterPtr writer, - int pe, const xmlChar * name); - XMLPUBFUN int XMLCALL xmlTextWriterEndDTDEntity(xmlTextWriterPtr - writer); +XMLPUBFUN int XMLCALL +xmlTextWriterStartDTDEntity(xmlTextWriterPtr writer, + int pe, const xmlChar * name); +XMLPUBFUN int XMLCALL xmlTextWriterEndDTDEntity(xmlTextWriterPtr + writer); /* * DTD entity definition conveniency functions */ - XMLPUBFUN int XMLCALL - xmlTextWriterWriteFormatDTDInternalEntity(xmlTextWriterPtr writer, - int pe, - const xmlChar * name, - const char *format, ...) - LIBXML_ATTR_FORMAT(4,5); - XMLPUBFUN int XMLCALL - xmlTextWriterWriteVFormatDTDInternalEntity(xmlTextWriterPtr writer, - int pe, - const xmlChar * name, - const char *format, - va_list argptr) - LIBXML_ATTR_FORMAT(4,0); - XMLPUBFUN int XMLCALL - xmlTextWriterWriteDTDInternalEntity(xmlTextWriterPtr writer, - int pe, - const xmlChar * name, - const xmlChar * content); - XMLPUBFUN int XMLCALL - xmlTextWriterWriteDTDExternalEntity(xmlTextWriterPtr writer, - int pe, - const xmlChar * name, - const xmlChar * pubid, - const xmlChar * sysid, - const xmlChar * ndataid); - XMLPUBFUN int XMLCALL - xmlTextWriterWriteDTDExternalEntityContents(xmlTextWriterPtr - writer, - const xmlChar * pubid, - const xmlChar * sysid, - const xmlChar * - ndataid); - XMLPUBFUN int XMLCALL xmlTextWriterWriteDTDEntity(xmlTextWriterPtr - writer, int pe, - const xmlChar * name, - const xmlChar * - pubid, - const xmlChar * - sysid, - const xmlChar * - ndataid, - const xmlChar * - content); +XMLPUBFUN int XMLCALL +xmlTextWriterWriteFormatDTDInternalEntity(xmlTextWriterPtr writer, + int pe, + const xmlChar * name, + const char *format, ...) +LIBXML_ATTR_FORMAT(4,5); +XMLPUBFUN int XMLCALL +xmlTextWriterWriteVFormatDTDInternalEntity(xmlTextWriterPtr writer, + int pe, + const xmlChar * name, + const char *format, + va_list argptr) +LIBXML_ATTR_FORMAT(4,0); +XMLPUBFUN int XMLCALL +xmlTextWriterWriteDTDInternalEntity(xmlTextWriterPtr writer, + int pe, + const xmlChar * name, + const xmlChar * content); +XMLPUBFUN int XMLCALL +xmlTextWriterWriteDTDExternalEntity(xmlTextWriterPtr writer, + int pe, + const xmlChar * name, + const xmlChar * pubid, + const xmlChar * sysid, + const xmlChar * ndataid); +XMLPUBFUN int XMLCALL +xmlTextWriterWriteDTDExternalEntityContents(xmlTextWriterPtr + writer, + const xmlChar * pubid, + const xmlChar * sysid, + const xmlChar * + ndataid); +XMLPUBFUN int XMLCALL xmlTextWriterWriteDTDEntity(xmlTextWriterPtr + writer, int pe, + const xmlChar * name, + const xmlChar * + pubid, + const xmlChar * + sysid, + const xmlChar * + ndataid, + const xmlChar * + content); /* * DTD notation definition */ - XMLPUBFUN int XMLCALL - xmlTextWriterWriteDTDNotation(xmlTextWriterPtr writer, - const xmlChar * name, - const xmlChar * pubid, - const xmlChar * sysid); +XMLPUBFUN int XMLCALL +xmlTextWriterWriteDTDNotation(xmlTextWriterPtr writer, + const xmlChar * name, + const xmlChar * pubid, + const xmlChar * sysid); /* * Indentation */ - XMLPUBFUN int XMLCALL - xmlTextWriterSetIndent(xmlTextWriterPtr writer, int indent); - XMLPUBFUN int XMLCALL - xmlTextWriterSetIndentString(xmlTextWriterPtr writer, - const xmlChar * str); +XMLPUBFUN int XMLCALL +xmlTextWriterSetIndent(xmlTextWriterPtr writer, int indent); +XMLPUBFUN int XMLCALL +xmlTextWriterSetIndentString(xmlTextWriterPtr writer, + const xmlChar * str); - XMLPUBFUN int XMLCALL - xmlTextWriterSetQuoteChar(xmlTextWriterPtr writer, xmlChar quotechar); +XMLPUBFUN int XMLCALL +xmlTextWriterSetQuoteChar(xmlTextWriterPtr writer, xmlChar quotechar); /* * misc */ - XMLPUBFUN int XMLCALL xmlTextWriterFlush(xmlTextWriterPtr writer); +XMLPUBFUN int XMLCALL xmlTextWriterFlush(xmlTextWriterPtr writer); #ifdef __cplusplus } diff --git a/thirdparties/common/include/libxml2/libxml/xpath.h b/thirdparties/common/include/libxml2/libxml/xpath.h index d96776c..dc082ef 100755 --- a/thirdparties/common/include/libxml2/libxml/xpath.h +++ b/thirdparties/common/include/libxml2/libxml/xpath.h @@ -166,7 +166,7 @@ struct _xmlXPathVariable { */ typedef void (*xmlXPathEvalFunc)(xmlXPathParserContextPtr ctxt, - int nargs); + int nargs); /* * Extra function: a name and a evaluation function. @@ -192,7 +192,7 @@ struct _xmlXPathFunct { */ typedef xmlXPathObjectPtr (*xmlXPathAxisFunc) (xmlXPathParserContextPtr ctxt, - xmlXPathObjectPtr cur); + xmlXPathObjectPtr cur); /* * Extra axis: a name and an axis function. @@ -233,8 +233,8 @@ typedef void (*xmlXPathFunction) (xmlXPathParserContextPtr ctxt, int nargs); * Returns the XPath object value or NULL if not found. */ typedef xmlXPathObjectPtr (*xmlXPathVariableLookupFunc) (void *ctxt, - const xmlChar *name, - const xmlChar *ns_uri); + const xmlChar *name, + const xmlChar *ns_uri); /** * xmlXPathFuncLookupFunc: @@ -248,8 +248,8 @@ typedef xmlXPathObjectPtr (*xmlXPathVariableLookupFunc) (void *ctxt, * Returns the XPath function or NULL if not found. */ typedef xmlXPathFunction (*xmlXPathFuncLookupFunc) (void *ctxt, - const xmlChar *name, - const xmlChar *ns_uri); + const xmlChar *name, + const xmlChar *ns_uri); /** * xmlXPathFlags: @@ -438,116 +438,116 @@ XMLPUBVAR double xmlXPathNINF; XMLPUBFUN void XMLCALL - xmlXPathFreeObject (xmlXPathObjectPtr obj); +xmlXPathFreeObject (xmlXPathObjectPtr obj); XMLPUBFUN xmlNodeSetPtr XMLCALL - xmlXPathNodeSetCreate (xmlNodePtr val); +xmlXPathNodeSetCreate (xmlNodePtr val); XMLPUBFUN void XMLCALL - xmlXPathFreeNodeSetList (xmlXPathObjectPtr obj); +xmlXPathFreeNodeSetList (xmlXPathObjectPtr obj); XMLPUBFUN void XMLCALL - xmlXPathFreeNodeSet (xmlNodeSetPtr obj); +xmlXPathFreeNodeSet (xmlNodeSetPtr obj); XMLPUBFUN xmlXPathObjectPtr XMLCALL - xmlXPathObjectCopy (xmlXPathObjectPtr val); +xmlXPathObjectCopy (xmlXPathObjectPtr val); XMLPUBFUN int XMLCALL - xmlXPathCmpNodes (xmlNodePtr node1, - xmlNodePtr node2); +xmlXPathCmpNodes (xmlNodePtr node1, + xmlNodePtr node2); /** * Conversion functions to basic types. */ XMLPUBFUN int XMLCALL - xmlXPathCastNumberToBoolean (double val); +xmlXPathCastNumberToBoolean (double val); XMLPUBFUN int XMLCALL - xmlXPathCastStringToBoolean (const xmlChar * val); +xmlXPathCastStringToBoolean (const xmlChar * val); XMLPUBFUN int XMLCALL - xmlXPathCastNodeSetToBoolean(xmlNodeSetPtr ns); +xmlXPathCastNodeSetToBoolean(xmlNodeSetPtr ns); XMLPUBFUN int XMLCALL - xmlXPathCastToBoolean (xmlXPathObjectPtr val); +xmlXPathCastToBoolean (xmlXPathObjectPtr val); XMLPUBFUN double XMLCALL - xmlXPathCastBooleanToNumber (int val); +xmlXPathCastBooleanToNumber (int val); XMLPUBFUN double XMLCALL - xmlXPathCastStringToNumber (const xmlChar * val); +xmlXPathCastStringToNumber (const xmlChar * val); XMLPUBFUN double XMLCALL - xmlXPathCastNodeToNumber (xmlNodePtr node); +xmlXPathCastNodeToNumber (xmlNodePtr node); XMLPUBFUN double XMLCALL - xmlXPathCastNodeSetToNumber (xmlNodeSetPtr ns); +xmlXPathCastNodeSetToNumber (xmlNodeSetPtr ns); XMLPUBFUN double XMLCALL - xmlXPathCastToNumber (xmlXPathObjectPtr val); +xmlXPathCastToNumber (xmlXPathObjectPtr val); XMLPUBFUN xmlChar * XMLCALL - xmlXPathCastBooleanToString (int val); +xmlXPathCastBooleanToString (int val); XMLPUBFUN xmlChar * XMLCALL - xmlXPathCastNumberToString (double val); +xmlXPathCastNumberToString (double val); XMLPUBFUN xmlChar * XMLCALL - xmlXPathCastNodeToString (xmlNodePtr node); +xmlXPathCastNodeToString (xmlNodePtr node); XMLPUBFUN xmlChar * XMLCALL - xmlXPathCastNodeSetToString (xmlNodeSetPtr ns); +xmlXPathCastNodeSetToString (xmlNodeSetPtr ns); XMLPUBFUN xmlChar * XMLCALL - xmlXPathCastToString (xmlXPathObjectPtr val); +xmlXPathCastToString (xmlXPathObjectPtr val); XMLPUBFUN xmlXPathObjectPtr XMLCALL - xmlXPathConvertBoolean (xmlXPathObjectPtr val); +xmlXPathConvertBoolean (xmlXPathObjectPtr val); XMLPUBFUN xmlXPathObjectPtr XMLCALL - xmlXPathConvertNumber (xmlXPathObjectPtr val); +xmlXPathConvertNumber (xmlXPathObjectPtr val); XMLPUBFUN xmlXPathObjectPtr XMLCALL - xmlXPathConvertString (xmlXPathObjectPtr val); +xmlXPathConvertString (xmlXPathObjectPtr val); /** * Context handling. */ XMLPUBFUN xmlXPathContextPtr XMLCALL - xmlXPathNewContext (xmlDocPtr doc); +xmlXPathNewContext (xmlDocPtr doc); XMLPUBFUN void XMLCALL - xmlXPathFreeContext (xmlXPathContextPtr ctxt); +xmlXPathFreeContext (xmlXPathContextPtr ctxt); XMLPUBFUN int XMLCALL - xmlXPathContextSetCache(xmlXPathContextPtr ctxt, - int active, - int value, - int options); +xmlXPathContextSetCache(xmlXPathContextPtr ctxt, + int active, + int value, + int options); /** * Evaluation functions. */ XMLPUBFUN long XMLCALL - xmlXPathOrderDocElems (xmlDocPtr doc); +xmlXPathOrderDocElems (xmlDocPtr doc); XMLPUBFUN int XMLCALL - xmlXPathSetContextNode (xmlNodePtr node, - xmlXPathContextPtr ctx); +xmlXPathSetContextNode (xmlNodePtr node, + xmlXPathContextPtr ctx); XMLPUBFUN xmlXPathObjectPtr XMLCALL - xmlXPathNodeEval (xmlNodePtr node, - const xmlChar *str, - xmlXPathContextPtr ctx); +xmlXPathNodeEval (xmlNodePtr node, + const xmlChar *str, + xmlXPathContextPtr ctx); XMLPUBFUN xmlXPathObjectPtr XMLCALL - xmlXPathEval (const xmlChar *str, - xmlXPathContextPtr ctx); +xmlXPathEval (const xmlChar *str, + xmlXPathContextPtr ctx); XMLPUBFUN xmlXPathObjectPtr XMLCALL - xmlXPathEvalExpression (const xmlChar *str, - xmlXPathContextPtr ctxt); +xmlXPathEvalExpression (const xmlChar *str, + xmlXPathContextPtr ctxt); XMLPUBFUN int XMLCALL - xmlXPathEvalPredicate (xmlXPathContextPtr ctxt, - xmlXPathObjectPtr res); +xmlXPathEvalPredicate (xmlXPathContextPtr ctxt, + xmlXPathObjectPtr res); /** * Separate compilation/evaluation entry points. */ XMLPUBFUN xmlXPathCompExprPtr XMLCALL - xmlXPathCompile (const xmlChar *str); +xmlXPathCompile (const xmlChar *str); XMLPUBFUN xmlXPathCompExprPtr XMLCALL - xmlXPathCtxtCompile (xmlXPathContextPtr ctxt, - const xmlChar *str); +xmlXPathCtxtCompile (xmlXPathContextPtr ctxt, + const xmlChar *str); XMLPUBFUN xmlXPathObjectPtr XMLCALL - xmlXPathCompiledEval (xmlXPathCompExprPtr comp, - xmlXPathContextPtr ctx); +xmlXPathCompiledEval (xmlXPathCompExprPtr comp, + xmlXPathContextPtr ctx); XMLPUBFUN int XMLCALL - xmlXPathCompiledEvalToBoolean(xmlXPathCompExprPtr comp, - xmlXPathContextPtr ctxt); +xmlXPathCompiledEvalToBoolean(xmlXPathCompExprPtr comp, + xmlXPathContextPtr ctxt); XMLPUBFUN void XMLCALL - xmlXPathFreeCompExpr (xmlXPathCompExprPtr comp); +xmlXPathFreeCompExpr (xmlXPathCompExprPtr comp); #endif /* LIBXML_XPATH_ENABLED */ #if defined(LIBXML_XPATH_ENABLED) || defined(LIBXML_SCHEMAS_ENABLED) XMLPUBFUN void XMLCALL - xmlXPathInit (void); +xmlXPathInit (void); XMLPUBFUN int XMLCALL - xmlXPathIsNaN (double val); +xmlXPathIsNaN (double val); XMLPUBFUN int XMLCALL - xmlXPathIsInf (double val); +xmlXPathIsInf (double val); #ifdef __cplusplus } diff --git a/thirdparties/common/include/libxml2/libxml/xpathInternals.h b/thirdparties/common/include/libxml2/libxml/xpathInternals.h index 70c9db9..c150b64 100755 --- a/thirdparties/common/include/libxml2/libxml/xpathInternals.h +++ b/thirdparties/common/include/libxml2/libxml/xpathInternals.h @@ -101,15 +101,15 @@ extern "C" { #define xmlXPathGetContextNode(ctxt) ((ctxt)->context->node) XMLPUBFUN int XMLCALL - xmlXPathPopBoolean (xmlXPathParserContextPtr ctxt); +xmlXPathPopBoolean (xmlXPathParserContextPtr ctxt); XMLPUBFUN double XMLCALL - xmlXPathPopNumber (xmlXPathParserContextPtr ctxt); +xmlXPathPopNumber (xmlXPathParserContextPtr ctxt); XMLPUBFUN xmlChar * XMLCALL - xmlXPathPopString (xmlXPathParserContextPtr ctxt); +xmlXPathPopString (xmlXPathParserContextPtr ctxt); XMLPUBFUN xmlNodeSetPtr XMLCALL - xmlXPathPopNodeSet (xmlXPathParserContextPtr ctxt); +xmlXPathPopNodeSet (xmlXPathParserContextPtr ctxt); XMLPUBFUN void * XMLCALL - xmlXPathPopExternal (xmlXPathParserContextPtr ctxt); +xmlXPathPopExternal (xmlXPathParserContextPtr ctxt); /** * xmlXPathReturnBoolean: @@ -332,89 +332,89 @@ XMLPUBFUN void * XMLCALL */ XMLPUBFUN void XMLCALL - xmlXPathRegisterVariableLookup (xmlXPathContextPtr ctxt, - xmlXPathVariableLookupFunc f, - void *data); +xmlXPathRegisterVariableLookup (xmlXPathContextPtr ctxt, + xmlXPathVariableLookupFunc f, + void *data); /* * Function Lookup forwarding. */ XMLPUBFUN void XMLCALL - xmlXPathRegisterFuncLookup (xmlXPathContextPtr ctxt, - xmlXPathFuncLookupFunc f, - void *funcCtxt); +xmlXPathRegisterFuncLookup (xmlXPathContextPtr ctxt, + xmlXPathFuncLookupFunc f, + void *funcCtxt); /* * Error reporting. */ XMLPUBFUN void XMLCALL - xmlXPatherror (xmlXPathParserContextPtr ctxt, - const char *file, - int line, - int no); +xmlXPatherror (xmlXPathParserContextPtr ctxt, + const char *file, + int line, + int no); XMLPUBFUN void XMLCALL - xmlXPathErr (xmlXPathParserContextPtr ctxt, - int error); +xmlXPathErr (xmlXPathParserContextPtr ctxt, + int error); #ifdef LIBXML_DEBUG_ENABLED XMLPUBFUN void XMLCALL - xmlXPathDebugDumpObject (FILE *output, - xmlXPathObjectPtr cur, - int depth); +xmlXPathDebugDumpObject (FILE *output, + xmlXPathObjectPtr cur, + int depth); XMLPUBFUN void XMLCALL - xmlXPathDebugDumpCompExpr(FILE *output, - xmlXPathCompExprPtr comp, - int depth); +xmlXPathDebugDumpCompExpr(FILE *output, + xmlXPathCompExprPtr comp, + int depth); #endif /** * NodeSet handling. */ XMLPUBFUN int XMLCALL - xmlXPathNodeSetContains (xmlNodeSetPtr cur, - xmlNodePtr val); +xmlXPathNodeSetContains (xmlNodeSetPtr cur, + xmlNodePtr val); XMLPUBFUN xmlNodeSetPtr XMLCALL - xmlXPathDifference (xmlNodeSetPtr nodes1, - xmlNodeSetPtr nodes2); +xmlXPathDifference (xmlNodeSetPtr nodes1, + xmlNodeSetPtr nodes2); XMLPUBFUN xmlNodeSetPtr XMLCALL - xmlXPathIntersection (xmlNodeSetPtr nodes1, - xmlNodeSetPtr nodes2); +xmlXPathIntersection (xmlNodeSetPtr nodes1, + xmlNodeSetPtr nodes2); XMLPUBFUN xmlNodeSetPtr XMLCALL - xmlXPathDistinctSorted (xmlNodeSetPtr nodes); +xmlXPathDistinctSorted (xmlNodeSetPtr nodes); XMLPUBFUN xmlNodeSetPtr XMLCALL - xmlXPathDistinct (xmlNodeSetPtr nodes); +xmlXPathDistinct (xmlNodeSetPtr nodes); XMLPUBFUN int XMLCALL - xmlXPathHasSameNodes (xmlNodeSetPtr nodes1, - xmlNodeSetPtr nodes2); +xmlXPathHasSameNodes (xmlNodeSetPtr nodes1, + xmlNodeSetPtr nodes2); XMLPUBFUN xmlNodeSetPtr XMLCALL - xmlXPathNodeLeadingSorted (xmlNodeSetPtr nodes, - xmlNodePtr node); +xmlXPathNodeLeadingSorted (xmlNodeSetPtr nodes, + xmlNodePtr node); XMLPUBFUN xmlNodeSetPtr XMLCALL - xmlXPathLeadingSorted (xmlNodeSetPtr nodes1, - xmlNodeSetPtr nodes2); +xmlXPathLeadingSorted (xmlNodeSetPtr nodes1, + xmlNodeSetPtr nodes2); XMLPUBFUN xmlNodeSetPtr XMLCALL - xmlXPathNodeLeading (xmlNodeSetPtr nodes, - xmlNodePtr node); +xmlXPathNodeLeading (xmlNodeSetPtr nodes, + xmlNodePtr node); XMLPUBFUN xmlNodeSetPtr XMLCALL - xmlXPathLeading (xmlNodeSetPtr nodes1, - xmlNodeSetPtr nodes2); +xmlXPathLeading (xmlNodeSetPtr nodes1, + xmlNodeSetPtr nodes2); XMLPUBFUN xmlNodeSetPtr XMLCALL - xmlXPathNodeTrailingSorted (xmlNodeSetPtr nodes, - xmlNodePtr node); +xmlXPathNodeTrailingSorted (xmlNodeSetPtr nodes, + xmlNodePtr node); XMLPUBFUN xmlNodeSetPtr XMLCALL - xmlXPathTrailingSorted (xmlNodeSetPtr nodes1, - xmlNodeSetPtr nodes2); +xmlXPathTrailingSorted (xmlNodeSetPtr nodes1, + xmlNodeSetPtr nodes2); XMLPUBFUN xmlNodeSetPtr XMLCALL - xmlXPathNodeTrailing (xmlNodeSetPtr nodes, - xmlNodePtr node); +xmlXPathNodeTrailing (xmlNodeSetPtr nodes, + xmlNodePtr node); XMLPUBFUN xmlNodeSetPtr XMLCALL - xmlXPathTrailing (xmlNodeSetPtr nodes1, - xmlNodeSetPtr nodes2); +xmlXPathTrailing (xmlNodeSetPtr nodes1, + xmlNodeSetPtr nodes2); /** @@ -422,131 +422,131 @@ XMLPUBFUN xmlNodeSetPtr XMLCALL */ XMLPUBFUN int XMLCALL - xmlXPathRegisterNs (xmlXPathContextPtr ctxt, - const xmlChar *prefix, - const xmlChar *ns_uri); +xmlXPathRegisterNs (xmlXPathContextPtr ctxt, + const xmlChar *prefix, + const xmlChar *ns_uri); XMLPUBFUN const xmlChar * XMLCALL - xmlXPathNsLookup (xmlXPathContextPtr ctxt, - const xmlChar *prefix); +xmlXPathNsLookup (xmlXPathContextPtr ctxt, + const xmlChar *prefix); XMLPUBFUN void XMLCALL - xmlXPathRegisteredNsCleanup (xmlXPathContextPtr ctxt); +xmlXPathRegisteredNsCleanup (xmlXPathContextPtr ctxt); XMLPUBFUN int XMLCALL - xmlXPathRegisterFunc (xmlXPathContextPtr ctxt, - const xmlChar *name, - xmlXPathFunction f); +xmlXPathRegisterFunc (xmlXPathContextPtr ctxt, + const xmlChar *name, + xmlXPathFunction f); XMLPUBFUN int XMLCALL - xmlXPathRegisterFuncNS (xmlXPathContextPtr ctxt, - const xmlChar *name, - const xmlChar *ns_uri, - xmlXPathFunction f); +xmlXPathRegisterFuncNS (xmlXPathContextPtr ctxt, + const xmlChar *name, + const xmlChar *ns_uri, + xmlXPathFunction f); XMLPUBFUN int XMLCALL - xmlXPathRegisterVariable (xmlXPathContextPtr ctxt, - const xmlChar *name, - xmlXPathObjectPtr value); +xmlXPathRegisterVariable (xmlXPathContextPtr ctxt, + const xmlChar *name, + xmlXPathObjectPtr value); XMLPUBFUN int XMLCALL - xmlXPathRegisterVariableNS (xmlXPathContextPtr ctxt, - const xmlChar *name, - const xmlChar *ns_uri, - xmlXPathObjectPtr value); +xmlXPathRegisterVariableNS (xmlXPathContextPtr ctxt, + const xmlChar *name, + const xmlChar *ns_uri, + xmlXPathObjectPtr value); XMLPUBFUN xmlXPathFunction XMLCALL - xmlXPathFunctionLookup (xmlXPathContextPtr ctxt, - const xmlChar *name); +xmlXPathFunctionLookup (xmlXPathContextPtr ctxt, + const xmlChar *name); XMLPUBFUN xmlXPathFunction XMLCALL - xmlXPathFunctionLookupNS (xmlXPathContextPtr ctxt, - const xmlChar *name, - const xmlChar *ns_uri); +xmlXPathFunctionLookupNS (xmlXPathContextPtr ctxt, + const xmlChar *name, + const xmlChar *ns_uri); XMLPUBFUN void XMLCALL - xmlXPathRegisteredFuncsCleanup (xmlXPathContextPtr ctxt); +xmlXPathRegisteredFuncsCleanup (xmlXPathContextPtr ctxt); XMLPUBFUN xmlXPathObjectPtr XMLCALL - xmlXPathVariableLookup (xmlXPathContextPtr ctxt, - const xmlChar *name); +xmlXPathVariableLookup (xmlXPathContextPtr ctxt, + const xmlChar *name); XMLPUBFUN xmlXPathObjectPtr XMLCALL - xmlXPathVariableLookupNS (xmlXPathContextPtr ctxt, - const xmlChar *name, - const xmlChar *ns_uri); +xmlXPathVariableLookupNS (xmlXPathContextPtr ctxt, + const xmlChar *name, + const xmlChar *ns_uri); XMLPUBFUN void XMLCALL - xmlXPathRegisteredVariablesCleanup(xmlXPathContextPtr ctxt); +xmlXPathRegisteredVariablesCleanup(xmlXPathContextPtr ctxt); /** * Utilities to extend XPath. */ XMLPUBFUN xmlXPathParserContextPtr XMLCALL - xmlXPathNewParserContext (const xmlChar *str, - xmlXPathContextPtr ctxt); +xmlXPathNewParserContext (const xmlChar *str, + xmlXPathContextPtr ctxt); XMLPUBFUN void XMLCALL - xmlXPathFreeParserContext (xmlXPathParserContextPtr ctxt); +xmlXPathFreeParserContext (xmlXPathParserContextPtr ctxt); /* TODO: remap to xmlXPathValuePop and Push. */ XMLPUBFUN xmlXPathObjectPtr XMLCALL - valuePop (xmlXPathParserContextPtr ctxt); +valuePop (xmlXPathParserContextPtr ctxt); XMLPUBFUN int XMLCALL - valuePush (xmlXPathParserContextPtr ctxt, - xmlXPathObjectPtr value); +valuePush (xmlXPathParserContextPtr ctxt, + xmlXPathObjectPtr value); XMLPUBFUN xmlXPathObjectPtr XMLCALL - xmlXPathNewString (const xmlChar *val); +xmlXPathNewString (const xmlChar *val); XMLPUBFUN xmlXPathObjectPtr XMLCALL - xmlXPathNewCString (const char *val); +xmlXPathNewCString (const char *val); XMLPUBFUN xmlXPathObjectPtr XMLCALL - xmlXPathWrapString (xmlChar *val); +xmlXPathWrapString (xmlChar *val); XMLPUBFUN xmlXPathObjectPtr XMLCALL - xmlXPathWrapCString (char * val); +xmlXPathWrapCString (char * val); XMLPUBFUN xmlXPathObjectPtr XMLCALL - xmlXPathNewFloat (double val); +xmlXPathNewFloat (double val); XMLPUBFUN xmlXPathObjectPtr XMLCALL - xmlXPathNewBoolean (int val); +xmlXPathNewBoolean (int val); XMLPUBFUN xmlXPathObjectPtr XMLCALL - xmlXPathNewNodeSet (xmlNodePtr val); +xmlXPathNewNodeSet (xmlNodePtr val); XMLPUBFUN xmlXPathObjectPtr XMLCALL - xmlXPathNewValueTree (xmlNodePtr val); +xmlXPathNewValueTree (xmlNodePtr val); XMLPUBFUN int XMLCALL - xmlXPathNodeSetAdd (xmlNodeSetPtr cur, - xmlNodePtr val); +xmlXPathNodeSetAdd (xmlNodeSetPtr cur, + xmlNodePtr val); XMLPUBFUN int XMLCALL - xmlXPathNodeSetAddUnique (xmlNodeSetPtr cur, - xmlNodePtr val); +xmlXPathNodeSetAddUnique (xmlNodeSetPtr cur, + xmlNodePtr val); XMLPUBFUN int XMLCALL - xmlXPathNodeSetAddNs (xmlNodeSetPtr cur, - xmlNodePtr node, - xmlNsPtr ns); +xmlXPathNodeSetAddNs (xmlNodeSetPtr cur, + xmlNodePtr node, + xmlNsPtr ns); XMLPUBFUN void XMLCALL - xmlXPathNodeSetSort (xmlNodeSetPtr set); +xmlXPathNodeSetSort (xmlNodeSetPtr set); XMLPUBFUN void XMLCALL - xmlXPathRoot (xmlXPathParserContextPtr ctxt); +xmlXPathRoot (xmlXPathParserContextPtr ctxt); XMLPUBFUN void XMLCALL - xmlXPathEvalExpr (xmlXPathParserContextPtr ctxt); +xmlXPathEvalExpr (xmlXPathParserContextPtr ctxt); XMLPUBFUN xmlChar * XMLCALL - xmlXPathParseName (xmlXPathParserContextPtr ctxt); +xmlXPathParseName (xmlXPathParserContextPtr ctxt); XMLPUBFUN xmlChar * XMLCALL - xmlXPathParseNCName (xmlXPathParserContextPtr ctxt); +xmlXPathParseNCName (xmlXPathParserContextPtr ctxt); /* * Existing functions. */ XMLPUBFUN double XMLCALL - xmlXPathStringEvalNumber (const xmlChar *str); +xmlXPathStringEvalNumber (const xmlChar *str); XMLPUBFUN int XMLCALL - xmlXPathEvaluatePredicateResult (xmlXPathParserContextPtr ctxt, - xmlXPathObjectPtr res); +xmlXPathEvaluatePredicateResult (xmlXPathParserContextPtr ctxt, + xmlXPathObjectPtr res); XMLPUBFUN void XMLCALL - xmlXPathRegisterAllFunctions (xmlXPathContextPtr ctxt); +xmlXPathRegisterAllFunctions (xmlXPathContextPtr ctxt); XMLPUBFUN xmlNodeSetPtr XMLCALL - xmlXPathNodeSetMerge (xmlNodeSetPtr val1, - xmlNodeSetPtr val2); +xmlXPathNodeSetMerge (xmlNodeSetPtr val1, + xmlNodeSetPtr val2); XMLPUBFUN void XMLCALL - xmlXPathNodeSetDel (xmlNodeSetPtr cur, - xmlNodePtr val); +xmlXPathNodeSetDel (xmlNodeSetPtr cur, + xmlNodePtr val); XMLPUBFUN void XMLCALL - xmlXPathNodeSetRemove (xmlNodeSetPtr cur, - int val); +xmlXPathNodeSetRemove (xmlNodeSetPtr cur, + int val); XMLPUBFUN xmlXPathObjectPtr XMLCALL - xmlXPathNewNodeSetList (xmlNodeSetPtr val); +xmlXPathNewNodeSetList (xmlNodeSetPtr val); XMLPUBFUN xmlXPathObjectPtr XMLCALL - xmlXPathWrapNodeSet (xmlNodeSetPtr val); +xmlXPathWrapNodeSet (xmlNodeSetPtr val); XMLPUBFUN xmlXPathObjectPtr XMLCALL - xmlXPathWrapExternal (void *val); +xmlXPathWrapExternal (void *val); XMLPUBFUN int XMLCALL xmlXPathEqualValues(xmlXPathParserContextPtr ctxt); XMLPUBFUN int XMLCALL xmlXPathNotEqualValues(xmlXPathParserContextPtr ctxt); @@ -564,31 +564,31 @@ XMLPUBFUN int XMLCALL xmlXPathIsNodeType(const xmlChar *name); * Some of the axis navigation routines. */ XMLPUBFUN xmlNodePtr XMLCALL xmlXPathNextSelf(xmlXPathParserContextPtr ctxt, - xmlNodePtr cur); + xmlNodePtr cur); XMLPUBFUN xmlNodePtr XMLCALL xmlXPathNextChild(xmlXPathParserContextPtr ctxt, - xmlNodePtr cur); + xmlNodePtr cur); XMLPUBFUN xmlNodePtr XMLCALL xmlXPathNextDescendant(xmlXPathParserContextPtr ctxt, - xmlNodePtr cur); + xmlNodePtr cur); XMLPUBFUN xmlNodePtr XMLCALL xmlXPathNextDescendantOrSelf(xmlXPathParserContextPtr ctxt, - xmlNodePtr cur); + xmlNodePtr cur); XMLPUBFUN xmlNodePtr XMLCALL xmlXPathNextParent(xmlXPathParserContextPtr ctxt, - xmlNodePtr cur); + xmlNodePtr cur); XMLPUBFUN xmlNodePtr XMLCALL xmlXPathNextAncestorOrSelf(xmlXPathParserContextPtr ctxt, - xmlNodePtr cur); + xmlNodePtr cur); XMLPUBFUN xmlNodePtr XMLCALL xmlXPathNextFollowingSibling(xmlXPathParserContextPtr ctxt, - xmlNodePtr cur); + xmlNodePtr cur); XMLPUBFUN xmlNodePtr XMLCALL xmlXPathNextFollowing(xmlXPathParserContextPtr ctxt, - xmlNodePtr cur); + xmlNodePtr cur); XMLPUBFUN xmlNodePtr XMLCALL xmlXPathNextNamespace(xmlXPathParserContextPtr ctxt, - xmlNodePtr cur); + xmlNodePtr cur); XMLPUBFUN xmlNodePtr XMLCALL xmlXPathNextAttribute(xmlXPathParserContextPtr ctxt, - xmlNodePtr cur); + xmlNodePtr cur); XMLPUBFUN xmlNodePtr XMLCALL xmlXPathNextPreceding(xmlXPathParserContextPtr ctxt, - xmlNodePtr cur); + xmlNodePtr cur); XMLPUBFUN xmlNodePtr XMLCALL xmlXPathNextAncestor(xmlXPathParserContextPtr ctxt, - xmlNodePtr cur); + xmlNodePtr cur); XMLPUBFUN xmlNodePtr XMLCALL xmlXPathNextPrecedingSibling(xmlXPathParserContextPtr ctxt, - xmlNodePtr cur); + xmlNodePtr cur); /* * The official core of XPath functions. */ diff --git a/thirdparties/common/include/libxml2/libxml/xpointer.h b/thirdparties/common/include/libxml2/libxml/xpointer.h index b99112b..7cb05e8 100755 --- a/thirdparties/common/include/libxml2/libxml/xpointer.h +++ b/thirdparties/common/include/libxml2/libxml/xpointer.h @@ -44,68 +44,68 @@ struct _xmlLocationSet { */ XMLPUBFUN xmlLocationSetPtr XMLCALL - xmlXPtrLocationSetCreate (xmlXPathObjectPtr val); +xmlXPtrLocationSetCreate (xmlXPathObjectPtr val); XMLPUBFUN void XMLCALL - xmlXPtrFreeLocationSet (xmlLocationSetPtr obj); +xmlXPtrFreeLocationSet (xmlLocationSetPtr obj); XMLPUBFUN xmlLocationSetPtr XMLCALL - xmlXPtrLocationSetMerge (xmlLocationSetPtr val1, - xmlLocationSetPtr val2); +xmlXPtrLocationSetMerge (xmlLocationSetPtr val1, + xmlLocationSetPtr val2); XMLPUBFUN xmlXPathObjectPtr XMLCALL - xmlXPtrNewRange (xmlNodePtr start, - int startindex, - xmlNodePtr end, - int endindex); +xmlXPtrNewRange (xmlNodePtr start, + int startindex, + xmlNodePtr end, + int endindex); XMLPUBFUN xmlXPathObjectPtr XMLCALL - xmlXPtrNewRangePoints (xmlXPathObjectPtr start, - xmlXPathObjectPtr end); +xmlXPtrNewRangePoints (xmlXPathObjectPtr start, + xmlXPathObjectPtr end); XMLPUBFUN xmlXPathObjectPtr XMLCALL - xmlXPtrNewRangeNodePoint (xmlNodePtr start, - xmlXPathObjectPtr end); +xmlXPtrNewRangeNodePoint (xmlNodePtr start, + xmlXPathObjectPtr end); XMLPUBFUN xmlXPathObjectPtr XMLCALL - xmlXPtrNewRangePointNode (xmlXPathObjectPtr start, - xmlNodePtr end); +xmlXPtrNewRangePointNode (xmlXPathObjectPtr start, + xmlNodePtr end); XMLPUBFUN xmlXPathObjectPtr XMLCALL - xmlXPtrNewRangeNodes (xmlNodePtr start, - xmlNodePtr end); +xmlXPtrNewRangeNodes (xmlNodePtr start, + xmlNodePtr end); XMLPUBFUN xmlXPathObjectPtr XMLCALL - xmlXPtrNewLocationSetNodes (xmlNodePtr start, - xmlNodePtr end); +xmlXPtrNewLocationSetNodes (xmlNodePtr start, + xmlNodePtr end); XMLPUBFUN xmlXPathObjectPtr XMLCALL - xmlXPtrNewLocationSetNodeSet(xmlNodeSetPtr set); +xmlXPtrNewLocationSetNodeSet(xmlNodeSetPtr set); XMLPUBFUN xmlXPathObjectPtr XMLCALL - xmlXPtrNewRangeNodeObject (xmlNodePtr start, - xmlXPathObjectPtr end); +xmlXPtrNewRangeNodeObject (xmlNodePtr start, + xmlXPathObjectPtr end); XMLPUBFUN xmlXPathObjectPtr XMLCALL - xmlXPtrNewCollapsedRange (xmlNodePtr start); +xmlXPtrNewCollapsedRange (xmlNodePtr start); XMLPUBFUN void XMLCALL - xmlXPtrLocationSetAdd (xmlLocationSetPtr cur, - xmlXPathObjectPtr val); +xmlXPtrLocationSetAdd (xmlLocationSetPtr cur, + xmlXPathObjectPtr val); XMLPUBFUN xmlXPathObjectPtr XMLCALL - xmlXPtrWrapLocationSet (xmlLocationSetPtr val); +xmlXPtrWrapLocationSet (xmlLocationSetPtr val); XMLPUBFUN void XMLCALL - xmlXPtrLocationSetDel (xmlLocationSetPtr cur, - xmlXPathObjectPtr val); +xmlXPtrLocationSetDel (xmlLocationSetPtr cur, + xmlXPathObjectPtr val); XMLPUBFUN void XMLCALL - xmlXPtrLocationSetRemove (xmlLocationSetPtr cur, - int val); +xmlXPtrLocationSetRemove (xmlLocationSetPtr cur, + int val); /* * Functions. */ XMLPUBFUN xmlXPathContextPtr XMLCALL - xmlXPtrNewContext (xmlDocPtr doc, - xmlNodePtr here, - xmlNodePtr origin); +xmlXPtrNewContext (xmlDocPtr doc, + xmlNodePtr here, + xmlNodePtr origin); XMLPUBFUN xmlXPathObjectPtr XMLCALL - xmlXPtrEval (const xmlChar *str, - xmlXPathContextPtr ctx); +xmlXPtrEval (const xmlChar *str, + xmlXPathContextPtr ctx); XMLPUBFUN void XMLCALL - xmlXPtrRangeToFunction (xmlXPathParserContextPtr ctxt, - int nargs); +xmlXPtrRangeToFunction (xmlXPathParserContextPtr ctxt, + int nargs); XMLPUBFUN xmlNodePtr XMLCALL - xmlXPtrBuildNodeList (xmlXPathObjectPtr obj); +xmlXPtrBuildNodeList (xmlXPathObjectPtr obj); XMLPUBFUN void XMLCALL - xmlXPtrEvalRangePredicate (xmlXPathParserContextPtr ctxt); +xmlXPtrEvalRangePredicate (xmlXPathParserContextPtr ctxt); #ifdef __cplusplus } #endif |
