pub const U_COPYRIGHT_STRING : & [u8 ; 120] = b" Copyright (C) 2016 and later: Unicode, Inc. and others. License & terms of use: http://www.unicode.org/copyright.html \0" ;
["Offset of field: __mbstate_t::__count"][::std::mem::offset_of!(__mbstate_t, __count) - 0usize];
["Offset of field: __mbstate_t::__value"][::std::mem::offset_of!(__mbstate_t, __value) - 4usize];
["Offset of field: _G_fpos64_t::__state"][::std::mem::offset_of!(_G_fpos64_t, __state) - 8usize];
["Offset of field: _IO_FILE::_shortbuf"][::std::mem::offset_of!(_IO_FILE, _shortbuf) - 131usize];
pub fn fdopen(__fd: ::std::os::raw::c_int, __modes: *const ::std::os::raw::c_char) -> *mut FILE;
pub fn fputc_unlocked(__c: ::std::os::raw::c_int, __stream: *mut FILE) -> ::std::os::raw::c_int;
pub fn putc_unlocked(__c: ::std::os::raw::c_int, __stream: *mut FILE) -> ::std::os::raw::c_int;
pub fn fputs(__s: *const ::std::os::raw::c_char, __stream: *mut FILE) -> ::std::os::raw::c_int;
#[doc = " xmlChar:\n\n This is a basic byte in an UTF-8 encoded string.\n It's unsigned allowing to pinpoint case where char * are assigned\n to xmlChar * (possibly making serialization back impossible)."]
pub fn xmlUTF8Strsize(utf: *const xmlChar, len: ::std::os::raw::c_int) -> ::std::os::raw::c_int;
#[doc = " xmlParserCtxt:\n\n The parser context.\n NOTE This doesn't completely define the parser state, the (current ?)\n design of the parser uses recursive function calls since this allow\n and easy mapping from the production rules of the specification\n to the actual code. The drawback is that the actual function call\n also reflect the parser state. However most of the parsing routines\n takes as the only argument the parser context pointer, so migrating\n to a state based parser for progressive parsing shouldn't be too hard."]
#[doc = " xmlBufferAllocationScheme:\n\n A buffer allocation scheme can be defined to either match exactly the\n need or double it's allocated size each time it is found too small."]
#[doc = " xmlBuffer:\n\n A buffer structure, this old construct is limited to 2GB and\n is being deprecated, use API with xmlBuf instead"]
["Offset of field: _xmlBuffer::content"][::std::mem::offset_of!(_xmlBuffer, content) - 0usize];
#[doc = " xmlBuf:\n\n A buffer structure, new one, the actual structure internals are not public"]
#[doc = " xmlBufPtr:\n\n A pointer to a buffer structure, the actual structure internals are not\n public"]
["Offset of field: _xmlAttribute::type_"][::std::mem::offset_of!(_xmlAttribute, type_) - 8usize];
["Offset of field: _xmlAttribute::name"][::std::mem::offset_of!(_xmlAttribute, name) - 16usize];
["Offset of field: _xmlAttribute::last"][::std::mem::offset_of!(_xmlAttribute, last) - 32usize];
["Offset of field: _xmlAttribute::next"][::std::mem::offset_of!(_xmlAttribute, next) - 48usize];
["Offset of field: _xmlAttribute::prev"][::std::mem::offset_of!(_xmlAttribute, prev) - 56usize];
["Offset of field: _xmlAttribute::nexth"][::std::mem::offset_of!(_xmlAttribute, nexth) - 72usize];
["Offset of field: _xmlAttribute::atype"][::std::mem::offset_of!(_xmlAttribute, atype) - 80usize];
["Offset of field: _xmlAttribute::tree"][::std::mem::offset_of!(_xmlAttribute, tree) - 96usize];
["Offset of field: _xmlAttribute::elem"][::std::mem::offset_of!(_xmlAttribute, elem) - 112usize];
#[doc = " xmlElementContent:\n\n An XML Element content as stored after parsing an element definition\n in a DTD."]
#[doc = " xmlRegexpPtr:\n\n A libxml regular expression, they can actually be far more complex\n thank the POSIX regex expressions."]
#[doc = " xmlRegExecCallbacks:\n @exec: the regular expression context\n @token: the current token string\n @transdata: transition data\n @inputdata: input data\n\n Callback function when doing a transition in the automata"]
["Offset of field: _xmlElement::parent"][::std::mem::offset_of!(_xmlElement, parent) - 40usize];
["Offset of field: _xmlElement::content"][::std::mem::offset_of!(_xmlElement, content) - 80usize];
["Offset of field: _xmlElement::prefix"][::std::mem::offset_of!(_xmlElement, prefix) - 96usize];
#[doc = " xmlNs:\n\n An XML namespace.\n Note that prefix == NULL is valid, it defines the default namespace\n within the subtree (until overridden).\n\n xmlNsType is unified with xmlElementType."]
#[doc = " xmlDtd:\n\n An XML DTD, as defined by <!DOCTYPE ... There is actually one for\n the internal subset and for the external subset."]
["Offset of field: _xmlDtd::attributes"][::std::mem::offset_of!(_xmlDtd, attributes) - 88usize];
["Offset of field: _xmlDtd::ExternalID"][::std::mem::offset_of!(_xmlDtd, ExternalID) - 104usize];
["Offset of field: _xmlDtd::pentities"][::std::mem::offset_of!(_xmlDtd, pentities) - 120usize];
["Offset of field: _xmlNode::properties"][::std::mem::offset_of!(_xmlNode, properties) - 88usize];
#[doc = " xmlDocProperty\n\n Set of properties of the document as found by the parser\n Some of them are linked to similarly named xmlParserOption"]
["Offset of field: _xmlDoc::compression"][::std::mem::offset_of!(_xmlDoc, compression) - 72usize];
["Offset of field: _xmlDoc::standalone"][::std::mem::offset_of!(_xmlDoc, standalone) - 76usize];
["Offset of field: _xmlDoc::parseFlags"][::std::mem::offset_of!(_xmlDoc, parseFlags) - 168usize];
["Offset of field: _xmlDoc::properties"][::std::mem::offset_of!(_xmlDoc, properties) - 172usize];
#[doc = " xmlDOMWrapAcquireNsFunction:\n @ctxt: a DOM wrapper context\n @node: the context node (element or attribute)\n @nsName: the requested namespace name\n @nsPrefix: the requested namespace prefix\n\n A function called to acquire namespaces (xmlNs) from the wrapper.\n\n Returns an xmlNsPtr or NULL in case of an error."]
pub fn xmlSplitQName3(name: *const xmlChar, len: *mut ::std::os::raw::c_int) -> *const xmlChar;
pub fn xmlBufferResize(buf: xmlBufferPtr, size: ::std::os::raw::c_uint) -> ::std::os::raw::c_int;
pub fn xmlBufferShrink(buf: xmlBufferPtr, len: ::std::os::raw::c_uint) -> ::std::os::raw::c_int;
pub fn xmlNewGlobalNs(doc: xmlDocPtr, href: *const xmlChar, prefix: *const xmlChar) -> xmlNsPtr;
pub fn xmlNewDocProp(doc: xmlDocPtr, name: *const xmlChar, value: *const xmlChar) -> xmlAttrPtr;
pub fn xmlNewProp(node: xmlNodePtr, name: *const xmlChar, value: *const xmlChar) -> xmlAttrPtr;
pub fn xmlNewDocPI(doc: xmlDocPtr, name: *const xmlChar, content: *const xmlChar) -> xmlNodePtr;
pub fn xmlSetProp(node: xmlNodePtr, name: *const xmlChar, value: *const xmlChar) -> xmlAttrPtr;
pub fn xmlNodeSetContentLen(cur: xmlNodePtr, content: *const xmlChar, len: ::std::os::raw::c_int);
pub fn xmlNodeAddContentLen(cur: xmlNodePtr, content: *const xmlChar, len: ::std::os::raw::c_int);
pub fn xmlNodeBufGetContent(buffer: xmlBufferPtr, cur: *const xmlNode) -> ::std::os::raw::c_int;
pub fn xmlDocDumpMemory(cur: xmlDocPtr, mem: *mut *mut xmlChar, size: *mut ::std::os::raw::c_int);
pub fn xmlIsXHTML(systemID: *const xmlChar, publicID: *const xmlChar) -> ::std::os::raw::c_int;
#[doc = " xmlFreeFunc:\n @mem: an already allocated block of memory\n\n Signature for a free() implementation."]
#[doc = " xmlMallocFunc:\n @size: the size requested in bytes\n\n Signature for a malloc() implementation.\n\n Returns a pointer to the newly allocated block or NULL in case of error."]
#[doc = " xmlReallocFunc:\n @mem: an already allocated block of memory\n @size: the new size requested in bytes\n\n Signature for a realloc() implementation.\n\n Returns a pointer to the newly reallocated block or NULL in case of error."]
#[doc = " xmlStrdupFunc:\n @str: a zero terminated string\n\n Signature for an strdup() implementation.\n\n Returns the copy of the string or NULL in case of error."]
#[doc = " xmlHashDeallocator:\n @payload: the data in the hash\n @name: the name associated\n\n Callback to free data from a hash."]
#[doc = " xmlHashCopier:\n @payload: the data in the hash\n @name: the name associated\n\n Callback to copy data from a hash.\n\n Returns a copy of the data or NULL in case of error."]
#[doc = " xmlHashScanner:\n @payload: the data in the hash\n @data: extra scanner data\n @name: the name associated\n\n Callback when scanning data in a hash with the simple scanner."]
#[doc = " xmlHashScannerFull:\n @payload: the data in the hash\n @data: extra scanner data\n @name: the name associated\n @name2: the second name associated\n @name3: the third name associated\n\n Callback when scanning data in a hash with the full scanner."]
pub fn xmlHashScan(table: xmlHashTablePtr, f: xmlHashScanner, data: *mut ::std::os::raw::c_void);
pub const xmlParserErrors_XML_SCHEMAP_SRC_RESTRICTION_BASE_OR_SIMPLETYPE: xmlParserErrors = 3005;
pub const xmlParserErrors_XML_SCHEMAP_SRC_UNION_MEMBERTYPES_OR_SIMPLETYPES: xmlParserErrors = 3007;
#[doc = " xmlGenericErrorFunc:\n @ctx: a parsing context\n @msg: the message\n @...: the extra arguments of the varargs to format the message\n\n Signature of the function to use when there is an error and\n no parsing or validity context available ."]
unsafe extern "C" fn(ctx: *mut ::std::os::raw::c_void, msg: *const ::std::os::raw::c_char, ...),
#[doc = " xmlStructuredErrorFunc:\n @userData: user provided data for the error callback\n @error: the error being raised.\n\n Signature of the function to use when there is an error and\n the module handles the new error reporting mechanism."]
pub fn xmlParserError(ctx: *mut ::std::os::raw::c_void, msg: *const ::std::os::raw::c_char, ...);
#[doc = " xmlListDeallocator:\n @lk: the data to deallocate\n\n Callback function used to free data from a list."]
#[doc = " xmlListDataCompare:\n @data0: the first data\n @data1: the second data\n\n Callback function used to compare 2 data.\n\n Returns 0 is equality, -1 or 1 otherwise depending on the ordering."]
#[doc = " xmlListWalker:\n @data: the data found in the list\n @user: extra user provided data to the walker\n\n Callback function used when walking a list with xmlListWalk().\n\n Returns 0 to stop walking the list, 1 otherwise."]
pub fn xmlListCreate(deallocator: xmlListDeallocator, compare: xmlListDataCompare) -> xmlListPtr;
pub fn xmlListInsert(l: xmlListPtr, data: *mut ::std::os::raw::c_void) -> ::std::os::raw::c_int;
pub fn xmlListAppend(l: xmlListPtr, data: *mut ::std::os::raw::c_void) -> ::std::os::raw::c_int;
#[doc = " xmlAutomataPtr:\n\n A libxml automata description, It can be compiled into a regexp"]
#[doc = " xmlValidityErrorFunc:\n @ctx: usually an xmlValidCtxtPtr to a validity error context,\n but comes from ctxt->userData (which normally contains such\n a pointer); ctxt->userData can be changed by the user.\n @msg: the string to format *printf like vararg\n @...: remaining arguments to the format\n\n Callback called when a validity error is found. This is a message\n oriented function similar to an *printf function."]
unsafe extern "C" fn(ctx: *mut ::std::os::raw::c_void, msg: *const ::std::os::raw::c_char, ...),
#[doc = " xmlValidityWarningFunc:\n @ctx: usually an xmlValidCtxtPtr to a validity error context,\n but comes from ctxt->userData (which normally contains such\n a pointer); ctxt->userData can be changed by the user.\n @msg: the string to format *printf like vararg\n @...: remaining arguments to the format\n\n Callback called when a validity warning is found. This is a message\n oriented function similar to an *printf function."]
unsafe extern "C" fn(ctx: *mut ::std::os::raw::c_void, msg: *const ::std::os::raw::c_char, ...),
["Offset of field: _xmlValidCtxt::error"][::std::mem::offset_of!(_xmlValidCtxt, error) - 8usize];
["Offset of field: _xmlValidCtxt::node"][::std::mem::offset_of!(_xmlValidCtxt, node) - 24usize];
["Offset of field: _xmlValidCtxt::valid"][::std::mem::offset_of!(_xmlValidCtxt, valid) - 64usize];
pub fn xmlValidateDocumentFinal(ctxt: xmlValidCtxtPtr, doc: xmlDocPtr) -> ::std::os::raw::c_int;
["Offset of field: _xmlEntity::_private"][::std::mem::offset_of!(_xmlEntity, _private) - 0usize];
["Offset of field: _xmlEntity::children"][::std::mem::offset_of!(_xmlEntity, children) - 24usize];
["Offset of field: _xmlEntity::content"][::std::mem::offset_of!(_xmlEntity, content) - 80usize];
["Offset of field: _xmlEntity::checked"][::std::mem::offset_of!(_xmlEntity, checked) - 132usize];
#[doc = " xmlParserInputDeallocate:\n @str: the string to deallocate\n\n Callback for freeing some parser input allocations."]
pub type xmlParserInputDeallocate = ::std::option::Option<unsafe extern "C" fn(str_: *mut xmlChar)>;
["Offset of field: _xmlParserInput::buf"][::std::mem::offset_of!(_xmlParserInput, buf) - 0usize];
["Offset of field: _xmlParserInput::cur"][::std::mem::offset_of!(_xmlParserInput, cur) - 32usize];
["Offset of field: _xmlParserInput::end"][::std::mem::offset_of!(_xmlParserInput, end) - 40usize];
["Offset of field: _xmlParserInput::col"][::std::mem::offset_of!(_xmlParserInput, col) - 56usize];
["Offset of field: _xmlParserInput::id"][::std::mem::offset_of!(_xmlParserInput, id) - 100usize];
#[doc = " xmlParserNodeInfo:\n\n The parser can be asked to collect Node information, i.e. at what\n place in the file they were detected.\n NOTE: This is off by default and not very well tested."]
["Alignment of _xmlParserNodeInfoSeq"][::std::mem::align_of::<_xmlParserNodeInfoSeq>() - 8usize];
#[doc = " xmlParserInputState:\n\n The parser is now working also as a state based parser.\n The recursive one use the state info for entities processing."]
#[doc = " xmlParserCtxt:\n\n The parser context.\n NOTE This doesn't completely define the parser state, the (current ?)\n design of the parser uses recursive function calls since this allow\n and easy mapping from the production rules of the specification\n to the actual code. The drawback is that the actual function call\n also reflect the parser state. However most of the parsing routines\n takes as the only argument the parser context pointer, so migrating\n to a state based parser for progressive parsing shouldn't be too hard."]
["Offset of field: _xmlParserCtxt::sax"][::std::mem::offset_of!(_xmlParserCtxt, sax) - 0usize];
["Offset of field: _xmlParserCtxt::html"][::std::mem::offset_of!(_xmlParserCtxt, html) - 52usize];
["Offset of field: _xmlParserCtxt::node"][::std::mem::offset_of!(_xmlParserCtxt, node) - 80usize];
::std::option::Option<unsafe extern "C" fn(ctx: *mut ::std::os::raw::c_void) -> *const xmlChar>,
::std::option::Option<unsafe extern "C" fn(ctx: *mut ::std::os::raw::c_void) -> *const xmlChar>,
#[doc = " resolveEntitySAXFunc:\n @ctx: the user data (XML parser context)\n @publicId: The public ID of the entity\n @systemId: The system ID of the entity\n\n Callback:\n The entity loader, to control the loading of external entities,\n the application can either:\n - override this resolveEntity() callback in the SAX block\n - or better use the xmlSetExternalEntityLoader() function to\n set up it's own entity resolution routine\n\n Returns the xmlParserInputPtr if inlined or NULL for DOM behaviour."]
#[doc = " internalSubsetSAXFunc:\n @ctx: the user data (XML parser context)\n @name: the root element name\n @ExternalID: the external ID\n @SystemID: the SYSTEM ID (e.g. filename or URL)\n\n Callback on internal subset declaration."]
#[doc = " externalSubsetSAXFunc:\n @ctx: the user data (XML parser context)\n @name: the root element name\n @ExternalID: the external ID\n @SystemID: the SYSTEM ID (e.g. filename or URL)\n\n Callback on external subset declaration."]
#[doc = " getEntitySAXFunc:\n @ctx: the user data (XML parser context)\n @name: The entity name\n\n Get an entity by name.\n\n Returns the xmlEntityPtr if found."]
#[doc = " getParameterEntitySAXFunc:\n @ctx: the user data (XML parser context)\n @name: The entity name\n\n Get a parameter entity by name.\n\n Returns the xmlEntityPtr if found."]
#[doc = " entityDeclSAXFunc:\n @ctx: the user data (XML parser context)\n @name: the entity name\n @type: the entity type\n @publicId: The public ID of the entity\n @systemId: The system ID of the entity\n @content: the entity value (without processing).\n\n An entity definition has been parsed."]
#[doc = " notationDeclSAXFunc:\n @ctx: the user data (XML parser context)\n @name: The name of the notation\n @publicId: The public ID of the entity\n @systemId: The system ID of the entity\n\n What to do when a notation declaration has been parsed."]
#[doc = " attributeDeclSAXFunc:\n @ctx: the user data (XML parser context)\n @elem: the name of the element\n @fullname: the attribute name\n @type: the attribute type\n @def: the type of default value\n @defaultValue: the attribute default value\n @tree: the tree of enumerated value set\n\n An attribute definition has been parsed."]
#[doc = " elementDeclSAXFunc:\n @ctx: the user data (XML parser context)\n @name: the element name\n @type: the element type\n @content: the element value tree\n\n An element definition has been parsed."]
#[doc = " unparsedEntityDeclSAXFunc:\n @ctx: the user data (XML parser context)\n @name: The name of the entity\n @publicId: The public ID of the entity\n @systemId: The system ID of the entity\n @notationName: the name of the notation\n\n What to do when an unparsed entity declaration is parsed."]
#[doc = " setDocumentLocatorSAXFunc:\n @ctx: the user data (XML parser context)\n @loc: A SAX Locator\n\n Receive the document locator at startup, actually xmlDefaultSAXLocator.\n Everything is available on the context, so this is useless in our case."]
#[doc = " startDocumentSAXFunc:\n @ctx: the user data (XML parser context)\n\n Called when the document start being processed."]
#[doc = " endDocumentSAXFunc:\n @ctx: the user data (XML parser context)\n\n Called when the document end has been detected."]
#[doc = " startElementSAXFunc:\n @ctx: the user data (XML parser context)\n @name: The element name, including namespace prefix\n @atts: An array of name/value attributes pairs, NULL terminated\n\n Called when an opening tag has been processed."]
#[doc = " endElementSAXFunc:\n @ctx: the user data (XML parser context)\n @name: The element name\n\n Called when the end of an element has been detected."]
#[doc = " attributeSAXFunc:\n @ctx: the user data (XML parser context)\n @name: The attribute name, including namespace prefix\n @value: The attribute value\n\n Handle an attribute that has been read by the parser.\n The default handling is to convert the attribute into an\n DOM subtree and past it in a new xmlAttr element added to\n the element."]
#[doc = " referenceSAXFunc:\n @ctx: the user data (XML parser context)\n @name: The entity name\n\n Called when an entity reference is detected."]
#[doc = " charactersSAXFunc:\n @ctx: the user data (XML parser context)\n @ch: a xmlChar string\n @len: the number of xmlChar\n\n Receiving some chars from the parser."]
#[doc = " ignorableWhitespaceSAXFunc:\n @ctx: the user data (XML parser context)\n @ch: a xmlChar string\n @len: the number of xmlChar\n\n Receiving some ignorable whitespaces from the parser.\n UNUSED: by default the DOM building will use characters."]
#[doc = " processingInstructionSAXFunc:\n @ctx: the user data (XML parser context)\n @target: the target name\n @data: the PI data's\n\n A processing instruction has been parsed."]
#[doc = " commentSAXFunc:\n @ctx: the user data (XML parser context)\n @value: the comment content\n\n A comment has been parsed."]
#[doc = " cdataBlockSAXFunc:\n @ctx: the user data (XML parser context)\n @value: The pcdata content\n @len: the block length\n\n Called when a pcdata block has been parsed."]
#[doc = " warningSAXFunc:\n @ctx: an XML parser context\n @msg: the message to display/transmit\n @...: extra parameters for the message display\n\n Display and format a warning messages, callback."]
unsafe extern "C" fn(ctx: *mut ::std::os::raw::c_void, msg: *const ::std::os::raw::c_char, ...),
#[doc = " errorSAXFunc:\n @ctx: an XML parser context\n @msg: the message to display/transmit\n @...: extra parameters for the message display\n\n Display and format an error messages, callback."]
unsafe extern "C" fn(ctx: *mut ::std::os::raw::c_void, msg: *const ::std::os::raw::c_char, ...),
#[doc = " fatalErrorSAXFunc:\n @ctx: an XML parser context\n @msg: the message to display/transmit\n @...: extra parameters for the message display\n\n Display and format fatal error messages, callback.\n Note: so far fatalError() SAX callbacks are not used, error()\n get all the callbacks for errors."]
unsafe extern "C" fn(ctx: *mut ::std::os::raw::c_void, msg: *const ::std::os::raw::c_char, ...),
#[doc = " isStandaloneSAXFunc:\n @ctx: the user data (XML parser context)\n\n Is this document tagged standalone?\n\n Returns 1 if true"]
#[doc = " hasInternalSubsetSAXFunc:\n @ctx: the user data (XML parser context)\n\n Does this document has an internal subset.\n\n Returns 1 if true"]
#[doc = " hasExternalSubsetSAXFunc:\n @ctx: the user data (XML parser context)\n\n Does this document has an external subset?\n\n Returns 1 if true"]
#[doc = " startElementNsSAX2Func:\n @ctx: the user data (XML parser context)\n @localname: the local name of the element\n @prefix: the element namespace prefix if available\n @URI: the element namespace name if available\n @nb_namespaces: number of namespace definitions on that node\n @namespaces: pointer to the array of prefix/URI pairs namespace definitions\n @nb_attributes: the number of attributes on that node\n @nb_defaulted: the number of defaulted attributes. The defaulted\n ones are at the end of the array\n @attributes: pointer to the array of (localname/prefix/URI/value/end)\n attribute values.\n\n SAX2 callback when an element start has been detected by the parser.\n It provides the namespace information for the element, as well as\n the new namespace declarations on the element."]
#[doc = " endElementNsSAX2Func:\n @ctx: the user data (XML parser context)\n @localname: the local name of the element\n @prefix: the element namespace prefix if available\n @URI: the element namespace name if available\n\n SAX2 callback when an element end has been detected by the parser.\n It provides the namespace information for the element."]
#[doc = " xmlExternalEntityLoader:\n @URL: The System ID of the resource requested\n @ID: The Public ID of the resource requested\n @context: the XML parser context\n\n External entity loaders types.\n\n Returns the entity input parser."]
pub fn u_versionToString_74(versionArray: *const u8, versionString: *mut ::std::os::raw::c_char);
["Size of UConverterToUnicodeArgs"][::std::mem::size_of::<UConverterToUnicodeArgs>() - 56usize];
pub fn ucnv_getStandard_74(n: u16, pErrorCode: *mut UErrorCode) -> *const ::std::os::raw::c_char;
#[doc = " xmlCharEncodingInputFunc:\n @out: a pointer to an array of bytes to store the UTF-8 result\n @outlen: the length of @out\n @in: a pointer to an array of chars in the original encoding\n @inlen: the length of @in\n\n Take a block of chars in the original encoding and try to convert\n it to an UTF-8 block of chars out.\n\n Returns the number of bytes written, -1 if lack of space, or -2\n if the transcoding failed.\n The value of @inlen after return is the number of octets consumed\n if the return value is positive, else unpredictiable.\n The value of @outlen after return is the number of octets consumed."]
#[doc = " xmlCharEncodingOutputFunc:\n @out: a pointer to an array of bytes to store the result\n @outlen: the length of @out\n @in: a pointer to an array of UTF-8 chars\n @inlen: the length of @in\n\n Take a block of UTF-8 chars in and try to convert it to another\n encoding.\n Note: a first call designed to produce heading info is called with\n in = NULL. If stateful this should also initialize the encoder state.\n\n Returns the number of bytes written, -1 if lack of space, or -2\n if the transcoding failed.\n The value of @inlen after return is the number of octets consumed\n if the return value is positive, else unpredictiable.\n The value of @outlen after return is the number of octets produced."]
["Offset of field: _uconv_t::pivot_buf"][::std::mem::offset_of!(_uconv_t, pivot_buf) - 16usize];
["Size of _xmlCharEncodingHandler"][::std::mem::size_of::<_xmlCharEncodingHandler>() - 56usize];
#[doc = " xmlInputMatchCallback:\n @filename: the filename or URI\n\n Callback used in the I/O Input API to detect if the current handler\n can provide input functionality for this resource.\n\n Returns 1 if yes and 0 if another Input module should be used"]
#[doc = " xmlInputOpenCallback:\n @filename: the filename or URI\n\n Callback used in the I/O Input API to open the resource\n\n Returns an Input context or NULL in case or error"]
#[doc = " xmlInputReadCallback:\n @context: an Input context\n @buffer: the buffer to store data read\n @len: the length of the buffer in bytes\n\n Callback used in the I/O Input API to read the resource\n\n Returns the number of bytes read or -1 in case of error"]
#[doc = " xmlInputCloseCallback:\n @context: an Input context\n\n Callback used in the I/O Input API to close the resource\n\n Returns 0 or -1 in case of error"]
#[doc = " xmlOutputMatchCallback:\n @filename: the filename or URI\n\n Callback used in the I/O Output API to detect if the current handler\n can provide output functionality for this resource.\n\n Returns 1 if yes and 0 if another Output module should be used"]
#[doc = " xmlOutputOpenCallback:\n @filename: the filename or URI\n\n Callback used in the I/O Output API to open the resource\n\n Returns an Output context or NULL in case or error"]
#[doc = " xmlOutputWriteCallback:\n @context: an Output context\n @buffer: the buffer of data to write\n @len: the length of the buffer in bytes\n\n Callback used in the I/O Output API to write to the resource\n\n Returns the number of bytes written or -1 in case of error"]
#[doc = " xmlOutputCloseCallback:\n @context: an Output context\n\n Callback used in the I/O Output API to close the resource\n\n Returns 0 or -1 in case of error"]
["Alignment of _xmlParserInputBuffer"][::std::mem::align_of::<_xmlParserInputBuffer>() - 8usize];
#[doc = " xmlParserOption:\n\n This is the set of XML parser options that can be passed down\n to the xmlReadDoc() and similar calls."]
#[doc = " xmlFeature:\n\n Used to examine the existence of features that can be enabled\n or disabled at compile-time.\n They used to be called XML_FEATURE_xxx but this clashed with Expat"]
["Alignment of __atomic_wide_counter"][::std::mem::align_of::<__atomic_wide_counter>() - 8usize];
["Size of __pthread_internal_list"][::std::mem::size_of::<__pthread_internal_list>() - 16usize];
["Size of __pthread_internal_slist"][::std::mem::size_of::<__pthread_internal_slist>() - 8usize];
["Size of __pthread_rwlock_arch_t"][::std::mem::size_of::<__pthread_rwlock_arch_t>() - 56usize];
["Offset of field: __once_flag::__data"][::std::mem::offset_of!(__once_flag, __data) - 0usize];
["Alignment of pthread_rwlockattr_t"][::std::mem::align_of::<pthread_rwlockattr_t>() - 8usize];
["Alignment of pthread_barrierattr_t"][::std::mem::align_of::<pthread_barrierattr_t>() - 4usize];
["Offset of field: random_data::end_ptr"][::std::mem::offset_of!(random_data, end_ptr) - 40usize];
["Offset of field: drand48_data::__init"][::std::mem::offset_of!(drand48_data, __init) - 14usize];
pub fn mbstowcs(__pwcs: *mut wchar_t, __s: *const ::std::os::raw::c_char, __n: usize) -> usize;
pub fn wcstombs(__s: *mut ::std::os::raw::c_char, __pwcs: *const wchar_t, __n: usize) -> usize;
pub fn getloadavg(__loadavg: *mut f64, __nelem: ::std::os::raw::c_int) -> ::std::os::raw::c_int;
#[doc = " Various defines for the various Link properties.\n\n NOTE: the link detection layer will try to resolve QName expansion\n of namespaces. If \"foo\" is the prefix for \"http://foo.com/\"\n then the link detection layer will expand role=\"foo:myrole\"\n to \"http://foo.com/:myrole\".\n NOTE: the link detection layer will expand URI-References found on\n href attributes by using the base mechanism if found."]
#[doc = " xlinkNodeDetectFunc:\n @ctx: user data pointer\n @node: the node to check\n\n This is the prototype for the link detection routine.\n It calls the default link detection callbacks upon link detection."]
::std::option::Option<unsafe extern "C" fn(ctx: *mut ::std::os::raw::c_void, node: xmlNodePtr)>;
#[doc = " xlinkSimpleLinkFunk:\n @ctx: user data pointer\n @node: the node carrying the link\n @href: the target of the link\n @role: the role string\n @title: the link title\n\n This is the prototype for a simple link detection callback."]
#[doc = " xlinkExtendedLinkFunk:\n @ctx: user data pointer\n @node: the node carrying the link\n @nbLocators: the number of locators detected on the link\n @hrefs: pointer to the array of locator hrefs\n @roles: pointer to the array of locator roles\n @nbArcs: the number of arcs detected on the link\n @from: pointer to the array of source roles found on the arcs\n @to: pointer to the array of target roles found on the arcs\n @show: array of values for the show attributes found on the arcs\n @actuate: array of values for the actuate attributes found on the arcs\n @nbTitles: the number of titles detected on the link\n @title: array of titles detected on the link\n @langs: array of xml:lang values for the titles\n\n This is the prototype for a extended link detection callback."]
#[doc = " xlinkExtendedLinkSetFunk:\n @ctx: user data pointer\n @node: the node carrying the link\n @nbLocators: the number of locators detected on the link\n @hrefs: pointer to the array of locator hrefs\n @roles: pointer to the array of locator roles\n @nbTitles: the number of titles detected on the link\n @title: array of titles detected on the link\n @langs: array of xml:lang values for the titles\n\n This is the prototype for a extended link set detection callback."]
#[doc = " This is the structure containing a set of Links detection callbacks.\n\n There is no default xlink callbacks, if one want to get link\n recognition activated, those call backs must be provided before parsing."]
pub fn xmlSAX2GetEntity(ctx: *mut ::std::os::raw::c_void, name: *const xmlChar) -> xmlEntityPtr;
#[doc = " xmlParserInputBufferCreateFilenameFunc:\n @URI: the URI to read from\n @enc: the requested source encoding\n\n Signature for the function doing the lookup for a suitable input method\n corresponding to an URI.\n\n Returns the new xmlParserInputBufferPtr in case of success or NULL if no\n method was found."]
#[doc = " xmlOutputBufferCreateFilenameFunc:\n @URI: the URI to write to\n @enc: the requested target encoding\n\n Signature for the function doing the lookup for a suitable output method\n corresponding to an URI.\n\n Returns the new xmlOutputBufferPtr in case of success or NULL if no\n method was found."]
#[doc = " xmlRegisterNodeFunc:\n @node: the current node\n\n Signature for the registration callback of a created node"]
#[doc = " xmlDeregisterNodeFunc:\n @node: the current node\n\n Signature for the deregistration callback of a discarded node"]
pub type xmlDeregisterNodeFunc = ::std::option::Option<unsafe extern "C" fn(node: xmlNodePtr)>;
pub fn __xmlParserInputBufferCreateFilenameValue() -> *mut xmlParserInputBufferCreateFilenameFunc;
#[doc = " xmlXPathContext:\n\n Expression evaluation occurs with respect to a context.\n he context consists of:\n - a node (the context node)\n - a node list (the context node list)\n - a set of variable bindings\n - a function library\n - the set of namespace declarations in scope for the expression\n Following the switch to hash tables, this need to be trimmed up at\n the next binary incompatible release.\n The node may be modified when the context is passed to libxml2\n for an XPath evaluation so you may need to initialize it again\n before the next call."]
#[doc = " xmlXPathParserContext:\n\n An XPath parser context. It contains pure parsing information,\n an xmlXPathContext, and the stack of objects."]
["Offset of field: _xmlNodeSet::nodeNr"][::std::mem::offset_of!(_xmlNodeSet, nodeNr) - 0usize];
["Offset of field: _xmlNodeSet::nodeMax"][::std::mem::offset_of!(_xmlNodeSet, nodeMax) - 4usize];
["Offset of field: _xmlNodeSet::nodeTab"][::std::mem::offset_of!(_xmlNodeSet, nodeTab) - 8usize];
#[doc = " xmlXPathConvertFunc:\n @obj: an XPath object\n @type: the number of the target type\n\n A conversion function is associated to a type and used to cast\n the new type to primitive values.\n\n Returns -1 in case of error, 0 otherwise"]
["Offset of field: _xmlXPathType::name"][::std::mem::offset_of!(_xmlXPathType, name) - 0usize];
["Offset of field: _xmlXPathType::func"][::std::mem::offset_of!(_xmlXPathType, func) - 8usize];
#[doc = " xmlXPathEvalFunc:\n @ctxt: an XPath parser context\n @nargs: the number of arguments passed to the function\n\n An XPath evaluation function, the parameters are on the XPath context stack."]
["Offset of field: _xmlXPathFunct::name"][::std::mem::offset_of!(_xmlXPathFunct, name) - 0usize];
["Offset of field: _xmlXPathFunct::func"][::std::mem::offset_of!(_xmlXPathFunct, func) - 8usize];
#[doc = " xmlXPathAxisFunc:\n @ctxt: the XPath interpreter context\n @cur: the previous node being explored on that axis\n\n An axis traversal function. To traverse an axis, the engine calls\n the first time with cur == NULL and repeat until the function returns\n NULL indicating the end of the axis traversal.\n\n Returns the next node in that axis or NULL if at the end of the axis."]
unsafe extern "C" fn(ctxt: xmlXPathParserContextPtr, cur: xmlXPathObjectPtr) -> xmlXPathObjectPtr,
["Offset of field: _xmlXPathAxis::name"][::std::mem::offset_of!(_xmlXPathAxis, name) - 0usize];
["Offset of field: _xmlXPathAxis::func"][::std::mem::offset_of!(_xmlXPathAxis, func) - 8usize];
#[doc = " xmlXPathFunction:\n @ctxt: the XPath interprestation context\n @nargs: the number of arguments\n\n An XPath function.\n The arguments (if any) are popped out from the context stack\n and the result is pushed on the stack."]
#[doc = " xmlXPathVariableLookupFunc:\n @ctxt: an XPath context\n @name: name of the variable\n @ns_uri: the namespace name hosting this variable\n\n Prototype for callbacks used to plug variable lookup in the XPath\n engine.\n\n Returns the XPath object value or NULL if not found."]
#[doc = " xmlXPathFuncLookupFunc:\n @ctxt: an XPath context\n @name: name of the function\n @ns_uri: the namespace name hosting this function\n\n Prototype for callbacks used to plug function lookup in the XPath\n engine.\n\n Returns the XPath function or NULL if not found."]
#[doc = " xmlXPathContext:\n\n Expression evaluation occurs with respect to a context.\n he context consists of:\n - a node (the context node)\n - a node list (the context node list)\n - a set of variable bindings\n - a function library\n - the set of namespace declarations in scope for the expression\n Following the switch to hash tables, this need to be trimmed up at\n the next binary incompatible release.\n The node may be modified when the context is passed to libxml2\n for an XPath evaluation so you may need to initialize it again\n before the next call."]
#[doc = " xmlXPathParserContext:\n\n An XPath parser context. It contains pure parsing information,\n an xmlXPathContext, and the stack of objects."]
#[doc = " This is the core C14N function\n/\n/**\n xmlC14NIsVisibleCallback:\n @user_data: user data\n @node: the current node\n @parent: the parent node\n\n Signature for a C14N callback on visible nodes\n\n Returns 1 if the node should be included"]
pub fn xmlACatalogRemove(catal: xmlCatalogPtr, value: *const xmlChar) -> ::std::os::raw::c_int;
#[doc = " xmlParserCtxt:\n\n The parser context.\n NOTE This doesn't completely define the parser state, the (current ?)\n design of the parser uses recursive function calls since this allow\n and easy mapping from the production rules of the specification\n to the actual code. The drawback is that the actual function call\n also reflect the parser state. However most of the parsing routines\n takes as the only argument the parser context pointer, so migrating\n to a state based parser for progressive parsing shouldn't be too hard."]
["Offset of field: _htmlElemDesc::name"][::std::mem::offset_of!(_htmlElemDesc, name) - 0usize];
["Offset of field: _htmlElemDesc::empty"][::std::mem::offset_of!(_htmlElemDesc, empty) - 11usize];
["Offset of field: _htmlElemDesc::depr"][::std::mem::offset_of!(_htmlElemDesc, depr) - 12usize];
["Offset of field: _htmlElemDesc::dtd"][::std::mem::offset_of!(_htmlElemDesc, dtd) - 13usize];
["Offset of field: _htmlElemDesc::desc"][::std::mem::offset_of!(_htmlElemDesc, desc) - 16usize];
pub fn htmlParseDoc(cur: *const xmlChar, encoding: *const ::std::os::raw::c_char) -> htmlDocPtr;
#[doc = " xmlParserOption:\n\n This is the set of XML parser options that can be passed down\n to the xmlReadDoc() and similar calls."]
pub fn htmlElementStatusHere(arg1: *const htmlElemDesc, arg2: *const htmlElemDesc) -> htmlStatus;
pub fn htmlSetMetaEncoding(doc: htmlDocPtr, encoding: *const xmlChar) -> ::std::os::raw::c_int;
pub fn htmlNodeDump(buf: xmlBufferPtr, doc: xmlDocPtr, cur: xmlNodePtr) -> ::std::os::raw::c_int;
#[doc = " ftpListCallback:\n @userData: user provided data for the callback\n @filename: the file name (including \"->\" when links are shown)\n @attrib: the attribute string\n @owner: the owner string\n @group: the group string\n @size: the file size\n @links: the link count\n @year: the year\n @month: the month\n @day: the day\n @hour: the hour\n @minute: the minute\n\n A callback for the xmlNanoFTPList command.\n Note that only one of year and day:minute are specified."]
#[doc = " ftpDataCallback:\n @userData: the user provided context\n @data: the data received\n @len: its size in bytes\n\n A callback for the xmlNanoFTPGet command."]
pub fn xmlNanoHTTPAuthHeader(ctx: *mut ::std::os::raw::c_void) -> *const ::std::os::raw::c_char;
pub fn xmlNanoHTTPEncoding(ctx: *mut ::std::os::raw::c_void) -> *const ::std::os::raw::c_char;
pub fn xmlNanoHTTPMimeType(ctx: *mut ::std::os::raw::c_void) -> *const ::std::os::raw::c_char;
#[doc = " xmlParserMaxDepth:\n\n arbitrary depth limit for the XML documents that we allow to\n process. This is not a limitation of the parser but a safety\n boundary feature, use XML_PARSE_HUGE option to override it."]
pub fn xmlSwitchEncoding(ctxt: xmlParserCtxtPtr, enc: xmlCharEncoding) -> ::std::os::raw::c_int;
pub fn xmlPushInput(ctxt: xmlParserCtxtPtr, input: xmlParserInputPtr) -> ::std::os::raw::c_int;
#[doc = " xmlEntityReferenceFunc:\n @ent: the entity\n @firstNode: the fist node in the chunk\n @lastNode: the last nod in the chunk\n\n Callback function used when one needs to be able to track back the\n provenance of a chunk of nodes inherited from an entity replacement."]
pub fn xmlNamespaceParseQName(ctxt: xmlParserCtxtPtr, prefix: *mut *mut xmlChar) -> *mut xmlChar;
#[doc = " xmlPatternFlags:\n\n This is the set of options affecting the behaviour of pattern\n matching with this module\n"]
#[doc = " xmlRelaxNGValidityErrorFunc:\n @ctx: the validation context\n @msg: the message\n @...: extra arguments\n\n Signature of an error callback from a Relax-NG validation"]
unsafe extern "C" fn(ctx: *mut ::std::os::raw::c_void, msg: *const ::std::os::raw::c_char, ...),
#[doc = " xmlRelaxNGValidityWarningFunc:\n @ctx: the validation context\n @msg: the message\n @...: extra arguments\n\n Signature of a warning callback from a Relax-NG validation"]
unsafe extern "C" fn(ctx: *mut ::std::os::raw::c_void, msg: *const ::std::os::raw::c_char, ...),
pub fn xmlRelaxNGNewParserCtxt(URL: *const ::std::os::raw::c_char) -> xmlRelaxNGParserCtxtPtr;
pub const xmlSchemaContentType_XML_SCHEMA_CONTENT_MIXED_OR_ELEMENTS: xmlSchemaContentType = 5;
#[doc = " xmlSchemaAttributeLink:\n Used to build a list of attribute uses on complexType definitions.\n WARNING: Deprecated; not used."]
["Size of _xmlSchemaAttributeLink"][::std::mem::size_of::<_xmlSchemaAttributeLink>() - 16usize];
["Alignment of _xmlSchemaWildcardNs"][::std::mem::align_of::<_xmlSchemaWildcardNs>() - 8usize];
#[doc = " An attribute group definition.\n\n xmlSchemaAttribute and xmlSchemaAttributeGroup start of structures\n must be kept similar"]
#[doc = " xmlSchemaTypeLink:\n Used to build a list of types (e.g. member types of\n simpleType with variety \"union\")."]
["Offset of field: _xmlSchemaType::next"][::std::mem::offset_of!(_xmlSchemaType, next) - 8usize];
["Offset of field: _xmlSchemaType::name"][::std::mem::offset_of!(_xmlSchemaType, name) - 16usize];
["Offset of field: _xmlSchemaType::id"][::std::mem::offset_of!(_xmlSchemaType, id) - 24usize];
["Offset of field: _xmlSchemaType::ref_"][::std::mem::offset_of!(_xmlSchemaType, ref_) - 32usize];
["Offset of field: _xmlSchemaType::node"][::std::mem::offset_of!(_xmlSchemaType, node) - 72usize];
["Offset of field: _xmlSchemaType::base"][::std::mem::offset_of!(_xmlSchemaType, base) - 96usize];
["Offset of field: _xmlSchemaFacet::id"][::std::mem::offset_of!(_xmlSchemaFacet, id) - 24usize];
["Offset of field: _xmlSchemaFacet::val"][::std::mem::offset_of!(_xmlSchemaFacet, val) - 56usize];
["Offset of field: _xmlSchema::version"][::std::mem::offset_of!(_xmlSchema, version) - 16usize];
["Offset of field: _xmlSchema::typeDecl"][::std::mem::offset_of!(_xmlSchema, typeDecl) - 56usize];
["Offset of field: _xmlSchema::attrDecl"][::std::mem::offset_of!(_xmlSchema, attrDecl) - 64usize];
["Offset of field: _xmlSchema::elemDecl"][::std::mem::offset_of!(_xmlSchema, elemDecl) - 80usize];
["Offset of field: _xmlSchema::notaDecl"][::std::mem::offset_of!(_xmlSchema, notaDecl) - 88usize];
["Offset of field: _xmlSchema::counter"][::std::mem::offset_of!(_xmlSchema, counter) - 140usize];
["Offset of field: _xmlSchema::idcDef"][::std::mem::offset_of!(_xmlSchema, idcDef) - 144usize];
pub const xmlSchematronValidOptions_XML_SCHEMATRON_OUT_BUFFER: xmlSchematronValidOptions = 512;
#[doc = " xmlSchematronValidityErrorFunc:\n @ctx: the validation context\n @msg: the message\n @...: extra arguments\n\n Signature of an error callback from a Schematron validation"]
unsafe extern "C" fn(ctx: *mut ::std::os::raw::c_void, msg: *const ::std::os::raw::c_char, ...),
#[doc = " xmlSchematronValidityWarningFunc:\n @ctx: the validation context\n @msg: the message\n @...: extra arguments\n\n Signature of a warning callback from a Schematron validation"]
unsafe extern "C" fn(ctx: *mut ::std::os::raw::c_void, msg: *const ::std::os::raw::c_char, ...),
#[doc = "XMLPUBFUN void XMLCALL\nxmlSchematronSetParserErrors(xmlSchematronParserCtxtPtr ctxt,\nxmlSchematronValidityErrorFunc err,\nxmlSchematronValidityWarningFunc warn,\nvoid *ctx);\nXMLPUBFUN int XMLCALL\nxmlSchematronGetParserErrors(xmlSchematronParserCtxtPtr ctxt,\nxmlSchematronValidityErrorFunc * err,\nxmlSchematronValidityWarningFunc * warn,\nvoid **ctx);\nXMLPUBFUN int XMLCALL\nxmlSchematronIsValid\t(xmlSchematronValidCtxtPtr ctxt);"]
#[doc = "XMLPUBFUN void XMLCALL\nxmlSchematronSetValidErrors\t(xmlSchematronValidCtxtPtr ctxt,\nxmlSchematronValidityErrorFunc err,\nxmlSchematronValidityWarningFunc warn,\nvoid *ctx);\nXMLPUBFUN int XMLCALL\nxmlSchematronGetValidErrors\t(xmlSchematronValidCtxtPtr ctxt,\nxmlSchematronValidityErrorFunc *err,\nxmlSchematronValidityWarningFunc *warn,\nvoid **ctx);\nXMLPUBFUN int XMLCALL\nxmlSchematronSetValidOptions(xmlSchematronValidCtxtPtr ctxt,\nint options);\nXMLPUBFUN int XMLCALL\nxmlSchematronValidCtxtGetOptions(xmlSchematronValidCtxtPtr ctxt);\nXMLPUBFUN int XMLCALL\nxmlSchematronValidateOneElement (xmlSchematronValidCtxtPtr ctxt,\nxmlNodePtr elem);"]
#[doc = " xmlURI:\n\n A parsed URI reference. This is a struct containing the various fields\n as described in RFC 2396 but separated for further processing.\n\n Note: query is a deprecated field which is incorrectly unescaped.\n query_raw takes precedence over query if the former is set.\n See: http://mail.gnome.org/archives/xml/2007-April/thread.html#00127"]
["Offset of field: _xmlURI::authority"][::std::mem::offset_of!(_xmlURI, authority) - 16usize];
["Offset of field: _xmlURI::query_raw"][::std::mem::offset_of!(_xmlURI, query_raw) - 80usize];
#[doc = " xmlModuleOption:\n\n enumeration of options that can be passed down to xmlModuleOpen()"]
#[doc = " xmlSchemaValidityErrorFunc:\n @ctx: the validation context\n @msg: the message\n @...: extra arguments\n\n Signature of an error callback from an XSD validation"]
unsafe extern "C" fn(ctx: *mut ::std::os::raw::c_void, msg: *const ::std::os::raw::c_char, ...),
#[doc = " xmlSchemaValidityWarningFunc:\n @ctx: the validation context\n @msg: the message\n @...: extra arguments\n\n Signature of a warning callback from an XSD validation"]
unsafe extern "C" fn(ctx: *mut ::std::os::raw::c_void, msg: *const ::std::os::raw::c_char, ...),
#[doc = " xmlSchemaValidityLocatorFunc:\n @ctx: user provided context\n @file: returned file information\n @line: returned line information\n\n A schemas validation locator, a callback called by the validator.\n This is used when file or node information are not available\n to find out what file and line number are affected\n\n Returns: 0 in case of success and -1 in case of error"]
#[doc = " xmlParserSeverities:\n\n How severe an error callback is when the per-reader error callback API\n is used."]
#[doc = " xmlParserProperties:\n\n Some common options to use with xmlTextReaderSetParserProp, but it\n is better to use xmlParserOption and the xmlReaderNewxxx and\n xmlReaderForxxx APIs now."]
pub fn xmlTextReaderGetAttribute(reader: xmlTextReaderPtr, name: *const xmlChar) -> *mut xmlChar;
#[doc = " xmlTextReaderErrorFunc:\n @arg: the user argument\n @msg: the message\n @severity: the severity of the error\n @locator: a locator indicating where the error occurred\n\n Signature of an error callback from a reader parser"]
pub fn xmlTextReaderLocatorLineNumber(locator: xmlTextReaderLocatorPtr) -> ::std::os::raw::c_int;
#[doc = " xmlSaveOption:\n\n This is the set of XML save options that can be passed down\n to the xmlSaveToFd() and similar calls."]
pub const xmlSchemaWhitespaceValueType_XML_SCHEMA_WHITESPACE_UNKNOWN: xmlSchemaWhitespaceValueType =
pub const xmlSchemaWhitespaceValueType_XML_SCHEMA_WHITESPACE_REPLACE: xmlSchemaWhitespaceValueType =
pub fn xmlSchemaGetPredefinedType(name: *const xmlChar, ns: *const xmlChar) -> xmlSchemaTypePtr;
pub fn xmlSchemaCompareValues(x: xmlSchemaValPtr, y: xmlSchemaValPtr) -> ::std::os::raw::c_int;
pub fn xmlSchemaGetBuiltInListSimpleTypeItemType(type_: xmlSchemaTypePtr) -> xmlSchemaTypePtr;
pub fn xmlSchemaNewNOTATIONValue(name: *const xmlChar, ns: *const xmlChar) -> xmlSchemaValPtr;
pub fn xmlUCSIsAlphabeticPresentationForms(code: ::std::os::raw::c_int) -> ::std::os::raw::c_int;
pub fn xmlUCSIsArabicPresentationFormsA(code: ::std::os::raw::c_int) -> ::std::os::raw::c_int;
pub fn xmlUCSIsArabicPresentationFormsB(code: ::std::os::raw::c_int) -> ::std::os::raw::c_int;
pub fn xmlUCSIsCJKCompatibilityIdeographs(code: ::std::os::raw::c_int) -> ::std::os::raw::c_int;
pub fn xmlUCSIsCJKSymbolsandPunctuation(code: ::std::os::raw::c_int) -> ::std::os::raw::c_int;
pub fn xmlUCSIsCombiningDiacriticalMarks(code: ::std::os::raw::c_int) -> ::std::os::raw::c_int;
pub fn xmlUCSIsCombiningMarksforSymbols(code: ::std::os::raw::c_int) -> ::std::os::raw::c_int;
pub fn xmlUCSIsEnclosedCJKLettersandMonths(code: ::std::os::raw::c_int) -> ::std::os::raw::c_int;
pub fn xmlUCSIsHalfwidthandFullwidthForms(code: ::std::os::raw::c_int) -> ::std::os::raw::c_int;
pub fn xmlUCSIsHighPrivateUseSurrogates(code: ::std::os::raw::c_int) -> ::std::os::raw::c_int;
pub fn xmlUCSIsKatakanaPhoneticExtensions(code: ::std::os::raw::c_int) -> ::std::os::raw::c_int;
pub fn xmlUCSIsOpticalCharacterRecognition(code: ::std::os::raw::c_int) -> ::std::os::raw::c_int;
pub fn xmlUCSIsSuperscriptsandSubscripts(code: ::std::os::raw::c_int) -> ::std::os::raw::c_int;
pub fn xmlXPathNodeSetAddUnique(cur: xmlNodeSetPtr, val: xmlNodePtr) -> ::std::os::raw::c_int;
pub fn xmlXPathNextAncestorOrSelf(ctxt: xmlXPathParserContextPtr, cur: xmlNodePtr) -> xmlNodePtr;
pub fn xmlXPathPositionFunction(ctxt: xmlXPathParserContextPtr, nargs: ::std::os::raw::c_int);
pub fn xmlXPathLocalNameFunction(ctxt: xmlXPathParserContextPtr, nargs: ::std::os::raw::c_int);
pub fn xmlXPathNamespaceURIFunction(ctxt: xmlXPathParserContextPtr, nargs: ::std::os::raw::c_int);
pub fn xmlXPathStringLengthFunction(ctxt: xmlXPathParserContextPtr, nargs: ::std::os::raw::c_int);
pub fn xmlXPathContainsFunction(ctxt: xmlXPathParserContextPtr, nargs: ::std::os::raw::c_int);
pub fn xmlXPathStartsWithFunction(ctxt: xmlXPathParserContextPtr, nargs: ::std::os::raw::c_int);
pub fn xmlXPathSubstringFunction(ctxt: xmlXPathParserContextPtr, nargs: ::std::os::raw::c_int);
pub fn xmlXPathNormalizeFunction(ctxt: xmlXPathParserContextPtr, nargs: ::std::os::raw::c_int);
pub fn xmlXPathTranslateFunction(ctxt: xmlXPathParserContextPtr, nargs: ::std::os::raw::c_int);
pub fn xmlXPtrNewRangeNodePoint(start: xmlNodePtr, end: xmlXPathObjectPtr) -> xmlXPathObjectPtr;
pub fn xmlXPtrNewRangePointNode(start: xmlXPathObjectPtr, end: xmlNodePtr) -> xmlXPathObjectPtr;
pub fn xmlXPtrNewRangeNodeObject(start: xmlNodePtr, end: xmlXPathObjectPtr) -> xmlXPathObjectPtr;