pub const LIBXML_DOTTED_VERSION: &[u8; 7usize] = b"2.10.3\0";
pub const LIBXML_VERSION: u32 = 21003;
pub const LIBXML_VERSION_STRING: &[u8; 6usize] = b"21003\0";
pub const LIBXML_VERSION_EXTRA: &[u8; 1usize] = b"\0";
pub const LIBXML_MODULE_EXTENSION: &[u8; 4usize] = b".so\0";
pub const BASE_BUFFER_SIZE: u32 = 4096;
pub const XML_DOCB_DOCUMENT_NODE: u32 = 21;
pub const XML_DEFAULT_VERSION: &[u8; 4usize] = b"1.0\0";
pub const XML_DETECT_IDS: u32 = 2;
pub const XML_COMPLETE_ATTRS: u32 = 4;
pub const XML_SKIP_IDS: u32 = 8;
pub const XML_SAX2_MAGIC: u32 = 3740122799;
pub const XPATH_POINT: u32 = 5;
pub const XPATH_RANGE: u32 = 6;
pub const XPATH_LOCATIONSET: u32 = 7;
pub const XML_XPATH_CHECKNS: u32 = 1;
pub const XML_XPATH_NOVAR: u32 = 2;
pub const XML_SCHEMAS_ANYATTR_SKIP: u32 = 1;
pub const XML_SCHEMAS_ANYATTR_LAX: u32 = 2;
pub const XML_SCHEMAS_ANYATTR_STRICT: u32 = 3;
pub const XML_SCHEMAS_ANY_SKIP: u32 = 1;
pub const XML_SCHEMAS_ANY_LAX: u32 = 2;
pub const XML_SCHEMAS_ANY_STRICT: u32 = 3;
pub const XML_SCHEMAS_ATTR_USE_PROHIBITED: u32 = 0;
pub const XML_SCHEMAS_ATTR_USE_REQUIRED: u32 = 1;
pub const XML_SCHEMAS_ATTR_USE_OPTIONAL: u32 = 2;
pub const XML_SCHEMAS_ATTR_GLOBAL: u32 = 1;
pub const XML_SCHEMAS_ATTR_NSDEFAULT: u32 = 128;
pub const XML_SCHEMAS_ATTR_INTERNAL_RESOLVED: u32 = 256;
pub const XML_SCHEMAS_ATTR_FIXED: u32 = 512;
pub const XML_SCHEMAS_WILDCARD_COMPLETE: u32 = 1;
pub const XML_SCHEMAS_ATTRGROUP_WILDCARD_BUILDED: u32 = 1;
pub const XML_SCHEMAS_ATTRGROUP_GLOBAL: u32 = 2;
pub const XML_SCHEMAS_ATTRGROUP_MARKED: u32 = 4;
pub const XML_SCHEMAS_ATTRGROUP_REDEFINED: u32 = 8;
pub const XML_SCHEMAS_ATTRGROUP_HAS_REFS: u32 = 16;
pub const XML_SCHEMAS_TYPE_MIXED: u32 = 1;
pub const XML_SCHEMAS_TYPE_DERIVATION_METHOD_EXTENSION: u32 = 2;
pub const XML_SCHEMAS_TYPE_DERIVATION_METHOD_RESTRICTION: u32 = 4;
pub const XML_SCHEMAS_TYPE_GLOBAL: u32 = 8;
pub const XML_SCHEMAS_TYPE_OWNED_ATTR_WILDCARD: u32 = 16;
pub const XML_SCHEMAS_TYPE_VARIETY_ABSENT: u32 = 32;
pub const XML_SCHEMAS_TYPE_VARIETY_LIST: u32 = 64;
pub const XML_SCHEMAS_TYPE_VARIETY_UNION: u32 = 128;
pub const XML_SCHEMAS_TYPE_VARIETY_ATOMIC: u32 = 256;
pub const XML_SCHEMAS_TYPE_FINAL_EXTENSION: u32 = 512;
pub const XML_SCHEMAS_TYPE_FINAL_RESTRICTION: u32 = 1024;
pub const XML_SCHEMAS_TYPE_FINAL_LIST: u32 = 2048;
pub const XML_SCHEMAS_TYPE_FINAL_UNION: u32 = 4096;
pub const XML_SCHEMAS_TYPE_FINAL_DEFAULT: u32 = 8192;
pub const XML_SCHEMAS_TYPE_BUILTIN_PRIMITIVE: u32 = 16384;
pub const XML_SCHEMAS_TYPE_MARKED: u32 = 65536;
pub const XML_SCHEMAS_TYPE_BLOCK_DEFAULT: u32 = 131072;
pub const XML_SCHEMAS_TYPE_BLOCK_EXTENSION: u32 = 262144;
pub const XML_SCHEMAS_TYPE_BLOCK_RESTRICTION: u32 = 524288;
pub const XML_SCHEMAS_TYPE_ABSTRACT: u32 = 1048576;
pub const XML_SCHEMAS_TYPE_FACETSNEEDVALUE: u32 = 2097152;
pub const XML_SCHEMAS_TYPE_INTERNAL_RESOLVED: u32 = 4194304;
pub const XML_SCHEMAS_TYPE_INTERNAL_INVALID: u32 = 8388608;
pub const XML_SCHEMAS_TYPE_WHITESPACE_PRESERVE: u32 = 16777216;
pub const XML_SCHEMAS_TYPE_WHITESPACE_REPLACE: u32 = 33554432;
pub const XML_SCHEMAS_TYPE_WHITESPACE_COLLAPSE: u32 = 67108864;
pub const XML_SCHEMAS_TYPE_HAS_FACETS: u32 = 134217728;
pub const XML_SCHEMAS_TYPE_NORMVALUENEEDED: u32 = 268435456;
pub const XML_SCHEMAS_TYPE_FIXUP_1: u32 = 536870912;
pub const XML_SCHEMAS_TYPE_REDEFINED: u32 = 1073741824;
pub const XML_SCHEMAS_ELEM_NILLABLE: u32 = 1;
pub const XML_SCHEMAS_ELEM_GLOBAL: u32 = 2;
pub const XML_SCHEMAS_ELEM_DEFAULT: u32 = 4;
pub const XML_SCHEMAS_ELEM_FIXED: u32 = 8;
pub const XML_SCHEMAS_ELEM_ABSTRACT: u32 = 16;
pub const XML_SCHEMAS_ELEM_TOPLEVEL: u32 = 32;
pub const XML_SCHEMAS_ELEM_REF: u32 = 64;
pub const XML_SCHEMAS_ELEM_NSDEFAULT: u32 = 128;
pub const XML_SCHEMAS_ELEM_INTERNAL_RESOLVED: u32 = 256;
pub const XML_SCHEMAS_ELEM_CIRCULAR: u32 = 512;
pub const XML_SCHEMAS_ELEM_BLOCK_ABSENT: u32 = 1024;
pub const XML_SCHEMAS_ELEM_BLOCK_EXTENSION: u32 = 2048;
pub const XML_SCHEMAS_ELEM_BLOCK_RESTRICTION: u32 = 4096;
pub const XML_SCHEMAS_ELEM_BLOCK_SUBSTITUTION: u32 = 8192;
pub const XML_SCHEMAS_ELEM_FINAL_ABSENT: u32 = 16384;
pub const XML_SCHEMAS_ELEM_FINAL_EXTENSION: u32 = 32768;
pub const XML_SCHEMAS_ELEM_FINAL_RESTRICTION: u32 = 65536;
pub const XML_SCHEMAS_ELEM_SUBST_GROUP_HEAD: u32 = 131072;
pub const XML_SCHEMAS_ELEM_INTERNAL_CHECKED: u32 = 262144;
pub const XML_SCHEMAS_FACET_UNKNOWN: u32 = 0;
pub const XML_SCHEMAS_FACET_PRESERVE: u32 = 1;
pub const XML_SCHEMAS_FACET_REPLACE: u32 = 2;
pub const XML_SCHEMAS_FACET_COLLAPSE: u32 = 3;
pub const XML_SCHEMAS_QUALIF_ELEM: u32 = 1;
pub const XML_SCHEMAS_QUALIF_ATTR: u32 = 2;
pub const XML_SCHEMAS_FINAL_DEFAULT_EXTENSION: u32 = 4;
pub const XML_SCHEMAS_FINAL_DEFAULT_RESTRICTION: u32 = 8;
pub const XML_SCHEMAS_FINAL_DEFAULT_LIST: u32 = 16;
pub const XML_SCHEMAS_FINAL_DEFAULT_UNION: u32 = 32;
pub const XML_SCHEMAS_BLOCK_DEFAULT_EXTENSION: u32 = 64;
pub const XML_SCHEMAS_BLOCK_DEFAULT_RESTRICTION: u32 = 128;
pub const XML_SCHEMAS_BLOCK_DEFAULT_SUBSTITUTION: u32 = 256;
pub const XML_SCHEMAS_INCLUDING_CONVERT_NS: u32 = 512;
pub const XML_MAX_TEXT_LENGTH: u32 = 10000000;
pub const XML_MAX_NAME_LENGTH: u32 = 50000;
pub const XML_MAX_DICTIONARY_LIMIT: u32 = 10000000;
pub const XML_MAX_LOOKUP_LIMIT: u32 = 10000000;
pub const XML_MAX_NAMELEN: u32 = 100;
pub const INPUT_CHUNK: u32 = 250;
pub const XML_SUBSTITUTE_NONE: u32 = 0;
pub const XML_SUBSTITUTE_REF: u32 = 1;
pub const XML_SUBSTITUTE_PEREF: u32 = 2;
pub const XML_SUBSTITUTE_BOTH: u32 = 3;
pub type __int64_t = ::std::os::raw::c_longlong;
pub type __darwin_va_list = __builtin_va_list;
pub type __darwin_off_t = __int64_t;
pub type va_list = __darwin_va_list;
pub type fpos_t = __darwin_off_t;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct __sbuf {
pub _base: *mut ::std::os::raw::c_uchar,
pub _size: ::std::os::raw::c_int,
}
#[test]
fn bindgen_test_layout___sbuf() {
const UNINIT: ::std::mem::MaybeUninit<__sbuf> = ::std::mem::MaybeUninit::uninit();
let ptr = UNINIT.as_ptr();
assert_eq!(
::std::mem::size_of::<__sbuf>(),
16usize,
concat!("Size of: ", stringify!(__sbuf))
);
assert_eq!(
::std::mem::align_of::<__sbuf>(),
8usize,
concat!("Alignment of ", stringify!(__sbuf))
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr)._base) as usize - ptr as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(__sbuf),
"::",
stringify!(_base)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr)._size) as usize - ptr as usize },
8usize,
concat!(
"Offset of field: ",
stringify!(__sbuf),
"::",
stringify!(_size)
)
);
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct __sFILEX {
_unused: [u8; 0],
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct __sFILE {
pub _p: *mut ::std::os::raw::c_uchar,
pub _r: ::std::os::raw::c_int,
pub _w: ::std::os::raw::c_int,
pub _flags: ::std::os::raw::c_short,
pub _file: ::std::os::raw::c_short,
pub _bf: __sbuf,
pub _lbfsize: ::std::os::raw::c_int,
pub _cookie: *mut ::std::os::raw::c_void,
pub _close: ::std::option::Option<
unsafe extern "C" fn(arg1: *mut ::std::os::raw::c_void) -> ::std::os::raw::c_int,
>,
pub _read: ::std::option::Option<
unsafe extern "C" fn(
arg1: *mut ::std::os::raw::c_void,
arg2: *mut ::std::os::raw::c_char,
arg3: ::std::os::raw::c_int,
) -> ::std::os::raw::c_int,
>,
pub _seek: ::std::option::Option<
unsafe extern "C" fn(
arg1: *mut ::std::os::raw::c_void,
arg2: fpos_t,
arg3: ::std::os::raw::c_int,
) -> fpos_t,
>,
pub _write: ::std::option::Option<
unsafe extern "C" fn(
arg1: *mut ::std::os::raw::c_void,
arg2: *const ::std::os::raw::c_char,
arg3: ::std::os::raw::c_int,
) -> ::std::os::raw::c_int,
>,
pub _ub: __sbuf,
pub _extra: *mut __sFILEX,
pub _ur: ::std::os::raw::c_int,
pub _ubuf: [::std::os::raw::c_uchar; 3usize],
pub _nbuf: [::std::os::raw::c_uchar; 1usize],
pub _lb: __sbuf,
pub _blksize: ::std::os::raw::c_int,
pub _offset: fpos_t,
}
#[test]
fn bindgen_test_layout___sFILE() {
const UNINIT: ::std::mem::MaybeUninit<__sFILE> = ::std::mem::MaybeUninit::uninit();
let ptr = UNINIT.as_ptr();
assert_eq!(
::std::mem::size_of::<__sFILE>(),
152usize,
concat!("Size of: ", stringify!(__sFILE))
);
assert_eq!(
::std::mem::align_of::<__sFILE>(),
8usize,
concat!("Alignment of ", stringify!(__sFILE))
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr)._p) as usize - ptr as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(__sFILE),
"::",
stringify!(_p)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr)._r) as usize - ptr as usize },
8usize,
concat!(
"Offset of field: ",
stringify!(__sFILE),
"::",
stringify!(_r)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr)._w) as usize - ptr as usize },
12usize,
concat!(
"Offset of field: ",
stringify!(__sFILE),
"::",
stringify!(_w)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr)._flags) as usize - ptr as usize },
16usize,
concat!(
"Offset of field: ",
stringify!(__sFILE),
"::",
stringify!(_flags)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr)._file) as usize - ptr as usize },
18usize,
concat!(
"Offset of field: ",
stringify!(__sFILE),
"::",
stringify!(_file)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr)._bf) as usize - ptr as usize },
24usize,
concat!(
"Offset of field: ",
stringify!(__sFILE),
"::",
stringify!(_bf)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr)._lbfsize) as usize - ptr as usize },
40usize,
concat!(
"Offset of field: ",
stringify!(__sFILE),
"::",
stringify!(_lbfsize)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr)._cookie) as usize - ptr as usize },
48usize,
concat!(
"Offset of field: ",
stringify!(__sFILE),
"::",
stringify!(_cookie)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr)._close) as usize - ptr as usize },
56usize,
concat!(
"Offset of field: ",
stringify!(__sFILE),
"::",
stringify!(_close)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr)._read) as usize - ptr as usize },
64usize,
concat!(
"Offset of field: ",
stringify!(__sFILE),
"::",
stringify!(_read)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr)._seek) as usize - ptr as usize },
72usize,
concat!(
"Offset of field: ",
stringify!(__sFILE),
"::",
stringify!(_seek)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr)._write) as usize - ptr as usize },
80usize,
concat!(
"Offset of field: ",
stringify!(__sFILE),
"::",
stringify!(_write)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr)._ub) as usize - ptr as usize },
88usize,
concat!(
"Offset of field: ",
stringify!(__sFILE),
"::",
stringify!(_ub)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr)._extra) as usize - ptr as usize },
104usize,
concat!(
"Offset of field: ",
stringify!(__sFILE),
"::",
stringify!(_extra)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr)._ur) as usize - ptr as usize },
112usize,
concat!(
"Offset of field: ",
stringify!(__sFILE),
"::",
stringify!(_ur)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr)._ubuf) as usize - ptr as usize },
116usize,
concat!(
"Offset of field: ",
stringify!(__sFILE),
"::",
stringify!(_ubuf)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr)._nbuf) as usize - ptr as usize },
119usize,
concat!(
"Offset of field: ",
stringify!(__sFILE),
"::",
stringify!(_nbuf)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr)._lb) as usize - ptr as usize },
120usize,
concat!(
"Offset of field: ",
stringify!(__sFILE),
"::",
stringify!(_lb)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr)._blksize) as usize - ptr as usize },
136usize,
concat!(
"Offset of field: ",
stringify!(__sFILE),
"::",
stringify!(_blksize)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr)._offset) as usize - ptr as usize },
144usize,
concat!(
"Offset of field: ",
stringify!(__sFILE),
"::",
stringify!(_offset)
)
);
}
pub type FILE = __sFILE;
extern "C" {
pub fn xmlCheckVersion(version: ::std::os::raw::c_int);
}
pub type xmlChar = ::std::os::raw::c_uchar;
extern "C" {
pub fn xmlStrdup(cur: *const xmlChar) -> *mut xmlChar;
}
extern "C" {
pub fn xmlStrndup(cur: *const xmlChar, len: ::std::os::raw::c_int) -> *mut xmlChar;
}
extern "C" {
pub fn xmlCharStrndup(
cur: *const ::std::os::raw::c_char,
len: ::std::os::raw::c_int,
) -> *mut xmlChar;
}
extern "C" {
pub fn xmlCharStrdup(cur: *const ::std::os::raw::c_char) -> *mut xmlChar;
}
extern "C" {
pub fn xmlStrsub(
str_: *const xmlChar,
start: ::std::os::raw::c_int,
len: ::std::os::raw::c_int,
) -> *mut xmlChar;
}
extern "C" {
pub fn xmlStrchr(str_: *const xmlChar, val: xmlChar) -> *const xmlChar;
}
extern "C" {
pub fn xmlStrstr(str_: *const xmlChar, val: *const xmlChar) -> *const xmlChar;
}
extern "C" {
pub fn xmlStrcasestr(str_: *const xmlChar, val: *const xmlChar) -> *const xmlChar;
}
extern "C" {
pub fn xmlStrcmp(str1: *const xmlChar, str2: *const xmlChar) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn xmlStrncmp(
str1: *const xmlChar,
str2: *const xmlChar,
len: ::std::os::raw::c_int,
) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn xmlStrcasecmp(str1: *const xmlChar, str2: *const xmlChar) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn xmlStrncasecmp(
str1: *const xmlChar,
str2: *const xmlChar,
len: ::std::os::raw::c_int,
) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn xmlStrEqual(str1: *const xmlChar, str2: *const xmlChar) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn xmlStrQEqual(
pref: *const xmlChar,
name: *const xmlChar,
str_: *const xmlChar,
) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn xmlStrlen(str_: *const xmlChar) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn xmlStrcat(cur: *mut xmlChar, add: *const xmlChar) -> *mut xmlChar;
}
extern "C" {
pub fn xmlStrncat(
cur: *mut xmlChar,
add: *const xmlChar,
len: ::std::os::raw::c_int,
) -> *mut xmlChar;
}
extern "C" {
pub fn xmlStrncatNew(
str1: *const xmlChar,
str2: *const xmlChar,
len: ::std::os::raw::c_int,
) -> *mut xmlChar;
}
extern "C" {
pub fn xmlStrPrintf(
buf: *mut xmlChar,
len: ::std::os::raw::c_int,
msg: *const ::std::os::raw::c_char,
...
) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn xmlStrVPrintf(
buf: *mut xmlChar,
len: ::std::os::raw::c_int,
msg: *const ::std::os::raw::c_char,
ap: va_list,
) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn xmlGetUTF8Char(
utf: *const ::std::os::raw::c_uchar,
len: *mut ::std::os::raw::c_int,
) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn xmlCheckUTF8(utf: *const ::std::os::raw::c_uchar) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn xmlUTF8Strsize(utf: *const xmlChar, len: ::std::os::raw::c_int)
-> ::std::os::raw::c_int;
}
extern "C" {
pub fn xmlUTF8Strndup(utf: *const xmlChar, len: ::std::os::raw::c_int) -> *mut xmlChar;
}
extern "C" {
pub fn xmlUTF8Strpos(utf: *const xmlChar, pos: ::std::os::raw::c_int) -> *const xmlChar;
}
extern "C" {
pub fn xmlUTF8Strloc(utf: *const xmlChar, utfchar: *const xmlChar) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn xmlUTF8Strsub(
utf: *const xmlChar,
start: ::std::os::raw::c_int,
len: ::std::os::raw::c_int,
) -> *mut xmlChar;
}
extern "C" {
pub fn xmlUTF8Strlen(utf: *const xmlChar) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn xmlUTF8Size(utf: *const xmlChar) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn xmlUTF8Charcmp(utf1: *const xmlChar, utf2: *const xmlChar) -> ::std::os::raw::c_int;
}
pub type xmlParserInputBuffer = _xmlParserInputBuffer;
pub type xmlParserInputBufferPtr = *mut xmlParserInputBuffer;
pub type xmlOutputBuffer = _xmlOutputBuffer;
pub type xmlOutputBufferPtr = *mut xmlOutputBuffer;
pub type xmlParserInput = _xmlParserInput;
pub type xmlParserInputPtr = *mut xmlParserInput;
pub type xmlParserCtxt = _xmlParserCtxt;
pub type xmlParserCtxtPtr = *mut xmlParserCtxt;
pub type xmlSAXLocator = _xmlSAXLocator;
pub type xmlSAXLocatorPtr = *mut xmlSAXLocator;
pub type xmlSAXHandler = _xmlSAXHandler;
pub type xmlSAXHandlerPtr = *mut xmlSAXHandler;
pub type xmlEntity = _xmlEntity;
pub type xmlEntityPtr = *mut xmlEntity;
pub const xmlBufferAllocationScheme_XML_BUFFER_ALLOC_DOUBLEIT: xmlBufferAllocationScheme = 0;
pub const xmlBufferAllocationScheme_XML_BUFFER_ALLOC_EXACT: xmlBufferAllocationScheme = 1;
pub const xmlBufferAllocationScheme_XML_BUFFER_ALLOC_IMMUTABLE: xmlBufferAllocationScheme = 2;
pub const xmlBufferAllocationScheme_XML_BUFFER_ALLOC_IO: xmlBufferAllocationScheme = 3;
pub const xmlBufferAllocationScheme_XML_BUFFER_ALLOC_HYBRID: xmlBufferAllocationScheme = 4;
pub const xmlBufferAllocationScheme_XML_BUFFER_ALLOC_BOUNDED: xmlBufferAllocationScheme = 5;
pub type xmlBufferAllocationScheme = ::std::os::raw::c_uint;
pub type xmlBuffer = _xmlBuffer;
pub type xmlBufferPtr = *mut xmlBuffer;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct _xmlBuffer {
pub content: *mut xmlChar,
pub use_: ::std::os::raw::c_uint,
pub size: ::std::os::raw::c_uint,
pub alloc: xmlBufferAllocationScheme,
pub contentIO: *mut xmlChar,
}
#[test]
fn bindgen_test_layout__xmlBuffer() {
const UNINIT: ::std::mem::MaybeUninit<_xmlBuffer> = ::std::mem::MaybeUninit::uninit();
let ptr = UNINIT.as_ptr();
assert_eq!(
::std::mem::size_of::<_xmlBuffer>(),
32usize,
concat!("Size of: ", stringify!(_xmlBuffer))
);
assert_eq!(
::std::mem::align_of::<_xmlBuffer>(),
8usize,
concat!("Alignment of ", stringify!(_xmlBuffer))
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).content) as usize - ptr as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(_xmlBuffer),
"::",
stringify!(content)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).use_) as usize - ptr as usize },
8usize,
concat!(
"Offset of field: ",
stringify!(_xmlBuffer),
"::",
stringify!(use_)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).size) as usize - ptr as usize },
12usize,
concat!(
"Offset of field: ",
stringify!(_xmlBuffer),
"::",
stringify!(size)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).alloc) as usize - ptr as usize },
16usize,
concat!(
"Offset of field: ",
stringify!(_xmlBuffer),
"::",
stringify!(alloc)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).contentIO) as usize - ptr as usize },
24usize,
concat!(
"Offset of field: ",
stringify!(_xmlBuffer),
"::",
stringify!(contentIO)
)
);
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct _xmlBuf {
_unused: [u8; 0],
}
pub type xmlBuf = _xmlBuf;
pub type xmlBufPtr = *mut xmlBuf;
extern "C" {
pub fn xmlBufContent(buf: *const xmlBuf) -> *mut xmlChar;
}
extern "C" {
pub fn xmlBufEnd(buf: xmlBufPtr) -> *mut xmlChar;
}
extern "C" {
pub fn xmlBufUse(buf: xmlBufPtr) -> usize;
}
extern "C" {
pub fn xmlBufShrink(buf: xmlBufPtr, len: usize) -> usize;
}
pub const xmlElementType_XML_ELEMENT_NODE: xmlElementType = 1;
pub const xmlElementType_XML_ATTRIBUTE_NODE: xmlElementType = 2;
pub const xmlElementType_XML_TEXT_NODE: xmlElementType = 3;
pub const xmlElementType_XML_CDATA_SECTION_NODE: xmlElementType = 4;
pub const xmlElementType_XML_ENTITY_REF_NODE: xmlElementType = 5;
pub const xmlElementType_XML_ENTITY_NODE: xmlElementType = 6;
pub const xmlElementType_XML_PI_NODE: xmlElementType = 7;
pub const xmlElementType_XML_COMMENT_NODE: xmlElementType = 8;
pub const xmlElementType_XML_DOCUMENT_NODE: xmlElementType = 9;
pub const xmlElementType_XML_DOCUMENT_TYPE_NODE: xmlElementType = 10;
pub const xmlElementType_XML_DOCUMENT_FRAG_NODE: xmlElementType = 11;
pub const xmlElementType_XML_NOTATION_NODE: xmlElementType = 12;
pub const xmlElementType_XML_HTML_DOCUMENT_NODE: xmlElementType = 13;
pub const xmlElementType_XML_DTD_NODE: xmlElementType = 14;
pub const xmlElementType_XML_ELEMENT_DECL: xmlElementType = 15;
pub const xmlElementType_XML_ATTRIBUTE_DECL: xmlElementType = 16;
pub const xmlElementType_XML_ENTITY_DECL: xmlElementType = 17;
pub const xmlElementType_XML_NAMESPACE_DECL: xmlElementType = 18;
pub const xmlElementType_XML_XINCLUDE_START: xmlElementType = 19;
pub const xmlElementType_XML_XINCLUDE_END: xmlElementType = 20;
pub type xmlElementType = ::std::os::raw::c_uint;
pub type xmlNotation = _xmlNotation;
pub type xmlNotationPtr = *mut xmlNotation;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct _xmlNotation {
pub name: *const xmlChar,
pub PublicID: *const xmlChar,
pub SystemID: *const xmlChar,
}
#[test]
fn bindgen_test_layout__xmlNotation() {
const UNINIT: ::std::mem::MaybeUninit<_xmlNotation> = ::std::mem::MaybeUninit::uninit();
let ptr = UNINIT.as_ptr();
assert_eq!(
::std::mem::size_of::<_xmlNotation>(),
24usize,
concat!("Size of: ", stringify!(_xmlNotation))
);
assert_eq!(
::std::mem::align_of::<_xmlNotation>(),
8usize,
concat!("Alignment of ", stringify!(_xmlNotation))
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).name) as usize - ptr as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(_xmlNotation),
"::",
stringify!(name)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).PublicID) as usize - ptr as usize },
8usize,
concat!(
"Offset of field: ",
stringify!(_xmlNotation),
"::",
stringify!(PublicID)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).SystemID) as usize - ptr as usize },
16usize,
concat!(
"Offset of field: ",
stringify!(_xmlNotation),
"::",
stringify!(SystemID)
)
);
}
pub const xmlAttributeType_XML_ATTRIBUTE_CDATA: xmlAttributeType = 1;
pub const xmlAttributeType_XML_ATTRIBUTE_ID: xmlAttributeType = 2;
pub const xmlAttributeType_XML_ATTRIBUTE_IDREF: xmlAttributeType = 3;
pub const xmlAttributeType_XML_ATTRIBUTE_IDREFS: xmlAttributeType = 4;
pub const xmlAttributeType_XML_ATTRIBUTE_ENTITY: xmlAttributeType = 5;
pub const xmlAttributeType_XML_ATTRIBUTE_ENTITIES: xmlAttributeType = 6;
pub const xmlAttributeType_XML_ATTRIBUTE_NMTOKEN: xmlAttributeType = 7;
pub const xmlAttributeType_XML_ATTRIBUTE_NMTOKENS: xmlAttributeType = 8;
pub const xmlAttributeType_XML_ATTRIBUTE_ENUMERATION: xmlAttributeType = 9;
pub const xmlAttributeType_XML_ATTRIBUTE_NOTATION: xmlAttributeType = 10;
pub type xmlAttributeType = ::std::os::raw::c_uint;
pub const xmlAttributeDefault_XML_ATTRIBUTE_NONE: xmlAttributeDefault = 1;
pub const xmlAttributeDefault_XML_ATTRIBUTE_REQUIRED: xmlAttributeDefault = 2;
pub const xmlAttributeDefault_XML_ATTRIBUTE_IMPLIED: xmlAttributeDefault = 3;
pub const xmlAttributeDefault_XML_ATTRIBUTE_FIXED: xmlAttributeDefault = 4;
pub type xmlAttributeDefault = ::std::os::raw::c_uint;
pub type xmlEnumeration = _xmlEnumeration;
pub type xmlEnumerationPtr = *mut xmlEnumeration;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct _xmlEnumeration {
pub next: *mut _xmlEnumeration,
pub name: *const xmlChar,
}
#[test]
fn bindgen_test_layout__xmlEnumeration() {
const UNINIT: ::std::mem::MaybeUninit<_xmlEnumeration> = ::std::mem::MaybeUninit::uninit();
let ptr = UNINIT.as_ptr();
assert_eq!(
::std::mem::size_of::<_xmlEnumeration>(),
16usize,
concat!("Size of: ", stringify!(_xmlEnumeration))
);
assert_eq!(
::std::mem::align_of::<_xmlEnumeration>(),
8usize,
concat!("Alignment of ", stringify!(_xmlEnumeration))
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).next) as usize - ptr as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(_xmlEnumeration),
"::",
stringify!(next)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).name) as usize - ptr as usize },
8usize,
concat!(
"Offset of field: ",
stringify!(_xmlEnumeration),
"::",
stringify!(name)
)
);
}
pub type xmlAttribute = _xmlAttribute;
pub type xmlAttributePtr = *mut xmlAttribute;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct _xmlAttribute {
pub _private: *mut ::std::os::raw::c_void,
pub type_: xmlElementType,
pub name: *const xmlChar,
pub children: *mut _xmlNode,
pub last: *mut _xmlNode,
pub parent: *mut _xmlDtd,
pub next: *mut _xmlNode,
pub prev: *mut _xmlNode,
pub doc: *mut _xmlDoc,
pub nexth: *mut _xmlAttribute,
pub atype: xmlAttributeType,
pub def: xmlAttributeDefault,
pub defaultValue: *const xmlChar,
pub tree: xmlEnumerationPtr,
pub prefix: *const xmlChar,
pub elem: *const xmlChar,
}
#[test]
fn bindgen_test_layout__xmlAttribute() {
const UNINIT: ::std::mem::MaybeUninit<_xmlAttribute> = ::std::mem::MaybeUninit::uninit();
let ptr = UNINIT.as_ptr();
assert_eq!(
::std::mem::size_of::<_xmlAttribute>(),
120usize,
concat!("Size of: ", stringify!(_xmlAttribute))
);
assert_eq!(
::std::mem::align_of::<_xmlAttribute>(),
8usize,
concat!("Alignment of ", stringify!(_xmlAttribute))
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr)._private) as usize - ptr as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(_xmlAttribute),
"::",
stringify!(_private)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).type_) as usize - ptr as usize },
8usize,
concat!(
"Offset of field: ",
stringify!(_xmlAttribute),
"::",
stringify!(type_)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).name) as usize - ptr as usize },
16usize,
concat!(
"Offset of field: ",
stringify!(_xmlAttribute),
"::",
stringify!(name)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).children) as usize - ptr as usize },
24usize,
concat!(
"Offset of field: ",
stringify!(_xmlAttribute),
"::",
stringify!(children)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).last) as usize - ptr as usize },
32usize,
concat!(
"Offset of field: ",
stringify!(_xmlAttribute),
"::",
stringify!(last)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).parent) as usize - ptr as usize },
40usize,
concat!(
"Offset of field: ",
stringify!(_xmlAttribute),
"::",
stringify!(parent)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).next) as usize - ptr as usize },
48usize,
concat!(
"Offset of field: ",
stringify!(_xmlAttribute),
"::",
stringify!(next)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).prev) as usize - ptr as usize },
56usize,
concat!(
"Offset of field: ",
stringify!(_xmlAttribute),
"::",
stringify!(prev)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).doc) as usize - ptr as usize },
64usize,
concat!(
"Offset of field: ",
stringify!(_xmlAttribute),
"::",
stringify!(doc)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).nexth) as usize - ptr as usize },
72usize,
concat!(
"Offset of field: ",
stringify!(_xmlAttribute),
"::",
stringify!(nexth)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).atype) as usize - ptr as usize },
80usize,
concat!(
"Offset of field: ",
stringify!(_xmlAttribute),
"::",
stringify!(atype)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).def) as usize - ptr as usize },
84usize,
concat!(
"Offset of field: ",
stringify!(_xmlAttribute),
"::",
stringify!(def)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).defaultValue) as usize - ptr as usize },
88usize,
concat!(
"Offset of field: ",
stringify!(_xmlAttribute),
"::",
stringify!(defaultValue)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).tree) as usize - ptr as usize },
96usize,
concat!(
"Offset of field: ",
stringify!(_xmlAttribute),
"::",
stringify!(tree)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).prefix) as usize - ptr as usize },
104usize,
concat!(
"Offset of field: ",
stringify!(_xmlAttribute),
"::",
stringify!(prefix)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).elem) as usize - ptr as usize },
112usize,
concat!(
"Offset of field: ",
stringify!(_xmlAttribute),
"::",
stringify!(elem)
)
);
}
pub const xmlElementContentType_XML_ELEMENT_CONTENT_PCDATA: xmlElementContentType = 1;
pub const xmlElementContentType_XML_ELEMENT_CONTENT_ELEMENT: xmlElementContentType = 2;
pub const xmlElementContentType_XML_ELEMENT_CONTENT_SEQ: xmlElementContentType = 3;
pub const xmlElementContentType_XML_ELEMENT_CONTENT_OR: xmlElementContentType = 4;
pub type xmlElementContentType = ::std::os::raw::c_uint;
pub const xmlElementContentOccur_XML_ELEMENT_CONTENT_ONCE: xmlElementContentOccur = 1;
pub const xmlElementContentOccur_XML_ELEMENT_CONTENT_OPT: xmlElementContentOccur = 2;
pub const xmlElementContentOccur_XML_ELEMENT_CONTENT_MULT: xmlElementContentOccur = 3;
pub const xmlElementContentOccur_XML_ELEMENT_CONTENT_PLUS: xmlElementContentOccur = 4;
pub type xmlElementContentOccur = ::std::os::raw::c_uint;
pub type xmlElementContent = _xmlElementContent;
pub type xmlElementContentPtr = *mut xmlElementContent;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct _xmlElementContent {
pub type_: xmlElementContentType,
pub ocur: xmlElementContentOccur,
pub name: *const xmlChar,
pub c1: *mut _xmlElementContent,
pub c2: *mut _xmlElementContent,
pub parent: *mut _xmlElementContent,
pub prefix: *const xmlChar,
}
#[test]
fn bindgen_test_layout__xmlElementContent() {
const UNINIT: ::std::mem::MaybeUninit<_xmlElementContent> = ::std::mem::MaybeUninit::uninit();
let ptr = UNINIT.as_ptr();
assert_eq!(
::std::mem::size_of::<_xmlElementContent>(),
48usize,
concat!("Size of: ", stringify!(_xmlElementContent))
);
assert_eq!(
::std::mem::align_of::<_xmlElementContent>(),
8usize,
concat!("Alignment of ", stringify!(_xmlElementContent))
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).type_) as usize - ptr as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(_xmlElementContent),
"::",
stringify!(type_)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).ocur) as usize - ptr as usize },
4usize,
concat!(
"Offset of field: ",
stringify!(_xmlElementContent),
"::",
stringify!(ocur)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).name) as usize - ptr as usize },
8usize,
concat!(
"Offset of field: ",
stringify!(_xmlElementContent),
"::",
stringify!(name)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).c1) as usize - ptr as usize },
16usize,
concat!(
"Offset of field: ",
stringify!(_xmlElementContent),
"::",
stringify!(c1)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).c2) as usize - ptr as usize },
24usize,
concat!(
"Offset of field: ",
stringify!(_xmlElementContent),
"::",
stringify!(c2)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).parent) as usize - ptr as usize },
32usize,
concat!(
"Offset of field: ",
stringify!(_xmlElementContent),
"::",
stringify!(parent)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).prefix) as usize - ptr as usize },
40usize,
concat!(
"Offset of field: ",
stringify!(_xmlElementContent),
"::",
stringify!(prefix)
)
);
}
pub const xmlElementTypeVal_XML_ELEMENT_TYPE_UNDEFINED: xmlElementTypeVal = 0;
pub const xmlElementTypeVal_XML_ELEMENT_TYPE_EMPTY: xmlElementTypeVal = 1;
pub const xmlElementTypeVal_XML_ELEMENT_TYPE_ANY: xmlElementTypeVal = 2;
pub const xmlElementTypeVal_XML_ELEMENT_TYPE_MIXED: xmlElementTypeVal = 3;
pub const xmlElementTypeVal_XML_ELEMENT_TYPE_ELEMENT: xmlElementTypeVal = 4;
pub type xmlElementTypeVal = ::std::os::raw::c_uint;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct _xmlRegexp {
_unused: [u8; 0],
}
pub type xmlRegexp = _xmlRegexp;
pub type xmlRegexpPtr = *mut xmlRegexp;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct _xmlRegExecCtxt {
_unused: [u8; 0],
}
pub type xmlRegExecCtxt = _xmlRegExecCtxt;
pub type xmlRegExecCtxtPtr = *mut xmlRegExecCtxt;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct _xmlDict {
_unused: [u8; 0],
}
pub type xmlDict = _xmlDict;
pub type xmlDictPtr = *mut xmlDict;
extern "C" {
pub fn xmlInitializeDict() -> ::std::os::raw::c_int;
}
extern "C" {
pub fn xmlDictCreate() -> xmlDictPtr;
}
extern "C" {
pub fn xmlDictSetLimit(dict: xmlDictPtr, limit: usize) -> usize;
}
extern "C" {
pub fn xmlDictGetUsage(dict: xmlDictPtr) -> usize;
}
extern "C" {
pub fn xmlDictCreateSub(sub: xmlDictPtr) -> xmlDictPtr;
}
extern "C" {
pub fn xmlDictReference(dict: xmlDictPtr) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn xmlDictFree(dict: xmlDictPtr);
}
extern "C" {
pub fn xmlDictLookup(
dict: xmlDictPtr,
name: *const xmlChar,
len: ::std::os::raw::c_int,
) -> *const xmlChar;
}
extern "C" {
pub fn xmlDictExists(
dict: xmlDictPtr,
name: *const xmlChar,
len: ::std::os::raw::c_int,
) -> *const xmlChar;
}
extern "C" {
pub fn xmlDictQLookup(
dict: xmlDictPtr,
prefix: *const xmlChar,
name: *const xmlChar,
) -> *const xmlChar;
}
extern "C" {
pub fn xmlDictOwns(dict: xmlDictPtr, str_: *const xmlChar) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn xmlDictSize(dict: xmlDictPtr) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn xmlDictCleanup();
}
extern "C" {
pub fn xmlRegexpCompile(regexp: *const xmlChar) -> xmlRegexpPtr;
}
extern "C" {
pub fn xmlRegFreeRegexp(regexp: xmlRegexpPtr);
}
extern "C" {
pub fn xmlRegexpExec(comp: xmlRegexpPtr, value: *const xmlChar) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn xmlRegexpPrint(output: *mut FILE, regexp: xmlRegexpPtr);
}
extern "C" {
pub fn xmlRegexpIsDeterminist(comp: xmlRegexpPtr) -> ::std::os::raw::c_int;
}
pub type xmlRegExecCallbacks = ::std::option::Option<
unsafe extern "C" fn(
exec: xmlRegExecCtxtPtr,
token: *const xmlChar,
transdata: *mut ::std::os::raw::c_void,
inputdata: *mut ::std::os::raw::c_void,
),
>;
extern "C" {
pub fn xmlRegNewExecCtxt(
comp: xmlRegexpPtr,
callback: xmlRegExecCallbacks,
data: *mut ::std::os::raw::c_void,
) -> xmlRegExecCtxtPtr;
}
extern "C" {
pub fn xmlRegFreeExecCtxt(exec: xmlRegExecCtxtPtr);
}
extern "C" {
pub fn xmlRegExecPushString(
exec: xmlRegExecCtxtPtr,
value: *const xmlChar,
data: *mut ::std::os::raw::c_void,
) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn xmlRegExecPushString2(
exec: xmlRegExecCtxtPtr,
value: *const xmlChar,
value2: *const xmlChar,
data: *mut ::std::os::raw::c_void,
) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn xmlRegExecNextValues(
exec: xmlRegExecCtxtPtr,
nbval: *mut ::std::os::raw::c_int,
nbneg: *mut ::std::os::raw::c_int,
values: *mut *mut xmlChar,
terminal: *mut ::std::os::raw::c_int,
) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn xmlRegExecErrInfo(
exec: xmlRegExecCtxtPtr,
string: *mut *const xmlChar,
nbval: *mut ::std::os::raw::c_int,
nbneg: *mut ::std::os::raw::c_int,
values: *mut *mut xmlChar,
terminal: *mut ::std::os::raw::c_int,
) -> ::std::os::raw::c_int;
}
pub type xmlElement = _xmlElement;
pub type xmlElementPtr = *mut xmlElement;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct _xmlElement {
pub _private: *mut ::std::os::raw::c_void,
pub type_: xmlElementType,
pub name: *const xmlChar,
pub children: *mut _xmlNode,
pub last: *mut _xmlNode,
pub parent: *mut _xmlDtd,
pub next: *mut _xmlNode,
pub prev: *mut _xmlNode,
pub doc: *mut _xmlDoc,
pub etype: xmlElementTypeVal,
pub content: xmlElementContentPtr,
pub attributes: xmlAttributePtr,
pub prefix: *const xmlChar,
pub contModel: xmlRegexpPtr,
}
#[test]
fn bindgen_test_layout__xmlElement() {
const UNINIT: ::std::mem::MaybeUninit<_xmlElement> = ::std::mem::MaybeUninit::uninit();
let ptr = UNINIT.as_ptr();
assert_eq!(
::std::mem::size_of::<_xmlElement>(),
112usize,
concat!("Size of: ", stringify!(_xmlElement))
);
assert_eq!(
::std::mem::align_of::<_xmlElement>(),
8usize,
concat!("Alignment of ", stringify!(_xmlElement))
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr)._private) as usize - ptr as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(_xmlElement),
"::",
stringify!(_private)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).type_) as usize - ptr as usize },
8usize,
concat!(
"Offset of field: ",
stringify!(_xmlElement),
"::",
stringify!(type_)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).name) as usize - ptr as usize },
16usize,
concat!(
"Offset of field: ",
stringify!(_xmlElement),
"::",
stringify!(name)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).children) as usize - ptr as usize },
24usize,
concat!(
"Offset of field: ",
stringify!(_xmlElement),
"::",
stringify!(children)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).last) as usize - ptr as usize },
32usize,
concat!(
"Offset of field: ",
stringify!(_xmlElement),
"::",
stringify!(last)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).parent) as usize - ptr as usize },
40usize,
concat!(
"Offset of field: ",
stringify!(_xmlElement),
"::",
stringify!(parent)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).next) as usize - ptr as usize },
48usize,
concat!(
"Offset of field: ",
stringify!(_xmlElement),
"::",
stringify!(next)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).prev) as usize - ptr as usize },
56usize,
concat!(
"Offset of field: ",
stringify!(_xmlElement),
"::",
stringify!(prev)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).doc) as usize - ptr as usize },
64usize,
concat!(
"Offset of field: ",
stringify!(_xmlElement),
"::",
stringify!(doc)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).etype) as usize - ptr as usize },
72usize,
concat!(
"Offset of field: ",
stringify!(_xmlElement),
"::",
stringify!(etype)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).content) as usize - ptr as usize },
80usize,
concat!(
"Offset of field: ",
stringify!(_xmlElement),
"::",
stringify!(content)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).attributes) as usize - ptr as usize },
88usize,
concat!(
"Offset of field: ",
stringify!(_xmlElement),
"::",
stringify!(attributes)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).prefix) as usize - ptr as usize },
96usize,
concat!(
"Offset of field: ",
stringify!(_xmlElement),
"::",
stringify!(prefix)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).contModel) as usize - ptr as usize },
104usize,
concat!(
"Offset of field: ",
stringify!(_xmlElement),
"::",
stringify!(contModel)
)
);
}
pub use self::xmlElementType as xmlNsType;
pub type xmlNs = _xmlNs;
pub type xmlNsPtr = *mut xmlNs;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct _xmlNs {
pub next: *mut _xmlNs,
pub type_: xmlNsType,
pub href: *const xmlChar,
pub prefix: *const xmlChar,
pub _private: *mut ::std::os::raw::c_void,
pub context: *mut _xmlDoc,
}
#[test]
fn bindgen_test_layout__xmlNs() {
const UNINIT: ::std::mem::MaybeUninit<_xmlNs> = ::std::mem::MaybeUninit::uninit();
let ptr = UNINIT.as_ptr();
assert_eq!(
::std::mem::size_of::<_xmlNs>(),
48usize,
concat!("Size of: ", stringify!(_xmlNs))
);
assert_eq!(
::std::mem::align_of::<_xmlNs>(),
8usize,
concat!("Alignment of ", stringify!(_xmlNs))
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).next) as usize - ptr as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(_xmlNs),
"::",
stringify!(next)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).type_) as usize - ptr as usize },
8usize,
concat!(
"Offset of field: ",
stringify!(_xmlNs),
"::",
stringify!(type_)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).href) as usize - ptr as usize },
16usize,
concat!(
"Offset of field: ",
stringify!(_xmlNs),
"::",
stringify!(href)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).prefix) as usize - ptr as usize },
24usize,
concat!(
"Offset of field: ",
stringify!(_xmlNs),
"::",
stringify!(prefix)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr)._private) as usize - ptr as usize },
32usize,
concat!(
"Offset of field: ",
stringify!(_xmlNs),
"::",
stringify!(_private)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).context) as usize - ptr as usize },
40usize,
concat!(
"Offset of field: ",
stringify!(_xmlNs),
"::",
stringify!(context)
)
);
}
pub type xmlDtd = _xmlDtd;
pub type xmlDtdPtr = *mut xmlDtd;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct _xmlDtd {
pub _private: *mut ::std::os::raw::c_void,
pub type_: xmlElementType,
pub name: *const xmlChar,
pub children: *mut _xmlNode,
pub last: *mut _xmlNode,
pub parent: *mut _xmlDoc,
pub next: *mut _xmlNode,
pub prev: *mut _xmlNode,
pub doc: *mut _xmlDoc,
pub notations: *mut ::std::os::raw::c_void,
pub elements: *mut ::std::os::raw::c_void,
pub attributes: *mut ::std::os::raw::c_void,
pub entities: *mut ::std::os::raw::c_void,
pub ExternalID: *const xmlChar,
pub SystemID: *const xmlChar,
pub pentities: *mut ::std::os::raw::c_void,
}
#[test]
fn bindgen_test_layout__xmlDtd() {
const UNINIT: ::std::mem::MaybeUninit<_xmlDtd> = ::std::mem::MaybeUninit::uninit();
let ptr = UNINIT.as_ptr();
assert_eq!(
::std::mem::size_of::<_xmlDtd>(),
128usize,
concat!("Size of: ", stringify!(_xmlDtd))
);
assert_eq!(
::std::mem::align_of::<_xmlDtd>(),
8usize,
concat!("Alignment of ", stringify!(_xmlDtd))
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr)._private) as usize - ptr as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(_xmlDtd),
"::",
stringify!(_private)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).type_) as usize - ptr as usize },
8usize,
concat!(
"Offset of field: ",
stringify!(_xmlDtd),
"::",
stringify!(type_)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).name) as usize - ptr as usize },
16usize,
concat!(
"Offset of field: ",
stringify!(_xmlDtd),
"::",
stringify!(name)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).children) as usize - ptr as usize },
24usize,
concat!(
"Offset of field: ",
stringify!(_xmlDtd),
"::",
stringify!(children)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).last) as usize - ptr as usize },
32usize,
concat!(
"Offset of field: ",
stringify!(_xmlDtd),
"::",
stringify!(last)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).parent) as usize - ptr as usize },
40usize,
concat!(
"Offset of field: ",
stringify!(_xmlDtd),
"::",
stringify!(parent)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).next) as usize - ptr as usize },
48usize,
concat!(
"Offset of field: ",
stringify!(_xmlDtd),
"::",
stringify!(next)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).prev) as usize - ptr as usize },
56usize,
concat!(
"Offset of field: ",
stringify!(_xmlDtd),
"::",
stringify!(prev)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).doc) as usize - ptr as usize },
64usize,
concat!(
"Offset of field: ",
stringify!(_xmlDtd),
"::",
stringify!(doc)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).notations) as usize - ptr as usize },
72usize,
concat!(
"Offset of field: ",
stringify!(_xmlDtd),
"::",
stringify!(notations)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).elements) as usize - ptr as usize },
80usize,
concat!(
"Offset of field: ",
stringify!(_xmlDtd),
"::",
stringify!(elements)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).attributes) as usize - ptr as usize },
88usize,
concat!(
"Offset of field: ",
stringify!(_xmlDtd),
"::",
stringify!(attributes)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).entities) as usize - ptr as usize },
96usize,
concat!(
"Offset of field: ",
stringify!(_xmlDtd),
"::",
stringify!(entities)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).ExternalID) as usize - ptr as usize },
104usize,
concat!(
"Offset of field: ",
stringify!(_xmlDtd),
"::",
stringify!(ExternalID)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).SystemID) as usize - ptr as usize },
112usize,
concat!(
"Offset of field: ",
stringify!(_xmlDtd),
"::",
stringify!(SystemID)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).pentities) as usize - ptr as usize },
120usize,
concat!(
"Offset of field: ",
stringify!(_xmlDtd),
"::",
stringify!(pentities)
)
);
}
pub type xmlAttr = _xmlAttr;
pub type xmlAttrPtr = *mut xmlAttr;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct _xmlAttr {
pub _private: *mut ::std::os::raw::c_void,
pub type_: xmlElementType,
pub name: *const xmlChar,
pub children: *mut _xmlNode,
pub last: *mut _xmlNode,
pub parent: *mut _xmlNode,
pub next: *mut _xmlAttr,
pub prev: *mut _xmlAttr,
pub doc: *mut _xmlDoc,
pub ns: *mut xmlNs,
pub atype: xmlAttributeType,
pub psvi: *mut ::std::os::raw::c_void,
}
#[test]
fn bindgen_test_layout__xmlAttr() {
const UNINIT: ::std::mem::MaybeUninit<_xmlAttr> = ::std::mem::MaybeUninit::uninit();
let ptr = UNINIT.as_ptr();
assert_eq!(
::std::mem::size_of::<_xmlAttr>(),
96usize,
concat!("Size of: ", stringify!(_xmlAttr))
);
assert_eq!(
::std::mem::align_of::<_xmlAttr>(),
8usize,
concat!("Alignment of ", stringify!(_xmlAttr))
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr)._private) as usize - ptr as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(_xmlAttr),
"::",
stringify!(_private)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).type_) as usize - ptr as usize },
8usize,
concat!(
"Offset of field: ",
stringify!(_xmlAttr),
"::",
stringify!(type_)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).name) as usize - ptr as usize },
16usize,
concat!(
"Offset of field: ",
stringify!(_xmlAttr),
"::",
stringify!(name)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).children) as usize - ptr as usize },
24usize,
concat!(
"Offset of field: ",
stringify!(_xmlAttr),
"::",
stringify!(children)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).last) as usize - ptr as usize },
32usize,
concat!(
"Offset of field: ",
stringify!(_xmlAttr),
"::",
stringify!(last)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).parent) as usize - ptr as usize },
40usize,
concat!(
"Offset of field: ",
stringify!(_xmlAttr),
"::",
stringify!(parent)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).next) as usize - ptr as usize },
48usize,
concat!(
"Offset of field: ",
stringify!(_xmlAttr),
"::",
stringify!(next)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).prev) as usize - ptr as usize },
56usize,
concat!(
"Offset of field: ",
stringify!(_xmlAttr),
"::",
stringify!(prev)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).doc) as usize - ptr as usize },
64usize,
concat!(
"Offset of field: ",
stringify!(_xmlAttr),
"::",
stringify!(doc)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).ns) as usize - ptr as usize },
72usize,
concat!(
"Offset of field: ",
stringify!(_xmlAttr),
"::",
stringify!(ns)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).atype) as usize - ptr as usize },
80usize,
concat!(
"Offset of field: ",
stringify!(_xmlAttr),
"::",
stringify!(atype)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).psvi) as usize - ptr as usize },
88usize,
concat!(
"Offset of field: ",
stringify!(_xmlAttr),
"::",
stringify!(psvi)
)
);
}
pub type xmlID = _xmlID;
pub type xmlIDPtr = *mut xmlID;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct _xmlID {
pub next: *mut _xmlID,
pub value: *const xmlChar,
pub attr: xmlAttrPtr,
pub name: *const xmlChar,
pub lineno: ::std::os::raw::c_int,
pub doc: *mut _xmlDoc,
}
#[test]
fn bindgen_test_layout__xmlID() {
const UNINIT: ::std::mem::MaybeUninit<_xmlID> = ::std::mem::MaybeUninit::uninit();
let ptr = UNINIT.as_ptr();
assert_eq!(
::std::mem::size_of::<_xmlID>(),
48usize,
concat!("Size of: ", stringify!(_xmlID))
);
assert_eq!(
::std::mem::align_of::<_xmlID>(),
8usize,
concat!("Alignment of ", stringify!(_xmlID))
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).next) as usize - ptr as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(_xmlID),
"::",
stringify!(next)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).value) as usize - ptr as usize },
8usize,
concat!(
"Offset of field: ",
stringify!(_xmlID),
"::",
stringify!(value)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).attr) as usize - ptr as usize },
16usize,
concat!(
"Offset of field: ",
stringify!(_xmlID),
"::",
stringify!(attr)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).name) as usize - ptr as usize },
24usize,
concat!(
"Offset of field: ",
stringify!(_xmlID),
"::",
stringify!(name)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).lineno) as usize - ptr as usize },
32usize,
concat!(
"Offset of field: ",
stringify!(_xmlID),
"::",
stringify!(lineno)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).doc) as usize - ptr as usize },
40usize,
concat!(
"Offset of field: ",
stringify!(_xmlID),
"::",
stringify!(doc)
)
);
}
pub type xmlRef = _xmlRef;
pub type xmlRefPtr = *mut xmlRef;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct _xmlRef {
pub next: *mut _xmlRef,
pub value: *const xmlChar,
pub attr: xmlAttrPtr,
pub name: *const xmlChar,
pub lineno: ::std::os::raw::c_int,
}
#[test]
fn bindgen_test_layout__xmlRef() {
const UNINIT: ::std::mem::MaybeUninit<_xmlRef> = ::std::mem::MaybeUninit::uninit();
let ptr = UNINIT.as_ptr();
assert_eq!(
::std::mem::size_of::<_xmlRef>(),
40usize,
concat!("Size of: ", stringify!(_xmlRef))
);
assert_eq!(
::std::mem::align_of::<_xmlRef>(),
8usize,
concat!("Alignment of ", stringify!(_xmlRef))
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).next) as usize - ptr as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(_xmlRef),
"::",
stringify!(next)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).value) as usize - ptr as usize },
8usize,
concat!(
"Offset of field: ",
stringify!(_xmlRef),
"::",
stringify!(value)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).attr) as usize - ptr as usize },
16usize,
concat!(
"Offset of field: ",
stringify!(_xmlRef),
"::",
stringify!(attr)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).name) as usize - ptr as usize },
24usize,
concat!(
"Offset of field: ",
stringify!(_xmlRef),
"::",
stringify!(name)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).lineno) as usize - ptr as usize },
32usize,
concat!(
"Offset of field: ",
stringify!(_xmlRef),
"::",
stringify!(lineno)
)
);
}
pub type xmlNode = _xmlNode;
pub type xmlNodePtr = *mut xmlNode;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct _xmlNode {
pub _private: *mut ::std::os::raw::c_void,
pub type_: xmlElementType,
pub name: *const xmlChar,
pub children: *mut _xmlNode,
pub last: *mut _xmlNode,
pub parent: *mut _xmlNode,
pub next: *mut _xmlNode,
pub prev: *mut _xmlNode,
pub doc: *mut _xmlDoc,
pub ns: *mut xmlNs,
pub content: *mut xmlChar,
pub properties: *mut _xmlAttr,
pub nsDef: *mut xmlNs,
pub psvi: *mut ::std::os::raw::c_void,
pub line: ::std::os::raw::c_ushort,
pub extra: ::std::os::raw::c_ushort,
}
#[test]
fn bindgen_test_layout__xmlNode() {
const UNINIT: ::std::mem::MaybeUninit<_xmlNode> = ::std::mem::MaybeUninit::uninit();
let ptr = UNINIT.as_ptr();
assert_eq!(
::std::mem::size_of::<_xmlNode>(),
120usize,
concat!("Size of: ", stringify!(_xmlNode))
);
assert_eq!(
::std::mem::align_of::<_xmlNode>(),
8usize,
concat!("Alignment of ", stringify!(_xmlNode))
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr)._private) as usize - ptr as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(_xmlNode),
"::",
stringify!(_private)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).type_) as usize - ptr as usize },
8usize,
concat!(
"Offset of field: ",
stringify!(_xmlNode),
"::",
stringify!(type_)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).name) as usize - ptr as usize },
16usize,
concat!(
"Offset of field: ",
stringify!(_xmlNode),
"::",
stringify!(name)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).children) as usize - ptr as usize },
24usize,
concat!(
"Offset of field: ",
stringify!(_xmlNode),
"::",
stringify!(children)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).last) as usize - ptr as usize },
32usize,
concat!(
"Offset of field: ",
stringify!(_xmlNode),
"::",
stringify!(last)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).parent) as usize - ptr as usize },
40usize,
concat!(
"Offset of field: ",
stringify!(_xmlNode),
"::",
stringify!(parent)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).next) as usize - ptr as usize },
48usize,
concat!(
"Offset of field: ",
stringify!(_xmlNode),
"::",
stringify!(next)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).prev) as usize - ptr as usize },
56usize,
concat!(
"Offset of field: ",
stringify!(_xmlNode),
"::",
stringify!(prev)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).doc) as usize - ptr as usize },
64usize,
concat!(
"Offset of field: ",
stringify!(_xmlNode),
"::",
stringify!(doc)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).ns) as usize - ptr as usize },
72usize,
concat!(
"Offset of field: ",
stringify!(_xmlNode),
"::",
stringify!(ns)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).content) as usize - ptr as usize },
80usize,
concat!(
"Offset of field: ",
stringify!(_xmlNode),
"::",
stringify!(content)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).properties) as usize - ptr as usize },
88usize,
concat!(
"Offset of field: ",
stringify!(_xmlNode),
"::",
stringify!(properties)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).nsDef) as usize - ptr as usize },
96usize,
concat!(
"Offset of field: ",
stringify!(_xmlNode),
"::",
stringify!(nsDef)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).psvi) as usize - ptr as usize },
104usize,
concat!(
"Offset of field: ",
stringify!(_xmlNode),
"::",
stringify!(psvi)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).line) as usize - ptr as usize },
112usize,
concat!(
"Offset of field: ",
stringify!(_xmlNode),
"::",
stringify!(line)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).extra) as usize - ptr as usize },
114usize,
concat!(
"Offset of field: ",
stringify!(_xmlNode),
"::",
stringify!(extra)
)
);
}
pub const xmlDocProperties_XML_DOC_WELLFORMED: xmlDocProperties = 1;
pub const xmlDocProperties_XML_DOC_NSVALID: xmlDocProperties = 2;
pub const xmlDocProperties_XML_DOC_OLD10: xmlDocProperties = 4;
pub const xmlDocProperties_XML_DOC_DTDVALID: xmlDocProperties = 8;
pub const xmlDocProperties_XML_DOC_XINCLUDE: xmlDocProperties = 16;
pub const xmlDocProperties_XML_DOC_USERBUILT: xmlDocProperties = 32;
pub const xmlDocProperties_XML_DOC_INTERNAL: xmlDocProperties = 64;
pub const xmlDocProperties_XML_DOC_HTML: xmlDocProperties = 128;
pub type xmlDocProperties = ::std::os::raw::c_uint;
pub type xmlDoc = _xmlDoc;
pub type xmlDocPtr = *mut xmlDoc;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct _xmlDoc {
pub _private: *mut ::std::os::raw::c_void,
pub type_: xmlElementType,
pub name: *mut ::std::os::raw::c_char,
pub children: *mut _xmlNode,
pub last: *mut _xmlNode,
pub parent: *mut _xmlNode,
pub next: *mut _xmlNode,
pub prev: *mut _xmlNode,
pub doc: *mut _xmlDoc,
pub compression: ::std::os::raw::c_int,
pub standalone: ::std::os::raw::c_int,
pub intSubset: *mut _xmlDtd,
pub extSubset: *mut _xmlDtd,
pub oldNs: *mut _xmlNs,
pub version: *const xmlChar,
pub encoding: *const xmlChar,
pub ids: *mut ::std::os::raw::c_void,
pub refs: *mut ::std::os::raw::c_void,
pub URL: *const xmlChar,
pub charset: ::std::os::raw::c_int,
pub dict: *mut _xmlDict,
pub psvi: *mut ::std::os::raw::c_void,
pub parseFlags: ::std::os::raw::c_int,
pub properties: ::std::os::raw::c_int,
}
#[test]
fn bindgen_test_layout__xmlDoc() {
const UNINIT: ::std::mem::MaybeUninit<_xmlDoc> = ::std::mem::MaybeUninit::uninit();
let ptr = UNINIT.as_ptr();
assert_eq!(
::std::mem::size_of::<_xmlDoc>(),
176usize,
concat!("Size of: ", stringify!(_xmlDoc))
);
assert_eq!(
::std::mem::align_of::<_xmlDoc>(),
8usize,
concat!("Alignment of ", stringify!(_xmlDoc))
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr)._private) as usize - ptr as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(_xmlDoc),
"::",
stringify!(_private)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).type_) as usize - ptr as usize },
8usize,
concat!(
"Offset of field: ",
stringify!(_xmlDoc),
"::",
stringify!(type_)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).name) as usize - ptr as usize },
16usize,
concat!(
"Offset of field: ",
stringify!(_xmlDoc),
"::",
stringify!(name)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).children) as usize - ptr as usize },
24usize,
concat!(
"Offset of field: ",
stringify!(_xmlDoc),
"::",
stringify!(children)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).last) as usize - ptr as usize },
32usize,
concat!(
"Offset of field: ",
stringify!(_xmlDoc),
"::",
stringify!(last)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).parent) as usize - ptr as usize },
40usize,
concat!(
"Offset of field: ",
stringify!(_xmlDoc),
"::",
stringify!(parent)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).next) as usize - ptr as usize },
48usize,
concat!(
"Offset of field: ",
stringify!(_xmlDoc),
"::",
stringify!(next)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).prev) as usize - ptr as usize },
56usize,
concat!(
"Offset of field: ",
stringify!(_xmlDoc),
"::",
stringify!(prev)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).doc) as usize - ptr as usize },
64usize,
concat!(
"Offset of field: ",
stringify!(_xmlDoc),
"::",
stringify!(doc)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).compression) as usize - ptr as usize },
72usize,
concat!(
"Offset of field: ",
stringify!(_xmlDoc),
"::",
stringify!(compression)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).standalone) as usize - ptr as usize },
76usize,
concat!(
"Offset of field: ",
stringify!(_xmlDoc),
"::",
stringify!(standalone)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).intSubset) as usize - ptr as usize },
80usize,
concat!(
"Offset of field: ",
stringify!(_xmlDoc),
"::",
stringify!(intSubset)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).extSubset) as usize - ptr as usize },
88usize,
concat!(
"Offset of field: ",
stringify!(_xmlDoc),
"::",
stringify!(extSubset)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).oldNs) as usize - ptr as usize },
96usize,
concat!(
"Offset of field: ",
stringify!(_xmlDoc),
"::",
stringify!(oldNs)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).version) as usize - ptr as usize },
104usize,
concat!(
"Offset of field: ",
stringify!(_xmlDoc),
"::",
stringify!(version)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).encoding) as usize - ptr as usize },
112usize,
concat!(
"Offset of field: ",
stringify!(_xmlDoc),
"::",
stringify!(encoding)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).ids) as usize - ptr as usize },
120usize,
concat!(
"Offset of field: ",
stringify!(_xmlDoc),
"::",
stringify!(ids)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).refs) as usize - ptr as usize },
128usize,
concat!(
"Offset of field: ",
stringify!(_xmlDoc),
"::",
stringify!(refs)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).URL) as usize - ptr as usize },
136usize,
concat!(
"Offset of field: ",
stringify!(_xmlDoc),
"::",
stringify!(URL)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).charset) as usize - ptr as usize },
144usize,
concat!(
"Offset of field: ",
stringify!(_xmlDoc),
"::",
stringify!(charset)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).dict) as usize - ptr as usize },
152usize,
concat!(
"Offset of field: ",
stringify!(_xmlDoc),
"::",
stringify!(dict)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).psvi) as usize - ptr as usize },
160usize,
concat!(
"Offset of field: ",
stringify!(_xmlDoc),
"::",
stringify!(psvi)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).parseFlags) as usize - ptr as usize },
168usize,
concat!(
"Offset of field: ",
stringify!(_xmlDoc),
"::",
stringify!(parseFlags)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).properties) as usize - ptr as usize },
172usize,
concat!(
"Offset of field: ",
stringify!(_xmlDoc),
"::",
stringify!(properties)
)
);
}
pub type xmlDOMWrapCtxt = _xmlDOMWrapCtxt;
pub type xmlDOMWrapCtxtPtr = *mut xmlDOMWrapCtxt;
pub type xmlDOMWrapAcquireNsFunction = ::std::option::Option<
unsafe extern "C" fn(
ctxt: xmlDOMWrapCtxtPtr,
node: xmlNodePtr,
nsName: *const xmlChar,
nsPrefix: *const xmlChar,
) -> xmlNsPtr,
>;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct _xmlDOMWrapCtxt {
pub _private: *mut ::std::os::raw::c_void,
pub type_: ::std::os::raw::c_int,
pub namespaceMap: *mut ::std::os::raw::c_void,
pub getNsForNodeFunc: xmlDOMWrapAcquireNsFunction,
}
#[test]
fn bindgen_test_layout__xmlDOMWrapCtxt() {
const UNINIT: ::std::mem::MaybeUninit<_xmlDOMWrapCtxt> = ::std::mem::MaybeUninit::uninit();
let ptr = UNINIT.as_ptr();
assert_eq!(
::std::mem::size_of::<_xmlDOMWrapCtxt>(),
32usize,
concat!("Size of: ", stringify!(_xmlDOMWrapCtxt))
);
assert_eq!(
::std::mem::align_of::<_xmlDOMWrapCtxt>(),
8usize,
concat!("Alignment of ", stringify!(_xmlDOMWrapCtxt))
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr)._private) as usize - ptr as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(_xmlDOMWrapCtxt),
"::",
stringify!(_private)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).type_) as usize - ptr as usize },
8usize,
concat!(
"Offset of field: ",
stringify!(_xmlDOMWrapCtxt),
"::",
stringify!(type_)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).namespaceMap) as usize - ptr as usize },
16usize,
concat!(
"Offset of field: ",
stringify!(_xmlDOMWrapCtxt),
"::",
stringify!(namespaceMap)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).getNsForNodeFunc) as usize - ptr as usize },
24usize,
concat!(
"Offset of field: ",
stringify!(_xmlDOMWrapCtxt),
"::",
stringify!(getNsForNodeFunc)
)
);
}
extern "C" {
pub fn xmlValidateNCName(
value: *const xmlChar,
space: ::std::os::raw::c_int,
) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn xmlValidateQName(
value: *const xmlChar,
space: ::std::os::raw::c_int,
) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn xmlValidateName(
value: *const xmlChar,
space: ::std::os::raw::c_int,
) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn xmlValidateNMToken(
value: *const xmlChar,
space: ::std::os::raw::c_int,
) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn xmlBuildQName(
ncname: *const xmlChar,
prefix: *const xmlChar,
memory: *mut xmlChar,
len: ::std::os::raw::c_int,
) -> *mut xmlChar;
}
extern "C" {
pub fn xmlSplitQName2(name: *const xmlChar, prefix: *mut *mut xmlChar) -> *mut xmlChar;
}
extern "C" {
pub fn xmlSplitQName3(name: *const xmlChar, len: *mut ::std::os::raw::c_int) -> *const xmlChar;
}
extern "C" {
pub fn xmlSetBufferAllocationScheme(scheme: xmlBufferAllocationScheme);
}
extern "C" {
pub fn xmlGetBufferAllocationScheme() -> xmlBufferAllocationScheme;
}
extern "C" {
pub fn xmlBufferCreate() -> xmlBufferPtr;
}
extern "C" {
pub fn xmlBufferCreateSize(size: usize) -> xmlBufferPtr;
}
extern "C" {
pub fn xmlBufferCreateStatic(mem: *mut ::std::os::raw::c_void, size: usize) -> xmlBufferPtr;
}
extern "C" {
pub fn xmlBufferResize(
buf: xmlBufferPtr,
size: ::std::os::raw::c_uint,
) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn xmlBufferFree(buf: xmlBufferPtr);
}
extern "C" {
pub fn xmlBufferDump(file: *mut FILE, buf: xmlBufferPtr) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn xmlBufferAdd(
buf: xmlBufferPtr,
str_: *const xmlChar,
len: ::std::os::raw::c_int,
) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn xmlBufferAddHead(
buf: xmlBufferPtr,
str_: *const xmlChar,
len: ::std::os::raw::c_int,
) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn xmlBufferCat(buf: xmlBufferPtr, str_: *const xmlChar) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn xmlBufferCCat(
buf: xmlBufferPtr,
str_: *const ::std::os::raw::c_char,
) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn xmlBufferShrink(buf: xmlBufferPtr, len: ::std::os::raw::c_uint)
-> ::std::os::raw::c_int;
}
extern "C" {
pub fn xmlBufferGrow(buf: xmlBufferPtr, len: ::std::os::raw::c_uint) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn xmlBufferEmpty(buf: xmlBufferPtr);
}
extern "C" {
pub fn xmlBufferContent(buf: *const xmlBuffer) -> *const xmlChar;
}
extern "C" {
pub fn xmlBufferDetach(buf: xmlBufferPtr) -> *mut xmlChar;
}
extern "C" {
pub fn xmlBufferSetAllocationScheme(buf: xmlBufferPtr, scheme: xmlBufferAllocationScheme);
}
extern "C" {
pub fn xmlBufferLength(buf: *const xmlBuffer) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn xmlCreateIntSubset(
doc: xmlDocPtr,
name: *const xmlChar,
ExternalID: *const xmlChar,
SystemID: *const xmlChar,
) -> xmlDtdPtr;
}
extern "C" {
pub fn xmlNewDtd(
doc: xmlDocPtr,
name: *const xmlChar,
ExternalID: *const xmlChar,
SystemID: *const xmlChar,
) -> xmlDtdPtr;
}
extern "C" {
pub fn xmlGetIntSubset(doc: *const xmlDoc) -> xmlDtdPtr;
}
extern "C" {
pub fn xmlFreeDtd(cur: xmlDtdPtr);
}
extern "C" {
pub fn xmlNewNs(node: xmlNodePtr, href: *const xmlChar, prefix: *const xmlChar) -> xmlNsPtr;
}
extern "C" {
pub fn xmlFreeNs(cur: xmlNsPtr);
}
extern "C" {
pub fn xmlFreeNsList(cur: xmlNsPtr);
}
extern "C" {
pub fn xmlNewDoc(version: *const xmlChar) -> xmlDocPtr;
}
extern "C" {
pub fn xmlFreeDoc(cur: xmlDocPtr);
}
extern "C" {
pub fn xmlNewDocProp(doc: xmlDocPtr, name: *const xmlChar, value: *const xmlChar)
-> xmlAttrPtr;
}
extern "C" {
pub fn xmlNewProp(node: xmlNodePtr, name: *const xmlChar, value: *const xmlChar) -> xmlAttrPtr;
}
extern "C" {
pub fn xmlNewNsProp(
node: xmlNodePtr,
ns: xmlNsPtr,
name: *const xmlChar,
value: *const xmlChar,
) -> xmlAttrPtr;
}
extern "C" {
pub fn xmlNewNsPropEatName(
node: xmlNodePtr,
ns: xmlNsPtr,
name: *mut xmlChar,
value: *const xmlChar,
) -> xmlAttrPtr;
}
extern "C" {
pub fn xmlFreePropList(cur: xmlAttrPtr);
}
extern "C" {
pub fn xmlFreeProp(cur: xmlAttrPtr);
}
extern "C" {
pub fn xmlCopyProp(target: xmlNodePtr, cur: xmlAttrPtr) -> xmlAttrPtr;
}
extern "C" {
pub fn xmlCopyPropList(target: xmlNodePtr, cur: xmlAttrPtr) -> xmlAttrPtr;
}
extern "C" {
pub fn xmlCopyDtd(dtd: xmlDtdPtr) -> xmlDtdPtr;
}
extern "C" {
pub fn xmlCopyDoc(doc: xmlDocPtr, recursive: ::std::os::raw::c_int) -> xmlDocPtr;
}
extern "C" {
pub fn xmlNewDocNode(
doc: xmlDocPtr,
ns: xmlNsPtr,
name: *const xmlChar,
content: *const xmlChar,
) -> xmlNodePtr;
}
extern "C" {
pub fn xmlNewDocNodeEatName(
doc: xmlDocPtr,
ns: xmlNsPtr,
name: *mut xmlChar,
content: *const xmlChar,
) -> xmlNodePtr;
}
extern "C" {
pub fn xmlNewNode(ns: xmlNsPtr, name: *const xmlChar) -> xmlNodePtr;
}
extern "C" {
pub fn xmlNewNodeEatName(ns: xmlNsPtr, name: *mut xmlChar) -> xmlNodePtr;
}
extern "C" {
pub fn xmlNewChild(
parent: xmlNodePtr,
ns: xmlNsPtr,
name: *const xmlChar,
content: *const xmlChar,
) -> xmlNodePtr;
}
extern "C" {
pub fn xmlNewDocText(doc: *const xmlDoc, content: *const xmlChar) -> xmlNodePtr;
}
extern "C" {
pub fn xmlNewText(content: *const xmlChar) -> xmlNodePtr;
}
extern "C" {
pub fn xmlNewDocPI(doc: xmlDocPtr, name: *const xmlChar, content: *const xmlChar)
-> xmlNodePtr;
}
extern "C" {
pub fn xmlNewPI(name: *const xmlChar, content: *const xmlChar) -> xmlNodePtr;
}
extern "C" {
pub fn xmlNewDocTextLen(
doc: xmlDocPtr,
content: *const xmlChar,
len: ::std::os::raw::c_int,
) -> xmlNodePtr;
}
extern "C" {
pub fn xmlNewTextLen(content: *const xmlChar, len: ::std::os::raw::c_int) -> xmlNodePtr;
}
extern "C" {
pub fn xmlNewDocComment(doc: xmlDocPtr, content: *const xmlChar) -> xmlNodePtr;
}
extern "C" {
pub fn xmlNewComment(content: *const xmlChar) -> xmlNodePtr;
}
extern "C" {
pub fn xmlNewCDataBlock(
doc: xmlDocPtr,
content: *const xmlChar,
len: ::std::os::raw::c_int,
) -> xmlNodePtr;
}
extern "C" {
pub fn xmlNewCharRef(doc: xmlDocPtr, name: *const xmlChar) -> xmlNodePtr;
}
extern "C" {
pub fn xmlNewReference(doc: *const xmlDoc, name: *const xmlChar) -> xmlNodePtr;
}
extern "C" {
pub fn xmlCopyNode(node: xmlNodePtr, recursive: ::std::os::raw::c_int) -> xmlNodePtr;
}
extern "C" {
pub fn xmlDocCopyNode(
node: xmlNodePtr,
doc: xmlDocPtr,
recursive: ::std::os::raw::c_int,
) -> xmlNodePtr;
}
extern "C" {
pub fn xmlDocCopyNodeList(doc: xmlDocPtr, node: xmlNodePtr) -> xmlNodePtr;
}
extern "C" {
pub fn xmlCopyNodeList(node: xmlNodePtr) -> xmlNodePtr;
}
extern "C" {
pub fn xmlNewTextChild(
parent: xmlNodePtr,
ns: xmlNsPtr,
name: *const xmlChar,
content: *const xmlChar,
) -> xmlNodePtr;
}
extern "C" {
pub fn xmlNewDocRawNode(
doc: xmlDocPtr,
ns: xmlNsPtr,
name: *const xmlChar,
content: *const xmlChar,
) -> xmlNodePtr;
}
extern "C" {
pub fn xmlNewDocFragment(doc: xmlDocPtr) -> xmlNodePtr;
}
extern "C" {
pub fn xmlGetLineNo(node: *const xmlNode) -> ::std::os::raw::c_long;
}
extern "C" {
pub fn xmlGetNodePath(node: *const xmlNode) -> *mut xmlChar;
}
extern "C" {
pub fn xmlDocGetRootElement(doc: *const xmlDoc) -> xmlNodePtr;
}
extern "C" {
pub fn xmlGetLastChild(parent: *const xmlNode) -> xmlNodePtr;
}
extern "C" {
pub fn xmlNodeIsText(node: *const xmlNode) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn xmlIsBlankNode(node: *const xmlNode) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn xmlDocSetRootElement(doc: xmlDocPtr, root: xmlNodePtr) -> xmlNodePtr;
}
extern "C" {
pub fn xmlNodeSetName(cur: xmlNodePtr, name: *const xmlChar);
}
extern "C" {
pub fn xmlAddChild(parent: xmlNodePtr, cur: xmlNodePtr) -> xmlNodePtr;
}
extern "C" {
pub fn xmlAddChildList(parent: xmlNodePtr, cur: xmlNodePtr) -> xmlNodePtr;
}
extern "C" {
pub fn xmlReplaceNode(old: xmlNodePtr, cur: xmlNodePtr) -> xmlNodePtr;
}
extern "C" {
pub fn xmlAddPrevSibling(cur: xmlNodePtr, elem: xmlNodePtr) -> xmlNodePtr;
}
extern "C" {
pub fn xmlAddSibling(cur: xmlNodePtr, elem: xmlNodePtr) -> xmlNodePtr;
}
extern "C" {
pub fn xmlAddNextSibling(cur: xmlNodePtr, elem: xmlNodePtr) -> xmlNodePtr;
}
extern "C" {
pub fn xmlUnlinkNode(cur: xmlNodePtr);
}
extern "C" {
pub fn xmlTextMerge(first: xmlNodePtr, second: xmlNodePtr) -> xmlNodePtr;
}
extern "C" {
pub fn xmlTextConcat(
node: xmlNodePtr,
content: *const xmlChar,
len: ::std::os::raw::c_int,
) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn xmlFreeNodeList(cur: xmlNodePtr);
}
extern "C" {
pub fn xmlFreeNode(cur: xmlNodePtr);
}
extern "C" {
pub fn xmlSetTreeDoc(tree: xmlNodePtr, doc: xmlDocPtr);
}
extern "C" {
pub fn xmlSetListDoc(list: xmlNodePtr, doc: xmlDocPtr);
}
extern "C" {
pub fn xmlSearchNs(doc: xmlDocPtr, node: xmlNodePtr, nameSpace: *const xmlChar) -> xmlNsPtr;
}
extern "C" {
pub fn xmlSearchNsByHref(doc: xmlDocPtr, node: xmlNodePtr, href: *const xmlChar) -> xmlNsPtr;
}
extern "C" {
pub fn xmlGetNsList(doc: *const xmlDoc, node: *const xmlNode) -> *mut xmlNsPtr;
}
extern "C" {
pub fn xmlSetNs(node: xmlNodePtr, ns: xmlNsPtr);
}
extern "C" {
pub fn xmlCopyNamespace(cur: xmlNsPtr) -> xmlNsPtr;
}
extern "C" {
pub fn xmlCopyNamespaceList(cur: xmlNsPtr) -> xmlNsPtr;
}
extern "C" {
pub fn xmlSetProp(node: xmlNodePtr, name: *const xmlChar, value: *const xmlChar) -> xmlAttrPtr;
}
extern "C" {
pub fn xmlSetNsProp(
node: xmlNodePtr,
ns: xmlNsPtr,
name: *const xmlChar,
value: *const xmlChar,
) -> xmlAttrPtr;
}
extern "C" {
pub fn xmlGetNoNsProp(node: *const xmlNode, name: *const xmlChar) -> *mut xmlChar;
}
extern "C" {
pub fn xmlGetProp(node: *const xmlNode, name: *const xmlChar) -> *mut xmlChar;
}
extern "C" {
pub fn xmlHasProp(node: *const xmlNode, name: *const xmlChar) -> xmlAttrPtr;
}
extern "C" {
pub fn xmlHasNsProp(
node: *const xmlNode,
name: *const xmlChar,
nameSpace: *const xmlChar,
) -> xmlAttrPtr;
}
extern "C" {
pub fn xmlGetNsProp(
node: *const xmlNode,
name: *const xmlChar,
nameSpace: *const xmlChar,
) -> *mut xmlChar;
}
extern "C" {
pub fn xmlStringGetNodeList(doc: *const xmlDoc, value: *const xmlChar) -> xmlNodePtr;
}
extern "C" {
pub fn xmlStringLenGetNodeList(
doc: *const xmlDoc,
value: *const xmlChar,
len: ::std::os::raw::c_int,
) -> xmlNodePtr;
}
extern "C" {
pub fn xmlNodeListGetString(
doc: xmlDocPtr,
list: *const xmlNode,
inLine: ::std::os::raw::c_int,
) -> *mut xmlChar;
}
extern "C" {
pub fn xmlNodeListGetRawString(
doc: *const xmlDoc,
list: *const xmlNode,
inLine: ::std::os::raw::c_int,
) -> *mut xmlChar;
}
extern "C" {
pub fn xmlNodeSetContent(cur: xmlNodePtr, content: *const xmlChar);
}
extern "C" {
pub fn xmlNodeSetContentLen(
cur: xmlNodePtr,
content: *const xmlChar,
len: ::std::os::raw::c_int,
);
}
extern "C" {
pub fn xmlNodeAddContent(cur: xmlNodePtr, content: *const xmlChar);
}
extern "C" {
pub fn xmlNodeAddContentLen(
cur: xmlNodePtr,
content: *const xmlChar,
len: ::std::os::raw::c_int,
);
}
extern "C" {
pub fn xmlNodeGetContent(cur: *const xmlNode) -> *mut xmlChar;
}
extern "C" {
pub fn xmlNodeBufGetContent(buffer: xmlBufferPtr, cur: *const xmlNode)
-> ::std::os::raw::c_int;
}
extern "C" {
pub fn xmlBufGetNodeContent(buf: xmlBufPtr, cur: *const xmlNode) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn xmlNodeGetLang(cur: *const xmlNode) -> *mut xmlChar;
}
extern "C" {
pub fn xmlNodeGetSpacePreserve(cur: *const xmlNode) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn xmlNodeSetLang(cur: xmlNodePtr, lang: *const xmlChar);
}
extern "C" {
pub fn xmlNodeSetSpacePreserve(cur: xmlNodePtr, val: ::std::os::raw::c_int);
}
extern "C" {
pub fn xmlNodeGetBase(doc: *const xmlDoc, cur: *const xmlNode) -> *mut xmlChar;
}
extern "C" {
pub fn xmlNodeSetBase(cur: xmlNodePtr, uri: *const xmlChar);
}
extern "C" {
pub fn xmlRemoveProp(cur: xmlAttrPtr) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn xmlUnsetNsProp(
node: xmlNodePtr,
ns: xmlNsPtr,
name: *const xmlChar,
) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn xmlUnsetProp(node: xmlNodePtr, name: *const xmlChar) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn xmlBufferWriteCHAR(buf: xmlBufferPtr, string: *const xmlChar);
}
extern "C" {
pub fn xmlBufferWriteChar(buf: xmlBufferPtr, string: *const ::std::os::raw::c_char);
}
extern "C" {
pub fn xmlBufferWriteQuotedString(buf: xmlBufferPtr, string: *const xmlChar);
}
extern "C" {
pub fn xmlAttrSerializeTxtContent(
buf: xmlBufferPtr,
doc: xmlDocPtr,
attr: xmlAttrPtr,
string: *const xmlChar,
);
}
extern "C" {
pub fn xmlReconciliateNs(doc: xmlDocPtr, tree: xmlNodePtr) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn xmlDocDumpFormatMemory(
cur: xmlDocPtr,
mem: *mut *mut xmlChar,
size: *mut ::std::os::raw::c_int,
format: ::std::os::raw::c_int,
);
}
extern "C" {
pub fn xmlDocDumpMemory(
cur: xmlDocPtr,
mem: *mut *mut xmlChar,
size: *mut ::std::os::raw::c_int,
);
}
extern "C" {
pub fn xmlDocDumpMemoryEnc(
out_doc: xmlDocPtr,
doc_txt_ptr: *mut *mut xmlChar,
doc_txt_len: *mut ::std::os::raw::c_int,
txt_encoding: *const ::std::os::raw::c_char,
);
}
extern "C" {
pub fn xmlDocDumpFormatMemoryEnc(
out_doc: xmlDocPtr,
doc_txt_ptr: *mut *mut xmlChar,
doc_txt_len: *mut ::std::os::raw::c_int,
txt_encoding: *const ::std::os::raw::c_char,
format: ::std::os::raw::c_int,
);
}
extern "C" {
pub fn xmlDocFormatDump(
f: *mut FILE,
cur: xmlDocPtr,
format: ::std::os::raw::c_int,
) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn xmlDocDump(f: *mut FILE, cur: xmlDocPtr) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn xmlElemDump(f: *mut FILE, doc: xmlDocPtr, cur: xmlNodePtr);
}
extern "C" {
pub fn xmlSaveFile(
filename: *const ::std::os::raw::c_char,
cur: xmlDocPtr,
) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn xmlSaveFormatFile(
filename: *const ::std::os::raw::c_char,
cur: xmlDocPtr,
format: ::std::os::raw::c_int,
) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn xmlBufNodeDump(
buf: xmlBufPtr,
doc: xmlDocPtr,
cur: xmlNodePtr,
level: ::std::os::raw::c_int,
format: ::std::os::raw::c_int,
) -> usize;
}
extern "C" {
pub fn xmlNodeDump(
buf: xmlBufferPtr,
doc: xmlDocPtr,
cur: xmlNodePtr,
level: ::std::os::raw::c_int,
format: ::std::os::raw::c_int,
) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn xmlSaveFileTo(
buf: xmlOutputBufferPtr,
cur: xmlDocPtr,
encoding: *const ::std::os::raw::c_char,
) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn xmlSaveFormatFileTo(
buf: xmlOutputBufferPtr,
cur: xmlDocPtr,
encoding: *const ::std::os::raw::c_char,
format: ::std::os::raw::c_int,
) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn xmlNodeDumpOutput(
buf: xmlOutputBufferPtr,
doc: xmlDocPtr,
cur: xmlNodePtr,
level: ::std::os::raw::c_int,
format: ::std::os::raw::c_int,
encoding: *const ::std::os::raw::c_char,
);
}
extern "C" {
pub fn xmlSaveFormatFileEnc(
filename: *const ::std::os::raw::c_char,
cur: xmlDocPtr,
encoding: *const ::std::os::raw::c_char,
format: ::std::os::raw::c_int,
) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn xmlSaveFileEnc(
filename: *const ::std::os::raw::c_char,
cur: xmlDocPtr,
encoding: *const ::std::os::raw::c_char,
) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn xmlIsXHTML(systemID: *const xmlChar, publicID: *const xmlChar) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn xmlGetDocCompressMode(doc: *const xmlDoc) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn xmlSetDocCompressMode(doc: xmlDocPtr, mode: ::std::os::raw::c_int);
}
extern "C" {
pub fn xmlGetCompressMode() -> ::std::os::raw::c_int;
}
extern "C" {
pub fn xmlSetCompressMode(mode: ::std::os::raw::c_int);
}
extern "C" {
pub fn xmlDOMWrapNewCtxt() -> xmlDOMWrapCtxtPtr;
}
extern "C" {
pub fn xmlDOMWrapFreeCtxt(ctxt: xmlDOMWrapCtxtPtr);
}
extern "C" {
pub fn xmlDOMWrapReconcileNamespaces(
ctxt: xmlDOMWrapCtxtPtr,
elem: xmlNodePtr,
options: ::std::os::raw::c_int,
) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn xmlDOMWrapAdoptNode(
ctxt: xmlDOMWrapCtxtPtr,
sourceDoc: xmlDocPtr,
node: xmlNodePtr,
destDoc: xmlDocPtr,
destParent: xmlNodePtr,
options: ::std::os::raw::c_int,
) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn xmlDOMWrapRemoveNode(
ctxt: xmlDOMWrapCtxtPtr,
doc: xmlDocPtr,
node: xmlNodePtr,
options: ::std::os::raw::c_int,
) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn xmlDOMWrapCloneNode(
ctxt: xmlDOMWrapCtxtPtr,
sourceDoc: xmlDocPtr,
node: xmlNodePtr,
clonedNode: *mut xmlNodePtr,
destDoc: xmlDocPtr,
destParent: xmlNodePtr,
deep: ::std::os::raw::c_int,
options: ::std::os::raw::c_int,
) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn xmlChildElementCount(parent: xmlNodePtr) -> ::std::os::raw::c_ulong;
}
extern "C" {
pub fn xmlNextElementSibling(node: xmlNodePtr) -> xmlNodePtr;
}
extern "C" {
pub fn xmlFirstElementChild(parent: xmlNodePtr) -> xmlNodePtr;
}
extern "C" {
pub fn xmlLastElementChild(parent: xmlNodePtr) -> xmlNodePtr;
}
extern "C" {
pub fn xmlPreviousElementSibling(node: xmlNodePtr) -> xmlNodePtr;
}
pub type xmlFreeFunc =
::std::option::Option<unsafe extern "C" fn(mem: *mut ::std::os::raw::c_void)>;
pub type xmlMallocFunc =
::std::option::Option<unsafe extern "C" fn(size: usize) -> *mut ::std::os::raw::c_void>;
pub type xmlReallocFunc = ::std::option::Option<
unsafe extern "C" fn(
mem: *mut ::std::os::raw::c_void,
size: usize,
) -> *mut ::std::os::raw::c_void,
>;
pub type xmlStrdupFunc = ::std::option::Option<
unsafe extern "C" fn(str_: *const ::std::os::raw::c_char) -> *mut ::std::os::raw::c_char,
>;
extern "C" {
pub fn xmlMemSetup(
freeFunc: xmlFreeFunc,
mallocFunc: xmlMallocFunc,
reallocFunc: xmlReallocFunc,
strdupFunc: xmlStrdupFunc,
) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn xmlMemGet(
freeFunc: *mut xmlFreeFunc,
mallocFunc: *mut xmlMallocFunc,
reallocFunc: *mut xmlReallocFunc,
strdupFunc: *mut xmlStrdupFunc,
) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn xmlGcMemSetup(
freeFunc: xmlFreeFunc,
mallocFunc: xmlMallocFunc,
mallocAtomicFunc: xmlMallocFunc,
reallocFunc: xmlReallocFunc,
strdupFunc: xmlStrdupFunc,
) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn xmlGcMemGet(
freeFunc: *mut xmlFreeFunc,
mallocFunc: *mut xmlMallocFunc,
mallocAtomicFunc: *mut xmlMallocFunc,
reallocFunc: *mut xmlReallocFunc,
strdupFunc: *mut xmlStrdupFunc,
) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn xmlInitMemory() -> ::std::os::raw::c_int;
}
extern "C" {
pub fn xmlCleanupMemory();
}
extern "C" {
pub fn xmlMemUsed() -> ::std::os::raw::c_int;
}
extern "C" {
pub fn xmlMemBlocks() -> ::std::os::raw::c_int;
}
extern "C" {
pub fn xmlMemDisplay(fp: *mut FILE);
}
extern "C" {
pub fn xmlMemDisplayLast(fp: *mut FILE, nbBytes: ::std::os::raw::c_long);
}
extern "C" {
pub fn xmlMemShow(fp: *mut FILE, nr: ::std::os::raw::c_int);
}
extern "C" {
pub fn xmlMemoryDump();
}
extern "C" {
pub fn xmlMemMalloc(size: usize) -> *mut ::std::os::raw::c_void;
}
extern "C" {
pub fn xmlMemRealloc(
ptr: *mut ::std::os::raw::c_void,
size: usize,
) -> *mut ::std::os::raw::c_void;
}
extern "C" {
pub fn xmlMemFree(ptr: *mut ::std::os::raw::c_void);
}
extern "C" {
pub fn xmlMemoryStrdup(str_: *const ::std::os::raw::c_char) -> *mut ::std::os::raw::c_char;
}
extern "C" {
pub fn xmlMallocLoc(
size: usize,
file: *const ::std::os::raw::c_char,
line: ::std::os::raw::c_int,
) -> *mut ::std::os::raw::c_void;
}
extern "C" {
pub fn xmlReallocLoc(
ptr: *mut ::std::os::raw::c_void,
size: usize,
file: *const ::std::os::raw::c_char,
line: ::std::os::raw::c_int,
) -> *mut ::std::os::raw::c_void;
}
extern "C" {
pub fn xmlMallocAtomicLoc(
size: usize,
file: *const ::std::os::raw::c_char,
line: ::std::os::raw::c_int,
) -> *mut ::std::os::raw::c_void;
}
extern "C" {
pub fn xmlMemStrdupLoc(
str_: *const ::std::os::raw::c_char,
file: *const ::std::os::raw::c_char,
line: ::std::os::raw::c_int,
) -> *mut ::std::os::raw::c_char;
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct _xmlMutex {
_unused: [u8; 0],
}
pub type xmlMutex = _xmlMutex;
pub type xmlMutexPtr = *mut xmlMutex;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct _xmlRMutex {
_unused: [u8; 0],
}
pub type xmlRMutex = _xmlRMutex;
pub type xmlRMutexPtr = *mut xmlRMutex;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct _xmlHashTable {
_unused: [u8; 0],
}
pub type xmlHashTable = _xmlHashTable;
pub type xmlHashTablePtr = *mut xmlHashTable;
pub type xmlHashDeallocator = ::std::option::Option<
unsafe extern "C" fn(payload: *mut ::std::os::raw::c_void, name: *const xmlChar),
>;
pub type xmlHashCopier = ::std::option::Option<
unsafe extern "C" fn(
payload: *mut ::std::os::raw::c_void,
name: *const xmlChar,
) -> *mut ::std::os::raw::c_void,
>;
pub type xmlHashScanner = ::std::option::Option<
unsafe extern "C" fn(
payload: *mut ::std::os::raw::c_void,
data: *mut ::std::os::raw::c_void,
name: *const xmlChar,
),
>;
pub type xmlHashScannerFull = ::std::option::Option<
unsafe extern "C" fn(
payload: *mut ::std::os::raw::c_void,
data: *mut ::std::os::raw::c_void,
name: *const xmlChar,
name2: *const xmlChar,
name3: *const xmlChar,
),
>;
extern "C" {
pub fn xmlHashCreate(size: ::std::os::raw::c_int) -> xmlHashTablePtr;
}
extern "C" {
pub fn xmlHashCreateDict(size: ::std::os::raw::c_int, dict: xmlDictPtr) -> xmlHashTablePtr;
}
extern "C" {
pub fn xmlHashFree(table: xmlHashTablePtr, f: xmlHashDeallocator);
}
extern "C" {
pub fn xmlHashDefaultDeallocator(entry: *mut ::std::os::raw::c_void, name: *const xmlChar);
}
extern "C" {
pub fn xmlHashAddEntry(
table: xmlHashTablePtr,
name: *const xmlChar,
userdata: *mut ::std::os::raw::c_void,
) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn xmlHashUpdateEntry(
table: xmlHashTablePtr,
name: *const xmlChar,
userdata: *mut ::std::os::raw::c_void,
f: xmlHashDeallocator,
) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn xmlHashAddEntry2(
table: xmlHashTablePtr,
name: *const xmlChar,
name2: *const xmlChar,
userdata: *mut ::std::os::raw::c_void,
) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn xmlHashUpdateEntry2(
table: xmlHashTablePtr,
name: *const xmlChar,
name2: *const xmlChar,
userdata: *mut ::std::os::raw::c_void,
f: xmlHashDeallocator,
) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn xmlHashAddEntry3(
table: xmlHashTablePtr,
name: *const xmlChar,
name2: *const xmlChar,
name3: *const xmlChar,
userdata: *mut ::std::os::raw::c_void,
) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn xmlHashUpdateEntry3(
table: xmlHashTablePtr,
name: *const xmlChar,
name2: *const xmlChar,
name3: *const xmlChar,
userdata: *mut ::std::os::raw::c_void,
f: xmlHashDeallocator,
) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn xmlHashRemoveEntry(
table: xmlHashTablePtr,
name: *const xmlChar,
f: xmlHashDeallocator,
) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn xmlHashRemoveEntry2(
table: xmlHashTablePtr,
name: *const xmlChar,
name2: *const xmlChar,
f: xmlHashDeallocator,
) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn xmlHashRemoveEntry3(
table: xmlHashTablePtr,
name: *const xmlChar,
name2: *const xmlChar,
name3: *const xmlChar,
f: xmlHashDeallocator,
) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn xmlHashLookup(
table: xmlHashTablePtr,
name: *const xmlChar,
) -> *mut ::std::os::raw::c_void;
}
extern "C" {
pub fn xmlHashLookup2(
table: xmlHashTablePtr,
name: *const xmlChar,
name2: *const xmlChar,
) -> *mut ::std::os::raw::c_void;
}
extern "C" {
pub fn xmlHashLookup3(
table: xmlHashTablePtr,
name: *const xmlChar,
name2: *const xmlChar,
name3: *const xmlChar,
) -> *mut ::std::os::raw::c_void;
}
extern "C" {
pub fn xmlHashQLookup(
table: xmlHashTablePtr,
name: *const xmlChar,
prefix: *const xmlChar,
) -> *mut ::std::os::raw::c_void;
}
extern "C" {
pub fn xmlHashQLookup2(
table: xmlHashTablePtr,
name: *const xmlChar,
prefix: *const xmlChar,
name2: *const xmlChar,
prefix2: *const xmlChar,
) -> *mut ::std::os::raw::c_void;
}
extern "C" {
pub fn xmlHashQLookup3(
table: xmlHashTablePtr,
name: *const xmlChar,
prefix: *const xmlChar,
name2: *const xmlChar,
prefix2: *const xmlChar,
name3: *const xmlChar,
prefix3: *const xmlChar,
) -> *mut ::std::os::raw::c_void;
}
extern "C" {
pub fn xmlHashCopy(table: xmlHashTablePtr, f: xmlHashCopier) -> xmlHashTablePtr;
}
extern "C" {
pub fn xmlHashSize(table: xmlHashTablePtr) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn xmlHashScan(
table: xmlHashTablePtr,
f: xmlHashScanner,
data: *mut ::std::os::raw::c_void,
);
}
extern "C" {
pub fn xmlHashScan3(
table: xmlHashTablePtr,
name: *const xmlChar,
name2: *const xmlChar,
name3: *const xmlChar,
f: xmlHashScanner,
data: *mut ::std::os::raw::c_void,
);
}
extern "C" {
pub fn xmlHashScanFull(
table: xmlHashTablePtr,
f: xmlHashScannerFull,
data: *mut ::std::os::raw::c_void,
);
}
extern "C" {
pub fn xmlHashScanFull3(
table: xmlHashTablePtr,
name: *const xmlChar,
name2: *const xmlChar,
name3: *const xmlChar,
f: xmlHashScannerFull,
data: *mut ::std::os::raw::c_void,
);
}
pub const xmlErrorLevel_XML_ERR_NONE: xmlErrorLevel = 0;
pub const xmlErrorLevel_XML_ERR_WARNING: xmlErrorLevel = 1;
pub const xmlErrorLevel_XML_ERR_ERROR: xmlErrorLevel = 2;
pub const xmlErrorLevel_XML_ERR_FATAL: xmlErrorLevel = 3;
pub type xmlErrorLevel = ::std::os::raw::c_uint;
pub const xmlErrorDomain_XML_FROM_NONE: xmlErrorDomain = 0;
pub const xmlErrorDomain_XML_FROM_PARSER: xmlErrorDomain = 1;
pub const xmlErrorDomain_XML_FROM_TREE: xmlErrorDomain = 2;
pub const xmlErrorDomain_XML_FROM_NAMESPACE: xmlErrorDomain = 3;
pub const xmlErrorDomain_XML_FROM_DTD: xmlErrorDomain = 4;
pub const xmlErrorDomain_XML_FROM_HTML: xmlErrorDomain = 5;
pub const xmlErrorDomain_XML_FROM_MEMORY: xmlErrorDomain = 6;
pub const xmlErrorDomain_XML_FROM_OUTPUT: xmlErrorDomain = 7;
pub const xmlErrorDomain_XML_FROM_IO: xmlErrorDomain = 8;
pub const xmlErrorDomain_XML_FROM_FTP: xmlErrorDomain = 9;
pub const xmlErrorDomain_XML_FROM_HTTP: xmlErrorDomain = 10;
pub const xmlErrorDomain_XML_FROM_XINCLUDE: xmlErrorDomain = 11;
pub const xmlErrorDomain_XML_FROM_XPATH: xmlErrorDomain = 12;
pub const xmlErrorDomain_XML_FROM_XPOINTER: xmlErrorDomain = 13;
pub const xmlErrorDomain_XML_FROM_REGEXP: xmlErrorDomain = 14;
pub const xmlErrorDomain_XML_FROM_DATATYPE: xmlErrorDomain = 15;
pub const xmlErrorDomain_XML_FROM_SCHEMASP: xmlErrorDomain = 16;
pub const xmlErrorDomain_XML_FROM_SCHEMASV: xmlErrorDomain = 17;
pub const xmlErrorDomain_XML_FROM_RELAXNGP: xmlErrorDomain = 18;
pub const xmlErrorDomain_XML_FROM_RELAXNGV: xmlErrorDomain = 19;
pub const xmlErrorDomain_XML_FROM_CATALOG: xmlErrorDomain = 20;
pub const xmlErrorDomain_XML_FROM_C14N: xmlErrorDomain = 21;
pub const xmlErrorDomain_XML_FROM_XSLT: xmlErrorDomain = 22;
pub const xmlErrorDomain_XML_FROM_VALID: xmlErrorDomain = 23;
pub const xmlErrorDomain_XML_FROM_CHECK: xmlErrorDomain = 24;
pub const xmlErrorDomain_XML_FROM_WRITER: xmlErrorDomain = 25;
pub const xmlErrorDomain_XML_FROM_MODULE: xmlErrorDomain = 26;
pub const xmlErrorDomain_XML_FROM_I18N: xmlErrorDomain = 27;
pub const xmlErrorDomain_XML_FROM_SCHEMATRONV: xmlErrorDomain = 28;
pub const xmlErrorDomain_XML_FROM_BUFFER: xmlErrorDomain = 29;
pub const xmlErrorDomain_XML_FROM_URI: xmlErrorDomain = 30;
pub type xmlErrorDomain = ::std::os::raw::c_uint;
pub type xmlError = _xmlError;
pub type xmlErrorPtr = *mut xmlError;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct _xmlError {
pub domain: ::std::os::raw::c_int,
pub code: ::std::os::raw::c_int,
pub message: *mut ::std::os::raw::c_char,
pub level: xmlErrorLevel,
pub file: *mut ::std::os::raw::c_char,
pub line: ::std::os::raw::c_int,
pub str1: *mut ::std::os::raw::c_char,
pub str2: *mut ::std::os::raw::c_char,
pub str3: *mut ::std::os::raw::c_char,
pub int1: ::std::os::raw::c_int,
pub int2: ::std::os::raw::c_int,
pub ctxt: *mut ::std::os::raw::c_void,
pub node: *mut ::std::os::raw::c_void,
}
#[test]
fn bindgen_test_layout__xmlError() {
const UNINIT: ::std::mem::MaybeUninit<_xmlError> = ::std::mem::MaybeUninit::uninit();
let ptr = UNINIT.as_ptr();
assert_eq!(
::std::mem::size_of::<_xmlError>(),
88usize,
concat!("Size of: ", stringify!(_xmlError))
);
assert_eq!(
::std::mem::align_of::<_xmlError>(),
8usize,
concat!("Alignment of ", stringify!(_xmlError))
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).domain) as usize - ptr as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(_xmlError),
"::",
stringify!(domain)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).code) as usize - ptr as usize },
4usize,
concat!(
"Offset of field: ",
stringify!(_xmlError),
"::",
stringify!(code)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).message) as usize - ptr as usize },
8usize,
concat!(
"Offset of field: ",
stringify!(_xmlError),
"::",
stringify!(message)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).level) as usize - ptr as usize },
16usize,
concat!(
"Offset of field: ",
stringify!(_xmlError),
"::",
stringify!(level)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).file) as usize - ptr as usize },
24usize,
concat!(
"Offset of field: ",
stringify!(_xmlError),
"::",
stringify!(file)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).line) as usize - ptr as usize },
32usize,
concat!(
"Offset of field: ",
stringify!(_xmlError),
"::",
stringify!(line)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).str1) as usize - ptr as usize },
40usize,
concat!(
"Offset of field: ",
stringify!(_xmlError),
"::",
stringify!(str1)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).str2) as usize - ptr as usize },
48usize,
concat!(
"Offset of field: ",
stringify!(_xmlError),
"::",
stringify!(str2)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).str3) as usize - ptr as usize },
56usize,
concat!(
"Offset of field: ",
stringify!(_xmlError),
"::",
stringify!(str3)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).int1) as usize - ptr as usize },
64usize,
concat!(
"Offset of field: ",
stringify!(_xmlError),
"::",
stringify!(int1)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).int2) as usize - ptr as usize },
68usize,
concat!(
"Offset of field: ",
stringify!(_xmlError),
"::",
stringify!(int2)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).ctxt) as usize - ptr as usize },
72usize,
concat!(
"Offset of field: ",
stringify!(_xmlError),
"::",
stringify!(ctxt)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).node) as usize - ptr as usize },
80usize,
concat!(
"Offset of field: ",
stringify!(_xmlError),
"::",
stringify!(node)
)
);
}
pub const xmlParserErrors_XML_ERR_OK: xmlParserErrors = 0;
pub const xmlParserErrors_XML_ERR_INTERNAL_ERROR: xmlParserErrors = 1;
pub const xmlParserErrors_XML_ERR_NO_MEMORY: xmlParserErrors = 2;
pub const xmlParserErrors_XML_ERR_DOCUMENT_START: xmlParserErrors = 3;
pub const xmlParserErrors_XML_ERR_DOCUMENT_EMPTY: xmlParserErrors = 4;
pub const xmlParserErrors_XML_ERR_DOCUMENT_END: xmlParserErrors = 5;
pub const xmlParserErrors_XML_ERR_INVALID_HEX_CHARREF: xmlParserErrors = 6;
pub const xmlParserErrors_XML_ERR_INVALID_DEC_CHARREF: xmlParserErrors = 7;
pub const xmlParserErrors_XML_ERR_INVALID_CHARREF: xmlParserErrors = 8;
pub const xmlParserErrors_XML_ERR_INVALID_CHAR: xmlParserErrors = 9;
pub const xmlParserErrors_XML_ERR_CHARREF_AT_EOF: xmlParserErrors = 10;
pub const xmlParserErrors_XML_ERR_CHARREF_IN_PROLOG: xmlParserErrors = 11;
pub const xmlParserErrors_XML_ERR_CHARREF_IN_EPILOG: xmlParserErrors = 12;
pub const xmlParserErrors_XML_ERR_CHARREF_IN_DTD: xmlParserErrors = 13;
pub const xmlParserErrors_XML_ERR_ENTITYREF_AT_EOF: xmlParserErrors = 14;
pub const xmlParserErrors_XML_ERR_ENTITYREF_IN_PROLOG: xmlParserErrors = 15;
pub const xmlParserErrors_XML_ERR_ENTITYREF_IN_EPILOG: xmlParserErrors = 16;
pub const xmlParserErrors_XML_ERR_ENTITYREF_IN_DTD: xmlParserErrors = 17;
pub const xmlParserErrors_XML_ERR_PEREF_AT_EOF: xmlParserErrors = 18;
pub const xmlParserErrors_XML_ERR_PEREF_IN_PROLOG: xmlParserErrors = 19;
pub const xmlParserErrors_XML_ERR_PEREF_IN_EPILOG: xmlParserErrors = 20;
pub const xmlParserErrors_XML_ERR_PEREF_IN_INT_SUBSET: xmlParserErrors = 21;
pub const xmlParserErrors_XML_ERR_ENTITYREF_NO_NAME: xmlParserErrors = 22;
pub const xmlParserErrors_XML_ERR_ENTITYREF_SEMICOL_MISSING: xmlParserErrors = 23;
pub const xmlParserErrors_XML_ERR_PEREF_NO_NAME: xmlParserErrors = 24;
pub const xmlParserErrors_XML_ERR_PEREF_SEMICOL_MISSING: xmlParserErrors = 25;
pub const xmlParserErrors_XML_ERR_UNDECLARED_ENTITY: xmlParserErrors = 26;
pub const xmlParserErrors_XML_WAR_UNDECLARED_ENTITY: xmlParserErrors = 27;
pub const xmlParserErrors_XML_ERR_UNPARSED_ENTITY: xmlParserErrors = 28;
pub const xmlParserErrors_XML_ERR_ENTITY_IS_EXTERNAL: xmlParserErrors = 29;
pub const xmlParserErrors_XML_ERR_ENTITY_IS_PARAMETER: xmlParserErrors = 30;
pub const xmlParserErrors_XML_ERR_UNKNOWN_ENCODING: xmlParserErrors = 31;
pub const xmlParserErrors_XML_ERR_UNSUPPORTED_ENCODING: xmlParserErrors = 32;
pub const xmlParserErrors_XML_ERR_STRING_NOT_STARTED: xmlParserErrors = 33;
pub const xmlParserErrors_XML_ERR_STRING_NOT_CLOSED: xmlParserErrors = 34;
pub const xmlParserErrors_XML_ERR_NS_DECL_ERROR: xmlParserErrors = 35;
pub const xmlParserErrors_XML_ERR_ENTITY_NOT_STARTED: xmlParserErrors = 36;
pub const xmlParserErrors_XML_ERR_ENTITY_NOT_FINISHED: xmlParserErrors = 37;
pub const xmlParserErrors_XML_ERR_LT_IN_ATTRIBUTE: xmlParserErrors = 38;
pub const xmlParserErrors_XML_ERR_ATTRIBUTE_NOT_STARTED: xmlParserErrors = 39;
pub const xmlParserErrors_XML_ERR_ATTRIBUTE_NOT_FINISHED: xmlParserErrors = 40;
pub const xmlParserErrors_XML_ERR_ATTRIBUTE_WITHOUT_VALUE: xmlParserErrors = 41;
pub const xmlParserErrors_XML_ERR_ATTRIBUTE_REDEFINED: xmlParserErrors = 42;
pub const xmlParserErrors_XML_ERR_LITERAL_NOT_STARTED: xmlParserErrors = 43;
pub const xmlParserErrors_XML_ERR_LITERAL_NOT_FINISHED: xmlParserErrors = 44;
pub const xmlParserErrors_XML_ERR_COMMENT_NOT_FINISHED: xmlParserErrors = 45;
pub const xmlParserErrors_XML_ERR_PI_NOT_STARTED: xmlParserErrors = 46;
pub const xmlParserErrors_XML_ERR_PI_NOT_FINISHED: xmlParserErrors = 47;
pub const xmlParserErrors_XML_ERR_NOTATION_NOT_STARTED: xmlParserErrors = 48;
pub const xmlParserErrors_XML_ERR_NOTATION_NOT_FINISHED: xmlParserErrors = 49;
pub const xmlParserErrors_XML_ERR_ATTLIST_NOT_STARTED: xmlParserErrors = 50;
pub const xmlParserErrors_XML_ERR_ATTLIST_NOT_FINISHED: xmlParserErrors = 51;
pub const xmlParserErrors_XML_ERR_MIXED_NOT_STARTED: xmlParserErrors = 52;
pub const xmlParserErrors_XML_ERR_MIXED_NOT_FINISHED: xmlParserErrors = 53;
pub const xmlParserErrors_XML_ERR_ELEMCONTENT_NOT_STARTED: xmlParserErrors = 54;
pub const xmlParserErrors_XML_ERR_ELEMCONTENT_NOT_FINISHED: xmlParserErrors = 55;
pub const xmlParserErrors_XML_ERR_XMLDECL_NOT_STARTED: xmlParserErrors = 56;
pub const xmlParserErrors_XML_ERR_XMLDECL_NOT_FINISHED: xmlParserErrors = 57;
pub const xmlParserErrors_XML_ERR_CONDSEC_NOT_STARTED: xmlParserErrors = 58;
pub const xmlParserErrors_XML_ERR_CONDSEC_NOT_FINISHED: xmlParserErrors = 59;
pub const xmlParserErrors_XML_ERR_EXT_SUBSET_NOT_FINISHED: xmlParserErrors = 60;
pub const xmlParserErrors_XML_ERR_DOCTYPE_NOT_FINISHED: xmlParserErrors = 61;
pub const xmlParserErrors_XML_ERR_MISPLACED_CDATA_END: xmlParserErrors = 62;
pub const xmlParserErrors_XML_ERR_CDATA_NOT_FINISHED: xmlParserErrors = 63;
pub const xmlParserErrors_XML_ERR_RESERVED_XML_NAME: xmlParserErrors = 64;
pub const xmlParserErrors_XML_ERR_SPACE_REQUIRED: xmlParserErrors = 65;
pub const xmlParserErrors_XML_ERR_SEPARATOR_REQUIRED: xmlParserErrors = 66;
pub const xmlParserErrors_XML_ERR_NMTOKEN_REQUIRED: xmlParserErrors = 67;
pub const xmlParserErrors_XML_ERR_NAME_REQUIRED: xmlParserErrors = 68;
pub const xmlParserErrors_XML_ERR_PCDATA_REQUIRED: xmlParserErrors = 69;
pub const xmlParserErrors_XML_ERR_URI_REQUIRED: xmlParserErrors = 70;
pub const xmlParserErrors_XML_ERR_PUBID_REQUIRED: xmlParserErrors = 71;
pub const xmlParserErrors_XML_ERR_LT_REQUIRED: xmlParserErrors = 72;
pub const xmlParserErrors_XML_ERR_GT_REQUIRED: xmlParserErrors = 73;
pub const xmlParserErrors_XML_ERR_LTSLASH_REQUIRED: xmlParserErrors = 74;
pub const xmlParserErrors_XML_ERR_EQUAL_REQUIRED: xmlParserErrors = 75;
pub const xmlParserErrors_XML_ERR_TAG_NAME_MISMATCH: xmlParserErrors = 76;
pub const xmlParserErrors_XML_ERR_TAG_NOT_FINISHED: xmlParserErrors = 77;
pub const xmlParserErrors_XML_ERR_STANDALONE_VALUE: xmlParserErrors = 78;
pub const xmlParserErrors_XML_ERR_ENCODING_NAME: xmlParserErrors = 79;
pub const xmlParserErrors_XML_ERR_HYPHEN_IN_COMMENT: xmlParserErrors = 80;
pub const xmlParserErrors_XML_ERR_INVALID_ENCODING: xmlParserErrors = 81;
pub const xmlParserErrors_XML_ERR_EXT_ENTITY_STANDALONE: xmlParserErrors = 82;
pub const xmlParserErrors_XML_ERR_CONDSEC_INVALID: xmlParserErrors = 83;
pub const xmlParserErrors_XML_ERR_VALUE_REQUIRED: xmlParserErrors = 84;
pub const xmlParserErrors_XML_ERR_NOT_WELL_BALANCED: xmlParserErrors = 85;
pub const xmlParserErrors_XML_ERR_EXTRA_CONTENT: xmlParserErrors = 86;
pub const xmlParserErrors_XML_ERR_ENTITY_CHAR_ERROR: xmlParserErrors = 87;
pub const xmlParserErrors_XML_ERR_ENTITY_PE_INTERNAL: xmlParserErrors = 88;
pub const xmlParserErrors_XML_ERR_ENTITY_LOOP: xmlParserErrors = 89;
pub const xmlParserErrors_XML_ERR_ENTITY_BOUNDARY: xmlParserErrors = 90;
pub const xmlParserErrors_XML_ERR_INVALID_URI: xmlParserErrors = 91;
pub const xmlParserErrors_XML_ERR_URI_FRAGMENT: xmlParserErrors = 92;
pub const xmlParserErrors_XML_WAR_CATALOG_PI: xmlParserErrors = 93;
pub const xmlParserErrors_XML_ERR_NO_DTD: xmlParserErrors = 94;
pub const xmlParserErrors_XML_ERR_CONDSEC_INVALID_KEYWORD: xmlParserErrors = 95;
pub const xmlParserErrors_XML_ERR_VERSION_MISSING: xmlParserErrors = 96;
pub const xmlParserErrors_XML_WAR_UNKNOWN_VERSION: xmlParserErrors = 97;
pub const xmlParserErrors_XML_WAR_LANG_VALUE: xmlParserErrors = 98;
pub const xmlParserErrors_XML_WAR_NS_URI: xmlParserErrors = 99;
pub const xmlParserErrors_XML_WAR_NS_URI_RELATIVE: xmlParserErrors = 100;
pub const xmlParserErrors_XML_ERR_MISSING_ENCODING: xmlParserErrors = 101;
pub const xmlParserErrors_XML_WAR_SPACE_VALUE: xmlParserErrors = 102;
pub const xmlParserErrors_XML_ERR_NOT_STANDALONE: xmlParserErrors = 103;
pub const xmlParserErrors_XML_ERR_ENTITY_PROCESSING: xmlParserErrors = 104;
pub const xmlParserErrors_XML_ERR_NOTATION_PROCESSING: xmlParserErrors = 105;
pub const xmlParserErrors_XML_WAR_NS_COLUMN: xmlParserErrors = 106;
pub const xmlParserErrors_XML_WAR_ENTITY_REDEFINED: xmlParserErrors = 107;
pub const xmlParserErrors_XML_ERR_UNKNOWN_VERSION: xmlParserErrors = 108;
pub const xmlParserErrors_XML_ERR_VERSION_MISMATCH: xmlParserErrors = 109;
pub const xmlParserErrors_XML_ERR_NAME_TOO_LONG: xmlParserErrors = 110;
pub const xmlParserErrors_XML_ERR_USER_STOP: xmlParserErrors = 111;
pub const xmlParserErrors_XML_ERR_COMMENT_ABRUPTLY_ENDED: xmlParserErrors = 112;
pub const xmlParserErrors_XML_NS_ERR_XML_NAMESPACE: xmlParserErrors = 200;
pub const xmlParserErrors_XML_NS_ERR_UNDEFINED_NAMESPACE: xmlParserErrors = 201;
pub const xmlParserErrors_XML_NS_ERR_QNAME: xmlParserErrors = 202;
pub const xmlParserErrors_XML_NS_ERR_ATTRIBUTE_REDEFINED: xmlParserErrors = 203;
pub const xmlParserErrors_XML_NS_ERR_EMPTY: xmlParserErrors = 204;
pub const xmlParserErrors_XML_NS_ERR_COLON: xmlParserErrors = 205;
pub const xmlParserErrors_XML_DTD_ATTRIBUTE_DEFAULT: xmlParserErrors = 500;
pub const xmlParserErrors_XML_DTD_ATTRIBUTE_REDEFINED: xmlParserErrors = 501;
pub const xmlParserErrors_XML_DTD_ATTRIBUTE_VALUE: xmlParserErrors = 502;
pub const xmlParserErrors_XML_DTD_CONTENT_ERROR: xmlParserErrors = 503;
pub const xmlParserErrors_XML_DTD_CONTENT_MODEL: xmlParserErrors = 504;
pub const xmlParserErrors_XML_DTD_CONTENT_NOT_DETERMINIST: xmlParserErrors = 505;
pub const xmlParserErrors_XML_DTD_DIFFERENT_PREFIX: xmlParserErrors = 506;
pub const xmlParserErrors_XML_DTD_ELEM_DEFAULT_NAMESPACE: xmlParserErrors = 507;
pub const xmlParserErrors_XML_DTD_ELEM_NAMESPACE: xmlParserErrors = 508;
pub const xmlParserErrors_XML_DTD_ELEM_REDEFINED: xmlParserErrors = 509;
pub const xmlParserErrors_XML_DTD_EMPTY_NOTATION: xmlParserErrors = 510;
pub const xmlParserErrors_XML_DTD_ENTITY_TYPE: xmlParserErrors = 511;
pub const xmlParserErrors_XML_DTD_ID_FIXED: xmlParserErrors = 512;
pub const xmlParserErrors_XML_DTD_ID_REDEFINED: xmlParserErrors = 513;
pub const xmlParserErrors_XML_DTD_ID_SUBSET: xmlParserErrors = 514;
pub const xmlParserErrors_XML_DTD_INVALID_CHILD: xmlParserErrors = 515;
pub const xmlParserErrors_XML_DTD_INVALID_DEFAULT: xmlParserErrors = 516;
pub const xmlParserErrors_XML_DTD_LOAD_ERROR: xmlParserErrors = 517;
pub const xmlParserErrors_XML_DTD_MISSING_ATTRIBUTE: xmlParserErrors = 518;
pub const xmlParserErrors_XML_DTD_MIXED_CORRUPT: xmlParserErrors = 519;
pub const xmlParserErrors_XML_DTD_MULTIPLE_ID: xmlParserErrors = 520;
pub const xmlParserErrors_XML_DTD_NO_DOC: xmlParserErrors = 521;
pub const xmlParserErrors_XML_DTD_NO_DTD: xmlParserErrors = 522;
pub const xmlParserErrors_XML_DTD_NO_ELEM_NAME: xmlParserErrors = 523;
pub const xmlParserErrors_XML_DTD_NO_PREFIX: xmlParserErrors = 524;
pub const xmlParserErrors_XML_DTD_NO_ROOT: xmlParserErrors = 525;
pub const xmlParserErrors_XML_DTD_NOTATION_REDEFINED: xmlParserErrors = 526;
pub const xmlParserErrors_XML_DTD_NOTATION_VALUE: xmlParserErrors = 527;
pub const xmlParserErrors_XML_DTD_NOT_EMPTY: xmlParserErrors = 528;
pub const xmlParserErrors_XML_DTD_NOT_PCDATA: xmlParserErrors = 529;
pub const xmlParserErrors_XML_DTD_NOT_STANDALONE: xmlParserErrors = 530;
pub const xmlParserErrors_XML_DTD_ROOT_NAME: xmlParserErrors = 531;
pub const xmlParserErrors_XML_DTD_STANDALONE_WHITE_SPACE: xmlParserErrors = 532;
pub const xmlParserErrors_XML_DTD_UNKNOWN_ATTRIBUTE: xmlParserErrors = 533;
pub const xmlParserErrors_XML_DTD_UNKNOWN_ELEM: xmlParserErrors = 534;
pub const xmlParserErrors_XML_DTD_UNKNOWN_ENTITY: xmlParserErrors = 535;
pub const xmlParserErrors_XML_DTD_UNKNOWN_ID: xmlParserErrors = 536;
pub const xmlParserErrors_XML_DTD_UNKNOWN_NOTATION: xmlParserErrors = 537;
pub const xmlParserErrors_XML_DTD_STANDALONE_DEFAULTED: xmlParserErrors = 538;
pub const xmlParserErrors_XML_DTD_XMLID_VALUE: xmlParserErrors = 539;
pub const xmlParserErrors_XML_DTD_XMLID_TYPE: xmlParserErrors = 540;
pub const xmlParserErrors_XML_DTD_DUP_TOKEN: xmlParserErrors = 541;
pub const xmlParserErrors_XML_HTML_STRUCURE_ERROR: xmlParserErrors = 800;
pub const xmlParserErrors_XML_HTML_UNKNOWN_TAG: xmlParserErrors = 801;
pub const xmlParserErrors_XML_HTML_INCORRECTLY_OPENED_COMMENT: xmlParserErrors = 802;
pub const xmlParserErrors_XML_RNGP_ANYNAME_ATTR_ANCESTOR: xmlParserErrors = 1000;
pub const xmlParserErrors_XML_RNGP_ATTR_CONFLICT: xmlParserErrors = 1001;
pub const xmlParserErrors_XML_RNGP_ATTRIBUTE_CHILDREN: xmlParserErrors = 1002;
pub const xmlParserErrors_XML_RNGP_ATTRIBUTE_CONTENT: xmlParserErrors = 1003;
pub const xmlParserErrors_XML_RNGP_ATTRIBUTE_EMPTY: xmlParserErrors = 1004;
pub const xmlParserErrors_XML_RNGP_ATTRIBUTE_NOOP: xmlParserErrors = 1005;
pub const xmlParserErrors_XML_RNGP_CHOICE_CONTENT: xmlParserErrors = 1006;
pub const xmlParserErrors_XML_RNGP_CHOICE_EMPTY: xmlParserErrors = 1007;
pub const xmlParserErrors_XML_RNGP_CREATE_FAILURE: xmlParserErrors = 1008;
pub const xmlParserErrors_XML_RNGP_DATA_CONTENT: xmlParserErrors = 1009;
pub const xmlParserErrors_XML_RNGP_DEF_CHOICE_AND_INTERLEAVE: xmlParserErrors = 1010;
pub const xmlParserErrors_XML_RNGP_DEFINE_CREATE_FAILED: xmlParserErrors = 1011;
pub const xmlParserErrors_XML_RNGP_DEFINE_EMPTY: xmlParserErrors = 1012;
pub const xmlParserErrors_XML_RNGP_DEFINE_MISSING: xmlParserErrors = 1013;
pub const xmlParserErrors_XML_RNGP_DEFINE_NAME_MISSING: xmlParserErrors = 1014;
pub const xmlParserErrors_XML_RNGP_ELEM_CONTENT_EMPTY: xmlParserErrors = 1015;
pub const xmlParserErrors_XML_RNGP_ELEM_CONTENT_ERROR: xmlParserErrors = 1016;
pub const xmlParserErrors_XML_RNGP_ELEMENT_EMPTY: xmlParserErrors = 1017;
pub const xmlParserErrors_XML_RNGP_ELEMENT_CONTENT: xmlParserErrors = 1018;
pub const xmlParserErrors_XML_RNGP_ELEMENT_NAME: xmlParserErrors = 1019;
pub const xmlParserErrors_XML_RNGP_ELEMENT_NO_CONTENT: xmlParserErrors = 1020;
pub const xmlParserErrors_XML_RNGP_ELEM_TEXT_CONFLICT: xmlParserErrors = 1021;
pub const xmlParserErrors_XML_RNGP_EMPTY: xmlParserErrors = 1022;
pub const xmlParserErrors_XML_RNGP_EMPTY_CONSTRUCT: xmlParserErrors = 1023;
pub const xmlParserErrors_XML_RNGP_EMPTY_CONTENT: xmlParserErrors = 1024;
pub const xmlParserErrors_XML_RNGP_EMPTY_NOT_EMPTY: xmlParserErrors = 1025;
pub const xmlParserErrors_XML_RNGP_ERROR_TYPE_LIB: xmlParserErrors = 1026;
pub const xmlParserErrors_XML_RNGP_EXCEPT_EMPTY: xmlParserErrors = 1027;
pub const xmlParserErrors_XML_RNGP_EXCEPT_MISSING: xmlParserErrors = 1028;
pub const xmlParserErrors_XML_RNGP_EXCEPT_MULTIPLE: xmlParserErrors = 1029;
pub const xmlParserErrors_XML_RNGP_EXCEPT_NO_CONTENT: xmlParserErrors = 1030;
pub const xmlParserErrors_XML_RNGP_EXTERNALREF_EMTPY: xmlParserErrors = 1031;
pub const xmlParserErrors_XML_RNGP_EXTERNAL_REF_FAILURE: xmlParserErrors = 1032;
pub const xmlParserErrors_XML_RNGP_EXTERNALREF_RECURSE: xmlParserErrors = 1033;
pub const xmlParserErrors_XML_RNGP_FORBIDDEN_ATTRIBUTE: xmlParserErrors = 1034;
pub const xmlParserErrors_XML_RNGP_FOREIGN_ELEMENT: xmlParserErrors = 1035;
pub const xmlParserErrors_XML_RNGP_GRAMMAR_CONTENT: xmlParserErrors = 1036;
pub const xmlParserErrors_XML_RNGP_GRAMMAR_EMPTY: xmlParserErrors = 1037;
pub const xmlParserErrors_XML_RNGP_GRAMMAR_MISSING: xmlParserErrors = 1038;
pub const xmlParserErrors_XML_RNGP_GRAMMAR_NO_START: xmlParserErrors = 1039;
pub const xmlParserErrors_XML_RNGP_GROUP_ATTR_CONFLICT: xmlParserErrors = 1040;
pub const xmlParserErrors_XML_RNGP_HREF_ERROR: xmlParserErrors = 1041;
pub const xmlParserErrors_XML_RNGP_INCLUDE_EMPTY: xmlParserErrors = 1042;
pub const xmlParserErrors_XML_RNGP_INCLUDE_FAILURE: xmlParserErrors = 1043;
pub const xmlParserErrors_XML_RNGP_INCLUDE_RECURSE: xmlParserErrors = 1044;
pub const xmlParserErrors_XML_RNGP_INTERLEAVE_ADD: xmlParserErrors = 1045;
pub const xmlParserErrors_XML_RNGP_INTERLEAVE_CREATE_FAILED: xmlParserErrors = 1046;
pub const xmlParserErrors_XML_RNGP_INTERLEAVE_EMPTY: xmlParserErrors = 1047;
pub const xmlParserErrors_XML_RNGP_INTERLEAVE_NO_CONTENT: xmlParserErrors = 1048;
pub const xmlParserErrors_XML_RNGP_INVALID_DEFINE_NAME: xmlParserErrors = 1049;
pub const xmlParserErrors_XML_RNGP_INVALID_URI: xmlParserErrors = 1050;
pub const xmlParserErrors_XML_RNGP_INVALID_VALUE: xmlParserErrors = 1051;
pub const xmlParserErrors_XML_RNGP_MISSING_HREF: xmlParserErrors = 1052;
pub const xmlParserErrors_XML_RNGP_NAME_MISSING: xmlParserErrors = 1053;
pub const xmlParserErrors_XML_RNGP_NEED_COMBINE: xmlParserErrors = 1054;
pub const xmlParserErrors_XML_RNGP_NOTALLOWED_NOT_EMPTY: xmlParserErrors = 1055;
pub const xmlParserErrors_XML_RNGP_NSNAME_ATTR_ANCESTOR: xmlParserErrors = 1056;
pub const xmlParserErrors_XML_RNGP_NSNAME_NO_NS: xmlParserErrors = 1057;
pub const xmlParserErrors_XML_RNGP_PARAM_FORBIDDEN: xmlParserErrors = 1058;
pub const xmlParserErrors_XML_RNGP_PARAM_NAME_MISSING: xmlParserErrors = 1059;
pub const xmlParserErrors_XML_RNGP_PARENTREF_CREATE_FAILED: xmlParserErrors = 1060;
pub const xmlParserErrors_XML_RNGP_PARENTREF_NAME_INVALID: xmlParserErrors = 1061;
pub const xmlParserErrors_XML_RNGP_PARENTREF_NO_NAME: xmlParserErrors = 1062;
pub const xmlParserErrors_XML_RNGP_PARENTREF_NO_PARENT: xmlParserErrors = 1063;
pub const xmlParserErrors_XML_RNGP_PARENTREF_NOT_EMPTY: xmlParserErrors = 1064;
pub const xmlParserErrors_XML_RNGP_PARSE_ERROR: xmlParserErrors = 1065;
pub const xmlParserErrors_XML_RNGP_PAT_ANYNAME_EXCEPT_ANYNAME: xmlParserErrors = 1066;
pub const xmlParserErrors_XML_RNGP_PAT_ATTR_ATTR: xmlParserErrors = 1067;
pub const xmlParserErrors_XML_RNGP_PAT_ATTR_ELEM: xmlParserErrors = 1068;
pub const xmlParserErrors_XML_RNGP_PAT_DATA_EXCEPT_ATTR: xmlParserErrors = 1069;
pub const xmlParserErrors_XML_RNGP_PAT_DATA_EXCEPT_ELEM: xmlParserErrors = 1070;
pub const xmlParserErrors_XML_RNGP_PAT_DATA_EXCEPT_EMPTY: xmlParserErrors = 1071;
pub const xmlParserErrors_XML_RNGP_PAT_DATA_EXCEPT_GROUP: xmlParserErrors = 1072;
pub const xmlParserErrors_XML_RNGP_PAT_DATA_EXCEPT_INTERLEAVE: xmlParserErrors = 1073;
pub const xmlParserErrors_XML_RNGP_PAT_DATA_EXCEPT_LIST: xmlParserErrors = 1074;
pub const xmlParserErrors_XML_RNGP_PAT_DATA_EXCEPT_ONEMORE: xmlParserErrors = 1075;
pub const xmlParserErrors_XML_RNGP_PAT_DATA_EXCEPT_REF: xmlParserErrors = 1076;
pub const xmlParserErrors_XML_RNGP_PAT_DATA_EXCEPT_TEXT: xmlParserErrors = 1077;
pub const xmlParserErrors_XML_RNGP_PAT_LIST_ATTR: xmlParserErrors = 1078;
pub const xmlParserErrors_XML_RNGP_PAT_LIST_ELEM: xmlParserErrors = 1079;
pub const xmlParserErrors_XML_RNGP_PAT_LIST_INTERLEAVE: xmlParserErrors = 1080;
pub const xmlParserErrors_XML_RNGP_PAT_LIST_LIST: xmlParserErrors = 1081;
pub const xmlParserErrors_XML_RNGP_PAT_LIST_REF: xmlParserErrors = 1082;
pub const xmlParserErrors_XML_RNGP_PAT_LIST_TEXT: xmlParserErrors = 1083;
pub const xmlParserErrors_XML_RNGP_PAT_NSNAME_EXCEPT_ANYNAME: xmlParserErrors = 1084;
pub const xmlParserErrors_XML_RNGP_PAT_NSNAME_EXCEPT_NSNAME: xmlParserErrors = 1085;
pub const xmlParserErrors_XML_RNGP_PAT_ONEMORE_GROUP_ATTR: xmlParserErrors = 1086;
pub const xmlParserErrors_XML_RNGP_PAT_ONEMORE_INTERLEAVE_ATTR: xmlParserErrors = 1087;
pub const xmlParserErrors_XML_RNGP_PAT_START_ATTR: xmlParserErrors = 1088;
pub const xmlParserErrors_XML_RNGP_PAT_START_DATA: xmlParserErrors = 1089;
pub const xmlParserErrors_XML_RNGP_PAT_START_EMPTY: xmlParserErrors = 1090;
pub const xmlParserErrors_XML_RNGP_PAT_START_GROUP: xmlParserErrors = 1091;
pub const xmlParserErrors_XML_RNGP_PAT_START_INTERLEAVE: xmlParserErrors = 1092;
pub const xmlParserErrors_XML_RNGP_PAT_START_LIST: xmlParserErrors = 1093;
pub const xmlParserErrors_XML_RNGP_PAT_START_ONEMORE: xmlParserErrors = 1094;
pub const xmlParserErrors_XML_RNGP_PAT_START_TEXT: xmlParserErrors = 1095;
pub const xmlParserErrors_XML_RNGP_PAT_START_VALUE: xmlParserErrors = 1096;
pub const xmlParserErrors_XML_RNGP_PREFIX_UNDEFINED: xmlParserErrors = 1097;
pub const xmlParserErrors_XML_RNGP_REF_CREATE_FAILED: xmlParserErrors = 1098;
pub const xmlParserErrors_XML_RNGP_REF_CYCLE: xmlParserErrors = 1099;
pub const xmlParserErrors_XML_RNGP_REF_NAME_INVALID: xmlParserErrors = 1100;
pub const xmlParserErrors_XML_RNGP_REF_NO_DEF: xmlParserErrors = 1101;
pub const xmlParserErrors_XML_RNGP_REF_NO_NAME: xmlParserErrors = 1102;
pub const xmlParserErrors_XML_RNGP_REF_NOT_EMPTY: xmlParserErrors = 1103;
pub const xmlParserErrors_XML_RNGP_START_CHOICE_AND_INTERLEAVE: xmlParserErrors = 1104;
pub const xmlParserErrors_XML_RNGP_START_CONTENT: xmlParserErrors = 1105;
pub const xmlParserErrors_XML_RNGP_START_EMPTY: xmlParserErrors = 1106;
pub const xmlParserErrors_XML_RNGP_START_MISSING: xmlParserErrors = 1107;
pub const xmlParserErrors_XML_RNGP_TEXT_EXPECTED: xmlParserErrors = 1108;
pub const xmlParserErrors_XML_RNGP_TEXT_HAS_CHILD: xmlParserErrors = 1109;
pub const xmlParserErrors_XML_RNGP_TYPE_MISSING: xmlParserErrors = 1110;
pub const xmlParserErrors_XML_RNGP_TYPE_NOT_FOUND: xmlParserErrors = 1111;
pub const xmlParserErrors_XML_RNGP_TYPE_VALUE: xmlParserErrors = 1112;
pub const xmlParserErrors_XML_RNGP_UNKNOWN_ATTRIBUTE: xmlParserErrors = 1113;
pub const xmlParserErrors_XML_RNGP_UNKNOWN_COMBINE: xmlParserErrors = 1114;
pub const xmlParserErrors_XML_RNGP_UNKNOWN_CONSTRUCT: xmlParserErrors = 1115;
pub const xmlParserErrors_XML_RNGP_UNKNOWN_TYPE_LIB: xmlParserErrors = 1116;
pub const xmlParserErrors_XML_RNGP_URI_FRAGMENT: xmlParserErrors = 1117;
pub const xmlParserErrors_XML_RNGP_URI_NOT_ABSOLUTE: xmlParserErrors = 1118;
pub const xmlParserErrors_XML_RNGP_VALUE_EMPTY: xmlParserErrors = 1119;
pub const xmlParserErrors_XML_RNGP_VALUE_NO_CONTENT: xmlParserErrors = 1120;
pub const xmlParserErrors_XML_RNGP_XMLNS_NAME: xmlParserErrors = 1121;
pub const xmlParserErrors_XML_RNGP_XML_NS: xmlParserErrors = 1122;
pub const xmlParserErrors_XML_XPATH_EXPRESSION_OK: xmlParserErrors = 1200;
pub const xmlParserErrors_XML_XPATH_NUMBER_ERROR: xmlParserErrors = 1201;
pub const xmlParserErrors_XML_XPATH_UNFINISHED_LITERAL_ERROR: xmlParserErrors = 1202;
pub const xmlParserErrors_XML_XPATH_START_LITERAL_ERROR: xmlParserErrors = 1203;
pub const xmlParserErrors_XML_XPATH_VARIABLE_REF_ERROR: xmlParserErrors = 1204;
pub const xmlParserErrors_XML_XPATH_UNDEF_VARIABLE_ERROR: xmlParserErrors = 1205;
pub const xmlParserErrors_XML_XPATH_INVALID_PREDICATE_ERROR: xmlParserErrors = 1206;
pub const xmlParserErrors_XML_XPATH_EXPR_ERROR: xmlParserErrors = 1207;
pub const xmlParserErrors_XML_XPATH_UNCLOSED_ERROR: xmlParserErrors = 1208;
pub const xmlParserErrors_XML_XPATH_UNKNOWN_FUNC_ERROR: xmlParserErrors = 1209;
pub const xmlParserErrors_XML_XPATH_INVALID_OPERAND: xmlParserErrors = 1210;
pub const xmlParserErrors_XML_XPATH_INVALID_TYPE: xmlParserErrors = 1211;
pub const xmlParserErrors_XML_XPATH_INVALID_ARITY: xmlParserErrors = 1212;
pub const xmlParserErrors_XML_XPATH_INVALID_CTXT_SIZE: xmlParserErrors = 1213;
pub const xmlParserErrors_XML_XPATH_INVALID_CTXT_POSITION: xmlParserErrors = 1214;
pub const xmlParserErrors_XML_XPATH_MEMORY_ERROR: xmlParserErrors = 1215;
pub const xmlParserErrors_XML_XPTR_SYNTAX_ERROR: xmlParserErrors = 1216;
pub const xmlParserErrors_XML_XPTR_RESOURCE_ERROR: xmlParserErrors = 1217;
pub const xmlParserErrors_XML_XPTR_SUB_RESOURCE_ERROR: xmlParserErrors = 1218;
pub const xmlParserErrors_XML_XPATH_UNDEF_PREFIX_ERROR: xmlParserErrors = 1219;
pub const xmlParserErrors_XML_XPATH_ENCODING_ERROR: xmlParserErrors = 1220;
pub const xmlParserErrors_XML_XPATH_INVALID_CHAR_ERROR: xmlParserErrors = 1221;
pub const xmlParserErrors_XML_TREE_INVALID_HEX: xmlParserErrors = 1300;
pub const xmlParserErrors_XML_TREE_INVALID_DEC: xmlParserErrors = 1301;
pub const xmlParserErrors_XML_TREE_UNTERMINATED_ENTITY: xmlParserErrors = 1302;
pub const xmlParserErrors_XML_TREE_NOT_UTF8: xmlParserErrors = 1303;
pub const xmlParserErrors_XML_SAVE_NOT_UTF8: xmlParserErrors = 1400;
pub const xmlParserErrors_XML_SAVE_CHAR_INVALID: xmlParserErrors = 1401;
pub const xmlParserErrors_XML_SAVE_NO_DOCTYPE: xmlParserErrors = 1402;
pub const xmlParserErrors_XML_SAVE_UNKNOWN_ENCODING: xmlParserErrors = 1403;
pub const xmlParserErrors_XML_REGEXP_COMPILE_ERROR: xmlParserErrors = 1450;
pub const xmlParserErrors_XML_IO_UNKNOWN: xmlParserErrors = 1500;
pub const xmlParserErrors_XML_IO_EACCES: xmlParserErrors = 1501;
pub const xmlParserErrors_XML_IO_EAGAIN: xmlParserErrors = 1502;
pub const xmlParserErrors_XML_IO_EBADF: xmlParserErrors = 1503;
pub const xmlParserErrors_XML_IO_EBADMSG: xmlParserErrors = 1504;
pub const xmlParserErrors_XML_IO_EBUSY: xmlParserErrors = 1505;
pub const xmlParserErrors_XML_IO_ECANCELED: xmlParserErrors = 1506;
pub const xmlParserErrors_XML_IO_ECHILD: xmlParserErrors = 1507;
pub const xmlParserErrors_XML_IO_EDEADLK: xmlParserErrors = 1508;
pub const xmlParserErrors_XML_IO_EDOM: xmlParserErrors = 1509;
pub const xmlParserErrors_XML_IO_EEXIST: xmlParserErrors = 1510;
pub const xmlParserErrors_XML_IO_EFAULT: xmlParserErrors = 1511;
pub const xmlParserErrors_XML_IO_EFBIG: xmlParserErrors = 1512;
pub const xmlParserErrors_XML_IO_EINPROGRESS: xmlParserErrors = 1513;
pub const xmlParserErrors_XML_IO_EINTR: xmlParserErrors = 1514;
pub const xmlParserErrors_XML_IO_EINVAL: xmlParserErrors = 1515;
pub const xmlParserErrors_XML_IO_EIO: xmlParserErrors = 1516;
pub const xmlParserErrors_XML_IO_EISDIR: xmlParserErrors = 1517;
pub const xmlParserErrors_XML_IO_EMFILE: xmlParserErrors = 1518;
pub const xmlParserErrors_XML_IO_EMLINK: xmlParserErrors = 1519;
pub const xmlParserErrors_XML_IO_EMSGSIZE: xmlParserErrors = 1520;
pub const xmlParserErrors_XML_IO_ENAMETOOLONG: xmlParserErrors = 1521;
pub const xmlParserErrors_XML_IO_ENFILE: xmlParserErrors = 1522;
pub const xmlParserErrors_XML_IO_ENODEV: xmlParserErrors = 1523;
pub const xmlParserErrors_XML_IO_ENOENT: xmlParserErrors = 1524;
pub const xmlParserErrors_XML_IO_ENOEXEC: xmlParserErrors = 1525;
pub const xmlParserErrors_XML_IO_ENOLCK: xmlParserErrors = 1526;
pub const xmlParserErrors_XML_IO_ENOMEM: xmlParserErrors = 1527;
pub const xmlParserErrors_XML_IO_ENOSPC: xmlParserErrors = 1528;
pub const xmlParserErrors_XML_IO_ENOSYS: xmlParserErrors = 1529;
pub const xmlParserErrors_XML_IO_ENOTDIR: xmlParserErrors = 1530;
pub const xmlParserErrors_XML_IO_ENOTEMPTY: xmlParserErrors = 1531;
pub const xmlParserErrors_XML_IO_ENOTSUP: xmlParserErrors = 1532;
pub const xmlParserErrors_XML_IO_ENOTTY: xmlParserErrors = 1533;
pub const xmlParserErrors_XML_IO_ENXIO: xmlParserErrors = 1534;
pub const xmlParserErrors_XML_IO_EPERM: xmlParserErrors = 1535;
pub const xmlParserErrors_XML_IO_EPIPE: xmlParserErrors = 1536;
pub const xmlParserErrors_XML_IO_ERANGE: xmlParserErrors = 1537;
pub const xmlParserErrors_XML_IO_EROFS: xmlParserErrors = 1538;
pub const xmlParserErrors_XML_IO_ESPIPE: xmlParserErrors = 1539;
pub const xmlParserErrors_XML_IO_ESRCH: xmlParserErrors = 1540;
pub const xmlParserErrors_XML_IO_ETIMEDOUT: xmlParserErrors = 1541;
pub const xmlParserErrors_XML_IO_EXDEV: xmlParserErrors = 1542;
pub const xmlParserErrors_XML_IO_NETWORK_ATTEMPT: xmlParserErrors = 1543;
pub const xmlParserErrors_XML_IO_ENCODER: xmlParserErrors = 1544;
pub const xmlParserErrors_XML_IO_FLUSH: xmlParserErrors = 1545;
pub const xmlParserErrors_XML_IO_WRITE: xmlParserErrors = 1546;
pub const xmlParserErrors_XML_IO_NO_INPUT: xmlParserErrors = 1547;
pub const xmlParserErrors_XML_IO_BUFFER_FULL: xmlParserErrors = 1548;
pub const xmlParserErrors_XML_IO_LOAD_ERROR: xmlParserErrors = 1549;
pub const xmlParserErrors_XML_IO_ENOTSOCK: xmlParserErrors = 1550;
pub const xmlParserErrors_XML_IO_EISCONN: xmlParserErrors = 1551;
pub const xmlParserErrors_XML_IO_ECONNREFUSED: xmlParserErrors = 1552;
pub const xmlParserErrors_XML_IO_ENETUNREACH: xmlParserErrors = 1553;
pub const xmlParserErrors_XML_IO_EADDRINUSE: xmlParserErrors = 1554;
pub const xmlParserErrors_XML_IO_EALREADY: xmlParserErrors = 1555;
pub const xmlParserErrors_XML_IO_EAFNOSUPPORT: xmlParserErrors = 1556;
pub const xmlParserErrors_XML_XINCLUDE_RECURSION: xmlParserErrors = 1600;
pub const xmlParserErrors_XML_XINCLUDE_PARSE_VALUE: xmlParserErrors = 1601;
pub const xmlParserErrors_XML_XINCLUDE_ENTITY_DEF_MISMATCH: xmlParserErrors = 1602;
pub const xmlParserErrors_XML_XINCLUDE_NO_HREF: xmlParserErrors = 1603;
pub const xmlParserErrors_XML_XINCLUDE_NO_FALLBACK: xmlParserErrors = 1604;
pub const xmlParserErrors_XML_XINCLUDE_HREF_URI: xmlParserErrors = 1605;
pub const xmlParserErrors_XML_XINCLUDE_TEXT_FRAGMENT: xmlParserErrors = 1606;
pub const xmlParserErrors_XML_XINCLUDE_TEXT_DOCUMENT: xmlParserErrors = 1607;
pub const xmlParserErrors_XML_XINCLUDE_INVALID_CHAR: xmlParserErrors = 1608;
pub const xmlParserErrors_XML_XINCLUDE_BUILD_FAILED: xmlParserErrors = 1609;
pub const xmlParserErrors_XML_XINCLUDE_UNKNOWN_ENCODING: xmlParserErrors = 1610;
pub const xmlParserErrors_XML_XINCLUDE_MULTIPLE_ROOT: xmlParserErrors = 1611;
pub const xmlParserErrors_XML_XINCLUDE_XPTR_FAILED: xmlParserErrors = 1612;
pub const xmlParserErrors_XML_XINCLUDE_XPTR_RESULT: xmlParserErrors = 1613;
pub const xmlParserErrors_XML_XINCLUDE_INCLUDE_IN_INCLUDE: xmlParserErrors = 1614;
pub const xmlParserErrors_XML_XINCLUDE_FALLBACKS_IN_INCLUDE: xmlParserErrors = 1615;
pub const xmlParserErrors_XML_XINCLUDE_FALLBACK_NOT_IN_INCLUDE: xmlParserErrors = 1616;
pub const xmlParserErrors_XML_XINCLUDE_DEPRECATED_NS: xmlParserErrors = 1617;
pub const xmlParserErrors_XML_XINCLUDE_FRAGMENT_ID: xmlParserErrors = 1618;
pub const xmlParserErrors_XML_CATALOG_MISSING_ATTR: xmlParserErrors = 1650;
pub const xmlParserErrors_XML_CATALOG_ENTRY_BROKEN: xmlParserErrors = 1651;
pub const xmlParserErrors_XML_CATALOG_PREFER_VALUE: xmlParserErrors = 1652;
pub const xmlParserErrors_XML_CATALOG_NOT_CATALOG: xmlParserErrors = 1653;
pub const xmlParserErrors_XML_CATALOG_RECURSION: xmlParserErrors = 1654;
pub const xmlParserErrors_XML_SCHEMAP_PREFIX_UNDEFINED: xmlParserErrors = 1700;
pub const xmlParserErrors_XML_SCHEMAP_ATTRFORMDEFAULT_VALUE: xmlParserErrors = 1701;
pub const xmlParserErrors_XML_SCHEMAP_ATTRGRP_NONAME_NOREF: xmlParserErrors = 1702;
pub const xmlParserErrors_XML_SCHEMAP_ATTR_NONAME_NOREF: xmlParserErrors = 1703;
pub const xmlParserErrors_XML_SCHEMAP_COMPLEXTYPE_NONAME_NOREF: xmlParserErrors = 1704;
pub const xmlParserErrors_XML_SCHEMAP_ELEMFORMDEFAULT_VALUE: xmlParserErrors = 1705;
pub const xmlParserErrors_XML_SCHEMAP_ELEM_NONAME_NOREF: xmlParserErrors = 1706;
pub const xmlParserErrors_XML_SCHEMAP_EXTENSION_NO_BASE: xmlParserErrors = 1707;
pub const xmlParserErrors_XML_SCHEMAP_FACET_NO_VALUE: xmlParserErrors = 1708;
pub const xmlParserErrors_XML_SCHEMAP_FAILED_BUILD_IMPORT: xmlParserErrors = 1709;
pub const xmlParserErrors_XML_SCHEMAP_GROUP_NONAME_NOREF: xmlParserErrors = 1710;
pub const xmlParserErrors_XML_SCHEMAP_IMPORT_NAMESPACE_NOT_URI: xmlParserErrors = 1711;
pub const xmlParserErrors_XML_SCHEMAP_IMPORT_REDEFINE_NSNAME: xmlParserErrors = 1712;
pub const xmlParserErrors_XML_SCHEMAP_IMPORT_SCHEMA_NOT_URI: xmlParserErrors = 1713;
pub const xmlParserErrors_XML_SCHEMAP_INVALID_BOOLEAN: xmlParserErrors = 1714;
pub const xmlParserErrors_XML_SCHEMAP_INVALID_ENUM: xmlParserErrors = 1715;
pub const xmlParserErrors_XML_SCHEMAP_INVALID_FACET: xmlParserErrors = 1716;
pub const xmlParserErrors_XML_SCHEMAP_INVALID_FACET_VALUE: xmlParserErrors = 1717;
pub const xmlParserErrors_XML_SCHEMAP_INVALID_MAXOCCURS: xmlParserErrors = 1718;
pub const xmlParserErrors_XML_SCHEMAP_INVALID_MINOCCURS: xmlParserErrors = 1719;
pub const xmlParserErrors_XML_SCHEMAP_INVALID_REF_AND_SUBTYPE: xmlParserErrors = 1720;
pub const xmlParserErrors_XML_SCHEMAP_INVALID_WHITE_SPACE: xmlParserErrors = 1721;
pub const xmlParserErrors_XML_SCHEMAP_NOATTR_NOREF: xmlParserErrors = 1722;
pub const xmlParserErrors_XML_SCHEMAP_NOTATION_NO_NAME: xmlParserErrors = 1723;
pub const xmlParserErrors_XML_SCHEMAP_NOTYPE_NOREF: xmlParserErrors = 1724;
pub const xmlParserErrors_XML_SCHEMAP_REF_AND_SUBTYPE: xmlParserErrors = 1725;
pub const xmlParserErrors_XML_SCHEMAP_RESTRICTION_NONAME_NOREF: xmlParserErrors = 1726;
pub const xmlParserErrors_XML_SCHEMAP_SIMPLETYPE_NONAME: xmlParserErrors = 1727;
pub const xmlParserErrors_XML_SCHEMAP_TYPE_AND_SUBTYPE: xmlParserErrors = 1728;
pub const xmlParserErrors_XML_SCHEMAP_UNKNOWN_ALL_CHILD: xmlParserErrors = 1729;
pub const xmlParserErrors_XML_SCHEMAP_UNKNOWN_ANYATTRIBUTE_CHILD: xmlParserErrors = 1730;
pub const xmlParserErrors_XML_SCHEMAP_UNKNOWN_ATTR_CHILD: xmlParserErrors = 1731;
pub const xmlParserErrors_XML_SCHEMAP_UNKNOWN_ATTRGRP_CHILD: xmlParserErrors = 1732;
pub const xmlParserErrors_XML_SCHEMAP_UNKNOWN_ATTRIBUTE_GROUP: xmlParserErrors = 1733;
pub const xmlParserErrors_XML_SCHEMAP_UNKNOWN_BASE_TYPE: xmlParserErrors = 1734;
pub const xmlParserErrors_XML_SCHEMAP_UNKNOWN_CHOICE_CHILD: xmlParserErrors = 1735;
pub const xmlParserErrors_XML_SCHEMAP_UNKNOWN_COMPLEXCONTENT_CHILD: xmlParserErrors = 1736;
pub const xmlParserErrors_XML_SCHEMAP_UNKNOWN_COMPLEXTYPE_CHILD: xmlParserErrors = 1737;
pub const xmlParserErrors_XML_SCHEMAP_UNKNOWN_ELEM_CHILD: xmlParserErrors = 1738;
pub const xmlParserErrors_XML_SCHEMAP_UNKNOWN_EXTENSION_CHILD: xmlParserErrors = 1739;
pub const xmlParserErrors_XML_SCHEMAP_UNKNOWN_FACET_CHILD: xmlParserErrors = 1740;
pub const xmlParserErrors_XML_SCHEMAP_UNKNOWN_FACET_TYPE: xmlParserErrors = 1741;
pub const xmlParserErrors_XML_SCHEMAP_UNKNOWN_GROUP_CHILD: xmlParserErrors = 1742;
pub const xmlParserErrors_XML_SCHEMAP_UNKNOWN_IMPORT_CHILD: xmlParserErrors = 1743;
pub const xmlParserErrors_XML_SCHEMAP_UNKNOWN_LIST_CHILD: xmlParserErrors = 1744;
pub const xmlParserErrors_XML_SCHEMAP_UNKNOWN_NOTATION_CHILD: xmlParserErrors = 1745;
pub const xmlParserErrors_XML_SCHEMAP_UNKNOWN_PROCESSCONTENT_CHILD: xmlParserErrors = 1746;
pub const xmlParserErrors_XML_SCHEMAP_UNKNOWN_REF: xmlParserErrors = 1747;
pub const xmlParserErrors_XML_SCHEMAP_UNKNOWN_RESTRICTION_CHILD: xmlParserErrors = 1748;
pub const xmlParserErrors_XML_SCHEMAP_UNKNOWN_SCHEMAS_CHILD: xmlParserErrors = 1749;
pub const xmlParserErrors_XML_SCHEMAP_UNKNOWN_SEQUENCE_CHILD: xmlParserErrors = 1750;
pub const xmlParserErrors_XML_SCHEMAP_UNKNOWN_SIMPLECONTENT_CHILD: xmlParserErrors = 1751;
pub const xmlParserErrors_XML_SCHEMAP_UNKNOWN_SIMPLETYPE_CHILD: xmlParserErrors = 1752;
pub const xmlParserErrors_XML_SCHEMAP_UNKNOWN_TYPE: xmlParserErrors = 1753;
pub const xmlParserErrors_XML_SCHEMAP_UNKNOWN_UNION_CHILD: xmlParserErrors = 1754;
pub const xmlParserErrors_XML_SCHEMAP_ELEM_DEFAULT_FIXED: xmlParserErrors = 1755;
pub const xmlParserErrors_XML_SCHEMAP_REGEXP_INVALID: xmlParserErrors = 1756;
pub const xmlParserErrors_XML_SCHEMAP_FAILED_LOAD: xmlParserErrors = 1757;
pub const xmlParserErrors_XML_SCHEMAP_NOTHING_TO_PARSE: xmlParserErrors = 1758;
pub const xmlParserErrors_XML_SCHEMAP_NOROOT: xmlParserErrors = 1759;
pub const xmlParserErrors_XML_SCHEMAP_REDEFINED_GROUP: xmlParserErrors = 1760;
pub const xmlParserErrors_XML_SCHEMAP_REDEFINED_TYPE: xmlParserErrors = 1761;
pub const xmlParserErrors_XML_SCHEMAP_REDEFINED_ELEMENT: xmlParserErrors = 1762;
pub const xmlParserErrors_XML_SCHEMAP_REDEFINED_ATTRGROUP: xmlParserErrors = 1763;
pub const xmlParserErrors_XML_SCHEMAP_REDEFINED_ATTR: xmlParserErrors = 1764;
pub const xmlParserErrors_XML_SCHEMAP_REDEFINED_NOTATION: xmlParserErrors = 1765;
pub const xmlParserErrors_XML_SCHEMAP_FAILED_PARSE: xmlParserErrors = 1766;
pub const xmlParserErrors_XML_SCHEMAP_UNKNOWN_PREFIX: xmlParserErrors = 1767;
pub const xmlParserErrors_XML_SCHEMAP_DEF_AND_PREFIX: xmlParserErrors = 1768;
pub const xmlParserErrors_XML_SCHEMAP_UNKNOWN_INCLUDE_CHILD: xmlParserErrors = 1769;
pub const xmlParserErrors_XML_SCHEMAP_INCLUDE_SCHEMA_NOT_URI: xmlParserErrors = 1770;
pub const xmlParserErrors_XML_SCHEMAP_INCLUDE_SCHEMA_NO_URI: xmlParserErrors = 1771;
pub const xmlParserErrors_XML_SCHEMAP_NOT_SCHEMA: xmlParserErrors = 1772;
pub const xmlParserErrors_XML_SCHEMAP_UNKNOWN_MEMBER_TYPE: xmlParserErrors = 1773;
pub const xmlParserErrors_XML_SCHEMAP_INVALID_ATTR_USE: xmlParserErrors = 1774;
pub const xmlParserErrors_XML_SCHEMAP_RECURSIVE: xmlParserErrors = 1775;
pub const xmlParserErrors_XML_SCHEMAP_SUPERNUMEROUS_LIST_ITEM_TYPE: xmlParserErrors = 1776;
pub const xmlParserErrors_XML_SCHEMAP_INVALID_ATTR_COMBINATION: xmlParserErrors = 1777;
pub const xmlParserErrors_XML_SCHEMAP_INVALID_ATTR_INLINE_COMBINATION: xmlParserErrors = 1778;
pub const xmlParserErrors_XML_SCHEMAP_MISSING_SIMPLETYPE_CHILD: xmlParserErrors = 1779;
pub const xmlParserErrors_XML_SCHEMAP_INVALID_ATTR_NAME: xmlParserErrors = 1780;
pub const xmlParserErrors_XML_SCHEMAP_REF_AND_CONTENT: xmlParserErrors = 1781;
pub const xmlParserErrors_XML_SCHEMAP_CT_PROPS_CORRECT_1: xmlParserErrors = 1782;
pub const xmlParserErrors_XML_SCHEMAP_CT_PROPS_CORRECT_2: xmlParserErrors = 1783;
pub const xmlParserErrors_XML_SCHEMAP_CT_PROPS_CORRECT_3: xmlParserErrors = 1784;
pub const xmlParserErrors_XML_SCHEMAP_CT_PROPS_CORRECT_4: xmlParserErrors = 1785;
pub const xmlParserErrors_XML_SCHEMAP_CT_PROPS_CORRECT_5: xmlParserErrors = 1786;
pub const xmlParserErrors_XML_SCHEMAP_DERIVATION_OK_RESTRICTION_1: xmlParserErrors = 1787;
pub const xmlParserErrors_XML_SCHEMAP_DERIVATION_OK_RESTRICTION_2_1_1: xmlParserErrors = 1788;
pub const xmlParserErrors_XML_SCHEMAP_DERIVATION_OK_RESTRICTION_2_1_2: xmlParserErrors = 1789;
pub const xmlParserErrors_XML_SCHEMAP_DERIVATION_OK_RESTRICTION_2_2: xmlParserErrors = 1790;
pub const xmlParserErrors_XML_SCHEMAP_DERIVATION_OK_RESTRICTION_3: xmlParserErrors = 1791;
pub const xmlParserErrors_XML_SCHEMAP_WILDCARD_INVALID_NS_MEMBER: xmlParserErrors = 1792;
pub const xmlParserErrors_XML_SCHEMAP_INTERSECTION_NOT_EXPRESSIBLE: xmlParserErrors = 1793;
pub const xmlParserErrors_XML_SCHEMAP_UNION_NOT_EXPRESSIBLE: xmlParserErrors = 1794;
pub const xmlParserErrors_XML_SCHEMAP_SRC_IMPORT_3_1: xmlParserErrors = 1795;
pub const xmlParserErrors_XML_SCHEMAP_SRC_IMPORT_3_2: xmlParserErrors = 1796;
pub const xmlParserErrors_XML_SCHEMAP_DERIVATION_OK_RESTRICTION_4_1: xmlParserErrors = 1797;
pub const xmlParserErrors_XML_SCHEMAP_DERIVATION_OK_RESTRICTION_4_2: xmlParserErrors = 1798;
pub const xmlParserErrors_XML_SCHEMAP_DERIVATION_OK_RESTRICTION_4_3: xmlParserErrors = 1799;
pub const xmlParserErrors_XML_SCHEMAP_COS_CT_EXTENDS_1_3: xmlParserErrors = 1800;
pub const xmlParserErrors_XML_SCHEMAV_NOROOT: xmlParserErrors = 1801;
pub const xmlParserErrors_XML_SCHEMAV_UNDECLAREDELEM: xmlParserErrors = 1802;
pub const xmlParserErrors_XML_SCHEMAV_NOTTOPLEVEL: xmlParserErrors = 1803;
pub const xmlParserErrors_XML_SCHEMAV_MISSING: xmlParserErrors = 1804;
pub const xmlParserErrors_XML_SCHEMAV_WRONGELEM: xmlParserErrors = 1805;
pub const xmlParserErrors_XML_SCHEMAV_NOTYPE: xmlParserErrors = 1806;
pub const xmlParserErrors_XML_SCHEMAV_NOROLLBACK: xmlParserErrors = 1807;
pub const xmlParserErrors_XML_SCHEMAV_ISABSTRACT: xmlParserErrors = 1808;
pub const xmlParserErrors_XML_SCHEMAV_NOTEMPTY: xmlParserErrors = 1809;
pub const xmlParserErrors_XML_SCHEMAV_ELEMCONT: xmlParserErrors = 1810;
pub const xmlParserErrors_XML_SCHEMAV_HAVEDEFAULT: xmlParserErrors = 1811;
pub const xmlParserErrors_XML_SCHEMAV_NOTNILLABLE: xmlParserErrors = 1812;
pub const xmlParserErrors_XML_SCHEMAV_EXTRACONTENT: xmlParserErrors = 1813;
pub const xmlParserErrors_XML_SCHEMAV_INVALIDATTR: xmlParserErrors = 1814;
pub const xmlParserErrors_XML_SCHEMAV_INVALIDELEM: xmlParserErrors = 1815;
pub const xmlParserErrors_XML_SCHEMAV_NOTDETERMINIST: xmlParserErrors = 1816;
pub const xmlParserErrors_XML_SCHEMAV_CONSTRUCT: xmlParserErrors = 1817;
pub const xmlParserErrors_XML_SCHEMAV_INTERNAL: xmlParserErrors = 1818;
pub const xmlParserErrors_XML_SCHEMAV_NOTSIMPLE: xmlParserErrors = 1819;
pub const xmlParserErrors_XML_SCHEMAV_ATTRUNKNOWN: xmlParserErrors = 1820;
pub const xmlParserErrors_XML_SCHEMAV_ATTRINVALID: xmlParserErrors = 1821;
pub const xmlParserErrors_XML_SCHEMAV_VALUE: xmlParserErrors = 1822;
pub const xmlParserErrors_XML_SCHEMAV_FACET: xmlParserErrors = 1823;
pub const xmlParserErrors_XML_SCHEMAV_CVC_DATATYPE_VALID_1_2_1: xmlParserErrors = 1824;
pub const xmlParserErrors_XML_SCHEMAV_CVC_DATATYPE_VALID_1_2_2: xmlParserErrors = 1825;
pub const xmlParserErrors_XML_SCHEMAV_CVC_DATATYPE_VALID_1_2_3: xmlParserErrors = 1826;
pub const xmlParserErrors_XML_SCHEMAV_CVC_TYPE_3_1_1: xmlParserErrors = 1827;
pub const xmlParserErrors_XML_SCHEMAV_CVC_TYPE_3_1_2: xmlParserErrors = 1828;
pub const xmlParserErrors_XML_SCHEMAV_CVC_FACET_VALID: xmlParserErrors = 1829;
pub const xmlParserErrors_XML_SCHEMAV_CVC_LENGTH_VALID: xmlParserErrors = 1830;
pub const xmlParserErrors_XML_SCHEMAV_CVC_MINLENGTH_VALID: xmlParserErrors = 1831;
pub const xmlParserErrors_XML_SCHEMAV_CVC_MAXLENGTH_VALID: xmlParserErrors = 1832;
pub const xmlParserErrors_XML_SCHEMAV_CVC_MININCLUSIVE_VALID: xmlParserErrors = 1833;
pub const xmlParserErrors_XML_SCHEMAV_CVC_MAXINCLUSIVE_VALID: xmlParserErrors = 1834;
pub const xmlParserErrors_XML_SCHEMAV_CVC_MINEXCLUSIVE_VALID: xmlParserErrors = 1835;
pub const xmlParserErrors_XML_SCHEMAV_CVC_MAXEXCLUSIVE_VALID: xmlParserErrors = 1836;
pub const xmlParserErrors_XML_SCHEMAV_CVC_TOTALDIGITS_VALID: xmlParserErrors = 1837;
pub const xmlParserErrors_XML_SCHEMAV_CVC_FRACTIONDIGITS_VALID: xmlParserErrors = 1838;
pub const xmlParserErrors_XML_SCHEMAV_CVC_PATTERN_VALID: xmlParserErrors = 1839;
pub const xmlParserErrors_XML_SCHEMAV_CVC_ENUMERATION_VALID: xmlParserErrors = 1840;
pub const xmlParserErrors_XML_SCHEMAV_CVC_COMPLEX_TYPE_2_1: xmlParserErrors = 1841;
pub const xmlParserErrors_XML_SCHEMAV_CVC_COMPLEX_TYPE_2_2: xmlParserErrors = 1842;
pub const xmlParserErrors_XML_SCHEMAV_CVC_COMPLEX_TYPE_2_3: xmlParserErrors = 1843;
pub const xmlParserErrors_XML_SCHEMAV_CVC_COMPLEX_TYPE_2_4: xmlParserErrors = 1844;
pub const xmlParserErrors_XML_SCHEMAV_CVC_ELT_1: xmlParserErrors = 1845;
pub const xmlParserErrors_XML_SCHEMAV_CVC_ELT_2: xmlParserErrors = 1846;
pub const xmlParserErrors_XML_SCHEMAV_CVC_ELT_3_1: xmlParserErrors = 1847;
pub const xmlParserErrors_XML_SCHEMAV_CVC_ELT_3_2_1: xmlParserErrors = 1848;
pub const xmlParserErrors_XML_SCHEMAV_CVC_ELT_3_2_2: xmlParserErrors = 1849;
pub const xmlParserErrors_XML_SCHEMAV_CVC_ELT_4_1: xmlParserErrors = 1850;
pub const xmlParserErrors_XML_SCHEMAV_CVC_ELT_4_2: xmlParserErrors = 1851;
pub const xmlParserErrors_XML_SCHEMAV_CVC_ELT_4_3: xmlParserErrors = 1852;
pub const xmlParserErrors_XML_SCHEMAV_CVC_ELT_5_1_1: xmlParserErrors = 1853;
pub const xmlParserErrors_XML_SCHEMAV_CVC_ELT_5_1_2: xmlParserErrors = 1854;
pub const xmlParserErrors_XML_SCHEMAV_CVC_ELT_5_2_1: xmlParserErrors = 1855;
pub const xmlParserErrors_XML_SCHEMAV_CVC_ELT_5_2_2_1: xmlParserErrors = 1856;
pub const xmlParserErrors_XML_SCHEMAV_CVC_ELT_5_2_2_2_1: xmlParserErrors = 1857;
pub const xmlParserErrors_XML_SCHEMAV_CVC_ELT_5_2_2_2_2: xmlParserErrors = 1858;
pub const xmlParserErrors_XML_SCHEMAV_CVC_ELT_6: xmlParserErrors = 1859;
pub const xmlParserErrors_XML_SCHEMAV_CVC_ELT_7: xmlParserErrors = 1860;
pub const xmlParserErrors_XML_SCHEMAV_CVC_ATTRIBUTE_1: xmlParserErrors = 1861;
pub const xmlParserErrors_XML_SCHEMAV_CVC_ATTRIBUTE_2: xmlParserErrors = 1862;
pub const xmlParserErrors_XML_SCHEMAV_CVC_ATTRIBUTE_3: xmlParserErrors = 1863;
pub const xmlParserErrors_XML_SCHEMAV_CVC_ATTRIBUTE_4: xmlParserErrors = 1864;
pub const xmlParserErrors_XML_SCHEMAV_CVC_COMPLEX_TYPE_3_1: xmlParserErrors = 1865;
pub const xmlParserErrors_XML_SCHEMAV_CVC_COMPLEX_TYPE_3_2_1: xmlParserErrors = 1866;
pub const xmlParserErrors_XML_SCHEMAV_CVC_COMPLEX_TYPE_3_2_2: xmlParserErrors = 1867;
pub const xmlParserErrors_XML_SCHEMAV_CVC_COMPLEX_TYPE_4: xmlParserErrors = 1868;
pub const xmlParserErrors_XML_SCHEMAV_CVC_COMPLEX_TYPE_5_1: xmlParserErrors = 1869;
pub const xmlParserErrors_XML_SCHEMAV_CVC_COMPLEX_TYPE_5_2: xmlParserErrors = 1870;
pub const xmlParserErrors_XML_SCHEMAV_ELEMENT_CONTENT: xmlParserErrors = 1871;
pub const xmlParserErrors_XML_SCHEMAV_DOCUMENT_ELEMENT_MISSING: xmlParserErrors = 1872;
pub const xmlParserErrors_XML_SCHEMAV_CVC_COMPLEX_TYPE_1: xmlParserErrors = 1873;
pub const xmlParserErrors_XML_SCHEMAV_CVC_AU: xmlParserErrors = 1874;
pub const xmlParserErrors_XML_SCHEMAV_CVC_TYPE_1: xmlParserErrors = 1875;
pub const xmlParserErrors_XML_SCHEMAV_CVC_TYPE_2: xmlParserErrors = 1876;
pub const xmlParserErrors_XML_SCHEMAV_CVC_IDC: xmlParserErrors = 1877;
pub const xmlParserErrors_XML_SCHEMAV_CVC_WILDCARD: xmlParserErrors = 1878;
pub const xmlParserErrors_XML_SCHEMAV_MISC: xmlParserErrors = 1879;
pub const xmlParserErrors_XML_XPTR_UNKNOWN_SCHEME: xmlParserErrors = 1900;
pub const xmlParserErrors_XML_XPTR_CHILDSEQ_START: xmlParserErrors = 1901;
pub const xmlParserErrors_XML_XPTR_EVAL_FAILED: xmlParserErrors = 1902;
pub const xmlParserErrors_XML_XPTR_EXTRA_OBJECTS: xmlParserErrors = 1903;
pub const xmlParserErrors_XML_C14N_CREATE_CTXT: xmlParserErrors = 1950;
pub const xmlParserErrors_XML_C14N_REQUIRES_UTF8: xmlParserErrors = 1951;
pub const xmlParserErrors_XML_C14N_CREATE_STACK: xmlParserErrors = 1952;
pub const xmlParserErrors_XML_C14N_INVALID_NODE: xmlParserErrors = 1953;
pub const xmlParserErrors_XML_C14N_UNKNOW_NODE: xmlParserErrors = 1954;
pub const xmlParserErrors_XML_C14N_RELATIVE_NAMESPACE: xmlParserErrors = 1955;
pub const xmlParserErrors_XML_FTP_PASV_ANSWER: xmlParserErrors = 2000;
pub const xmlParserErrors_XML_FTP_EPSV_ANSWER: xmlParserErrors = 2001;
pub const xmlParserErrors_XML_FTP_ACCNT: xmlParserErrors = 2002;
pub const xmlParserErrors_XML_FTP_URL_SYNTAX: xmlParserErrors = 2003;
pub const xmlParserErrors_XML_HTTP_URL_SYNTAX: xmlParserErrors = 2020;
pub const xmlParserErrors_XML_HTTP_USE_IP: xmlParserErrors = 2021;
pub const xmlParserErrors_XML_HTTP_UNKNOWN_HOST: xmlParserErrors = 2022;
pub const xmlParserErrors_XML_SCHEMAP_SRC_SIMPLE_TYPE_1: xmlParserErrors = 3000;
pub const xmlParserErrors_XML_SCHEMAP_SRC_SIMPLE_TYPE_2: xmlParserErrors = 3001;
pub const xmlParserErrors_XML_SCHEMAP_SRC_SIMPLE_TYPE_3: xmlParserErrors = 3002;
pub const xmlParserErrors_XML_SCHEMAP_SRC_SIMPLE_TYPE_4: xmlParserErrors = 3003;
pub const xmlParserErrors_XML_SCHEMAP_SRC_RESOLVE: xmlParserErrors = 3004;
pub const xmlParserErrors_XML_SCHEMAP_SRC_RESTRICTION_BASE_OR_SIMPLETYPE: xmlParserErrors = 3005;
pub const xmlParserErrors_XML_SCHEMAP_SRC_LIST_ITEMTYPE_OR_SIMPLETYPE: xmlParserErrors = 3006;
pub const xmlParserErrors_XML_SCHEMAP_SRC_UNION_MEMBERTYPES_OR_SIMPLETYPES: xmlParserErrors = 3007;
pub const xmlParserErrors_XML_SCHEMAP_ST_PROPS_CORRECT_1: xmlParserErrors = 3008;
pub const xmlParserErrors_XML_SCHEMAP_ST_PROPS_CORRECT_2: xmlParserErrors = 3009;
pub const xmlParserErrors_XML_SCHEMAP_ST_PROPS_CORRECT_3: xmlParserErrors = 3010;
pub const xmlParserErrors_XML_SCHEMAP_COS_ST_RESTRICTS_1_1: xmlParserErrors = 3011;
pub const xmlParserErrors_XML_SCHEMAP_COS_ST_RESTRICTS_1_2: xmlParserErrors = 3012;
pub const xmlParserErrors_XML_SCHEMAP_COS_ST_RESTRICTS_1_3_1: xmlParserErrors = 3013;
pub const xmlParserErrors_XML_SCHEMAP_COS_ST_RESTRICTS_1_3_2: xmlParserErrors = 3014;
pub const xmlParserErrors_XML_SCHEMAP_COS_ST_RESTRICTS_2_1: xmlParserErrors = 3015;
pub const xmlParserErrors_XML_SCHEMAP_COS_ST_RESTRICTS_2_3_1_1: xmlParserErrors = 3016;
pub const xmlParserErrors_XML_SCHEMAP_COS_ST_RESTRICTS_2_3_1_2: xmlParserErrors = 3017;
pub const xmlParserErrors_XML_SCHEMAP_COS_ST_RESTRICTS_2_3_2_1: xmlParserErrors = 3018;
pub const xmlParserErrors_XML_SCHEMAP_COS_ST_RESTRICTS_2_3_2_2: xmlParserErrors = 3019;
pub const xmlParserErrors_XML_SCHEMAP_COS_ST_RESTRICTS_2_3_2_3: xmlParserErrors = 3020;
pub const xmlParserErrors_XML_SCHEMAP_COS_ST_RESTRICTS_2_3_2_4: xmlParserErrors = 3021;
pub const xmlParserErrors_XML_SCHEMAP_COS_ST_RESTRICTS_2_3_2_5: xmlParserErrors = 3022;
pub const xmlParserErrors_XML_SCHEMAP_COS_ST_RESTRICTS_3_1: xmlParserErrors = 3023;
pub const xmlParserErrors_XML_SCHEMAP_COS_ST_RESTRICTS_3_3_1: xmlParserErrors = 3024;
pub const xmlParserErrors_XML_SCHEMAP_COS_ST_RESTRICTS_3_3_1_2: xmlParserErrors = 3025;
pub const xmlParserErrors_XML_SCHEMAP_COS_ST_RESTRICTS_3_3_2_2: xmlParserErrors = 3026;
pub const xmlParserErrors_XML_SCHEMAP_COS_ST_RESTRICTS_3_3_2_1: xmlParserErrors = 3027;
pub const xmlParserErrors_XML_SCHEMAP_COS_ST_RESTRICTS_3_3_2_3: xmlParserErrors = 3028;
pub const xmlParserErrors_XML_SCHEMAP_COS_ST_RESTRICTS_3_3_2_4: xmlParserErrors = 3029;
pub const xmlParserErrors_XML_SCHEMAP_COS_ST_RESTRICTS_3_3_2_5: xmlParserErrors = 3030;
pub const xmlParserErrors_XML_SCHEMAP_COS_ST_DERIVED_OK_2_1: xmlParserErrors = 3031;
pub const xmlParserErrors_XML_SCHEMAP_COS_ST_DERIVED_OK_2_2: xmlParserErrors = 3032;
pub const xmlParserErrors_XML_SCHEMAP_S4S_ELEM_NOT_ALLOWED: xmlParserErrors = 3033;
pub const xmlParserErrors_XML_SCHEMAP_S4S_ELEM_MISSING: xmlParserErrors = 3034;
pub const xmlParserErrors_XML_SCHEMAP_S4S_ATTR_NOT_ALLOWED: xmlParserErrors = 3035;
pub const xmlParserErrors_XML_SCHEMAP_S4S_ATTR_MISSING: xmlParserErrors = 3036;
pub const xmlParserErrors_XML_SCHEMAP_S4S_ATTR_INVALID_VALUE: xmlParserErrors = 3037;
pub const xmlParserErrors_XML_SCHEMAP_SRC_ELEMENT_1: xmlParserErrors = 3038;
pub const xmlParserErrors_XML_SCHEMAP_SRC_ELEMENT_2_1: xmlParserErrors = 3039;
pub const xmlParserErrors_XML_SCHEMAP_SRC_ELEMENT_2_2: xmlParserErrors = 3040;
pub const xmlParserErrors_XML_SCHEMAP_SRC_ELEMENT_3: xmlParserErrors = 3041;
pub const xmlParserErrors_XML_SCHEMAP_P_PROPS_CORRECT_1: xmlParserErrors = 3042;
pub const xmlParserErrors_XML_SCHEMAP_P_PROPS_CORRECT_2_1: xmlParserErrors = 3043;
pub const xmlParserErrors_XML_SCHEMAP_P_PROPS_CORRECT_2_2: xmlParserErrors = 3044;
pub const xmlParserErrors_XML_SCHEMAP_E_PROPS_CORRECT_2: xmlParserErrors = 3045;
pub const xmlParserErrors_XML_SCHEMAP_E_PROPS_CORRECT_3: xmlParserErrors = 3046;
pub const xmlParserErrors_XML_SCHEMAP_E_PROPS_CORRECT_4: xmlParserErrors = 3047;
pub const xmlParserErrors_XML_SCHEMAP_E_PROPS_CORRECT_5: xmlParserErrors = 3048;
pub const xmlParserErrors_XML_SCHEMAP_E_PROPS_CORRECT_6: xmlParserErrors = 3049;
pub const xmlParserErrors_XML_SCHEMAP_SRC_INCLUDE: xmlParserErrors = 3050;
pub const xmlParserErrors_XML_SCHEMAP_SRC_ATTRIBUTE_1: xmlParserErrors = 3051;
pub const xmlParserErrors_XML_SCHEMAP_SRC_ATTRIBUTE_2: xmlParserErrors = 3052;
pub const xmlParserErrors_XML_SCHEMAP_SRC_ATTRIBUTE_3_1: xmlParserErrors = 3053;
pub const xmlParserErrors_XML_SCHEMAP_SRC_ATTRIBUTE_3_2: xmlParserErrors = 3054;
pub const xmlParserErrors_XML_SCHEMAP_SRC_ATTRIBUTE_4: xmlParserErrors = 3055;
pub const xmlParserErrors_XML_SCHEMAP_NO_XMLNS: xmlParserErrors = 3056;
pub const xmlParserErrors_XML_SCHEMAP_NO_XSI: xmlParserErrors = 3057;
pub const xmlParserErrors_XML_SCHEMAP_COS_VALID_DEFAULT_1: xmlParserErrors = 3058;
pub const xmlParserErrors_XML_SCHEMAP_COS_VALID_DEFAULT_2_1: xmlParserErrors = 3059;
pub const xmlParserErrors_XML_SCHEMAP_COS_VALID_DEFAULT_2_2_1: xmlParserErrors = 3060;
pub const xmlParserErrors_XML_SCHEMAP_COS_VALID_DEFAULT_2_2_2: xmlParserErrors = 3061;
pub const xmlParserErrors_XML_SCHEMAP_CVC_SIMPLE_TYPE: xmlParserErrors = 3062;
pub const xmlParserErrors_XML_SCHEMAP_COS_CT_EXTENDS_1_1: xmlParserErrors = 3063;
pub const xmlParserErrors_XML_SCHEMAP_SRC_IMPORT_1_1: xmlParserErrors = 3064;
pub const xmlParserErrors_XML_SCHEMAP_SRC_IMPORT_1_2: xmlParserErrors = 3065;
pub const xmlParserErrors_XML_SCHEMAP_SRC_IMPORT_2: xmlParserErrors = 3066;
pub const xmlParserErrors_XML_SCHEMAP_SRC_IMPORT_2_1: xmlParserErrors = 3067;
pub const xmlParserErrors_XML_SCHEMAP_SRC_IMPORT_2_2: xmlParserErrors = 3068;
pub const xmlParserErrors_XML_SCHEMAP_INTERNAL: xmlParserErrors = 3069;
pub const xmlParserErrors_XML_SCHEMAP_NOT_DETERMINISTIC: xmlParserErrors = 3070;
pub const xmlParserErrors_XML_SCHEMAP_SRC_ATTRIBUTE_GROUP_1: xmlParserErrors = 3071;
pub const xmlParserErrors_XML_SCHEMAP_SRC_ATTRIBUTE_GROUP_2: xmlParserErrors = 3072;
pub const xmlParserErrors_XML_SCHEMAP_SRC_ATTRIBUTE_GROUP_3: xmlParserErrors = 3073;
pub const xmlParserErrors_XML_SCHEMAP_MG_PROPS_CORRECT_1: xmlParserErrors = 3074;
pub const xmlParserErrors_XML_SCHEMAP_MG_PROPS_CORRECT_2: xmlParserErrors = 3075;
pub const xmlParserErrors_XML_SCHEMAP_SRC_CT_1: xmlParserErrors = 3076;
pub const xmlParserErrors_XML_SCHEMAP_DERIVATION_OK_RESTRICTION_2_1_3: xmlParserErrors = 3077;
pub const xmlParserErrors_XML_SCHEMAP_AU_PROPS_CORRECT_2: xmlParserErrors = 3078;
pub const xmlParserErrors_XML_SCHEMAP_A_PROPS_CORRECT_2: xmlParserErrors = 3079;
pub const xmlParserErrors_XML_SCHEMAP_C_PROPS_CORRECT: xmlParserErrors = 3080;
pub const xmlParserErrors_XML_SCHEMAP_SRC_REDEFINE: xmlParserErrors = 3081;
pub const xmlParserErrors_XML_SCHEMAP_SRC_IMPORT: xmlParserErrors = 3082;
pub const xmlParserErrors_XML_SCHEMAP_WARN_SKIP_SCHEMA: xmlParserErrors = 3083;
pub const xmlParserErrors_XML_SCHEMAP_WARN_UNLOCATED_SCHEMA: xmlParserErrors = 3084;
pub const xmlParserErrors_XML_SCHEMAP_WARN_ATTR_REDECL_PROH: xmlParserErrors = 3085;
pub const xmlParserErrors_XML_SCHEMAP_WARN_ATTR_POINTLESS_PROH: xmlParserErrors = 3086;
pub const xmlParserErrors_XML_SCHEMAP_AG_PROPS_CORRECT: xmlParserErrors = 3087;
pub const xmlParserErrors_XML_SCHEMAP_COS_CT_EXTENDS_1_2: xmlParserErrors = 3088;
pub const xmlParserErrors_XML_SCHEMAP_AU_PROPS_CORRECT: xmlParserErrors = 3089;
pub const xmlParserErrors_XML_SCHEMAP_A_PROPS_CORRECT_3: xmlParserErrors = 3090;
pub const xmlParserErrors_XML_SCHEMAP_COS_ALL_LIMITED: xmlParserErrors = 3091;
pub const xmlParserErrors_XML_SCHEMATRONV_ASSERT: xmlParserErrors = 4000;
pub const xmlParserErrors_XML_SCHEMATRONV_REPORT: xmlParserErrors = 4001;
pub const xmlParserErrors_XML_MODULE_OPEN: xmlParserErrors = 4900;
pub const xmlParserErrors_XML_MODULE_CLOSE: xmlParserErrors = 4901;
pub const xmlParserErrors_XML_CHECK_FOUND_ELEMENT: xmlParserErrors = 5000;
pub const xmlParserErrors_XML_CHECK_FOUND_ATTRIBUTE: xmlParserErrors = 5001;
pub const xmlParserErrors_XML_CHECK_FOUND_TEXT: xmlParserErrors = 5002;
pub const xmlParserErrors_XML_CHECK_FOUND_CDATA: xmlParserErrors = 5003;
pub const xmlParserErrors_XML_CHECK_FOUND_ENTITYREF: xmlParserErrors = 5004;
pub const xmlParserErrors_XML_CHECK_FOUND_ENTITY: xmlParserErrors = 5005;
pub const xmlParserErrors_XML_CHECK_FOUND_PI: xmlParserErrors = 5006;
pub const xmlParserErrors_XML_CHECK_FOUND_COMMENT: xmlParserErrors = 5007;
pub const xmlParserErrors_XML_CHECK_FOUND_DOCTYPE: xmlParserErrors = 5008;
pub const xmlParserErrors_XML_CHECK_FOUND_FRAGMENT: xmlParserErrors = 5009;
pub const xmlParserErrors_XML_CHECK_FOUND_NOTATION: xmlParserErrors = 5010;
pub const xmlParserErrors_XML_CHECK_UNKNOWN_NODE: xmlParserErrors = 5011;
pub const xmlParserErrors_XML_CHECK_ENTITY_TYPE: xmlParserErrors = 5012;
pub const xmlParserErrors_XML_CHECK_NO_PARENT: xmlParserErrors = 5013;
pub const xmlParserErrors_XML_CHECK_NO_DOC: xmlParserErrors = 5014;
pub const xmlParserErrors_XML_CHECK_NO_NAME: xmlParserErrors = 5015;
pub const xmlParserErrors_XML_CHECK_NO_ELEM: xmlParserErrors = 5016;
pub const xmlParserErrors_XML_CHECK_WRONG_DOC: xmlParserErrors = 5017;
pub const xmlParserErrors_XML_CHECK_NO_PREV: xmlParserErrors = 5018;
pub const xmlParserErrors_XML_CHECK_WRONG_PREV: xmlParserErrors = 5019;
pub const xmlParserErrors_XML_CHECK_NO_NEXT: xmlParserErrors = 5020;
pub const xmlParserErrors_XML_CHECK_WRONG_NEXT: xmlParserErrors = 5021;
pub const xmlParserErrors_XML_CHECK_NOT_DTD: xmlParserErrors = 5022;
pub const xmlParserErrors_XML_CHECK_NOT_ATTR: xmlParserErrors = 5023;
pub const xmlParserErrors_XML_CHECK_NOT_ATTR_DECL: xmlParserErrors = 5024;
pub const xmlParserErrors_XML_CHECK_NOT_ELEM_DECL: xmlParserErrors = 5025;
pub const xmlParserErrors_XML_CHECK_NOT_ENTITY_DECL: xmlParserErrors = 5026;
pub const xmlParserErrors_XML_CHECK_NOT_NS_DECL: xmlParserErrors = 5027;
pub const xmlParserErrors_XML_CHECK_NO_HREF: xmlParserErrors = 5028;
pub const xmlParserErrors_XML_CHECK_WRONG_PARENT: xmlParserErrors = 5029;
pub const xmlParserErrors_XML_CHECK_NS_SCOPE: xmlParserErrors = 5030;
pub const xmlParserErrors_XML_CHECK_NS_ANCESTOR: xmlParserErrors = 5031;
pub const xmlParserErrors_XML_CHECK_NOT_UTF8: xmlParserErrors = 5032;
pub const xmlParserErrors_XML_CHECK_NO_DICT: xmlParserErrors = 5033;
pub const xmlParserErrors_XML_CHECK_NOT_NCNAME: xmlParserErrors = 5034;
pub const xmlParserErrors_XML_CHECK_OUTSIDE_DICT: xmlParserErrors = 5035;
pub const xmlParserErrors_XML_CHECK_WRONG_NAME: xmlParserErrors = 5036;
pub const xmlParserErrors_XML_CHECK_NAME_NOT_NULL: xmlParserErrors = 5037;
pub const xmlParserErrors_XML_I18N_NO_NAME: xmlParserErrors = 6000;
pub const xmlParserErrors_XML_I18N_NO_HANDLER: xmlParserErrors = 6001;
pub const xmlParserErrors_XML_I18N_EXCESS_HANDLER: xmlParserErrors = 6002;
pub const xmlParserErrors_XML_I18N_CONV_FAILED: xmlParserErrors = 6003;
pub const xmlParserErrors_XML_I18N_NO_OUTPUT: xmlParserErrors = 6004;
pub const xmlParserErrors_XML_BUF_OVERFLOW: xmlParserErrors = 7000;
pub type xmlParserErrors = ::std::os::raw::c_uint;
pub type xmlGenericErrorFunc = ::std::option::Option<
unsafe extern "C" fn(ctx: *mut ::std::os::raw::c_void, msg: *const ::std::os::raw::c_char, ...),
>;
pub type xmlStructuredErrorFunc = ::std::option::Option<
unsafe extern "C" fn(userData: *mut ::std::os::raw::c_void, error: xmlErrorPtr),
>;
extern "C" {
pub fn xmlSetGenericErrorFunc(ctx: *mut ::std::os::raw::c_void, handler: xmlGenericErrorFunc);
}
extern "C" {
pub fn initGenericErrorDefaultFunc(handler: *mut xmlGenericErrorFunc);
}
extern "C" {
pub fn xmlSetStructuredErrorFunc(
ctx: *mut ::std::os::raw::c_void,
handler: xmlStructuredErrorFunc,
);
}
extern "C" {
pub fn xmlParserError(
ctx: *mut ::std::os::raw::c_void,
msg: *const ::std::os::raw::c_char,
...
);
}
extern "C" {
pub fn xmlParserWarning(
ctx: *mut ::std::os::raw::c_void,
msg: *const ::std::os::raw::c_char,
...
);
}
extern "C" {
pub fn xmlParserValidityError(
ctx: *mut ::std::os::raw::c_void,
msg: *const ::std::os::raw::c_char,
...
);
}
extern "C" {
pub fn xmlParserValidityWarning(
ctx: *mut ::std::os::raw::c_void,
msg: *const ::std::os::raw::c_char,
...
);
}
extern "C" {
pub fn xmlParserPrintFileInfo(input: xmlParserInputPtr);
}
extern "C" {
pub fn xmlParserPrintFileContext(input: xmlParserInputPtr);
}
extern "C" {
pub fn xmlGetLastError() -> xmlErrorPtr;
}
extern "C" {
pub fn xmlResetLastError();
}
extern "C" {
pub fn xmlCtxtGetLastError(ctx: *mut ::std::os::raw::c_void) -> xmlErrorPtr;
}
extern "C" {
pub fn xmlCtxtResetLastError(ctx: *mut ::std::os::raw::c_void);
}
extern "C" {
pub fn xmlResetError(err: xmlErrorPtr);
}
extern "C" {
pub fn xmlCopyError(from: xmlErrorPtr, to: xmlErrorPtr) -> ::std::os::raw::c_int;
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct _xmlLink {
_unused: [u8; 0],
}
pub type xmlLink = _xmlLink;
pub type xmlLinkPtr = *mut xmlLink;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct _xmlList {
_unused: [u8; 0],
}
pub type xmlList = _xmlList;
pub type xmlListPtr = *mut xmlList;
pub type xmlListDeallocator = ::std::option::Option<unsafe extern "C" fn(lk: xmlLinkPtr)>;
pub type xmlListDataCompare = ::std::option::Option<
unsafe extern "C" fn(
data0: *const ::std::os::raw::c_void,
data1: *const ::std::os::raw::c_void,
) -> ::std::os::raw::c_int,
>;
pub type xmlListWalker = ::std::option::Option<
unsafe extern "C" fn(
data: *const ::std::os::raw::c_void,
user: *mut ::std::os::raw::c_void,
) -> ::std::os::raw::c_int,
>;
extern "C" {
pub fn xmlListCreate(
deallocator: xmlListDeallocator,
compare: xmlListDataCompare,
) -> xmlListPtr;
}
extern "C" {
pub fn xmlListDelete(l: xmlListPtr);
}
extern "C" {
pub fn xmlListSearch(
l: xmlListPtr,
data: *mut ::std::os::raw::c_void,
) -> *mut ::std::os::raw::c_void;
}
extern "C" {
pub fn xmlListReverseSearch(
l: xmlListPtr,
data: *mut ::std::os::raw::c_void,
) -> *mut ::std::os::raw::c_void;
}
extern "C" {
pub fn xmlListInsert(l: xmlListPtr, data: *mut ::std::os::raw::c_void)
-> ::std::os::raw::c_int;
}
extern "C" {
pub fn xmlListAppend(l: xmlListPtr, data: *mut ::std::os::raw::c_void)
-> ::std::os::raw::c_int;
}
extern "C" {
pub fn xmlListRemoveFirst(
l: xmlListPtr,
data: *mut ::std::os::raw::c_void,
) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn xmlListRemoveLast(
l: xmlListPtr,
data: *mut ::std::os::raw::c_void,
) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn xmlListRemoveAll(
l: xmlListPtr,
data: *mut ::std::os::raw::c_void,
) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn xmlListClear(l: xmlListPtr);
}
extern "C" {
pub fn xmlListEmpty(l: xmlListPtr) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn xmlListFront(l: xmlListPtr) -> xmlLinkPtr;
}
extern "C" {
pub fn xmlListEnd(l: xmlListPtr) -> xmlLinkPtr;
}
extern "C" {
pub fn xmlListSize(l: xmlListPtr) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn xmlListPopFront(l: xmlListPtr);
}
extern "C" {
pub fn xmlListPopBack(l: xmlListPtr);
}
extern "C" {
pub fn xmlListPushFront(
l: xmlListPtr,
data: *mut ::std::os::raw::c_void,
) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn xmlListPushBack(
l: xmlListPtr,
data: *mut ::std::os::raw::c_void,
) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn xmlListReverse(l: xmlListPtr);
}
extern "C" {
pub fn xmlListSort(l: xmlListPtr);
}
extern "C" {
pub fn xmlListWalk(l: xmlListPtr, walker: xmlListWalker, user: *mut ::std::os::raw::c_void);
}
extern "C" {
pub fn xmlListReverseWalk(
l: xmlListPtr,
walker: xmlListWalker,
user: *mut ::std::os::raw::c_void,
);
}
extern "C" {
pub fn xmlListMerge(l1: xmlListPtr, l2: xmlListPtr);
}
extern "C" {
pub fn xmlListDup(old: xmlListPtr) -> xmlListPtr;
}
extern "C" {
pub fn xmlListCopy(cur: xmlListPtr, old: xmlListPtr) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn xmlLinkGetData(lk: xmlLinkPtr) -> *mut ::std::os::raw::c_void;
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct _xmlAutomata {
_unused: [u8; 0],
}
pub type xmlAutomata = _xmlAutomata;
pub type xmlAutomataPtr = *mut xmlAutomata;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct _xmlAutomataState {
_unused: [u8; 0],
}
pub type xmlAutomataState = _xmlAutomataState;
pub type xmlAutomataStatePtr = *mut xmlAutomataState;
extern "C" {
pub fn xmlNewAutomata() -> xmlAutomataPtr;
}
extern "C" {
pub fn xmlFreeAutomata(am: xmlAutomataPtr);
}
extern "C" {
pub fn xmlAutomataGetInitState(am: xmlAutomataPtr) -> xmlAutomataStatePtr;
}
extern "C" {
pub fn xmlAutomataSetFinalState(
am: xmlAutomataPtr,
state: xmlAutomataStatePtr,
) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn xmlAutomataNewState(am: xmlAutomataPtr) -> xmlAutomataStatePtr;
}
extern "C" {
pub fn xmlAutomataNewTransition(
am: xmlAutomataPtr,
from: xmlAutomataStatePtr,
to: xmlAutomataStatePtr,
token: *const xmlChar,
data: *mut ::std::os::raw::c_void,
) -> xmlAutomataStatePtr;
}
extern "C" {
pub fn xmlAutomataNewTransition2(
am: xmlAutomataPtr,
from: xmlAutomataStatePtr,
to: xmlAutomataStatePtr,
token: *const xmlChar,
token2: *const xmlChar,
data: *mut ::std::os::raw::c_void,
) -> xmlAutomataStatePtr;
}
extern "C" {
pub fn xmlAutomataNewNegTrans(
am: xmlAutomataPtr,
from: xmlAutomataStatePtr,
to: xmlAutomataStatePtr,
token: *const xmlChar,
token2: *const xmlChar,
data: *mut ::std::os::raw::c_void,
) -> xmlAutomataStatePtr;
}
extern "C" {
pub fn xmlAutomataNewCountTrans(
am: xmlAutomataPtr,
from: xmlAutomataStatePtr,
to: xmlAutomataStatePtr,
token: *const xmlChar,
min: ::std::os::raw::c_int,
max: ::std::os::raw::c_int,
data: *mut ::std::os::raw::c_void,
) -> xmlAutomataStatePtr;
}
extern "C" {
pub fn xmlAutomataNewCountTrans2(
am: xmlAutomataPtr,
from: xmlAutomataStatePtr,
to: xmlAutomataStatePtr,
token: *const xmlChar,
token2: *const xmlChar,
min: ::std::os::raw::c_int,
max: ::std::os::raw::c_int,
data: *mut ::std::os::raw::c_void,
) -> xmlAutomataStatePtr;
}
extern "C" {
pub fn xmlAutomataNewOnceTrans(
am: xmlAutomataPtr,
from: xmlAutomataStatePtr,
to: xmlAutomataStatePtr,
token: *const xmlChar,
min: ::std::os::raw::c_int,
max: ::std::os::raw::c_int,
data: *mut ::std::os::raw::c_void,
) -> xmlAutomataStatePtr;
}
extern "C" {
pub fn xmlAutomataNewOnceTrans2(
am: xmlAutomataPtr,
from: xmlAutomataStatePtr,
to: xmlAutomataStatePtr,
token: *const xmlChar,
token2: *const xmlChar,
min: ::std::os::raw::c_int,
max: ::std::os::raw::c_int,
data: *mut ::std::os::raw::c_void,
) -> xmlAutomataStatePtr;
}
extern "C" {
pub fn xmlAutomataNewAllTrans(
am: xmlAutomataPtr,
from: xmlAutomataStatePtr,
to: xmlAutomataStatePtr,
lax: ::std::os::raw::c_int,
) -> xmlAutomataStatePtr;
}
extern "C" {
pub fn xmlAutomataNewEpsilon(
am: xmlAutomataPtr,
from: xmlAutomataStatePtr,
to: xmlAutomataStatePtr,
) -> xmlAutomataStatePtr;
}
extern "C" {
pub fn xmlAutomataNewCountedTrans(
am: xmlAutomataPtr,
from: xmlAutomataStatePtr,
to: xmlAutomataStatePtr,
counter: ::std::os::raw::c_int,
) -> xmlAutomataStatePtr;
}
extern "C" {
pub fn xmlAutomataNewCounterTrans(
am: xmlAutomataPtr,
from: xmlAutomataStatePtr,
to: xmlAutomataStatePtr,
counter: ::std::os::raw::c_int,
) -> xmlAutomataStatePtr;
}
extern "C" {
pub fn xmlAutomataNewCounter(
am: xmlAutomataPtr,
min: ::std::os::raw::c_int,
max: ::std::os::raw::c_int,
) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn xmlAutomataCompile(am: xmlAutomataPtr) -> xmlRegexpPtr;
}
extern "C" {
pub fn xmlAutomataIsDeterminist(am: xmlAutomataPtr) -> ::std::os::raw::c_int;
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct _xmlValidState {
_unused: [u8; 0],
}
pub type xmlValidState = _xmlValidState;
pub type xmlValidStatePtr = *mut xmlValidState;
pub type xmlValidityErrorFunc = ::std::option::Option<
unsafe extern "C" fn(ctx: *mut ::std::os::raw::c_void, msg: *const ::std::os::raw::c_char, ...),
>;
pub type xmlValidityWarningFunc = ::std::option::Option<
unsafe extern "C" fn(ctx: *mut ::std::os::raw::c_void, msg: *const ::std::os::raw::c_char, ...),
>;
pub type xmlValidCtxt = _xmlValidCtxt;
pub type xmlValidCtxtPtr = *mut xmlValidCtxt;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct _xmlValidCtxt {
pub userData: *mut ::std::os::raw::c_void,
pub error: xmlValidityErrorFunc,
pub warning: xmlValidityWarningFunc,
pub node: xmlNodePtr,
pub nodeNr: ::std::os::raw::c_int,
pub nodeMax: ::std::os::raw::c_int,
pub nodeTab: *mut xmlNodePtr,
pub flags: ::std::os::raw::c_uint,
pub doc: xmlDocPtr,
pub valid: ::std::os::raw::c_int,
pub vstate: *mut xmlValidState,
pub vstateNr: ::std::os::raw::c_int,
pub vstateMax: ::std::os::raw::c_int,
pub vstateTab: *mut xmlValidState,
pub am: xmlAutomataPtr,
pub state: xmlAutomataStatePtr,
}
#[test]
fn bindgen_test_layout__xmlValidCtxt() {
const UNINIT: ::std::mem::MaybeUninit<_xmlValidCtxt> = ::std::mem::MaybeUninit::uninit();
let ptr = UNINIT.as_ptr();
assert_eq!(
::std::mem::size_of::<_xmlValidCtxt>(),
112usize,
concat!("Size of: ", stringify!(_xmlValidCtxt))
);
assert_eq!(
::std::mem::align_of::<_xmlValidCtxt>(),
8usize,
concat!("Alignment of ", stringify!(_xmlValidCtxt))
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).userData) as usize - ptr as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(_xmlValidCtxt),
"::",
stringify!(userData)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).error) as usize - ptr as usize },
8usize,
concat!(
"Offset of field: ",
stringify!(_xmlValidCtxt),
"::",
stringify!(error)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).warning) as usize - ptr as usize },
16usize,
concat!(
"Offset of field: ",
stringify!(_xmlValidCtxt),
"::",
stringify!(warning)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).node) as usize - ptr as usize },
24usize,
concat!(
"Offset of field: ",
stringify!(_xmlValidCtxt),
"::",
stringify!(node)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).nodeNr) as usize - ptr as usize },
32usize,
concat!(
"Offset of field: ",
stringify!(_xmlValidCtxt),
"::",
stringify!(nodeNr)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).nodeMax) as usize - ptr as usize },
36usize,
concat!(
"Offset of field: ",
stringify!(_xmlValidCtxt),
"::",
stringify!(nodeMax)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).nodeTab) as usize - ptr as usize },
40usize,
concat!(
"Offset of field: ",
stringify!(_xmlValidCtxt),
"::",
stringify!(nodeTab)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).flags) as usize - ptr as usize },
48usize,
concat!(
"Offset of field: ",
stringify!(_xmlValidCtxt),
"::",
stringify!(flags)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).doc) as usize - ptr as usize },
56usize,
concat!(
"Offset of field: ",
stringify!(_xmlValidCtxt),
"::",
stringify!(doc)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).valid) as usize - ptr as usize },
64usize,
concat!(
"Offset of field: ",
stringify!(_xmlValidCtxt),
"::",
stringify!(valid)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).vstate) as usize - ptr as usize },
72usize,
concat!(
"Offset of field: ",
stringify!(_xmlValidCtxt),
"::",
stringify!(vstate)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).vstateNr) as usize - ptr as usize },
80usize,
concat!(
"Offset of field: ",
stringify!(_xmlValidCtxt),
"::",
stringify!(vstateNr)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).vstateMax) as usize - ptr as usize },
84usize,
concat!(
"Offset of field: ",
stringify!(_xmlValidCtxt),
"::",
stringify!(vstateMax)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).vstateTab) as usize - ptr as usize },
88usize,
concat!(
"Offset of field: ",
stringify!(_xmlValidCtxt),
"::",
stringify!(vstateTab)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).am) as usize - ptr as usize },
96usize,
concat!(
"Offset of field: ",
stringify!(_xmlValidCtxt),
"::",
stringify!(am)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).state) as usize - ptr as usize },
104usize,
concat!(
"Offset of field: ",
stringify!(_xmlValidCtxt),
"::",
stringify!(state)
)
);
}
pub type xmlNotationTable = _xmlHashTable;
pub type xmlNotationTablePtr = *mut xmlNotationTable;
pub type xmlElementTable = _xmlHashTable;
pub type xmlElementTablePtr = *mut xmlElementTable;
pub type xmlAttributeTable = _xmlHashTable;
pub type xmlAttributeTablePtr = *mut xmlAttributeTable;
pub type xmlIDTable = _xmlHashTable;
pub type xmlIDTablePtr = *mut xmlIDTable;
pub type xmlRefTable = _xmlHashTable;
pub type xmlRefTablePtr = *mut xmlRefTable;
extern "C" {
pub fn xmlAddNotationDecl(
ctxt: xmlValidCtxtPtr,
dtd: xmlDtdPtr,
name: *const xmlChar,
PublicID: *const xmlChar,
SystemID: *const xmlChar,
) -> xmlNotationPtr;
}
extern "C" {
pub fn xmlCopyNotationTable(table: xmlNotationTablePtr) -> xmlNotationTablePtr;
}
extern "C" {
pub fn xmlFreeNotationTable(table: xmlNotationTablePtr);
}
extern "C" {
pub fn xmlDumpNotationDecl(buf: xmlBufferPtr, nota: xmlNotationPtr);
}
extern "C" {
pub fn xmlDumpNotationTable(buf: xmlBufferPtr, table: xmlNotationTablePtr);
}
extern "C" {
pub fn xmlNewElementContent(
name: *const xmlChar,
type_: xmlElementContentType,
) -> xmlElementContentPtr;
}
extern "C" {
pub fn xmlCopyElementContent(content: xmlElementContentPtr) -> xmlElementContentPtr;
}
extern "C" {
pub fn xmlFreeElementContent(cur: xmlElementContentPtr);
}
extern "C" {
pub fn xmlNewDocElementContent(
doc: xmlDocPtr,
name: *const xmlChar,
type_: xmlElementContentType,
) -> xmlElementContentPtr;
}
extern "C" {
pub fn xmlCopyDocElementContent(
doc: xmlDocPtr,
content: xmlElementContentPtr,
) -> xmlElementContentPtr;
}
extern "C" {
pub fn xmlFreeDocElementContent(doc: xmlDocPtr, cur: xmlElementContentPtr);
}
extern "C" {
pub fn xmlSnprintfElementContent(
buf: *mut ::std::os::raw::c_char,
size: ::std::os::raw::c_int,
content: xmlElementContentPtr,
englob: ::std::os::raw::c_int,
);
}
extern "C" {
pub fn xmlSprintfElementContent(
buf: *mut ::std::os::raw::c_char,
content: xmlElementContentPtr,
englob: ::std::os::raw::c_int,
);
}
extern "C" {
pub fn xmlAddElementDecl(
ctxt: xmlValidCtxtPtr,
dtd: xmlDtdPtr,
name: *const xmlChar,
type_: xmlElementTypeVal,
content: xmlElementContentPtr,
) -> xmlElementPtr;
}
extern "C" {
pub fn xmlCopyElementTable(table: xmlElementTablePtr) -> xmlElementTablePtr;
}
extern "C" {
pub fn xmlFreeElementTable(table: xmlElementTablePtr);
}
extern "C" {
pub fn xmlDumpElementTable(buf: xmlBufferPtr, table: xmlElementTablePtr);
}
extern "C" {
pub fn xmlDumpElementDecl(buf: xmlBufferPtr, elem: xmlElementPtr);
}
extern "C" {
pub fn xmlCreateEnumeration(name: *const xmlChar) -> xmlEnumerationPtr;
}
extern "C" {
pub fn xmlFreeEnumeration(cur: xmlEnumerationPtr);
}
extern "C" {
pub fn xmlCopyEnumeration(cur: xmlEnumerationPtr) -> xmlEnumerationPtr;
}
extern "C" {
pub fn xmlAddAttributeDecl(
ctxt: xmlValidCtxtPtr,
dtd: xmlDtdPtr,
elem: *const xmlChar,
name: *const xmlChar,
ns: *const xmlChar,
type_: xmlAttributeType,
def: xmlAttributeDefault,
defaultValue: *const xmlChar,
tree: xmlEnumerationPtr,
) -> xmlAttributePtr;
}
extern "C" {
pub fn xmlCopyAttributeTable(table: xmlAttributeTablePtr) -> xmlAttributeTablePtr;
}
extern "C" {
pub fn xmlFreeAttributeTable(table: xmlAttributeTablePtr);
}
extern "C" {
pub fn xmlDumpAttributeTable(buf: xmlBufferPtr, table: xmlAttributeTablePtr);
}
extern "C" {
pub fn xmlDumpAttributeDecl(buf: xmlBufferPtr, attr: xmlAttributePtr);
}
extern "C" {
pub fn xmlAddID(
ctxt: xmlValidCtxtPtr,
doc: xmlDocPtr,
value: *const xmlChar,
attr: xmlAttrPtr,
) -> xmlIDPtr;
}
extern "C" {
pub fn xmlFreeIDTable(table: xmlIDTablePtr);
}
extern "C" {
pub fn xmlGetID(doc: xmlDocPtr, ID: *const xmlChar) -> xmlAttrPtr;
}
extern "C" {
pub fn xmlIsID(doc: xmlDocPtr, elem: xmlNodePtr, attr: xmlAttrPtr) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn xmlRemoveID(doc: xmlDocPtr, attr: xmlAttrPtr) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn xmlAddRef(
ctxt: xmlValidCtxtPtr,
doc: xmlDocPtr,
value: *const xmlChar,
attr: xmlAttrPtr,
) -> xmlRefPtr;
}
extern "C" {
pub fn xmlFreeRefTable(table: xmlRefTablePtr);
}
extern "C" {
pub fn xmlIsRef(doc: xmlDocPtr, elem: xmlNodePtr, attr: xmlAttrPtr) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn xmlRemoveRef(doc: xmlDocPtr, attr: xmlAttrPtr) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn xmlGetRefs(doc: xmlDocPtr, ID: *const xmlChar) -> xmlListPtr;
}
extern "C" {
pub fn xmlNewValidCtxt() -> xmlValidCtxtPtr;
}
extern "C" {
pub fn xmlFreeValidCtxt(arg1: xmlValidCtxtPtr);
}
extern "C" {
pub fn xmlValidateRoot(ctxt: xmlValidCtxtPtr, doc: xmlDocPtr) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn xmlValidateElementDecl(
ctxt: xmlValidCtxtPtr,
doc: xmlDocPtr,
elem: xmlElementPtr,
) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn xmlValidNormalizeAttributeValue(
doc: xmlDocPtr,
elem: xmlNodePtr,
name: *const xmlChar,
value: *const xmlChar,
) -> *mut xmlChar;
}
extern "C" {
pub fn xmlValidCtxtNormalizeAttributeValue(
ctxt: xmlValidCtxtPtr,
doc: xmlDocPtr,
elem: xmlNodePtr,
name: *const xmlChar,
value: *const xmlChar,
) -> *mut xmlChar;
}
extern "C" {
pub fn xmlValidateAttributeDecl(
ctxt: xmlValidCtxtPtr,
doc: xmlDocPtr,
attr: xmlAttributePtr,
) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn xmlValidateAttributeValue(
type_: xmlAttributeType,
value: *const xmlChar,
) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn xmlValidateNotationDecl(
ctxt: xmlValidCtxtPtr,
doc: xmlDocPtr,
nota: xmlNotationPtr,
) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn xmlValidateDtd(
ctxt: xmlValidCtxtPtr,
doc: xmlDocPtr,
dtd: xmlDtdPtr,
) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn xmlValidateDtdFinal(ctxt: xmlValidCtxtPtr, doc: xmlDocPtr) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn xmlValidateDocument(ctxt: xmlValidCtxtPtr, doc: xmlDocPtr) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn xmlValidateElement(
ctxt: xmlValidCtxtPtr,
doc: xmlDocPtr,
elem: xmlNodePtr,
) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn xmlValidateOneElement(
ctxt: xmlValidCtxtPtr,
doc: xmlDocPtr,
elem: xmlNodePtr,
) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn xmlValidateOneAttribute(
ctxt: xmlValidCtxtPtr,
doc: xmlDocPtr,
elem: xmlNodePtr,
attr: xmlAttrPtr,
value: *const xmlChar,
) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn xmlValidateOneNamespace(
ctxt: xmlValidCtxtPtr,
doc: xmlDocPtr,
elem: xmlNodePtr,
prefix: *const xmlChar,
ns: xmlNsPtr,
value: *const xmlChar,
) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn xmlValidateDocumentFinal(ctxt: xmlValidCtxtPtr, doc: xmlDocPtr)
-> ::std::os::raw::c_int;
}
extern "C" {
pub fn xmlValidateNotationUse(
ctxt: xmlValidCtxtPtr,
doc: xmlDocPtr,
notationName: *const xmlChar,
) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn xmlIsMixedElement(doc: xmlDocPtr, name: *const xmlChar) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn xmlGetDtdAttrDesc(
dtd: xmlDtdPtr,
elem: *const xmlChar,
name: *const xmlChar,
) -> xmlAttributePtr;
}
extern "C" {
pub fn xmlGetDtdQAttrDesc(
dtd: xmlDtdPtr,
elem: *const xmlChar,
name: *const xmlChar,
prefix: *const xmlChar,
) -> xmlAttributePtr;
}
extern "C" {
pub fn xmlGetDtdNotationDesc(dtd: xmlDtdPtr, name: *const xmlChar) -> xmlNotationPtr;
}
extern "C" {
pub fn xmlGetDtdQElementDesc(
dtd: xmlDtdPtr,
name: *const xmlChar,
prefix: *const xmlChar,
) -> xmlElementPtr;
}
extern "C" {
pub fn xmlGetDtdElementDesc(dtd: xmlDtdPtr, name: *const xmlChar) -> xmlElementPtr;
}
extern "C" {
pub fn xmlValidGetPotentialChildren(
ctree: *mut xmlElementContent,
names: *mut *const xmlChar,
len: *mut ::std::os::raw::c_int,
max: ::std::os::raw::c_int,
) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn xmlValidGetValidElements(
prev: *mut xmlNode,
next: *mut xmlNode,
names: *mut *const xmlChar,
max: ::std::os::raw::c_int,
) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn xmlValidateNameValue(value: *const xmlChar) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn xmlValidateNamesValue(value: *const xmlChar) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn xmlValidateNmtokenValue(value: *const xmlChar) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn xmlValidateNmtokensValue(value: *const xmlChar) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn xmlValidBuildContentModel(
ctxt: xmlValidCtxtPtr,
elem: xmlElementPtr,
) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn xmlValidatePushElement(
ctxt: xmlValidCtxtPtr,
doc: xmlDocPtr,
elem: xmlNodePtr,
qname: *const xmlChar,
) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn xmlValidatePushCData(
ctxt: xmlValidCtxtPtr,
data: *const xmlChar,
len: ::std::os::raw::c_int,
) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn xmlValidatePopElement(
ctxt: xmlValidCtxtPtr,
doc: xmlDocPtr,
elem: xmlNodePtr,
qname: *const xmlChar,
) -> ::std::os::raw::c_int;
}
pub const xmlEntityType_XML_INTERNAL_GENERAL_ENTITY: xmlEntityType = 1;
pub const xmlEntityType_XML_EXTERNAL_GENERAL_PARSED_ENTITY: xmlEntityType = 2;
pub const xmlEntityType_XML_EXTERNAL_GENERAL_UNPARSED_ENTITY: xmlEntityType = 3;
pub const xmlEntityType_XML_INTERNAL_PARAMETER_ENTITY: xmlEntityType = 4;
pub const xmlEntityType_XML_EXTERNAL_PARAMETER_ENTITY: xmlEntityType = 5;
pub const xmlEntityType_XML_INTERNAL_PREDEFINED_ENTITY: xmlEntityType = 6;
pub type xmlEntityType = ::std::os::raw::c_uint;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct _xmlEntity {
pub _private: *mut ::std::os::raw::c_void,
pub type_: xmlElementType,
pub name: *const xmlChar,
pub children: *mut _xmlNode,
pub last: *mut _xmlNode,
pub parent: *mut _xmlDtd,
pub next: *mut _xmlNode,
pub prev: *mut _xmlNode,
pub doc: *mut _xmlDoc,
pub orig: *mut xmlChar,
pub content: *mut xmlChar,
pub length: ::std::os::raw::c_int,
pub etype: xmlEntityType,
pub ExternalID: *const xmlChar,
pub SystemID: *const xmlChar,
pub nexte: *mut _xmlEntity,
pub URI: *const xmlChar,
pub owner: ::std::os::raw::c_int,
pub checked: ::std::os::raw::c_int,
}
#[test]
fn bindgen_test_layout__xmlEntity() {
const UNINIT: ::std::mem::MaybeUninit<_xmlEntity> = ::std::mem::MaybeUninit::uninit();
let ptr = UNINIT.as_ptr();
assert_eq!(
::std::mem::size_of::<_xmlEntity>(),
136usize,
concat!("Size of: ", stringify!(_xmlEntity))
);
assert_eq!(
::std::mem::align_of::<_xmlEntity>(),
8usize,
concat!("Alignment of ", stringify!(_xmlEntity))
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr)._private) as usize - ptr as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(_xmlEntity),
"::",
stringify!(_private)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).type_) as usize - ptr as usize },
8usize,
concat!(
"Offset of field: ",
stringify!(_xmlEntity),
"::",
stringify!(type_)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).name) as usize - ptr as usize },
16usize,
concat!(
"Offset of field: ",
stringify!(_xmlEntity),
"::",
stringify!(name)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).children) as usize - ptr as usize },
24usize,
concat!(
"Offset of field: ",
stringify!(_xmlEntity),
"::",
stringify!(children)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).last) as usize - ptr as usize },
32usize,
concat!(
"Offset of field: ",
stringify!(_xmlEntity),
"::",
stringify!(last)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).parent) as usize - ptr as usize },
40usize,
concat!(
"Offset of field: ",
stringify!(_xmlEntity),
"::",
stringify!(parent)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).next) as usize - ptr as usize },
48usize,
concat!(
"Offset of field: ",
stringify!(_xmlEntity),
"::",
stringify!(next)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).prev) as usize - ptr as usize },
56usize,
concat!(
"Offset of field: ",
stringify!(_xmlEntity),
"::",
stringify!(prev)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).doc) as usize - ptr as usize },
64usize,
concat!(
"Offset of field: ",
stringify!(_xmlEntity),
"::",
stringify!(doc)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).orig) as usize - ptr as usize },
72usize,
concat!(
"Offset of field: ",
stringify!(_xmlEntity),
"::",
stringify!(orig)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).content) as usize - ptr as usize },
80usize,
concat!(
"Offset of field: ",
stringify!(_xmlEntity),
"::",
stringify!(content)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).length) as usize - ptr as usize },
88usize,
concat!(
"Offset of field: ",
stringify!(_xmlEntity),
"::",
stringify!(length)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).etype) as usize - ptr as usize },
92usize,
concat!(
"Offset of field: ",
stringify!(_xmlEntity),
"::",
stringify!(etype)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).ExternalID) as usize - ptr as usize },
96usize,
concat!(
"Offset of field: ",
stringify!(_xmlEntity),
"::",
stringify!(ExternalID)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).SystemID) as usize - ptr as usize },
104usize,
concat!(
"Offset of field: ",
stringify!(_xmlEntity),
"::",
stringify!(SystemID)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).nexte) as usize - ptr as usize },
112usize,
concat!(
"Offset of field: ",
stringify!(_xmlEntity),
"::",
stringify!(nexte)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).URI) as usize - ptr as usize },
120usize,
concat!(
"Offset of field: ",
stringify!(_xmlEntity),
"::",
stringify!(URI)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).owner) as usize - ptr as usize },
128usize,
concat!(
"Offset of field: ",
stringify!(_xmlEntity),
"::",
stringify!(owner)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).checked) as usize - ptr as usize },
132usize,
concat!(
"Offset of field: ",
stringify!(_xmlEntity),
"::",
stringify!(checked)
)
);
}
pub type xmlEntitiesTable = _xmlHashTable;
pub type xmlEntitiesTablePtr = *mut xmlEntitiesTable;
extern "C" {
pub fn xmlNewEntity(
doc: xmlDocPtr,
name: *const xmlChar,
type_: ::std::os::raw::c_int,
ExternalID: *const xmlChar,
SystemID: *const xmlChar,
content: *const xmlChar,
) -> xmlEntityPtr;
}
extern "C" {
pub fn xmlAddDocEntity(
doc: xmlDocPtr,
name: *const xmlChar,
type_: ::std::os::raw::c_int,
ExternalID: *const xmlChar,
SystemID: *const xmlChar,
content: *const xmlChar,
) -> xmlEntityPtr;
}
extern "C" {
pub fn xmlAddDtdEntity(
doc: xmlDocPtr,
name: *const xmlChar,
type_: ::std::os::raw::c_int,
ExternalID: *const xmlChar,
SystemID: *const xmlChar,
content: *const xmlChar,
) -> xmlEntityPtr;
}
extern "C" {
pub fn xmlGetPredefinedEntity(name: *const xmlChar) -> xmlEntityPtr;
}
extern "C" {
pub fn xmlGetDocEntity(doc: *const xmlDoc, name: *const xmlChar) -> xmlEntityPtr;
}
extern "C" {
pub fn xmlGetDtdEntity(doc: xmlDocPtr, name: *const xmlChar) -> xmlEntityPtr;
}
extern "C" {
pub fn xmlGetParameterEntity(doc: xmlDocPtr, name: *const xmlChar) -> xmlEntityPtr;
}
extern "C" {
pub fn xmlEncodeEntitiesReentrant(doc: xmlDocPtr, input: *const xmlChar) -> *mut xmlChar;
}
extern "C" {
pub fn xmlEncodeSpecialChars(doc: *const xmlDoc, input: *const xmlChar) -> *mut xmlChar;
}
extern "C" {
pub fn xmlCreateEntitiesTable() -> xmlEntitiesTablePtr;
}
extern "C" {
pub fn xmlCopyEntitiesTable(table: xmlEntitiesTablePtr) -> xmlEntitiesTablePtr;
}
extern "C" {
pub fn xmlFreeEntitiesTable(table: xmlEntitiesTablePtr);
}
extern "C" {
pub fn xmlDumpEntitiesTable(buf: xmlBufferPtr, table: xmlEntitiesTablePtr);
}
extern "C" {
pub fn xmlDumpEntityDecl(buf: xmlBufferPtr, ent: xmlEntityPtr);
}
pub type xmlParserInputDeallocate = ::std::option::Option<unsafe extern "C" fn(str_: *mut xmlChar)>;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct _xmlParserInput {
pub buf: xmlParserInputBufferPtr,
pub filename: *const ::std::os::raw::c_char,
pub directory: *const ::std::os::raw::c_char,
pub base: *const xmlChar,
pub cur: *const xmlChar,
pub end: *const xmlChar,
pub length: ::std::os::raw::c_int,
pub line: ::std::os::raw::c_int,
pub col: ::std::os::raw::c_int,
pub consumed: ::std::os::raw::c_ulong,
pub free: xmlParserInputDeallocate,
pub encoding: *const xmlChar,
pub version: *const xmlChar,
pub standalone: ::std::os::raw::c_int,
pub id: ::std::os::raw::c_int,
}
#[test]
fn bindgen_test_layout__xmlParserInput() {
const UNINIT: ::std::mem::MaybeUninit<_xmlParserInput> = ::std::mem::MaybeUninit::uninit();
let ptr = UNINIT.as_ptr();
assert_eq!(
::std::mem::size_of::<_xmlParserInput>(),
104usize,
concat!("Size of: ", stringify!(_xmlParserInput))
);
assert_eq!(
::std::mem::align_of::<_xmlParserInput>(),
8usize,
concat!("Alignment of ", stringify!(_xmlParserInput))
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).buf) as usize - ptr as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(_xmlParserInput),
"::",
stringify!(buf)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).filename) as usize - ptr as usize },
8usize,
concat!(
"Offset of field: ",
stringify!(_xmlParserInput),
"::",
stringify!(filename)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).directory) as usize - ptr as usize },
16usize,
concat!(
"Offset of field: ",
stringify!(_xmlParserInput),
"::",
stringify!(directory)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).base) as usize - ptr as usize },
24usize,
concat!(
"Offset of field: ",
stringify!(_xmlParserInput),
"::",
stringify!(base)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).cur) as usize - ptr as usize },
32usize,
concat!(
"Offset of field: ",
stringify!(_xmlParserInput),
"::",
stringify!(cur)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).end) as usize - ptr as usize },
40usize,
concat!(
"Offset of field: ",
stringify!(_xmlParserInput),
"::",
stringify!(end)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).length) as usize - ptr as usize },
48usize,
concat!(
"Offset of field: ",
stringify!(_xmlParserInput),
"::",
stringify!(length)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).line) as usize - ptr as usize },
52usize,
concat!(
"Offset of field: ",
stringify!(_xmlParserInput),
"::",
stringify!(line)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).col) as usize - ptr as usize },
56usize,
concat!(
"Offset of field: ",
stringify!(_xmlParserInput),
"::",
stringify!(col)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).consumed) as usize - ptr as usize },
64usize,
concat!(
"Offset of field: ",
stringify!(_xmlParserInput),
"::",
stringify!(consumed)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).free) as usize - ptr as usize },
72usize,
concat!(
"Offset of field: ",
stringify!(_xmlParserInput),
"::",
stringify!(free)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).encoding) as usize - ptr as usize },
80usize,
concat!(
"Offset of field: ",
stringify!(_xmlParserInput),
"::",
stringify!(encoding)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).version) as usize - ptr as usize },
88usize,
concat!(
"Offset of field: ",
stringify!(_xmlParserInput),
"::",
stringify!(version)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).standalone) as usize - ptr as usize },
96usize,
concat!(
"Offset of field: ",
stringify!(_xmlParserInput),
"::",
stringify!(standalone)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).id) as usize - ptr as usize },
100usize,
concat!(
"Offset of field: ",
stringify!(_xmlParserInput),
"::",
stringify!(id)
)
);
}
pub type xmlParserNodeInfo = _xmlParserNodeInfo;
pub type xmlParserNodeInfoPtr = *mut xmlParserNodeInfo;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct _xmlParserNodeInfo {
pub node: *const _xmlNode,
pub begin_pos: ::std::os::raw::c_ulong,
pub begin_line: ::std::os::raw::c_ulong,
pub end_pos: ::std::os::raw::c_ulong,
pub end_line: ::std::os::raw::c_ulong,
}
#[test]
fn bindgen_test_layout__xmlParserNodeInfo() {
const UNINIT: ::std::mem::MaybeUninit<_xmlParserNodeInfo> = ::std::mem::MaybeUninit::uninit();
let ptr = UNINIT.as_ptr();
assert_eq!(
::std::mem::size_of::<_xmlParserNodeInfo>(),
40usize,
concat!("Size of: ", stringify!(_xmlParserNodeInfo))
);
assert_eq!(
::std::mem::align_of::<_xmlParserNodeInfo>(),
8usize,
concat!("Alignment of ", stringify!(_xmlParserNodeInfo))
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).node) as usize - ptr as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(_xmlParserNodeInfo),
"::",
stringify!(node)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).begin_pos) as usize - ptr as usize },
8usize,
concat!(
"Offset of field: ",
stringify!(_xmlParserNodeInfo),
"::",
stringify!(begin_pos)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).begin_line) as usize - ptr as usize },
16usize,
concat!(
"Offset of field: ",
stringify!(_xmlParserNodeInfo),
"::",
stringify!(begin_line)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).end_pos) as usize - ptr as usize },
24usize,
concat!(
"Offset of field: ",
stringify!(_xmlParserNodeInfo),
"::",
stringify!(end_pos)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).end_line) as usize - ptr as usize },
32usize,
concat!(
"Offset of field: ",
stringify!(_xmlParserNodeInfo),
"::",
stringify!(end_line)
)
);
}
pub type xmlParserNodeInfoSeq = _xmlParserNodeInfoSeq;
pub type xmlParserNodeInfoSeqPtr = *mut xmlParserNodeInfoSeq;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct _xmlParserNodeInfoSeq {
pub maximum: ::std::os::raw::c_ulong,
pub length: ::std::os::raw::c_ulong,
pub buffer: *mut xmlParserNodeInfo,
}
#[test]
fn bindgen_test_layout__xmlParserNodeInfoSeq() {
const UNINIT: ::std::mem::MaybeUninit<_xmlParserNodeInfoSeq> =
::std::mem::MaybeUninit::uninit();
let ptr = UNINIT.as_ptr();
assert_eq!(
::std::mem::size_of::<_xmlParserNodeInfoSeq>(),
24usize,
concat!("Size of: ", stringify!(_xmlParserNodeInfoSeq))
);
assert_eq!(
::std::mem::align_of::<_xmlParserNodeInfoSeq>(),
8usize,
concat!("Alignment of ", stringify!(_xmlParserNodeInfoSeq))
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).maximum) as usize - ptr as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(_xmlParserNodeInfoSeq),
"::",
stringify!(maximum)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).length) as usize - ptr as usize },
8usize,
concat!(
"Offset of field: ",
stringify!(_xmlParserNodeInfoSeq),
"::",
stringify!(length)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).buffer) as usize - ptr as usize },
16usize,
concat!(
"Offset of field: ",
stringify!(_xmlParserNodeInfoSeq),
"::",
stringify!(buffer)
)
);
}
pub const xmlParserInputState_XML_PARSER_EOF: xmlParserInputState = -1;
pub const xmlParserInputState_XML_PARSER_START: xmlParserInputState = 0;
pub const xmlParserInputState_XML_PARSER_MISC: xmlParserInputState = 1;
pub const xmlParserInputState_XML_PARSER_PI: xmlParserInputState = 2;
pub const xmlParserInputState_XML_PARSER_DTD: xmlParserInputState = 3;
pub const xmlParserInputState_XML_PARSER_PROLOG: xmlParserInputState = 4;
pub const xmlParserInputState_XML_PARSER_COMMENT: xmlParserInputState = 5;
pub const xmlParserInputState_XML_PARSER_START_TAG: xmlParserInputState = 6;
pub const xmlParserInputState_XML_PARSER_CONTENT: xmlParserInputState = 7;
pub const xmlParserInputState_XML_PARSER_CDATA_SECTION: xmlParserInputState = 8;
pub const xmlParserInputState_XML_PARSER_END_TAG: xmlParserInputState = 9;
pub const xmlParserInputState_XML_PARSER_ENTITY_DECL: xmlParserInputState = 10;
pub const xmlParserInputState_XML_PARSER_ENTITY_VALUE: xmlParserInputState = 11;
pub const xmlParserInputState_XML_PARSER_ATTRIBUTE_VALUE: xmlParserInputState = 12;
pub const xmlParserInputState_XML_PARSER_SYSTEM_LITERAL: xmlParserInputState = 13;
pub const xmlParserInputState_XML_PARSER_EPILOG: xmlParserInputState = 14;
pub const xmlParserInputState_XML_PARSER_IGNORE: xmlParserInputState = 15;
pub const xmlParserInputState_XML_PARSER_PUBLIC_LITERAL: xmlParserInputState = 16;
pub type xmlParserInputState = ::std::os::raw::c_int;
pub const xmlParserMode_XML_PARSE_UNKNOWN: xmlParserMode = 0;
pub const xmlParserMode_XML_PARSE_DOM: xmlParserMode = 1;
pub const xmlParserMode_XML_PARSE_SAX: xmlParserMode = 2;
pub const xmlParserMode_XML_PARSE_PUSH_DOM: xmlParserMode = 3;
pub const xmlParserMode_XML_PARSE_PUSH_SAX: xmlParserMode = 4;
pub const xmlParserMode_XML_PARSE_READER: xmlParserMode = 5;
pub type xmlParserMode = ::std::os::raw::c_uint;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct _xmlStartTag {
_unused: [u8; 0],
}
pub type xmlStartTag = _xmlStartTag;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct _xmlParserCtxt {
pub sax: *mut _xmlSAXHandler,
pub userData: *mut ::std::os::raw::c_void,
pub myDoc: xmlDocPtr,
pub wellFormed: ::std::os::raw::c_int,
pub replaceEntities: ::std::os::raw::c_int,
pub version: *const xmlChar,
pub encoding: *const xmlChar,
pub standalone: ::std::os::raw::c_int,
pub html: ::std::os::raw::c_int,
pub input: xmlParserInputPtr,
pub inputNr: ::std::os::raw::c_int,
pub inputMax: ::std::os::raw::c_int,
pub inputTab: *mut xmlParserInputPtr,
pub node: xmlNodePtr,
pub nodeNr: ::std::os::raw::c_int,
pub nodeMax: ::std::os::raw::c_int,
pub nodeTab: *mut xmlNodePtr,
pub record_info: ::std::os::raw::c_int,
pub node_seq: xmlParserNodeInfoSeq,
pub errNo: ::std::os::raw::c_int,
pub hasExternalSubset: ::std::os::raw::c_int,
pub hasPErefs: ::std::os::raw::c_int,
pub external: ::std::os::raw::c_int,
pub valid: ::std::os::raw::c_int,
pub validate: ::std::os::raw::c_int,
pub vctxt: xmlValidCtxt,
pub instate: xmlParserInputState,
pub token: ::std::os::raw::c_int,
pub directory: *mut ::std::os::raw::c_char,
pub name: *const xmlChar,
pub nameNr: ::std::os::raw::c_int,
pub nameMax: ::std::os::raw::c_int,
pub nameTab: *mut *const xmlChar,
pub nbChars: ::std::os::raw::c_long,
pub checkIndex: ::std::os::raw::c_long,
pub keepBlanks: ::std::os::raw::c_int,
pub disableSAX: ::std::os::raw::c_int,
pub inSubset: ::std::os::raw::c_int,
pub intSubName: *const xmlChar,
pub extSubURI: *mut xmlChar,
pub extSubSystem: *mut xmlChar,
pub space: *mut ::std::os::raw::c_int,
pub spaceNr: ::std::os::raw::c_int,
pub spaceMax: ::std::os::raw::c_int,
pub spaceTab: *mut ::std::os::raw::c_int,
pub depth: ::std::os::raw::c_int,
pub entity: xmlParserInputPtr,
pub charset: ::std::os::raw::c_int,
pub nodelen: ::std::os::raw::c_int,
pub nodemem: ::std::os::raw::c_int,
pub pedantic: ::std::os::raw::c_int,
pub _private: *mut ::std::os::raw::c_void,
pub loadsubset: ::std::os::raw::c_int,
pub linenumbers: ::std::os::raw::c_int,
pub catalogs: *mut ::std::os::raw::c_void,
pub recovery: ::std::os::raw::c_int,
pub progressive: ::std::os::raw::c_int,
pub dict: xmlDictPtr,
pub atts: *mut *const xmlChar,
pub maxatts: ::std::os::raw::c_int,
pub docdict: ::std::os::raw::c_int,
pub str_xml: *const xmlChar,
pub str_xmlns: *const xmlChar,
pub str_xml_ns: *const xmlChar,
pub sax2: ::std::os::raw::c_int,
pub nsNr: ::std::os::raw::c_int,
pub nsMax: ::std::os::raw::c_int,
pub nsTab: *mut *const xmlChar,
pub attallocs: *mut ::std::os::raw::c_int,
pub pushTab: *mut xmlStartTag,
pub attsDefault: xmlHashTablePtr,
pub attsSpecial: xmlHashTablePtr,
pub nsWellFormed: ::std::os::raw::c_int,
pub options: ::std::os::raw::c_int,
pub dictNames: ::std::os::raw::c_int,
pub freeElemsNr: ::std::os::raw::c_int,
pub freeElems: xmlNodePtr,
pub freeAttrsNr: ::std::os::raw::c_int,
pub freeAttrs: xmlAttrPtr,
pub lastError: xmlError,
pub parseMode: xmlParserMode,
pub nbentities: ::std::os::raw::c_ulong,
pub sizeentities: ::std::os::raw::c_ulong,
pub nodeInfo: *mut xmlParserNodeInfo,
pub nodeInfoNr: ::std::os::raw::c_int,
pub nodeInfoMax: ::std::os::raw::c_int,
pub nodeInfoTab: *mut xmlParserNodeInfo,
pub input_id: ::std::os::raw::c_int,
pub sizeentcopy: ::std::os::raw::c_ulong,
}
#[test]
fn bindgen_test_layout__xmlParserCtxt() {
const UNINIT: ::std::mem::MaybeUninit<_xmlParserCtxt> = ::std::mem::MaybeUninit::uninit();
let ptr = UNINIT.as_ptr();
assert_eq!(
::std::mem::size_of::<_xmlParserCtxt>(),
752usize,
concat!("Size of: ", stringify!(_xmlParserCtxt))
);
assert_eq!(
::std::mem::align_of::<_xmlParserCtxt>(),
8usize,
concat!("Alignment of ", stringify!(_xmlParserCtxt))
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).sax) as usize - ptr as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(_xmlParserCtxt),
"::",
stringify!(sax)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).userData) as usize - ptr as usize },
8usize,
concat!(
"Offset of field: ",
stringify!(_xmlParserCtxt),
"::",
stringify!(userData)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).myDoc) as usize - ptr as usize },
16usize,
concat!(
"Offset of field: ",
stringify!(_xmlParserCtxt),
"::",
stringify!(myDoc)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).wellFormed) as usize - ptr as usize },
24usize,
concat!(
"Offset of field: ",
stringify!(_xmlParserCtxt),
"::",
stringify!(wellFormed)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).replaceEntities) as usize - ptr as usize },
28usize,
concat!(
"Offset of field: ",
stringify!(_xmlParserCtxt),
"::",
stringify!(replaceEntities)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).version) as usize - ptr as usize },
32usize,
concat!(
"Offset of field: ",
stringify!(_xmlParserCtxt),
"::",
stringify!(version)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).encoding) as usize - ptr as usize },
40usize,
concat!(
"Offset of field: ",
stringify!(_xmlParserCtxt),
"::",
stringify!(encoding)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).standalone) as usize - ptr as usize },
48usize,
concat!(
"Offset of field: ",
stringify!(_xmlParserCtxt),
"::",
stringify!(standalone)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).html) as usize - ptr as usize },
52usize,
concat!(
"Offset of field: ",
stringify!(_xmlParserCtxt),
"::",
stringify!(html)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).input) as usize - ptr as usize },
56usize,
concat!(
"Offset of field: ",
stringify!(_xmlParserCtxt),
"::",
stringify!(input)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).inputNr) as usize - ptr as usize },
64usize,
concat!(
"Offset of field: ",
stringify!(_xmlParserCtxt),
"::",
stringify!(inputNr)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).inputMax) as usize - ptr as usize },
68usize,
concat!(
"Offset of field: ",
stringify!(_xmlParserCtxt),
"::",
stringify!(inputMax)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).inputTab) as usize - ptr as usize },
72usize,
concat!(
"Offset of field: ",
stringify!(_xmlParserCtxt),
"::",
stringify!(inputTab)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).node) as usize - ptr as usize },
80usize,
concat!(
"Offset of field: ",
stringify!(_xmlParserCtxt),
"::",
stringify!(node)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).nodeNr) as usize - ptr as usize },
88usize,
concat!(
"Offset of field: ",
stringify!(_xmlParserCtxt),
"::",
stringify!(nodeNr)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).nodeMax) as usize - ptr as usize },
92usize,
concat!(
"Offset of field: ",
stringify!(_xmlParserCtxt),
"::",
stringify!(nodeMax)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).nodeTab) as usize - ptr as usize },
96usize,
concat!(
"Offset of field: ",
stringify!(_xmlParserCtxt),
"::",
stringify!(nodeTab)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).record_info) as usize - ptr as usize },
104usize,
concat!(
"Offset of field: ",
stringify!(_xmlParserCtxt),
"::",
stringify!(record_info)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).node_seq) as usize - ptr as usize },
112usize,
concat!(
"Offset of field: ",
stringify!(_xmlParserCtxt),
"::",
stringify!(node_seq)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).errNo) as usize - ptr as usize },
136usize,
concat!(
"Offset of field: ",
stringify!(_xmlParserCtxt),
"::",
stringify!(errNo)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).hasExternalSubset) as usize - ptr as usize },
140usize,
concat!(
"Offset of field: ",
stringify!(_xmlParserCtxt),
"::",
stringify!(hasExternalSubset)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).hasPErefs) as usize - ptr as usize },
144usize,
concat!(
"Offset of field: ",
stringify!(_xmlParserCtxt),
"::",
stringify!(hasPErefs)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).external) as usize - ptr as usize },
148usize,
concat!(
"Offset of field: ",
stringify!(_xmlParserCtxt),
"::",
stringify!(external)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).valid) as usize - ptr as usize },
152usize,
concat!(
"Offset of field: ",
stringify!(_xmlParserCtxt),
"::",
stringify!(valid)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).validate) as usize - ptr as usize },
156usize,
concat!(
"Offset of field: ",
stringify!(_xmlParserCtxt),
"::",
stringify!(validate)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).vctxt) as usize - ptr as usize },
160usize,
concat!(
"Offset of field: ",
stringify!(_xmlParserCtxt),
"::",
stringify!(vctxt)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).instate) as usize - ptr as usize },
272usize,
concat!(
"Offset of field: ",
stringify!(_xmlParserCtxt),
"::",
stringify!(instate)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).token) as usize - ptr as usize },
276usize,
concat!(
"Offset of field: ",
stringify!(_xmlParserCtxt),
"::",
stringify!(token)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).directory) as usize - ptr as usize },
280usize,
concat!(
"Offset of field: ",
stringify!(_xmlParserCtxt),
"::",
stringify!(directory)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).name) as usize - ptr as usize },
288usize,
concat!(
"Offset of field: ",
stringify!(_xmlParserCtxt),
"::",
stringify!(name)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).nameNr) as usize - ptr as usize },
296usize,
concat!(
"Offset of field: ",
stringify!(_xmlParserCtxt),
"::",
stringify!(nameNr)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).nameMax) as usize - ptr as usize },
300usize,
concat!(
"Offset of field: ",
stringify!(_xmlParserCtxt),
"::",
stringify!(nameMax)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).nameTab) as usize - ptr as usize },
304usize,
concat!(
"Offset of field: ",
stringify!(_xmlParserCtxt),
"::",
stringify!(nameTab)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).nbChars) as usize - ptr as usize },
312usize,
concat!(
"Offset of field: ",
stringify!(_xmlParserCtxt),
"::",
stringify!(nbChars)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).checkIndex) as usize - ptr as usize },
320usize,
concat!(
"Offset of field: ",
stringify!(_xmlParserCtxt),
"::",
stringify!(checkIndex)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).keepBlanks) as usize - ptr as usize },
328usize,
concat!(
"Offset of field: ",
stringify!(_xmlParserCtxt),
"::",
stringify!(keepBlanks)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).disableSAX) as usize - ptr as usize },
332usize,
concat!(
"Offset of field: ",
stringify!(_xmlParserCtxt),
"::",
stringify!(disableSAX)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).inSubset) as usize - ptr as usize },
336usize,
concat!(
"Offset of field: ",
stringify!(_xmlParserCtxt),
"::",
stringify!(inSubset)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).intSubName) as usize - ptr as usize },
344usize,
concat!(
"Offset of field: ",
stringify!(_xmlParserCtxt),
"::",
stringify!(intSubName)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).extSubURI) as usize - ptr as usize },
352usize,
concat!(
"Offset of field: ",
stringify!(_xmlParserCtxt),
"::",
stringify!(extSubURI)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).extSubSystem) as usize - ptr as usize },
360usize,
concat!(
"Offset of field: ",
stringify!(_xmlParserCtxt),
"::",
stringify!(extSubSystem)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).space) as usize - ptr as usize },
368usize,
concat!(
"Offset of field: ",
stringify!(_xmlParserCtxt),
"::",
stringify!(space)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).spaceNr) as usize - ptr as usize },
376usize,
concat!(
"Offset of field: ",
stringify!(_xmlParserCtxt),
"::",
stringify!(spaceNr)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).spaceMax) as usize - ptr as usize },
380usize,
concat!(
"Offset of field: ",
stringify!(_xmlParserCtxt),
"::",
stringify!(spaceMax)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).spaceTab) as usize - ptr as usize },
384usize,
concat!(
"Offset of field: ",
stringify!(_xmlParserCtxt),
"::",
stringify!(spaceTab)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).depth) as usize - ptr as usize },
392usize,
concat!(
"Offset of field: ",
stringify!(_xmlParserCtxt),
"::",
stringify!(depth)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).entity) as usize - ptr as usize },
400usize,
concat!(
"Offset of field: ",
stringify!(_xmlParserCtxt),
"::",
stringify!(entity)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).charset) as usize - ptr as usize },
408usize,
concat!(
"Offset of field: ",
stringify!(_xmlParserCtxt),
"::",
stringify!(charset)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).nodelen) as usize - ptr as usize },
412usize,
concat!(
"Offset of field: ",
stringify!(_xmlParserCtxt),
"::",
stringify!(nodelen)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).nodemem) as usize - ptr as usize },
416usize,
concat!(
"Offset of field: ",
stringify!(_xmlParserCtxt),
"::",
stringify!(nodemem)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).pedantic) as usize - ptr as usize },
420usize,
concat!(
"Offset of field: ",
stringify!(_xmlParserCtxt),
"::",
stringify!(pedantic)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr)._private) as usize - ptr as usize },
424usize,
concat!(
"Offset of field: ",
stringify!(_xmlParserCtxt),
"::",
stringify!(_private)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).loadsubset) as usize - ptr as usize },
432usize,
concat!(
"Offset of field: ",
stringify!(_xmlParserCtxt),
"::",
stringify!(loadsubset)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).linenumbers) as usize - ptr as usize },
436usize,
concat!(
"Offset of field: ",
stringify!(_xmlParserCtxt),
"::",
stringify!(linenumbers)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).catalogs) as usize - ptr as usize },
440usize,
concat!(
"Offset of field: ",
stringify!(_xmlParserCtxt),
"::",
stringify!(catalogs)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).recovery) as usize - ptr as usize },
448usize,
concat!(
"Offset of field: ",
stringify!(_xmlParserCtxt),
"::",
stringify!(recovery)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).progressive) as usize - ptr as usize },
452usize,
concat!(
"Offset of field: ",
stringify!(_xmlParserCtxt),
"::",
stringify!(progressive)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).dict) as usize - ptr as usize },
456usize,
concat!(
"Offset of field: ",
stringify!(_xmlParserCtxt),
"::",
stringify!(dict)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).atts) as usize - ptr as usize },
464usize,
concat!(
"Offset of field: ",
stringify!(_xmlParserCtxt),
"::",
stringify!(atts)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).maxatts) as usize - ptr as usize },
472usize,
concat!(
"Offset of field: ",
stringify!(_xmlParserCtxt),
"::",
stringify!(maxatts)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).docdict) as usize - ptr as usize },
476usize,
concat!(
"Offset of field: ",
stringify!(_xmlParserCtxt),
"::",
stringify!(docdict)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).str_xml) as usize - ptr as usize },
480usize,
concat!(
"Offset of field: ",
stringify!(_xmlParserCtxt),
"::",
stringify!(str_xml)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).str_xmlns) as usize - ptr as usize },
488usize,
concat!(
"Offset of field: ",
stringify!(_xmlParserCtxt),
"::",
stringify!(str_xmlns)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).str_xml_ns) as usize - ptr as usize },
496usize,
concat!(
"Offset of field: ",
stringify!(_xmlParserCtxt),
"::",
stringify!(str_xml_ns)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).sax2) as usize - ptr as usize },
504usize,
concat!(
"Offset of field: ",
stringify!(_xmlParserCtxt),
"::",
stringify!(sax2)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).nsNr) as usize - ptr as usize },
508usize,
concat!(
"Offset of field: ",
stringify!(_xmlParserCtxt),
"::",
stringify!(nsNr)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).nsMax) as usize - ptr as usize },
512usize,
concat!(
"Offset of field: ",
stringify!(_xmlParserCtxt),
"::",
stringify!(nsMax)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).nsTab) as usize - ptr as usize },
520usize,
concat!(
"Offset of field: ",
stringify!(_xmlParserCtxt),
"::",
stringify!(nsTab)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).attallocs) as usize - ptr as usize },
528usize,
concat!(
"Offset of field: ",
stringify!(_xmlParserCtxt),
"::",
stringify!(attallocs)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).pushTab) as usize - ptr as usize },
536usize,
concat!(
"Offset of field: ",
stringify!(_xmlParserCtxt),
"::",
stringify!(pushTab)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).attsDefault) as usize - ptr as usize },
544usize,
concat!(
"Offset of field: ",
stringify!(_xmlParserCtxt),
"::",
stringify!(attsDefault)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).attsSpecial) as usize - ptr as usize },
552usize,
concat!(
"Offset of field: ",
stringify!(_xmlParserCtxt),
"::",
stringify!(attsSpecial)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).nsWellFormed) as usize - ptr as usize },
560usize,
concat!(
"Offset of field: ",
stringify!(_xmlParserCtxt),
"::",
stringify!(nsWellFormed)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).options) as usize - ptr as usize },
564usize,
concat!(
"Offset of field: ",
stringify!(_xmlParserCtxt),
"::",
stringify!(options)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).dictNames) as usize - ptr as usize },
568usize,
concat!(
"Offset of field: ",
stringify!(_xmlParserCtxt),
"::",
stringify!(dictNames)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).freeElemsNr) as usize - ptr as usize },
572usize,
concat!(
"Offset of field: ",
stringify!(_xmlParserCtxt),
"::",
stringify!(freeElemsNr)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).freeElems) as usize - ptr as usize },
576usize,
concat!(
"Offset of field: ",
stringify!(_xmlParserCtxt),
"::",
stringify!(freeElems)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).freeAttrsNr) as usize - ptr as usize },
584usize,
concat!(
"Offset of field: ",
stringify!(_xmlParserCtxt),
"::",
stringify!(freeAttrsNr)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).freeAttrs) as usize - ptr as usize },
592usize,
concat!(
"Offset of field: ",
stringify!(_xmlParserCtxt),
"::",
stringify!(freeAttrs)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).lastError) as usize - ptr as usize },
600usize,
concat!(
"Offset of field: ",
stringify!(_xmlParserCtxt),
"::",
stringify!(lastError)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).parseMode) as usize - ptr as usize },
688usize,
concat!(
"Offset of field: ",
stringify!(_xmlParserCtxt),
"::",
stringify!(parseMode)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).nbentities) as usize - ptr as usize },
696usize,
concat!(
"Offset of field: ",
stringify!(_xmlParserCtxt),
"::",
stringify!(nbentities)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).sizeentities) as usize - ptr as usize },
704usize,
concat!(
"Offset of field: ",
stringify!(_xmlParserCtxt),
"::",
stringify!(sizeentities)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).nodeInfo) as usize - ptr as usize },
712usize,
concat!(
"Offset of field: ",
stringify!(_xmlParserCtxt),
"::",
stringify!(nodeInfo)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).nodeInfoNr) as usize - ptr as usize },
720usize,
concat!(
"Offset of field: ",
stringify!(_xmlParserCtxt),
"::",
stringify!(nodeInfoNr)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).nodeInfoMax) as usize - ptr as usize },
724usize,
concat!(
"Offset of field: ",
stringify!(_xmlParserCtxt),
"::",
stringify!(nodeInfoMax)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).nodeInfoTab) as usize - ptr as usize },
728usize,
concat!(
"Offset of field: ",
stringify!(_xmlParserCtxt),
"::",
stringify!(nodeInfoTab)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).input_id) as usize - ptr as usize },
736usize,
concat!(
"Offset of field: ",
stringify!(_xmlParserCtxt),
"::",
stringify!(input_id)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).sizeentcopy) as usize - ptr as usize },
744usize,
concat!(
"Offset of field: ",
stringify!(_xmlParserCtxt),
"::",
stringify!(sizeentcopy)
)
);
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct _xmlSAXLocator {
pub getPublicId: ::std::option::Option<
unsafe extern "C" fn(ctx: *mut ::std::os::raw::c_void) -> *const xmlChar,
>,
pub getSystemId: ::std::option::Option<
unsafe extern "C" fn(ctx: *mut ::std::os::raw::c_void) -> *const xmlChar,
>,
pub getLineNumber: ::std::option::Option<
unsafe extern "C" fn(ctx: *mut ::std::os::raw::c_void) -> ::std::os::raw::c_int,
>,
pub getColumnNumber: ::std::option::Option<
unsafe extern "C" fn(ctx: *mut ::std::os::raw::c_void) -> ::std::os::raw::c_int,
>,
}
#[test]
fn bindgen_test_layout__xmlSAXLocator() {
const UNINIT: ::std::mem::MaybeUninit<_xmlSAXLocator> = ::std::mem::MaybeUninit::uninit();
let ptr = UNINIT.as_ptr();
assert_eq!(
::std::mem::size_of::<_xmlSAXLocator>(),
32usize,
concat!("Size of: ", stringify!(_xmlSAXLocator))
);
assert_eq!(
::std::mem::align_of::<_xmlSAXLocator>(),
8usize,
concat!("Alignment of ", stringify!(_xmlSAXLocator))
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).getPublicId) as usize - ptr as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(_xmlSAXLocator),
"::",
stringify!(getPublicId)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).getSystemId) as usize - ptr as usize },
8usize,
concat!(
"Offset of field: ",
stringify!(_xmlSAXLocator),
"::",
stringify!(getSystemId)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).getLineNumber) as usize - ptr as usize },
16usize,
concat!(
"Offset of field: ",
stringify!(_xmlSAXLocator),
"::",
stringify!(getLineNumber)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).getColumnNumber) as usize - ptr as usize },
24usize,
concat!(
"Offset of field: ",
stringify!(_xmlSAXLocator),
"::",
stringify!(getColumnNumber)
)
);
}
pub type resolveEntitySAXFunc = ::std::option::Option<
unsafe extern "C" fn(
ctx: *mut ::std::os::raw::c_void,
publicId: *const xmlChar,
systemId: *const xmlChar,
) -> xmlParserInputPtr,
>;
pub type internalSubsetSAXFunc = ::std::option::Option<
unsafe extern "C" fn(
ctx: *mut ::std::os::raw::c_void,
name: *const xmlChar,
ExternalID: *const xmlChar,
SystemID: *const xmlChar,
),
>;
pub type externalSubsetSAXFunc = ::std::option::Option<
unsafe extern "C" fn(
ctx: *mut ::std::os::raw::c_void,
name: *const xmlChar,
ExternalID: *const xmlChar,
SystemID: *const xmlChar,
),
>;
pub type getEntitySAXFunc = ::std::option::Option<
unsafe extern "C" fn(ctx: *mut ::std::os::raw::c_void, name: *const xmlChar) -> xmlEntityPtr,
>;
pub type getParameterEntitySAXFunc = ::std::option::Option<
unsafe extern "C" fn(ctx: *mut ::std::os::raw::c_void, name: *const xmlChar) -> xmlEntityPtr,
>;
pub type entityDeclSAXFunc = ::std::option::Option<
unsafe extern "C" fn(
ctx: *mut ::std::os::raw::c_void,
name: *const xmlChar,
type_: ::std::os::raw::c_int,
publicId: *const xmlChar,
systemId: *const xmlChar,
content: *mut xmlChar,
),
>;
pub type notationDeclSAXFunc = ::std::option::Option<
unsafe extern "C" fn(
ctx: *mut ::std::os::raw::c_void,
name: *const xmlChar,
publicId: *const xmlChar,
systemId: *const xmlChar,
),
>;
pub type attributeDeclSAXFunc = ::std::option::Option<
unsafe extern "C" fn(
ctx: *mut ::std::os::raw::c_void,
elem: *const xmlChar,
fullname: *const xmlChar,
type_: ::std::os::raw::c_int,
def: ::std::os::raw::c_int,
defaultValue: *const xmlChar,
tree: xmlEnumerationPtr,
),
>;
pub type elementDeclSAXFunc = ::std::option::Option<
unsafe extern "C" fn(
ctx: *mut ::std::os::raw::c_void,
name: *const xmlChar,
type_: ::std::os::raw::c_int,
content: xmlElementContentPtr,
),
>;
pub type unparsedEntityDeclSAXFunc = ::std::option::Option<
unsafe extern "C" fn(
ctx: *mut ::std::os::raw::c_void,
name: *const xmlChar,
publicId: *const xmlChar,
systemId: *const xmlChar,
notationName: *const xmlChar,
),
>;
pub type setDocumentLocatorSAXFunc = ::std::option::Option<
unsafe extern "C" fn(ctx: *mut ::std::os::raw::c_void, loc: xmlSAXLocatorPtr),
>;
pub type startDocumentSAXFunc =
::std::option::Option<unsafe extern "C" fn(ctx: *mut ::std::os::raw::c_void)>;
pub type endDocumentSAXFunc =
::std::option::Option<unsafe extern "C" fn(ctx: *mut ::std::os::raw::c_void)>;
pub type startElementSAXFunc = ::std::option::Option<
unsafe extern "C" fn(
ctx: *mut ::std::os::raw::c_void,
name: *const xmlChar,
atts: *mut *const xmlChar,
),
>;
pub type endElementSAXFunc = ::std::option::Option<
unsafe extern "C" fn(ctx: *mut ::std::os::raw::c_void, name: *const xmlChar),
>;
pub type attributeSAXFunc = ::std::option::Option<
unsafe extern "C" fn(
ctx: *mut ::std::os::raw::c_void,
name: *const xmlChar,
value: *const xmlChar,
),
>;
pub type referenceSAXFunc = ::std::option::Option<
unsafe extern "C" fn(ctx: *mut ::std::os::raw::c_void, name: *const xmlChar),
>;
pub type charactersSAXFunc = ::std::option::Option<
unsafe extern "C" fn(
ctx: *mut ::std::os::raw::c_void,
ch: *const xmlChar,
len: ::std::os::raw::c_int,
),
>;
pub type ignorableWhitespaceSAXFunc = ::std::option::Option<
unsafe extern "C" fn(
ctx: *mut ::std::os::raw::c_void,
ch: *const xmlChar,
len: ::std::os::raw::c_int,
),
>;
pub type processingInstructionSAXFunc = ::std::option::Option<
unsafe extern "C" fn(
ctx: *mut ::std::os::raw::c_void,
target: *const xmlChar,
data: *const xmlChar,
),
>;
pub type commentSAXFunc = ::std::option::Option<
unsafe extern "C" fn(ctx: *mut ::std::os::raw::c_void, value: *const xmlChar),
>;
pub type cdataBlockSAXFunc = ::std::option::Option<
unsafe extern "C" fn(
ctx: *mut ::std::os::raw::c_void,
value: *const xmlChar,
len: ::std::os::raw::c_int,
),
>;
pub type warningSAXFunc = ::std::option::Option<
unsafe extern "C" fn(ctx: *mut ::std::os::raw::c_void, msg: *const ::std::os::raw::c_char, ...),
>;
pub type errorSAXFunc = ::std::option::Option<
unsafe extern "C" fn(ctx: *mut ::std::os::raw::c_void, msg: *const ::std::os::raw::c_char, ...),
>;
pub type fatalErrorSAXFunc = ::std::option::Option<
unsafe extern "C" fn(ctx: *mut ::std::os::raw::c_void, msg: *const ::std::os::raw::c_char, ...),
>;
pub type isStandaloneSAXFunc = ::std::option::Option<
unsafe extern "C" fn(ctx: *mut ::std::os::raw::c_void) -> ::std::os::raw::c_int,
>;
pub type hasInternalSubsetSAXFunc = ::std::option::Option<
unsafe extern "C" fn(ctx: *mut ::std::os::raw::c_void) -> ::std::os::raw::c_int,
>;
pub type hasExternalSubsetSAXFunc = ::std::option::Option<
unsafe extern "C" fn(ctx: *mut ::std::os::raw::c_void) -> ::std::os::raw::c_int,
>;
pub type startElementNsSAX2Func = ::std::option::Option<
unsafe extern "C" fn(
ctx: *mut ::std::os::raw::c_void,
localname: *const xmlChar,
prefix: *const xmlChar,
URI: *const xmlChar,
nb_namespaces: ::std::os::raw::c_int,
namespaces: *mut *const xmlChar,
nb_attributes: ::std::os::raw::c_int,
nb_defaulted: ::std::os::raw::c_int,
attributes: *mut *const xmlChar,
),
>;
pub type endElementNsSAX2Func = ::std::option::Option<
unsafe extern "C" fn(
ctx: *mut ::std::os::raw::c_void,
localname: *const xmlChar,
prefix: *const xmlChar,
URI: *const xmlChar,
),
>;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct _xmlSAXHandler {
pub internalSubset: internalSubsetSAXFunc,
pub isStandalone: isStandaloneSAXFunc,
pub hasInternalSubset: hasInternalSubsetSAXFunc,
pub hasExternalSubset: hasExternalSubsetSAXFunc,
pub resolveEntity: resolveEntitySAXFunc,
pub getEntity: getEntitySAXFunc,
pub entityDecl: entityDeclSAXFunc,
pub notationDecl: notationDeclSAXFunc,
pub attributeDecl: attributeDeclSAXFunc,
pub elementDecl: elementDeclSAXFunc,
pub unparsedEntityDecl: unparsedEntityDeclSAXFunc,
pub setDocumentLocator: setDocumentLocatorSAXFunc,
pub startDocument: startDocumentSAXFunc,
pub endDocument: endDocumentSAXFunc,
pub startElement: startElementSAXFunc,
pub endElement: endElementSAXFunc,
pub reference: referenceSAXFunc,
pub characters: charactersSAXFunc,
pub ignorableWhitespace: ignorableWhitespaceSAXFunc,
pub processingInstruction: processingInstructionSAXFunc,
pub comment: commentSAXFunc,
pub warning: warningSAXFunc,
pub error: errorSAXFunc,
pub fatalError: fatalErrorSAXFunc,
pub getParameterEntity: getParameterEntitySAXFunc,
pub cdataBlock: cdataBlockSAXFunc,
pub externalSubset: externalSubsetSAXFunc,
pub initialized: ::std::os::raw::c_uint,
pub _private: *mut ::std::os::raw::c_void,
pub startElementNs: startElementNsSAX2Func,
pub endElementNs: endElementNsSAX2Func,
pub serror: xmlStructuredErrorFunc,
}
#[test]
fn bindgen_test_layout__xmlSAXHandler() {
const UNINIT: ::std::mem::MaybeUninit<_xmlSAXHandler> = ::std::mem::MaybeUninit::uninit();
let ptr = UNINIT.as_ptr();
assert_eq!(
::std::mem::size_of::<_xmlSAXHandler>(),
256usize,
concat!("Size of: ", stringify!(_xmlSAXHandler))
);
assert_eq!(
::std::mem::align_of::<_xmlSAXHandler>(),
8usize,
concat!("Alignment of ", stringify!(_xmlSAXHandler))
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).internalSubset) as usize - ptr as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(_xmlSAXHandler),
"::",
stringify!(internalSubset)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).isStandalone) as usize - ptr as usize },
8usize,
concat!(
"Offset of field: ",
stringify!(_xmlSAXHandler),
"::",
stringify!(isStandalone)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).hasInternalSubset) as usize - ptr as usize },
16usize,
concat!(
"Offset of field: ",
stringify!(_xmlSAXHandler),
"::",
stringify!(hasInternalSubset)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).hasExternalSubset) as usize - ptr as usize },
24usize,
concat!(
"Offset of field: ",
stringify!(_xmlSAXHandler),
"::",
stringify!(hasExternalSubset)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).resolveEntity) as usize - ptr as usize },
32usize,
concat!(
"Offset of field: ",
stringify!(_xmlSAXHandler),
"::",
stringify!(resolveEntity)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).getEntity) as usize - ptr as usize },
40usize,
concat!(
"Offset of field: ",
stringify!(_xmlSAXHandler),
"::",
stringify!(getEntity)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).entityDecl) as usize - ptr as usize },
48usize,
concat!(
"Offset of field: ",
stringify!(_xmlSAXHandler),
"::",
stringify!(entityDecl)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).notationDecl) as usize - ptr as usize },
56usize,
concat!(
"Offset of field: ",
stringify!(_xmlSAXHandler),
"::",
stringify!(notationDecl)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).attributeDecl) as usize - ptr as usize },
64usize,
concat!(
"Offset of field: ",
stringify!(_xmlSAXHandler),
"::",
stringify!(attributeDecl)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).elementDecl) as usize - ptr as usize },
72usize,
concat!(
"Offset of field: ",
stringify!(_xmlSAXHandler),
"::",
stringify!(elementDecl)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).unparsedEntityDecl) as usize - ptr as usize },
80usize,
concat!(
"Offset of field: ",
stringify!(_xmlSAXHandler),
"::",
stringify!(unparsedEntityDecl)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).setDocumentLocator) as usize - ptr as usize },
88usize,
concat!(
"Offset of field: ",
stringify!(_xmlSAXHandler),
"::",
stringify!(setDocumentLocator)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).startDocument) as usize - ptr as usize },
96usize,
concat!(
"Offset of field: ",
stringify!(_xmlSAXHandler),
"::",
stringify!(startDocument)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).endDocument) as usize - ptr as usize },
104usize,
concat!(
"Offset of field: ",
stringify!(_xmlSAXHandler),
"::",
stringify!(endDocument)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).startElement) as usize - ptr as usize },
112usize,
concat!(
"Offset of field: ",
stringify!(_xmlSAXHandler),
"::",
stringify!(startElement)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).endElement) as usize - ptr as usize },
120usize,
concat!(
"Offset of field: ",
stringify!(_xmlSAXHandler),
"::",
stringify!(endElement)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).reference) as usize - ptr as usize },
128usize,
concat!(
"Offset of field: ",
stringify!(_xmlSAXHandler),
"::",
stringify!(reference)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).characters) as usize - ptr as usize },
136usize,
concat!(
"Offset of field: ",
stringify!(_xmlSAXHandler),
"::",
stringify!(characters)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).ignorableWhitespace) as usize - ptr as usize },
144usize,
concat!(
"Offset of field: ",
stringify!(_xmlSAXHandler),
"::",
stringify!(ignorableWhitespace)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).processingInstruction) as usize - ptr as usize },
152usize,
concat!(
"Offset of field: ",
stringify!(_xmlSAXHandler),
"::",
stringify!(processingInstruction)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).comment) as usize - ptr as usize },
160usize,
concat!(
"Offset of field: ",
stringify!(_xmlSAXHandler),
"::",
stringify!(comment)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).warning) as usize - ptr as usize },
168usize,
concat!(
"Offset of field: ",
stringify!(_xmlSAXHandler),
"::",
stringify!(warning)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).error) as usize - ptr as usize },
176usize,
concat!(
"Offset of field: ",
stringify!(_xmlSAXHandler),
"::",
stringify!(error)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).fatalError) as usize - ptr as usize },
184usize,
concat!(
"Offset of field: ",
stringify!(_xmlSAXHandler),
"::",
stringify!(fatalError)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).getParameterEntity) as usize - ptr as usize },
192usize,
concat!(
"Offset of field: ",
stringify!(_xmlSAXHandler),
"::",
stringify!(getParameterEntity)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).cdataBlock) as usize - ptr as usize },
200usize,
concat!(
"Offset of field: ",
stringify!(_xmlSAXHandler),
"::",
stringify!(cdataBlock)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).externalSubset) as usize - ptr as usize },
208usize,
concat!(
"Offset of field: ",
stringify!(_xmlSAXHandler),
"::",
stringify!(externalSubset)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).initialized) as usize - ptr as usize },
216usize,
concat!(
"Offset of field: ",
stringify!(_xmlSAXHandler),
"::",
stringify!(initialized)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr)._private) as usize - ptr as usize },
224usize,
concat!(
"Offset of field: ",
stringify!(_xmlSAXHandler),
"::",
stringify!(_private)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).startElementNs) as usize - ptr as usize },
232usize,
concat!(
"Offset of field: ",
stringify!(_xmlSAXHandler),
"::",
stringify!(startElementNs)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).endElementNs) as usize - ptr as usize },
240usize,
concat!(
"Offset of field: ",
stringify!(_xmlSAXHandler),
"::",
stringify!(endElementNs)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).serror) as usize - ptr as usize },
248usize,
concat!(
"Offset of field: ",
stringify!(_xmlSAXHandler),
"::",
stringify!(serror)
)
);
}
pub type xmlSAXHandlerV1 = _xmlSAXHandlerV1;
pub type xmlSAXHandlerV1Ptr = *mut xmlSAXHandlerV1;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct _xmlSAXHandlerV1 {
pub internalSubset: internalSubsetSAXFunc,
pub isStandalone: isStandaloneSAXFunc,
pub hasInternalSubset: hasInternalSubsetSAXFunc,
pub hasExternalSubset: hasExternalSubsetSAXFunc,
pub resolveEntity: resolveEntitySAXFunc,
pub getEntity: getEntitySAXFunc,
pub entityDecl: entityDeclSAXFunc,
pub notationDecl: notationDeclSAXFunc,
pub attributeDecl: attributeDeclSAXFunc,
pub elementDecl: elementDeclSAXFunc,
pub unparsedEntityDecl: unparsedEntityDeclSAXFunc,
pub setDocumentLocator: setDocumentLocatorSAXFunc,
pub startDocument: startDocumentSAXFunc,
pub endDocument: endDocumentSAXFunc,
pub startElement: startElementSAXFunc,
pub endElement: endElementSAXFunc,
pub reference: referenceSAXFunc,
pub characters: charactersSAXFunc,
pub ignorableWhitespace: ignorableWhitespaceSAXFunc,
pub processingInstruction: processingInstructionSAXFunc,
pub comment: commentSAXFunc,
pub warning: warningSAXFunc,
pub error: errorSAXFunc,
pub fatalError: fatalErrorSAXFunc,
pub getParameterEntity: getParameterEntitySAXFunc,
pub cdataBlock: cdataBlockSAXFunc,
pub externalSubset: externalSubsetSAXFunc,
pub initialized: ::std::os::raw::c_uint,
}
#[test]
fn bindgen_test_layout__xmlSAXHandlerV1() {
const UNINIT: ::std::mem::MaybeUninit<_xmlSAXHandlerV1> = ::std::mem::MaybeUninit::uninit();
let ptr = UNINIT.as_ptr();
assert_eq!(
::std::mem::size_of::<_xmlSAXHandlerV1>(),
224usize,
concat!("Size of: ", stringify!(_xmlSAXHandlerV1))
);
assert_eq!(
::std::mem::align_of::<_xmlSAXHandlerV1>(),
8usize,
concat!("Alignment of ", stringify!(_xmlSAXHandlerV1))
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).internalSubset) as usize - ptr as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(_xmlSAXHandlerV1),
"::",
stringify!(internalSubset)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).isStandalone) as usize - ptr as usize },
8usize,
concat!(
"Offset of field: ",
stringify!(_xmlSAXHandlerV1),
"::",
stringify!(isStandalone)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).hasInternalSubset) as usize - ptr as usize },
16usize,
concat!(
"Offset of field: ",
stringify!(_xmlSAXHandlerV1),
"::",
stringify!(hasInternalSubset)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).hasExternalSubset) as usize - ptr as usize },
24usize,
concat!(
"Offset of field: ",
stringify!(_xmlSAXHandlerV1),
"::",
stringify!(hasExternalSubset)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).resolveEntity) as usize - ptr as usize },
32usize,
concat!(
"Offset of field: ",
stringify!(_xmlSAXHandlerV1),
"::",
stringify!(resolveEntity)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).getEntity) as usize - ptr as usize },
40usize,
concat!(
"Offset of field: ",
stringify!(_xmlSAXHandlerV1),
"::",
stringify!(getEntity)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).entityDecl) as usize - ptr as usize },
48usize,
concat!(
"Offset of field: ",
stringify!(_xmlSAXHandlerV1),
"::",
stringify!(entityDecl)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).notationDecl) as usize - ptr as usize },
56usize,
concat!(
"Offset of field: ",
stringify!(_xmlSAXHandlerV1),
"::",
stringify!(notationDecl)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).attributeDecl) as usize - ptr as usize },
64usize,
concat!(
"Offset of field: ",
stringify!(_xmlSAXHandlerV1),
"::",
stringify!(attributeDecl)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).elementDecl) as usize - ptr as usize },
72usize,
concat!(
"Offset of field: ",
stringify!(_xmlSAXHandlerV1),
"::",
stringify!(elementDecl)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).unparsedEntityDecl) as usize - ptr as usize },
80usize,
concat!(
"Offset of field: ",
stringify!(_xmlSAXHandlerV1),
"::",
stringify!(unparsedEntityDecl)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).setDocumentLocator) as usize - ptr as usize },
88usize,
concat!(
"Offset of field: ",
stringify!(_xmlSAXHandlerV1),
"::",
stringify!(setDocumentLocator)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).startDocument) as usize - ptr as usize },
96usize,
concat!(
"Offset of field: ",
stringify!(_xmlSAXHandlerV1),
"::",
stringify!(startDocument)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).endDocument) as usize - ptr as usize },
104usize,
concat!(
"Offset of field: ",
stringify!(_xmlSAXHandlerV1),
"::",
stringify!(endDocument)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).startElement) as usize - ptr as usize },
112usize,
concat!(
"Offset of field: ",
stringify!(_xmlSAXHandlerV1),
"::",
stringify!(startElement)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).endElement) as usize - ptr as usize },
120usize,
concat!(
"Offset of field: ",
stringify!(_xmlSAXHandlerV1),
"::",
stringify!(endElement)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).reference) as usize - ptr as usize },
128usize,
concat!(
"Offset of field: ",
stringify!(_xmlSAXHandlerV1),
"::",
stringify!(reference)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).characters) as usize - ptr as usize },
136usize,
concat!(
"Offset of field: ",
stringify!(_xmlSAXHandlerV1),
"::",
stringify!(characters)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).ignorableWhitespace) as usize - ptr as usize },
144usize,
concat!(
"Offset of field: ",
stringify!(_xmlSAXHandlerV1),
"::",
stringify!(ignorableWhitespace)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).processingInstruction) as usize - ptr as usize },
152usize,
concat!(
"Offset of field: ",
stringify!(_xmlSAXHandlerV1),
"::",
stringify!(processingInstruction)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).comment) as usize - ptr as usize },
160usize,
concat!(
"Offset of field: ",
stringify!(_xmlSAXHandlerV1),
"::",
stringify!(comment)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).warning) as usize - ptr as usize },
168usize,
concat!(
"Offset of field: ",
stringify!(_xmlSAXHandlerV1),
"::",
stringify!(warning)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).error) as usize - ptr as usize },
176usize,
concat!(
"Offset of field: ",
stringify!(_xmlSAXHandlerV1),
"::",
stringify!(error)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).fatalError) as usize - ptr as usize },
184usize,
concat!(
"Offset of field: ",
stringify!(_xmlSAXHandlerV1),
"::",
stringify!(fatalError)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).getParameterEntity) as usize - ptr as usize },
192usize,
concat!(
"Offset of field: ",
stringify!(_xmlSAXHandlerV1),
"::",
stringify!(getParameterEntity)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).cdataBlock) as usize - ptr as usize },
200usize,
concat!(
"Offset of field: ",
stringify!(_xmlSAXHandlerV1),
"::",
stringify!(cdataBlock)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).externalSubset) as usize - ptr as usize },
208usize,
concat!(
"Offset of field: ",
stringify!(_xmlSAXHandlerV1),
"::",
stringify!(externalSubset)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).initialized) as usize - ptr as usize },
216usize,
concat!(
"Offset of field: ",
stringify!(_xmlSAXHandlerV1),
"::",
stringify!(initialized)
)
);
}
pub type xmlExternalEntityLoader = ::std::option::Option<
unsafe extern "C" fn(
URL: *const ::std::os::raw::c_char,
ID: *const ::std::os::raw::c_char,
context: xmlParserCtxtPtr,
) -> xmlParserInputPtr,
>;
pub type iconv_t = *mut ::std::os::raw::c_void;
pub const xmlCharEncoding_XML_CHAR_ENCODING_ERROR: xmlCharEncoding = -1;
pub const xmlCharEncoding_XML_CHAR_ENCODING_NONE: xmlCharEncoding = 0;
pub const xmlCharEncoding_XML_CHAR_ENCODING_UTF8: xmlCharEncoding = 1;
pub const xmlCharEncoding_XML_CHAR_ENCODING_UTF16LE: xmlCharEncoding = 2;
pub const xmlCharEncoding_XML_CHAR_ENCODING_UTF16BE: xmlCharEncoding = 3;
pub const xmlCharEncoding_XML_CHAR_ENCODING_UCS4LE: xmlCharEncoding = 4;
pub const xmlCharEncoding_XML_CHAR_ENCODING_UCS4BE: xmlCharEncoding = 5;
pub const xmlCharEncoding_XML_CHAR_ENCODING_EBCDIC: xmlCharEncoding = 6;
pub const xmlCharEncoding_XML_CHAR_ENCODING_UCS4_2143: xmlCharEncoding = 7;
pub const xmlCharEncoding_XML_CHAR_ENCODING_UCS4_3412: xmlCharEncoding = 8;
pub const xmlCharEncoding_XML_CHAR_ENCODING_UCS2: xmlCharEncoding = 9;
pub const xmlCharEncoding_XML_CHAR_ENCODING_8859_1: xmlCharEncoding = 10;
pub const xmlCharEncoding_XML_CHAR_ENCODING_8859_2: xmlCharEncoding = 11;
pub const xmlCharEncoding_XML_CHAR_ENCODING_8859_3: xmlCharEncoding = 12;
pub const xmlCharEncoding_XML_CHAR_ENCODING_8859_4: xmlCharEncoding = 13;
pub const xmlCharEncoding_XML_CHAR_ENCODING_8859_5: xmlCharEncoding = 14;
pub const xmlCharEncoding_XML_CHAR_ENCODING_8859_6: xmlCharEncoding = 15;
pub const xmlCharEncoding_XML_CHAR_ENCODING_8859_7: xmlCharEncoding = 16;
pub const xmlCharEncoding_XML_CHAR_ENCODING_8859_8: xmlCharEncoding = 17;
pub const xmlCharEncoding_XML_CHAR_ENCODING_8859_9: xmlCharEncoding = 18;
pub const xmlCharEncoding_XML_CHAR_ENCODING_2022_JP: xmlCharEncoding = 19;
pub const xmlCharEncoding_XML_CHAR_ENCODING_SHIFT_JIS: xmlCharEncoding = 20;
pub const xmlCharEncoding_XML_CHAR_ENCODING_EUC_JP: xmlCharEncoding = 21;
pub const xmlCharEncoding_XML_CHAR_ENCODING_ASCII: xmlCharEncoding = 22;
pub type xmlCharEncoding = ::std::os::raw::c_int;
pub type xmlCharEncodingInputFunc = ::std::option::Option<
unsafe extern "C" fn(
out: *mut ::std::os::raw::c_uchar,
outlen: *mut ::std::os::raw::c_int,
in_: *const ::std::os::raw::c_uchar,
inlen: *mut ::std::os::raw::c_int,
) -> ::std::os::raw::c_int,
>;
pub type xmlCharEncodingOutputFunc = ::std::option::Option<
unsafe extern "C" fn(
out: *mut ::std::os::raw::c_uchar,
outlen: *mut ::std::os::raw::c_int,
in_: *const ::std::os::raw::c_uchar,
inlen: *mut ::std::os::raw::c_int,
) -> ::std::os::raw::c_int,
>;
pub type xmlCharEncodingHandler = _xmlCharEncodingHandler;
pub type xmlCharEncodingHandlerPtr = *mut xmlCharEncodingHandler;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct _xmlCharEncodingHandler {
pub name: *mut ::std::os::raw::c_char,
pub input: xmlCharEncodingInputFunc,
pub output: xmlCharEncodingOutputFunc,
pub iconv_in: iconv_t,
pub iconv_out: iconv_t,
pub uconv_in: *mut _uconv_t,
pub uconv_out: *mut _uconv_t,
}
#[test]
fn bindgen_test_layout__xmlCharEncodingHandler() {
const UNINIT: ::std::mem::MaybeUninit<_xmlCharEncodingHandler> =
::std::mem::MaybeUninit::uninit();
let ptr = UNINIT.as_ptr();
assert_eq!(
::std::mem::size_of::<_xmlCharEncodingHandler>(),
56usize,
concat!("Size of: ", stringify!(_xmlCharEncodingHandler))
);
assert_eq!(
::std::mem::align_of::<_xmlCharEncodingHandler>(),
8usize,
concat!("Alignment of ", stringify!(_xmlCharEncodingHandler))
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).name) as usize - ptr as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(_xmlCharEncodingHandler),
"::",
stringify!(name)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).input) as usize - ptr as usize },
8usize,
concat!(
"Offset of field: ",
stringify!(_xmlCharEncodingHandler),
"::",
stringify!(input)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).output) as usize - ptr as usize },
16usize,
concat!(
"Offset of field: ",
stringify!(_xmlCharEncodingHandler),
"::",
stringify!(output)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).iconv_in) as usize - ptr as usize },
24usize,
concat!(
"Offset of field: ",
stringify!(_xmlCharEncodingHandler),
"::",
stringify!(iconv_in)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).iconv_out) as usize - ptr as usize },
32usize,
concat!(
"Offset of field: ",
stringify!(_xmlCharEncodingHandler),
"::",
stringify!(iconv_out)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).uconv_in) as usize - ptr as usize },
40usize,
concat!(
"Offset of field: ",
stringify!(_xmlCharEncodingHandler),
"::",
stringify!(uconv_in)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).uconv_out) as usize - ptr as usize },
48usize,
concat!(
"Offset of field: ",
stringify!(_xmlCharEncodingHandler),
"::",
stringify!(uconv_out)
)
);
}
extern "C" {
pub fn xmlInitCharEncodingHandlers();
}
extern "C" {
pub fn xmlCleanupCharEncodingHandlers();
}
extern "C" {
pub fn xmlRegisterCharEncodingHandler(handler: xmlCharEncodingHandlerPtr);
}
extern "C" {
pub fn xmlGetCharEncodingHandler(enc: xmlCharEncoding) -> xmlCharEncodingHandlerPtr;
}
extern "C" {
pub fn xmlFindCharEncodingHandler(
name: *const ::std::os::raw::c_char,
) -> xmlCharEncodingHandlerPtr;
}
extern "C" {
pub fn xmlNewCharEncodingHandler(
name: *const ::std::os::raw::c_char,
input: xmlCharEncodingInputFunc,
output: xmlCharEncodingOutputFunc,
) -> xmlCharEncodingHandlerPtr;
}
extern "C" {
pub fn xmlAddEncodingAlias(
name: *const ::std::os::raw::c_char,
alias: *const ::std::os::raw::c_char,
) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn xmlDelEncodingAlias(alias: *const ::std::os::raw::c_char) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn xmlGetEncodingAlias(
alias: *const ::std::os::raw::c_char,
) -> *const ::std::os::raw::c_char;
}
extern "C" {
pub fn xmlCleanupEncodingAliases();
}
extern "C" {
pub fn xmlParseCharEncoding(name: *const ::std::os::raw::c_char) -> xmlCharEncoding;
}
extern "C" {
pub fn xmlGetCharEncodingName(enc: xmlCharEncoding) -> *const ::std::os::raw::c_char;
}
extern "C" {
pub fn xmlDetectCharEncoding(
in_: *const ::std::os::raw::c_uchar,
len: ::std::os::raw::c_int,
) -> xmlCharEncoding;
}
extern "C" {
pub fn xmlCharEncOutFunc(
handler: *mut xmlCharEncodingHandler,
out: xmlBufferPtr,
in_: xmlBufferPtr,
) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn xmlCharEncInFunc(
handler: *mut xmlCharEncodingHandler,
out: xmlBufferPtr,
in_: xmlBufferPtr,
) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn xmlCharEncFirstLine(
handler: *mut xmlCharEncodingHandler,
out: xmlBufferPtr,
in_: xmlBufferPtr,
) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn xmlCharEncCloseFunc(handler: *mut xmlCharEncodingHandler) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn UTF8Toisolat1(
out: *mut ::std::os::raw::c_uchar,
outlen: *mut ::std::os::raw::c_int,
in_: *const ::std::os::raw::c_uchar,
inlen: *mut ::std::os::raw::c_int,
) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn isolat1ToUTF8(
out: *mut ::std::os::raw::c_uchar,
outlen: *mut ::std::os::raw::c_int,
in_: *const ::std::os::raw::c_uchar,
inlen: *mut ::std::os::raw::c_int,
) -> ::std::os::raw::c_int;
}
pub type xmlInputMatchCallback = ::std::option::Option<
unsafe extern "C" fn(filename: *const ::std::os::raw::c_char) -> ::std::os::raw::c_int,
>;
pub type xmlInputOpenCallback = ::std::option::Option<
unsafe extern "C" fn(filename: *const ::std::os::raw::c_char) -> *mut ::std::os::raw::c_void,
>;
pub type xmlInputReadCallback = ::std::option::Option<
unsafe extern "C" fn(
context: *mut ::std::os::raw::c_void,
buffer: *mut ::std::os::raw::c_char,
len: ::std::os::raw::c_int,
) -> ::std::os::raw::c_int,
>;
pub type xmlInputCloseCallback = ::std::option::Option<
unsafe extern "C" fn(context: *mut ::std::os::raw::c_void) -> ::std::os::raw::c_int,
>;
pub type xmlOutputMatchCallback = ::std::option::Option<
unsafe extern "C" fn(filename: *const ::std::os::raw::c_char) -> ::std::os::raw::c_int,
>;
pub type xmlOutputOpenCallback = ::std::option::Option<
unsafe extern "C" fn(filename: *const ::std::os::raw::c_char) -> *mut ::std::os::raw::c_void,
>;
pub type xmlOutputWriteCallback = ::std::option::Option<
unsafe extern "C" fn(
context: *mut ::std::os::raw::c_void,
buffer: *const ::std::os::raw::c_char,
len: ::std::os::raw::c_int,
) -> ::std::os::raw::c_int,
>;
pub type xmlOutputCloseCallback = ::std::option::Option<
unsafe extern "C" fn(context: *mut ::std::os::raw::c_void) -> ::std::os::raw::c_int,
>;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct _xmlParserInputBuffer {
pub context: *mut ::std::os::raw::c_void,
pub readcallback: xmlInputReadCallback,
pub closecallback: xmlInputCloseCallback,
pub encoder: xmlCharEncodingHandlerPtr,
pub buffer: xmlBufPtr,
pub raw: xmlBufPtr,
pub compressed: ::std::os::raw::c_int,
pub error: ::std::os::raw::c_int,
pub rawconsumed: ::std::os::raw::c_ulong,
}
#[test]
fn bindgen_test_layout__xmlParserInputBuffer() {
const UNINIT: ::std::mem::MaybeUninit<_xmlParserInputBuffer> =
::std::mem::MaybeUninit::uninit();
let ptr = UNINIT.as_ptr();
assert_eq!(
::std::mem::size_of::<_xmlParserInputBuffer>(),
64usize,
concat!("Size of: ", stringify!(_xmlParserInputBuffer))
);
assert_eq!(
::std::mem::align_of::<_xmlParserInputBuffer>(),
8usize,
concat!("Alignment of ", stringify!(_xmlParserInputBuffer))
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).context) as usize - ptr as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(_xmlParserInputBuffer),
"::",
stringify!(context)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).readcallback) as usize - ptr as usize },
8usize,
concat!(
"Offset of field: ",
stringify!(_xmlParserInputBuffer),
"::",
stringify!(readcallback)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).closecallback) as usize - ptr as usize },
16usize,
concat!(
"Offset of field: ",
stringify!(_xmlParserInputBuffer),
"::",
stringify!(closecallback)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).encoder) as usize - ptr as usize },
24usize,
concat!(
"Offset of field: ",
stringify!(_xmlParserInputBuffer),
"::",
stringify!(encoder)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).buffer) as usize - ptr as usize },
32usize,
concat!(
"Offset of field: ",
stringify!(_xmlParserInputBuffer),
"::",
stringify!(buffer)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).raw) as usize - ptr as usize },
40usize,
concat!(
"Offset of field: ",
stringify!(_xmlParserInputBuffer),
"::",
stringify!(raw)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).compressed) as usize - ptr as usize },
48usize,
concat!(
"Offset of field: ",
stringify!(_xmlParserInputBuffer),
"::",
stringify!(compressed)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).error) as usize - ptr as usize },
52usize,
concat!(
"Offset of field: ",
stringify!(_xmlParserInputBuffer),
"::",
stringify!(error)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).rawconsumed) as usize - ptr as usize },
56usize,
concat!(
"Offset of field: ",
stringify!(_xmlParserInputBuffer),
"::",
stringify!(rawconsumed)
)
);
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct _xmlOutputBuffer {
pub context: *mut ::std::os::raw::c_void,
pub writecallback: xmlOutputWriteCallback,
pub closecallback: xmlOutputCloseCallback,
pub encoder: xmlCharEncodingHandlerPtr,
pub buffer: xmlBufPtr,
pub conv: xmlBufPtr,
pub written: ::std::os::raw::c_int,
pub error: ::std::os::raw::c_int,
}
#[test]
fn bindgen_test_layout__xmlOutputBuffer() {
const UNINIT: ::std::mem::MaybeUninit<_xmlOutputBuffer> = ::std::mem::MaybeUninit::uninit();
let ptr = UNINIT.as_ptr();
assert_eq!(
::std::mem::size_of::<_xmlOutputBuffer>(),
56usize,
concat!("Size of: ", stringify!(_xmlOutputBuffer))
);
assert_eq!(
::std::mem::align_of::<_xmlOutputBuffer>(),
8usize,
concat!("Alignment of ", stringify!(_xmlOutputBuffer))
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).context) as usize - ptr as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(_xmlOutputBuffer),
"::",
stringify!(context)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).writecallback) as usize - ptr as usize },
8usize,
concat!(
"Offset of field: ",
stringify!(_xmlOutputBuffer),
"::",
stringify!(writecallback)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).closecallback) as usize - ptr as usize },
16usize,
concat!(
"Offset of field: ",
stringify!(_xmlOutputBuffer),
"::",
stringify!(closecallback)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).encoder) as usize - ptr as usize },
24usize,
concat!(
"Offset of field: ",
stringify!(_xmlOutputBuffer),
"::",
stringify!(encoder)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).buffer) as usize - ptr as usize },
32usize,
concat!(
"Offset of field: ",
stringify!(_xmlOutputBuffer),
"::",
stringify!(buffer)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).conv) as usize - ptr as usize },
40usize,
concat!(
"Offset of field: ",
stringify!(_xmlOutputBuffer),
"::",
stringify!(conv)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).written) as usize - ptr as usize },
48usize,
concat!(
"Offset of field: ",
stringify!(_xmlOutputBuffer),
"::",
stringify!(written)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).error) as usize - ptr as usize },
52usize,
concat!(
"Offset of field: ",
stringify!(_xmlOutputBuffer),
"::",
stringify!(error)
)
);
}
extern "C" {
pub fn xmlCleanupInputCallbacks();
}
extern "C" {
pub fn xmlPopInputCallbacks() -> ::std::os::raw::c_int;
}
extern "C" {
pub fn xmlRegisterDefaultInputCallbacks();
}
extern "C" {
pub fn xmlAllocParserInputBuffer(enc: xmlCharEncoding) -> xmlParserInputBufferPtr;
}
extern "C" {
pub fn xmlParserInputBufferCreateFilename(
URI: *const ::std::os::raw::c_char,
enc: xmlCharEncoding,
) -> xmlParserInputBufferPtr;
}
extern "C" {
pub fn xmlParserInputBufferCreateFile(
file: *mut FILE,
enc: xmlCharEncoding,
) -> xmlParserInputBufferPtr;
}
extern "C" {
pub fn xmlParserInputBufferCreateFd(
fd: ::std::os::raw::c_int,
enc: xmlCharEncoding,
) -> xmlParserInputBufferPtr;
}
extern "C" {
pub fn xmlParserInputBufferCreateMem(
mem: *const ::std::os::raw::c_char,
size: ::std::os::raw::c_int,
enc: xmlCharEncoding,
) -> xmlParserInputBufferPtr;
}
extern "C" {
pub fn xmlParserInputBufferCreateStatic(
mem: *const ::std::os::raw::c_char,
size: ::std::os::raw::c_int,
enc: xmlCharEncoding,
) -> xmlParserInputBufferPtr;
}
extern "C" {
pub fn xmlParserInputBufferCreateIO(
ioread: xmlInputReadCallback,
ioclose: xmlInputCloseCallback,
ioctx: *mut ::std::os::raw::c_void,
enc: xmlCharEncoding,
) -> xmlParserInputBufferPtr;
}
extern "C" {
pub fn xmlParserInputBufferRead(
in_: xmlParserInputBufferPtr,
len: ::std::os::raw::c_int,
) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn xmlParserInputBufferGrow(
in_: xmlParserInputBufferPtr,
len: ::std::os::raw::c_int,
) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn xmlParserInputBufferPush(
in_: xmlParserInputBufferPtr,
len: ::std::os::raw::c_int,
buf: *const ::std::os::raw::c_char,
) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn xmlFreeParserInputBuffer(in_: xmlParserInputBufferPtr);
}
extern "C" {
pub fn xmlParserGetDirectory(
filename: *const ::std::os::raw::c_char,
) -> *mut ::std::os::raw::c_char;
}
extern "C" {
pub fn xmlRegisterInputCallbacks(
matchFunc: xmlInputMatchCallback,
openFunc: xmlInputOpenCallback,
readFunc: xmlInputReadCallback,
closeFunc: xmlInputCloseCallback,
) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn __xmlParserInputBufferCreateFilename(
URI: *const ::std::os::raw::c_char,
enc: xmlCharEncoding,
) -> xmlParserInputBufferPtr;
}
extern "C" {
pub fn xmlCleanupOutputCallbacks();
}
extern "C" {
pub fn xmlPopOutputCallbacks() -> ::std::os::raw::c_int;
}
extern "C" {
pub fn xmlRegisterDefaultOutputCallbacks();
}
extern "C" {
pub fn xmlAllocOutputBuffer(encoder: xmlCharEncodingHandlerPtr) -> xmlOutputBufferPtr;
}
extern "C" {
pub fn xmlOutputBufferCreateFilename(
URI: *const ::std::os::raw::c_char,
encoder: xmlCharEncodingHandlerPtr,
compression: ::std::os::raw::c_int,
) -> xmlOutputBufferPtr;
}
extern "C" {
pub fn xmlOutputBufferCreateFile(
file: *mut FILE,
encoder: xmlCharEncodingHandlerPtr,
) -> xmlOutputBufferPtr;
}
extern "C" {
pub fn xmlOutputBufferCreateBuffer(
buffer: xmlBufferPtr,
encoder: xmlCharEncodingHandlerPtr,
) -> xmlOutputBufferPtr;
}
extern "C" {
pub fn xmlOutputBufferCreateFd(
fd: ::std::os::raw::c_int,
encoder: xmlCharEncodingHandlerPtr,
) -> xmlOutputBufferPtr;
}
extern "C" {
pub fn xmlOutputBufferCreateIO(
iowrite: xmlOutputWriteCallback,
ioclose: xmlOutputCloseCallback,
ioctx: *mut ::std::os::raw::c_void,
encoder: xmlCharEncodingHandlerPtr,
) -> xmlOutputBufferPtr;
}
extern "C" {
pub fn xmlOutputBufferGetContent(out: xmlOutputBufferPtr) -> *const xmlChar;
}
extern "C" {
pub fn xmlOutputBufferGetSize(out: xmlOutputBufferPtr) -> usize;
}
extern "C" {
pub fn xmlOutputBufferWrite(
out: xmlOutputBufferPtr,
len: ::std::os::raw::c_int,
buf: *const ::std::os::raw::c_char,
) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn xmlOutputBufferWriteString(
out: xmlOutputBufferPtr,
str_: *const ::std::os::raw::c_char,
) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn xmlOutputBufferWriteEscape(
out: xmlOutputBufferPtr,
str_: *const xmlChar,
escaping: xmlCharEncodingOutputFunc,
) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn xmlOutputBufferFlush(out: xmlOutputBufferPtr) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn xmlOutputBufferClose(out: xmlOutputBufferPtr) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn xmlRegisterOutputCallbacks(
matchFunc: xmlOutputMatchCallback,
openFunc: xmlOutputOpenCallback,
writeFunc: xmlOutputWriteCallback,
closeFunc: xmlOutputCloseCallback,
) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn __xmlOutputBufferCreateFilename(
URI: *const ::std::os::raw::c_char,
encoder: xmlCharEncodingHandlerPtr,
compression: ::std::os::raw::c_int,
) -> xmlOutputBufferPtr;
}
extern "C" {
pub fn xmlRegisterHTTPPostCallbacks();
}
extern "C" {
pub fn xmlCheckHTTPInput(ctxt: xmlParserCtxtPtr, ret: xmlParserInputPtr) -> xmlParserInputPtr;
}
extern "C" {
pub fn xmlNoNetExternalEntityLoader(
URL: *const ::std::os::raw::c_char,
ID: *const ::std::os::raw::c_char,
ctxt: xmlParserCtxtPtr,
) -> xmlParserInputPtr;
}
extern "C" {
pub fn xmlNormalizeWindowsPath(path: *const xmlChar) -> *mut xmlChar;
}
extern "C" {
pub fn xmlCheckFilename(path: *const ::std::os::raw::c_char) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn xmlFileMatch(filename: *const ::std::os::raw::c_char) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn xmlFileOpen(filename: *const ::std::os::raw::c_char) -> *mut ::std::os::raw::c_void;
}
extern "C" {
pub fn xmlFileRead(
context: *mut ::std::os::raw::c_void,
buffer: *mut ::std::os::raw::c_char,
len: ::std::os::raw::c_int,
) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn xmlFileClose(context: *mut ::std::os::raw::c_void) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn xmlIOHTTPMatch(filename: *const ::std::os::raw::c_char) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn xmlIOHTTPOpen(filename: *const ::std::os::raw::c_char) -> *mut ::std::os::raw::c_void;
}
extern "C" {
pub fn xmlIOHTTPOpenW(
post_uri: *const ::std::os::raw::c_char,
compression: ::std::os::raw::c_int,
) -> *mut ::std::os::raw::c_void;
}
extern "C" {
pub fn xmlIOHTTPRead(
context: *mut ::std::os::raw::c_void,
buffer: *mut ::std::os::raw::c_char,
len: ::std::os::raw::c_int,
) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn xmlIOHTTPClose(context: *mut ::std::os::raw::c_void) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn xmlInitParser();
}
extern "C" {
pub fn xmlCleanupParser();
}
extern "C" {
pub fn xmlParserInputRead(
in_: xmlParserInputPtr,
len: ::std::os::raw::c_int,
) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn xmlParserInputGrow(
in_: xmlParserInputPtr,
len: ::std::os::raw::c_int,
) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn xmlParseDoc(cur: *const xmlChar) -> xmlDocPtr;
}
extern "C" {
pub fn xmlParseFile(filename: *const ::std::os::raw::c_char) -> xmlDocPtr;
}
extern "C" {
pub fn xmlParseMemory(
buffer: *const ::std::os::raw::c_char,
size: ::std::os::raw::c_int,
) -> xmlDocPtr;
}
extern "C" {
pub fn xmlSubstituteEntitiesDefault(val: ::std::os::raw::c_int) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn xmlKeepBlanksDefault(val: ::std::os::raw::c_int) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn xmlStopParser(ctxt: xmlParserCtxtPtr);
}
extern "C" {
pub fn xmlPedanticParserDefault(val: ::std::os::raw::c_int) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn xmlLineNumbersDefault(val: ::std::os::raw::c_int) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn xmlRecoverDoc(cur: *const xmlChar) -> xmlDocPtr;
}
extern "C" {
pub fn xmlRecoverMemory(
buffer: *const ::std::os::raw::c_char,
size: ::std::os::raw::c_int,
) -> xmlDocPtr;
}
extern "C" {
pub fn xmlRecoverFile(filename: *const ::std::os::raw::c_char) -> xmlDocPtr;
}
extern "C" {
pub fn xmlParseDocument(ctxt: xmlParserCtxtPtr) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn xmlParseExtParsedEnt(ctxt: xmlParserCtxtPtr) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn xmlSAXUserParseFile(
sax: xmlSAXHandlerPtr,
user_data: *mut ::std::os::raw::c_void,
filename: *const ::std::os::raw::c_char,
) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn xmlSAXUserParseMemory(
sax: xmlSAXHandlerPtr,
user_data: *mut ::std::os::raw::c_void,
buffer: *const ::std::os::raw::c_char,
size: ::std::os::raw::c_int,
) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn xmlSAXParseDoc(
sax: xmlSAXHandlerPtr,
cur: *const xmlChar,
recovery: ::std::os::raw::c_int,
) -> xmlDocPtr;
}
extern "C" {
pub fn xmlSAXParseMemory(
sax: xmlSAXHandlerPtr,
buffer: *const ::std::os::raw::c_char,
size: ::std::os::raw::c_int,
recovery: ::std::os::raw::c_int,
) -> xmlDocPtr;
}
extern "C" {
pub fn xmlSAXParseMemoryWithData(
sax: xmlSAXHandlerPtr,
buffer: *const ::std::os::raw::c_char,
size: ::std::os::raw::c_int,
recovery: ::std::os::raw::c_int,
data: *mut ::std::os::raw::c_void,
) -> xmlDocPtr;
}
extern "C" {
pub fn xmlSAXParseFile(
sax: xmlSAXHandlerPtr,
filename: *const ::std::os::raw::c_char,
recovery: ::std::os::raw::c_int,
) -> xmlDocPtr;
}
extern "C" {
pub fn xmlSAXParseFileWithData(
sax: xmlSAXHandlerPtr,
filename: *const ::std::os::raw::c_char,
recovery: ::std::os::raw::c_int,
data: *mut ::std::os::raw::c_void,
) -> xmlDocPtr;
}
extern "C" {
pub fn xmlSAXParseEntity(
sax: xmlSAXHandlerPtr,
filename: *const ::std::os::raw::c_char,
) -> xmlDocPtr;
}
extern "C" {
pub fn xmlParseEntity(filename: *const ::std::os::raw::c_char) -> xmlDocPtr;
}
extern "C" {
pub fn xmlSAXParseDTD(
sax: xmlSAXHandlerPtr,
ExternalID: *const xmlChar,
SystemID: *const xmlChar,
) -> xmlDtdPtr;
}
extern "C" {
pub fn xmlParseDTD(ExternalID: *const xmlChar, SystemID: *const xmlChar) -> xmlDtdPtr;
}
extern "C" {
pub fn xmlIOParseDTD(
sax: xmlSAXHandlerPtr,
input: xmlParserInputBufferPtr,
enc: xmlCharEncoding,
) -> xmlDtdPtr;
}
extern "C" {
pub fn xmlParseBalancedChunkMemory(
doc: xmlDocPtr,
sax: xmlSAXHandlerPtr,
user_data: *mut ::std::os::raw::c_void,
depth: ::std::os::raw::c_int,
string: *const xmlChar,
lst: *mut xmlNodePtr,
) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn xmlParseInNodeContext(
node: xmlNodePtr,
data: *const ::std::os::raw::c_char,
datalen: ::std::os::raw::c_int,
options: ::std::os::raw::c_int,
lst: *mut xmlNodePtr,
) -> xmlParserErrors;
}
extern "C" {
pub fn xmlParseBalancedChunkMemoryRecover(
doc: xmlDocPtr,
sax: xmlSAXHandlerPtr,
user_data: *mut ::std::os::raw::c_void,
depth: ::std::os::raw::c_int,
string: *const xmlChar,
lst: *mut xmlNodePtr,
recover: ::std::os::raw::c_int,
) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn xmlParseExternalEntity(
doc: xmlDocPtr,
sax: xmlSAXHandlerPtr,
user_data: *mut ::std::os::raw::c_void,
depth: ::std::os::raw::c_int,
URL: *const xmlChar,
ID: *const xmlChar,
lst: *mut xmlNodePtr,
) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn xmlParseCtxtExternalEntity(
ctx: xmlParserCtxtPtr,
URL: *const xmlChar,
ID: *const xmlChar,
lst: *mut xmlNodePtr,
) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn xmlNewParserCtxt() -> xmlParserCtxtPtr;
}
extern "C" {
pub fn xmlInitParserCtxt(ctxt: xmlParserCtxtPtr) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn xmlClearParserCtxt(ctxt: xmlParserCtxtPtr);
}
extern "C" {
pub fn xmlFreeParserCtxt(ctxt: xmlParserCtxtPtr);
}
extern "C" {
pub fn xmlSetupParserForBuffer(
ctxt: xmlParserCtxtPtr,
buffer: *const xmlChar,
filename: *const ::std::os::raw::c_char,
);
}
extern "C" {
pub fn xmlCreateDocParserCtxt(cur: *const xmlChar) -> xmlParserCtxtPtr;
}
extern "C" {
pub fn xmlCreatePushParserCtxt(
sax: xmlSAXHandlerPtr,
user_data: *mut ::std::os::raw::c_void,
chunk: *const ::std::os::raw::c_char,
size: ::std::os::raw::c_int,
filename: *const ::std::os::raw::c_char,
) -> xmlParserCtxtPtr;
}
extern "C" {
pub fn xmlParseChunk(
ctxt: xmlParserCtxtPtr,
chunk: *const ::std::os::raw::c_char,
size: ::std::os::raw::c_int,
terminate: ::std::os::raw::c_int,
) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn xmlCreateIOParserCtxt(
sax: xmlSAXHandlerPtr,
user_data: *mut ::std::os::raw::c_void,
ioread: xmlInputReadCallback,
ioclose: xmlInputCloseCallback,
ioctx: *mut ::std::os::raw::c_void,
enc: xmlCharEncoding,
) -> xmlParserCtxtPtr;
}
extern "C" {
pub fn xmlNewIOInputStream(
ctxt: xmlParserCtxtPtr,
input: xmlParserInputBufferPtr,
enc: xmlCharEncoding,
) -> xmlParserInputPtr;
}
extern "C" {
pub fn xmlParserFindNodeInfo(
ctxt: xmlParserCtxtPtr,
node: xmlNodePtr,
) -> *const xmlParserNodeInfo;
}
extern "C" {
pub fn xmlInitNodeInfoSeq(seq: xmlParserNodeInfoSeqPtr);
}
extern "C" {
pub fn xmlClearNodeInfoSeq(seq: xmlParserNodeInfoSeqPtr);
}
extern "C" {
pub fn xmlParserFindNodeInfoIndex(
seq: xmlParserNodeInfoSeqPtr,
node: xmlNodePtr,
) -> ::std::os::raw::c_ulong;
}
extern "C" {
pub fn xmlParserAddNodeInfo(ctxt: xmlParserCtxtPtr, info: xmlParserNodeInfoPtr);
}
extern "C" {
pub fn xmlSetExternalEntityLoader(f: xmlExternalEntityLoader);
}
extern "C" {
pub fn xmlGetExternalEntityLoader() -> xmlExternalEntityLoader;
}
extern "C" {
pub fn xmlLoadExternalEntity(
URL: *const ::std::os::raw::c_char,
ID: *const ::std::os::raw::c_char,
ctxt: xmlParserCtxtPtr,
) -> xmlParserInputPtr;
}
extern "C" {
pub fn xmlByteConsumed(ctxt: xmlParserCtxtPtr) -> ::std::os::raw::c_long;
}
pub const xmlParserOption_XML_PARSE_RECOVER: xmlParserOption = 1;
pub const xmlParserOption_XML_PARSE_NOENT: xmlParserOption = 2;
pub const xmlParserOption_XML_PARSE_DTDLOAD: xmlParserOption = 4;
pub const xmlParserOption_XML_PARSE_DTDATTR: xmlParserOption = 8;
pub const xmlParserOption_XML_PARSE_DTDVALID: xmlParserOption = 16;
pub const xmlParserOption_XML_PARSE_NOERROR: xmlParserOption = 32;
pub const xmlParserOption_XML_PARSE_NOWARNING: xmlParserOption = 64;
pub const xmlParserOption_XML_PARSE_PEDANTIC: xmlParserOption = 128;
pub const xmlParserOption_XML_PARSE_NOBLANKS: xmlParserOption = 256;
pub const xmlParserOption_XML_PARSE_SAX1: xmlParserOption = 512;
pub const xmlParserOption_XML_PARSE_XINCLUDE: xmlParserOption = 1024;
pub const xmlParserOption_XML_PARSE_NONET: xmlParserOption = 2048;
pub const xmlParserOption_XML_PARSE_NODICT: xmlParserOption = 4096;
pub const xmlParserOption_XML_PARSE_NSCLEAN: xmlParserOption = 8192;
pub const xmlParserOption_XML_PARSE_NOCDATA: xmlParserOption = 16384;
pub const xmlParserOption_XML_PARSE_NOXINCNODE: xmlParserOption = 32768;
pub const xmlParserOption_XML_PARSE_COMPACT: xmlParserOption = 65536;
pub const xmlParserOption_XML_PARSE_OLD10: xmlParserOption = 131072;
pub const xmlParserOption_XML_PARSE_NOBASEFIX: xmlParserOption = 262144;
pub const xmlParserOption_XML_PARSE_HUGE: xmlParserOption = 524288;
pub const xmlParserOption_XML_PARSE_OLDSAX: xmlParserOption = 1048576;
pub const xmlParserOption_XML_PARSE_IGNORE_ENC: xmlParserOption = 2097152;
pub const xmlParserOption_XML_PARSE_BIG_LINES: xmlParserOption = 4194304;
pub type xmlParserOption = ::std::os::raw::c_uint;
extern "C" {
pub fn xmlCtxtReset(ctxt: xmlParserCtxtPtr);
}
extern "C" {
pub fn xmlCtxtResetPush(
ctxt: xmlParserCtxtPtr,
chunk: *const ::std::os::raw::c_char,
size: ::std::os::raw::c_int,
filename: *const ::std::os::raw::c_char,
encoding: *const ::std::os::raw::c_char,
) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn xmlCtxtUseOptions(
ctxt: xmlParserCtxtPtr,
options: ::std::os::raw::c_int,
) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn xmlReadDoc(
cur: *const xmlChar,
URL: *const ::std::os::raw::c_char,
encoding: *const ::std::os::raw::c_char,
options: ::std::os::raw::c_int,
) -> xmlDocPtr;
}
extern "C" {
pub fn xmlReadFile(
URL: *const ::std::os::raw::c_char,
encoding: *const ::std::os::raw::c_char,
options: ::std::os::raw::c_int,
) -> xmlDocPtr;
}
extern "C" {
pub fn xmlReadMemory(
buffer: *const ::std::os::raw::c_char,
size: ::std::os::raw::c_int,
URL: *const ::std::os::raw::c_char,
encoding: *const ::std::os::raw::c_char,
options: ::std::os::raw::c_int,
) -> xmlDocPtr;
}
extern "C" {
pub fn xmlReadFd(
fd: ::std::os::raw::c_int,
URL: *const ::std::os::raw::c_char,
encoding: *const ::std::os::raw::c_char,
options: ::std::os::raw::c_int,
) -> xmlDocPtr;
}
extern "C" {
pub fn xmlReadIO(
ioread: xmlInputReadCallback,
ioclose: xmlInputCloseCallback,
ioctx: *mut ::std::os::raw::c_void,
URL: *const ::std::os::raw::c_char,
encoding: *const ::std::os::raw::c_char,
options: ::std::os::raw::c_int,
) -> xmlDocPtr;
}
extern "C" {
pub fn xmlCtxtReadDoc(
ctxt: xmlParserCtxtPtr,
cur: *const xmlChar,
URL: *const ::std::os::raw::c_char,
encoding: *const ::std::os::raw::c_char,
options: ::std::os::raw::c_int,
) -> xmlDocPtr;
}
extern "C" {
pub fn xmlCtxtReadFile(
ctxt: xmlParserCtxtPtr,
filename: *const ::std::os::raw::c_char,
encoding: *const ::std::os::raw::c_char,
options: ::std::os::raw::c_int,
) -> xmlDocPtr;
}
extern "C" {
pub fn xmlCtxtReadMemory(
ctxt: xmlParserCtxtPtr,
buffer: *const ::std::os::raw::c_char,
size: ::std::os::raw::c_int,
URL: *const ::std::os::raw::c_char,
encoding: *const ::std::os::raw::c_char,
options: ::std::os::raw::c_int,
) -> xmlDocPtr;
}
extern "C" {
pub fn xmlCtxtReadFd(
ctxt: xmlParserCtxtPtr,
fd: ::std::os::raw::c_int,
URL: *const ::std::os::raw::c_char,
encoding: *const ::std::os::raw::c_char,
options: ::std::os::raw::c_int,
) -> xmlDocPtr;
}
extern "C" {
pub fn xmlCtxtReadIO(
ctxt: xmlParserCtxtPtr,
ioread: xmlInputReadCallback,
ioclose: xmlInputCloseCallback,
ioctx: *mut ::std::os::raw::c_void,
URL: *const ::std::os::raw::c_char,
encoding: *const ::std::os::raw::c_char,
options: ::std::os::raw::c_int,
) -> xmlDocPtr;
}
pub const xmlFeature_XML_WITH_THREAD: xmlFeature = 1;
pub const xmlFeature_XML_WITH_TREE: xmlFeature = 2;
pub const xmlFeature_XML_WITH_OUTPUT: xmlFeature = 3;
pub const xmlFeature_XML_WITH_PUSH: xmlFeature = 4;
pub const xmlFeature_XML_WITH_READER: xmlFeature = 5;
pub const xmlFeature_XML_WITH_PATTERN: xmlFeature = 6;
pub const xmlFeature_XML_WITH_WRITER: xmlFeature = 7;
pub const xmlFeature_XML_WITH_SAX1: xmlFeature = 8;
pub const xmlFeature_XML_WITH_FTP: xmlFeature = 9;
pub const xmlFeature_XML_WITH_HTTP: xmlFeature = 10;
pub const xmlFeature_XML_WITH_VALID: xmlFeature = 11;
pub const xmlFeature_XML_WITH_HTML: xmlFeature = 12;
pub const xmlFeature_XML_WITH_LEGACY: xmlFeature = 13;
pub const xmlFeature_XML_WITH_C14N: xmlFeature = 14;
pub const xmlFeature_XML_WITH_CATALOG: xmlFeature = 15;
pub const xmlFeature_XML_WITH_XPATH: xmlFeature = 16;
pub const xmlFeature_XML_WITH_XPTR: xmlFeature = 17;
pub const xmlFeature_XML_WITH_XINCLUDE: xmlFeature = 18;
pub const xmlFeature_XML_WITH_ICONV: xmlFeature = 19;
pub const xmlFeature_XML_WITH_ISO8859X: xmlFeature = 20;
pub const xmlFeature_XML_WITH_UNICODE: xmlFeature = 21;
pub const xmlFeature_XML_WITH_REGEXP: xmlFeature = 22;
pub const xmlFeature_XML_WITH_AUTOMATA: xmlFeature = 23;
pub const xmlFeature_XML_WITH_EXPR: xmlFeature = 24;
pub const xmlFeature_XML_WITH_SCHEMAS: xmlFeature = 25;
pub const xmlFeature_XML_WITH_SCHEMATRON: xmlFeature = 26;
pub const xmlFeature_XML_WITH_MODULES: xmlFeature = 27;
pub const xmlFeature_XML_WITH_DEBUG: xmlFeature = 28;
pub const xmlFeature_XML_WITH_DEBUG_MEM: xmlFeature = 29;
pub const xmlFeature_XML_WITH_DEBUG_RUN: xmlFeature = 30;
pub const xmlFeature_XML_WITH_ZLIB: xmlFeature = 31;
pub const xmlFeature_XML_WITH_ICU: xmlFeature = 32;
pub const xmlFeature_XML_WITH_LZMA: xmlFeature = 33;
pub const xmlFeature_XML_WITH_NONE: xmlFeature = 99999;
pub type xmlFeature = ::std::os::raw::c_uint;
extern "C" {
pub fn xmlHasFeature(feature: xmlFeature) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn xmlSAX2GetPublicId(ctx: *mut ::std::os::raw::c_void) -> *const xmlChar;
}
extern "C" {
pub fn xmlSAX2GetSystemId(ctx: *mut ::std::os::raw::c_void) -> *const xmlChar;
}
extern "C" {
pub fn xmlSAX2SetDocumentLocator(ctx: *mut ::std::os::raw::c_void, loc: xmlSAXLocatorPtr);
}
extern "C" {
pub fn xmlSAX2GetLineNumber(ctx: *mut ::std::os::raw::c_void) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn xmlSAX2GetColumnNumber(ctx: *mut ::std::os::raw::c_void) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn xmlSAX2IsStandalone(ctx: *mut ::std::os::raw::c_void) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn xmlSAX2HasInternalSubset(ctx: *mut ::std::os::raw::c_void) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn xmlSAX2HasExternalSubset(ctx: *mut ::std::os::raw::c_void) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn xmlSAX2InternalSubset(
ctx: *mut ::std::os::raw::c_void,
name: *const xmlChar,
ExternalID: *const xmlChar,
SystemID: *const xmlChar,
);
}
extern "C" {
pub fn xmlSAX2ExternalSubset(
ctx: *mut ::std::os::raw::c_void,
name: *const xmlChar,
ExternalID: *const xmlChar,
SystemID: *const xmlChar,
);
}
extern "C" {
pub fn xmlSAX2GetEntity(ctx: *mut ::std::os::raw::c_void, name: *const xmlChar)
-> xmlEntityPtr;
}
extern "C" {
pub fn xmlSAX2GetParameterEntity(
ctx: *mut ::std::os::raw::c_void,
name: *const xmlChar,
) -> xmlEntityPtr;
}
extern "C" {
pub fn xmlSAX2ResolveEntity(
ctx: *mut ::std::os::raw::c_void,
publicId: *const xmlChar,
systemId: *const xmlChar,
) -> xmlParserInputPtr;
}
extern "C" {
pub fn xmlSAX2EntityDecl(
ctx: *mut ::std::os::raw::c_void,
name: *const xmlChar,
type_: ::std::os::raw::c_int,
publicId: *const xmlChar,
systemId: *const xmlChar,
content: *mut xmlChar,
);
}
extern "C" {
pub fn xmlSAX2AttributeDecl(
ctx: *mut ::std::os::raw::c_void,
elem: *const xmlChar,
fullname: *const xmlChar,
type_: ::std::os::raw::c_int,
def: ::std::os::raw::c_int,
defaultValue: *const xmlChar,
tree: xmlEnumerationPtr,
);
}
extern "C" {
pub fn xmlSAX2ElementDecl(
ctx: *mut ::std::os::raw::c_void,
name: *const xmlChar,
type_: ::std::os::raw::c_int,
content: xmlElementContentPtr,
);
}
extern "C" {
pub fn xmlSAX2NotationDecl(
ctx: *mut ::std::os::raw::c_void,
name: *const xmlChar,
publicId: *const xmlChar,
systemId: *const xmlChar,
);
}
extern "C" {
pub fn xmlSAX2UnparsedEntityDecl(
ctx: *mut ::std::os::raw::c_void,
name: *const xmlChar,
publicId: *const xmlChar,
systemId: *const xmlChar,
notationName: *const xmlChar,
);
}
extern "C" {
pub fn xmlSAX2StartDocument(ctx: *mut ::std::os::raw::c_void);
}
extern "C" {
pub fn xmlSAX2EndDocument(ctx: *mut ::std::os::raw::c_void);
}
extern "C" {
pub fn xmlSAX2StartElement(
ctx: *mut ::std::os::raw::c_void,
fullname: *const xmlChar,
atts: *mut *const xmlChar,
);
}
extern "C" {
pub fn xmlSAX2EndElement(ctx: *mut ::std::os::raw::c_void, name: *const xmlChar);
}
extern "C" {
pub fn xmlSAX2StartElementNs(
ctx: *mut ::std::os::raw::c_void,
localname: *const xmlChar,
prefix: *const xmlChar,
URI: *const xmlChar,
nb_namespaces: ::std::os::raw::c_int,
namespaces: *mut *const xmlChar,
nb_attributes: ::std::os::raw::c_int,
nb_defaulted: ::std::os::raw::c_int,
attributes: *mut *const xmlChar,
);
}
extern "C" {
pub fn xmlSAX2EndElementNs(
ctx: *mut ::std::os::raw::c_void,
localname: *const xmlChar,
prefix: *const xmlChar,
URI: *const xmlChar,
);
}
extern "C" {
pub fn xmlSAX2Reference(ctx: *mut ::std::os::raw::c_void, name: *const xmlChar);
}
extern "C" {
pub fn xmlSAX2Characters(
ctx: *mut ::std::os::raw::c_void,
ch: *const xmlChar,
len: ::std::os::raw::c_int,
);
}
extern "C" {
pub fn xmlSAX2IgnorableWhitespace(
ctx: *mut ::std::os::raw::c_void,
ch: *const xmlChar,
len: ::std::os::raw::c_int,
);
}
extern "C" {
pub fn xmlSAX2ProcessingInstruction(
ctx: *mut ::std::os::raw::c_void,
target: *const xmlChar,
data: *const xmlChar,
);
}
extern "C" {
pub fn xmlSAX2Comment(ctx: *mut ::std::os::raw::c_void, value: *const xmlChar);
}
extern "C" {
pub fn xmlSAX2CDataBlock(
ctx: *mut ::std::os::raw::c_void,
value: *const xmlChar,
len: ::std::os::raw::c_int,
);
}
extern "C" {
pub fn xmlSAXDefaultVersion(version: ::std::os::raw::c_int) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn xmlSAXVersion(
hdlr: *mut xmlSAXHandler,
version: ::std::os::raw::c_int,
) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn xmlSAX2InitDefaultSAXHandler(hdlr: *mut xmlSAXHandler, warning: ::std::os::raw::c_int);
}
extern "C" {
pub fn xmlSAX2InitHtmlDefaultSAXHandler(hdlr: *mut xmlSAXHandler);
}
extern "C" {
pub fn htmlDefaultSAXHandlerInit();
}
extern "C" {
pub fn xmlDefaultSAXHandlerInit();
}
extern "C" {
pub fn xmlInitGlobals();
}
extern "C" {
pub fn xmlCleanupGlobals();
}
pub type xmlParserInputBufferCreateFilenameFunc = ::std::option::Option<
unsafe extern "C" fn(
URI: *const ::std::os::raw::c_char,
enc: xmlCharEncoding,
) -> xmlParserInputBufferPtr,
>;
pub type xmlOutputBufferCreateFilenameFunc = ::std::option::Option<
unsafe extern "C" fn(
URI: *const ::std::os::raw::c_char,
encoder: xmlCharEncodingHandlerPtr,
compression: ::std::os::raw::c_int,
) -> xmlOutputBufferPtr,
>;
extern "C" {
pub fn xmlParserInputBufferCreateFilenameDefault(
func: xmlParserInputBufferCreateFilenameFunc,
) -> xmlParserInputBufferCreateFilenameFunc;
}
extern "C" {
pub fn xmlOutputBufferCreateFilenameDefault(
func: xmlOutputBufferCreateFilenameFunc,
) -> xmlOutputBufferCreateFilenameFunc;
}
pub type xmlRegisterNodeFunc = ::std::option::Option<unsafe extern "C" fn(node: xmlNodePtr)>;
pub type xmlDeregisterNodeFunc = ::std::option::Option<unsafe extern "C" fn(node: xmlNodePtr)>;
pub type xmlGlobalState = _xmlGlobalState;
pub type xmlGlobalStatePtr = *mut xmlGlobalState;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct _xmlGlobalState {
pub xmlParserVersion: *const ::std::os::raw::c_char,
pub xmlDefaultSAXLocator: xmlSAXLocator,
pub xmlDefaultSAXHandler: xmlSAXHandlerV1,
pub docbDefaultSAXHandler: xmlSAXHandlerV1,
pub htmlDefaultSAXHandler: xmlSAXHandlerV1,
pub xmlFree: xmlFreeFunc,
pub xmlMalloc: xmlMallocFunc,
pub xmlMemStrdup: xmlStrdupFunc,
pub xmlRealloc: xmlReallocFunc,
pub xmlGenericError: xmlGenericErrorFunc,
pub xmlStructuredError: xmlStructuredErrorFunc,
pub xmlGenericErrorContext: *mut ::std::os::raw::c_void,
pub oldXMLWDcompatibility: ::std::os::raw::c_int,
pub xmlBufferAllocScheme: xmlBufferAllocationScheme,
pub xmlDefaultBufferSize: ::std::os::raw::c_int,
pub xmlSubstituteEntitiesDefaultValue: ::std::os::raw::c_int,
pub xmlDoValidityCheckingDefaultValue: ::std::os::raw::c_int,
pub xmlGetWarningsDefaultValue: ::std::os::raw::c_int,
pub xmlKeepBlanksDefaultValue: ::std::os::raw::c_int,
pub xmlLineNumbersDefaultValue: ::std::os::raw::c_int,
pub xmlLoadExtDtdDefaultValue: ::std::os::raw::c_int,
pub xmlParserDebugEntities: ::std::os::raw::c_int,
pub xmlPedanticParserDefaultValue: ::std::os::raw::c_int,
pub xmlSaveNoEmptyTags: ::std::os::raw::c_int,
pub xmlIndentTreeOutput: ::std::os::raw::c_int,
pub xmlTreeIndentString: *const ::std::os::raw::c_char,
pub xmlRegisterNodeDefaultValue: xmlRegisterNodeFunc,
pub xmlDeregisterNodeDefaultValue: xmlDeregisterNodeFunc,
pub xmlMallocAtomic: xmlMallocFunc,
pub xmlLastError: xmlError,
pub xmlParserInputBufferCreateFilenameValue: xmlParserInputBufferCreateFilenameFunc,
pub xmlOutputBufferCreateFilenameValue: xmlOutputBufferCreateFilenameFunc,
pub xmlStructuredErrorContext: *mut ::std::os::raw::c_void,
}
#[test]
fn bindgen_test_layout__xmlGlobalState() {
const UNINIT: ::std::mem::MaybeUninit<_xmlGlobalState> = ::std::mem::MaybeUninit::uninit();
let ptr = UNINIT.as_ptr();
assert_eq!(
::std::mem::size_of::<_xmlGlobalState>(),
968usize,
concat!("Size of: ", stringify!(_xmlGlobalState))
);
assert_eq!(
::std::mem::align_of::<_xmlGlobalState>(),
8usize,
concat!("Alignment of ", stringify!(_xmlGlobalState))
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).xmlParserVersion) as usize - ptr as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(_xmlGlobalState),
"::",
stringify!(xmlParserVersion)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).xmlDefaultSAXLocator) as usize - ptr as usize },
8usize,
concat!(
"Offset of field: ",
stringify!(_xmlGlobalState),
"::",
stringify!(xmlDefaultSAXLocator)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).xmlDefaultSAXHandler) as usize - ptr as usize },
40usize,
concat!(
"Offset of field: ",
stringify!(_xmlGlobalState),
"::",
stringify!(xmlDefaultSAXHandler)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).docbDefaultSAXHandler) as usize - ptr as usize },
264usize,
concat!(
"Offset of field: ",
stringify!(_xmlGlobalState),
"::",
stringify!(docbDefaultSAXHandler)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).htmlDefaultSAXHandler) as usize - ptr as usize },
488usize,
concat!(
"Offset of field: ",
stringify!(_xmlGlobalState),
"::",
stringify!(htmlDefaultSAXHandler)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).xmlFree) as usize - ptr as usize },
712usize,
concat!(
"Offset of field: ",
stringify!(_xmlGlobalState),
"::",
stringify!(xmlFree)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).xmlMalloc) as usize - ptr as usize },
720usize,
concat!(
"Offset of field: ",
stringify!(_xmlGlobalState),
"::",
stringify!(xmlMalloc)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).xmlMemStrdup) as usize - ptr as usize },
728usize,
concat!(
"Offset of field: ",
stringify!(_xmlGlobalState),
"::",
stringify!(xmlMemStrdup)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).xmlRealloc) as usize - ptr as usize },
736usize,
concat!(
"Offset of field: ",
stringify!(_xmlGlobalState),
"::",
stringify!(xmlRealloc)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).xmlGenericError) as usize - ptr as usize },
744usize,
concat!(
"Offset of field: ",
stringify!(_xmlGlobalState),
"::",
stringify!(xmlGenericError)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).xmlStructuredError) as usize - ptr as usize },
752usize,
concat!(
"Offset of field: ",
stringify!(_xmlGlobalState),
"::",
stringify!(xmlStructuredError)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).xmlGenericErrorContext) as usize - ptr as usize },
760usize,
concat!(
"Offset of field: ",
stringify!(_xmlGlobalState),
"::",
stringify!(xmlGenericErrorContext)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).oldXMLWDcompatibility) as usize - ptr as usize },
768usize,
concat!(
"Offset of field: ",
stringify!(_xmlGlobalState),
"::",
stringify!(oldXMLWDcompatibility)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).xmlBufferAllocScheme) as usize - ptr as usize },
772usize,
concat!(
"Offset of field: ",
stringify!(_xmlGlobalState),
"::",
stringify!(xmlBufferAllocScheme)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).xmlDefaultBufferSize) as usize - ptr as usize },
776usize,
concat!(
"Offset of field: ",
stringify!(_xmlGlobalState),
"::",
stringify!(xmlDefaultBufferSize)
)
);
assert_eq!(
unsafe {
::std::ptr::addr_of!((*ptr).xmlSubstituteEntitiesDefaultValue) as usize - ptr as usize
},
780usize,
concat!(
"Offset of field: ",
stringify!(_xmlGlobalState),
"::",
stringify!(xmlSubstituteEntitiesDefaultValue)
)
);
assert_eq!(
unsafe {
::std::ptr::addr_of!((*ptr).xmlDoValidityCheckingDefaultValue) as usize - ptr as usize
},
784usize,
concat!(
"Offset of field: ",
stringify!(_xmlGlobalState),
"::",
stringify!(xmlDoValidityCheckingDefaultValue)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).xmlGetWarningsDefaultValue) as usize - ptr as usize },
788usize,
concat!(
"Offset of field: ",
stringify!(_xmlGlobalState),
"::",
stringify!(xmlGetWarningsDefaultValue)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).xmlKeepBlanksDefaultValue) as usize - ptr as usize },
792usize,
concat!(
"Offset of field: ",
stringify!(_xmlGlobalState),
"::",
stringify!(xmlKeepBlanksDefaultValue)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).xmlLineNumbersDefaultValue) as usize - ptr as usize },
796usize,
concat!(
"Offset of field: ",
stringify!(_xmlGlobalState),
"::",
stringify!(xmlLineNumbersDefaultValue)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).xmlLoadExtDtdDefaultValue) as usize - ptr as usize },
800usize,
concat!(
"Offset of field: ",
stringify!(_xmlGlobalState),
"::",
stringify!(xmlLoadExtDtdDefaultValue)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).xmlParserDebugEntities) as usize - ptr as usize },
804usize,
concat!(
"Offset of field: ",
stringify!(_xmlGlobalState),
"::",
stringify!(xmlParserDebugEntities)
)
);
assert_eq!(
unsafe {
::std::ptr::addr_of!((*ptr).xmlPedanticParserDefaultValue) as usize - ptr as usize
},
808usize,
concat!(
"Offset of field: ",
stringify!(_xmlGlobalState),
"::",
stringify!(xmlPedanticParserDefaultValue)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).xmlSaveNoEmptyTags) as usize - ptr as usize },
812usize,
concat!(
"Offset of field: ",
stringify!(_xmlGlobalState),
"::",
stringify!(xmlSaveNoEmptyTags)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).xmlIndentTreeOutput) as usize - ptr as usize },
816usize,
concat!(
"Offset of field: ",
stringify!(_xmlGlobalState),
"::",
stringify!(xmlIndentTreeOutput)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).xmlTreeIndentString) as usize - ptr as usize },
824usize,
concat!(
"Offset of field: ",
stringify!(_xmlGlobalState),
"::",
stringify!(xmlTreeIndentString)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).xmlRegisterNodeDefaultValue) as usize - ptr as usize },
832usize,
concat!(
"Offset of field: ",
stringify!(_xmlGlobalState),
"::",
stringify!(xmlRegisterNodeDefaultValue)
)
);
assert_eq!(
unsafe {
::std::ptr::addr_of!((*ptr).xmlDeregisterNodeDefaultValue) as usize - ptr as usize
},
840usize,
concat!(
"Offset of field: ",
stringify!(_xmlGlobalState),
"::",
stringify!(xmlDeregisterNodeDefaultValue)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).xmlMallocAtomic) as usize - ptr as usize },
848usize,
concat!(
"Offset of field: ",
stringify!(_xmlGlobalState),
"::",
stringify!(xmlMallocAtomic)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).xmlLastError) as usize - ptr as usize },
856usize,
concat!(
"Offset of field: ",
stringify!(_xmlGlobalState),
"::",
stringify!(xmlLastError)
)
);
assert_eq!(
unsafe {
::std::ptr::addr_of!((*ptr).xmlParserInputBufferCreateFilenameValue) as usize
- ptr as usize
},
944usize,
concat!(
"Offset of field: ",
stringify!(_xmlGlobalState),
"::",
stringify!(xmlParserInputBufferCreateFilenameValue)
)
);
assert_eq!(
unsafe {
::std::ptr::addr_of!((*ptr).xmlOutputBufferCreateFilenameValue) as usize - ptr as usize
},
952usize,
concat!(
"Offset of field: ",
stringify!(_xmlGlobalState),
"::",
stringify!(xmlOutputBufferCreateFilenameValue)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).xmlStructuredErrorContext) as usize - ptr as usize },
960usize,
concat!(
"Offset of field: ",
stringify!(_xmlGlobalState),
"::",
stringify!(xmlStructuredErrorContext)
)
);
}
extern "C" {
pub fn xmlInitializeGlobalState(gs: xmlGlobalStatePtr);
}
extern "C" {
pub fn xmlThrDefSetGenericErrorFunc(
ctx: *mut ::std::os::raw::c_void,
handler: xmlGenericErrorFunc,
);
}
extern "C" {
pub fn xmlThrDefSetStructuredErrorFunc(
ctx: *mut ::std::os::raw::c_void,
handler: xmlStructuredErrorFunc,
);
}
extern "C" {
pub fn xmlRegisterNodeDefault(func: xmlRegisterNodeFunc) -> xmlRegisterNodeFunc;
}
extern "C" {
pub fn xmlThrDefRegisterNodeDefault(func: xmlRegisterNodeFunc) -> xmlRegisterNodeFunc;
}
extern "C" {
pub fn xmlDeregisterNodeDefault(func: xmlDeregisterNodeFunc) -> xmlDeregisterNodeFunc;
}
extern "C" {
pub fn xmlThrDefDeregisterNodeDefault(func: xmlDeregisterNodeFunc) -> xmlDeregisterNodeFunc;
}
extern "C" {
pub fn xmlThrDefOutputBufferCreateFilenameDefault(
func: xmlOutputBufferCreateFilenameFunc,
) -> xmlOutputBufferCreateFilenameFunc;
}
extern "C" {
pub fn xmlThrDefParserInputBufferCreateFilenameDefault(
func: xmlParserInputBufferCreateFilenameFunc,
) -> xmlParserInputBufferCreateFilenameFunc;
}
extern "C" {
pub static mut xmlMalloc: xmlMallocFunc;
}
extern "C" {
pub static mut xmlMallocAtomic: xmlMallocFunc;
}
extern "C" {
pub static mut xmlRealloc: xmlReallocFunc;
}
extern "C" {
pub static mut xmlFree: xmlFreeFunc;
}
extern "C" {
pub static mut xmlMemStrdup: xmlStrdupFunc;
}
extern "C" {
pub fn __htmlDefaultSAXHandler() -> *mut xmlSAXHandlerV1;
}
extern "C" {
pub fn __xmlLastError() -> *mut xmlError;
}
extern "C" {
pub fn __oldXMLWDcompatibility() -> *mut ::std::os::raw::c_int;
}
extern "C" {
pub fn __xmlBufferAllocScheme() -> *mut xmlBufferAllocationScheme;
}
extern "C" {
pub fn xmlThrDefBufferAllocScheme(v: xmlBufferAllocationScheme) -> xmlBufferAllocationScheme;
}
extern "C" {
pub fn __xmlDefaultBufferSize() -> *mut ::std::os::raw::c_int;
}
extern "C" {
pub fn xmlThrDefDefaultBufferSize(v: ::std::os::raw::c_int) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn __xmlDefaultSAXHandler() -> *mut xmlSAXHandlerV1;
}
extern "C" {
pub fn __xmlDefaultSAXLocator() -> *mut xmlSAXLocator;
}
extern "C" {
pub fn __xmlDoValidityCheckingDefaultValue() -> *mut ::std::os::raw::c_int;
}
extern "C" {
pub fn xmlThrDefDoValidityCheckingDefaultValue(
v: ::std::os::raw::c_int,
) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn __xmlGenericError() -> *mut xmlGenericErrorFunc;
}
extern "C" {
pub fn __xmlStructuredError() -> *mut xmlStructuredErrorFunc;
}
extern "C" {
pub fn __xmlGenericErrorContext() -> *mut *mut ::std::os::raw::c_void;
}
extern "C" {
pub fn __xmlStructuredErrorContext() -> *mut *mut ::std::os::raw::c_void;
}
extern "C" {
pub fn __xmlGetWarningsDefaultValue() -> *mut ::std::os::raw::c_int;
}
extern "C" {
pub fn xmlThrDefGetWarningsDefaultValue(v: ::std::os::raw::c_int) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn __xmlIndentTreeOutput() -> *mut ::std::os::raw::c_int;
}
extern "C" {
pub fn xmlThrDefIndentTreeOutput(v: ::std::os::raw::c_int) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn __xmlTreeIndentString() -> *mut *const ::std::os::raw::c_char;
}
extern "C" {
pub fn xmlThrDefTreeIndentString(
v: *const ::std::os::raw::c_char,
) -> *const ::std::os::raw::c_char;
}
extern "C" {
pub fn __xmlKeepBlanksDefaultValue() -> *mut ::std::os::raw::c_int;
}
extern "C" {
pub fn xmlThrDefKeepBlanksDefaultValue(v: ::std::os::raw::c_int) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn __xmlLineNumbersDefaultValue() -> *mut ::std::os::raw::c_int;
}
extern "C" {
pub fn xmlThrDefLineNumbersDefaultValue(v: ::std::os::raw::c_int) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn __xmlLoadExtDtdDefaultValue() -> *mut ::std::os::raw::c_int;
}
extern "C" {
pub fn xmlThrDefLoadExtDtdDefaultValue(v: ::std::os::raw::c_int) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn __xmlParserDebugEntities() -> *mut ::std::os::raw::c_int;
}
extern "C" {
pub fn xmlThrDefParserDebugEntities(v: ::std::os::raw::c_int) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn __xmlParserVersion() -> *mut *const ::std::os::raw::c_char;
}
extern "C" {
pub fn __xmlPedanticParserDefaultValue() -> *mut ::std::os::raw::c_int;
}
extern "C" {
pub fn xmlThrDefPedanticParserDefaultValue(v: ::std::os::raw::c_int) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn __xmlSaveNoEmptyTags() -> *mut ::std::os::raw::c_int;
}
extern "C" {
pub fn xmlThrDefSaveNoEmptyTags(v: ::std::os::raw::c_int) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn __xmlSubstituteEntitiesDefaultValue() -> *mut ::std::os::raw::c_int;
}
extern "C" {
pub fn xmlThrDefSubstituteEntitiesDefaultValue(
v: ::std::os::raw::c_int,
) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn __xmlRegisterNodeDefaultValue() -> *mut xmlRegisterNodeFunc;
}
extern "C" {
pub fn __xmlDeregisterNodeDefaultValue() -> *mut xmlDeregisterNodeFunc;
}
extern "C" {
pub fn __xmlParserInputBufferCreateFilenameValue() -> *mut xmlParserInputBufferCreateFilenameFunc;
}
extern "C" {
pub fn __xmlOutputBufferCreateFilenameValue() -> *mut xmlOutputBufferCreateFilenameFunc;
}
extern "C" {
pub fn xmlNewMutex() -> xmlMutexPtr;
}
extern "C" {
pub fn xmlMutexLock(tok: xmlMutexPtr);
}
extern "C" {
pub fn xmlMutexUnlock(tok: xmlMutexPtr);
}
extern "C" {
pub fn xmlFreeMutex(tok: xmlMutexPtr);
}
extern "C" {
pub fn xmlNewRMutex() -> xmlRMutexPtr;
}
extern "C" {
pub fn xmlRMutexLock(tok: xmlRMutexPtr);
}
extern "C" {
pub fn xmlRMutexUnlock(tok: xmlRMutexPtr);
}
extern "C" {
pub fn xmlFreeRMutex(tok: xmlRMutexPtr);
}
extern "C" {
pub fn xmlInitThreads();
}
extern "C" {
pub fn xmlLockLibrary();
}
extern "C" {
pub fn xmlUnlockLibrary();
}
extern "C" {
pub fn xmlGetThreadId() -> ::std::os::raw::c_int;
}
extern "C" {
pub fn xmlIsMainThread() -> ::std::os::raw::c_int;
}
extern "C" {
pub fn xmlCleanupThreads();
}
extern "C" {
pub fn xmlGetGlobalState() -> xmlGlobalStatePtr;
}
pub type xmlXPathContext = _xmlXPathContext;
pub type xmlXPathContextPtr = *mut xmlXPathContext;
pub type xmlXPathParserContext = _xmlXPathParserContext;
pub type xmlXPathParserContextPtr = *mut xmlXPathParserContext;
pub const xmlXPathError_XPATH_EXPRESSION_OK: xmlXPathError = 0;
pub const xmlXPathError_XPATH_NUMBER_ERROR: xmlXPathError = 1;
pub const xmlXPathError_XPATH_UNFINISHED_LITERAL_ERROR: xmlXPathError = 2;
pub const xmlXPathError_XPATH_START_LITERAL_ERROR: xmlXPathError = 3;
pub const xmlXPathError_XPATH_VARIABLE_REF_ERROR: xmlXPathError = 4;
pub const xmlXPathError_XPATH_UNDEF_VARIABLE_ERROR: xmlXPathError = 5;
pub const xmlXPathError_XPATH_INVALID_PREDICATE_ERROR: xmlXPathError = 6;
pub const xmlXPathError_XPATH_EXPR_ERROR: xmlXPathError = 7;
pub const xmlXPathError_XPATH_UNCLOSED_ERROR: xmlXPathError = 8;
pub const xmlXPathError_XPATH_UNKNOWN_FUNC_ERROR: xmlXPathError = 9;
pub const xmlXPathError_XPATH_INVALID_OPERAND: xmlXPathError = 10;
pub const xmlXPathError_XPATH_INVALID_TYPE: xmlXPathError = 11;
pub const xmlXPathError_XPATH_INVALID_ARITY: xmlXPathError = 12;
pub const xmlXPathError_XPATH_INVALID_CTXT_SIZE: xmlXPathError = 13;
pub const xmlXPathError_XPATH_INVALID_CTXT_POSITION: xmlXPathError = 14;
pub const xmlXPathError_XPATH_MEMORY_ERROR: xmlXPathError = 15;
pub const xmlXPathError_XPTR_SYNTAX_ERROR: xmlXPathError = 16;
pub const xmlXPathError_XPTR_RESOURCE_ERROR: xmlXPathError = 17;
pub const xmlXPathError_XPTR_SUB_RESOURCE_ERROR: xmlXPathError = 18;
pub const xmlXPathError_XPATH_UNDEF_PREFIX_ERROR: xmlXPathError = 19;
pub const xmlXPathError_XPATH_ENCODING_ERROR: xmlXPathError = 20;
pub const xmlXPathError_XPATH_INVALID_CHAR_ERROR: xmlXPathError = 21;
pub const xmlXPathError_XPATH_INVALID_CTXT: xmlXPathError = 22;
pub const xmlXPathError_XPATH_STACK_ERROR: xmlXPathError = 23;
pub const xmlXPathError_XPATH_FORBID_VARIABLE_ERROR: xmlXPathError = 24;
pub const xmlXPathError_XPATH_OP_LIMIT_EXCEEDED: xmlXPathError = 25;
pub const xmlXPathError_XPATH_RECURSION_LIMIT_EXCEEDED: xmlXPathError = 26;
pub type xmlXPathError = ::std::os::raw::c_uint;
pub type xmlNodeSet = _xmlNodeSet;
pub type xmlNodeSetPtr = *mut xmlNodeSet;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct _xmlNodeSet {
pub nodeNr: ::std::os::raw::c_int,
pub nodeMax: ::std::os::raw::c_int,
pub nodeTab: *mut xmlNodePtr,
}
#[test]
fn bindgen_test_layout__xmlNodeSet() {
const UNINIT: ::std::mem::MaybeUninit<_xmlNodeSet> = ::std::mem::MaybeUninit::uninit();
let ptr = UNINIT.as_ptr();
assert_eq!(
::std::mem::size_of::<_xmlNodeSet>(),
16usize,
concat!("Size of: ", stringify!(_xmlNodeSet))
);
assert_eq!(
::std::mem::align_of::<_xmlNodeSet>(),
8usize,
concat!("Alignment of ", stringify!(_xmlNodeSet))
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).nodeNr) as usize - ptr as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(_xmlNodeSet),
"::",
stringify!(nodeNr)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).nodeMax) as usize - ptr as usize },
4usize,
concat!(
"Offset of field: ",
stringify!(_xmlNodeSet),
"::",
stringify!(nodeMax)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).nodeTab) as usize - ptr as usize },
8usize,
concat!(
"Offset of field: ",
stringify!(_xmlNodeSet),
"::",
stringify!(nodeTab)
)
);
}
pub const xmlXPathObjectType_XPATH_UNDEFINED: xmlXPathObjectType = 0;
pub const xmlXPathObjectType_XPATH_NODESET: xmlXPathObjectType = 1;
pub const xmlXPathObjectType_XPATH_BOOLEAN: xmlXPathObjectType = 2;
pub const xmlXPathObjectType_XPATH_NUMBER: xmlXPathObjectType = 3;
pub const xmlXPathObjectType_XPATH_STRING: xmlXPathObjectType = 4;
pub const xmlXPathObjectType_XPATH_USERS: xmlXPathObjectType = 8;
pub const xmlXPathObjectType_XPATH_XSLT_TREE: xmlXPathObjectType = 9;
pub type xmlXPathObjectType = ::std::os::raw::c_uint;
pub type xmlXPathObject = _xmlXPathObject;
pub type xmlXPathObjectPtr = *mut xmlXPathObject;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct _xmlXPathObject {
pub type_: xmlXPathObjectType,
pub nodesetval: xmlNodeSetPtr,
pub boolval: ::std::os::raw::c_int,
pub floatval: f64,
pub stringval: *mut xmlChar,
pub user: *mut ::std::os::raw::c_void,
pub index: ::std::os::raw::c_int,
pub user2: *mut ::std::os::raw::c_void,
pub index2: ::std::os::raw::c_int,
}
#[test]
fn bindgen_test_layout__xmlXPathObject() {
const UNINIT: ::std::mem::MaybeUninit<_xmlXPathObject> = ::std::mem::MaybeUninit::uninit();
let ptr = UNINIT.as_ptr();
assert_eq!(
::std::mem::size_of::<_xmlXPathObject>(),
72usize,
concat!("Size of: ", stringify!(_xmlXPathObject))
);
assert_eq!(
::std::mem::align_of::<_xmlXPathObject>(),
8usize,
concat!("Alignment of ", stringify!(_xmlXPathObject))
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).type_) as usize - ptr as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(_xmlXPathObject),
"::",
stringify!(type_)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).nodesetval) as usize - ptr as usize },
8usize,
concat!(
"Offset of field: ",
stringify!(_xmlXPathObject),
"::",
stringify!(nodesetval)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).boolval) as usize - ptr as usize },
16usize,
concat!(
"Offset of field: ",
stringify!(_xmlXPathObject),
"::",
stringify!(boolval)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).floatval) as usize - ptr as usize },
24usize,
concat!(
"Offset of field: ",
stringify!(_xmlXPathObject),
"::",
stringify!(floatval)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).stringval) as usize - ptr as usize },
32usize,
concat!(
"Offset of field: ",
stringify!(_xmlXPathObject),
"::",
stringify!(stringval)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).user) as usize - ptr as usize },
40usize,
concat!(
"Offset of field: ",
stringify!(_xmlXPathObject),
"::",
stringify!(user)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).index) as usize - ptr as usize },
48usize,
concat!(
"Offset of field: ",
stringify!(_xmlXPathObject),
"::",
stringify!(index)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).user2) as usize - ptr as usize },
56usize,
concat!(
"Offset of field: ",
stringify!(_xmlXPathObject),
"::",
stringify!(user2)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).index2) as usize - ptr as usize },
64usize,
concat!(
"Offset of field: ",
stringify!(_xmlXPathObject),
"::",
stringify!(index2)
)
);
}
pub type xmlXPathConvertFunc = ::std::option::Option<
unsafe extern "C" fn(
obj: xmlXPathObjectPtr,
type_: ::std::os::raw::c_int,
) -> ::std::os::raw::c_int,
>;
pub type xmlXPathType = _xmlXPathType;
pub type xmlXPathTypePtr = *mut xmlXPathType;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct _xmlXPathType {
pub name: *const xmlChar,
pub func: xmlXPathConvertFunc,
}
#[test]
fn bindgen_test_layout__xmlXPathType() {
const UNINIT: ::std::mem::MaybeUninit<_xmlXPathType> = ::std::mem::MaybeUninit::uninit();
let ptr = UNINIT.as_ptr();
assert_eq!(
::std::mem::size_of::<_xmlXPathType>(),
16usize,
concat!("Size of: ", stringify!(_xmlXPathType))
);
assert_eq!(
::std::mem::align_of::<_xmlXPathType>(),
8usize,
concat!("Alignment of ", stringify!(_xmlXPathType))
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).name) as usize - ptr as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(_xmlXPathType),
"::",
stringify!(name)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).func) as usize - ptr as usize },
8usize,
concat!(
"Offset of field: ",
stringify!(_xmlXPathType),
"::",
stringify!(func)
)
);
}
pub type xmlXPathVariable = _xmlXPathVariable;
pub type xmlXPathVariablePtr = *mut xmlXPathVariable;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct _xmlXPathVariable {
pub name: *const xmlChar,
pub value: xmlXPathObjectPtr,
}
#[test]
fn bindgen_test_layout__xmlXPathVariable() {
const UNINIT: ::std::mem::MaybeUninit<_xmlXPathVariable> = ::std::mem::MaybeUninit::uninit();
let ptr = UNINIT.as_ptr();
assert_eq!(
::std::mem::size_of::<_xmlXPathVariable>(),
16usize,
concat!("Size of: ", stringify!(_xmlXPathVariable))
);
assert_eq!(
::std::mem::align_of::<_xmlXPathVariable>(),
8usize,
concat!("Alignment of ", stringify!(_xmlXPathVariable))
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).name) as usize - ptr as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(_xmlXPathVariable),
"::",
stringify!(name)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).value) as usize - ptr as usize },
8usize,
concat!(
"Offset of field: ",
stringify!(_xmlXPathVariable),
"::",
stringify!(value)
)
);
}
pub type xmlXPathEvalFunc = ::std::option::Option<
unsafe extern "C" fn(ctxt: xmlXPathParserContextPtr, nargs: ::std::os::raw::c_int),
>;
pub type xmlXPathFunct = _xmlXPathFunct;
pub type xmlXPathFuncPtr = *mut xmlXPathFunct;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct _xmlXPathFunct {
pub name: *const xmlChar,
pub func: xmlXPathEvalFunc,
}
#[test]
fn bindgen_test_layout__xmlXPathFunct() {
const UNINIT: ::std::mem::MaybeUninit<_xmlXPathFunct> = ::std::mem::MaybeUninit::uninit();
let ptr = UNINIT.as_ptr();
assert_eq!(
::std::mem::size_of::<_xmlXPathFunct>(),
16usize,
concat!("Size of: ", stringify!(_xmlXPathFunct))
);
assert_eq!(
::std::mem::align_of::<_xmlXPathFunct>(),
8usize,
concat!("Alignment of ", stringify!(_xmlXPathFunct))
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).name) as usize - ptr as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(_xmlXPathFunct),
"::",
stringify!(name)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).func) as usize - ptr as usize },
8usize,
concat!(
"Offset of field: ",
stringify!(_xmlXPathFunct),
"::",
stringify!(func)
)
);
}
pub type xmlXPathAxisFunc = ::std::option::Option<
unsafe extern "C" fn(
ctxt: xmlXPathParserContextPtr,
cur: xmlXPathObjectPtr,
) -> xmlXPathObjectPtr,
>;
pub type xmlXPathAxis = _xmlXPathAxis;
pub type xmlXPathAxisPtr = *mut xmlXPathAxis;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct _xmlXPathAxis {
pub name: *const xmlChar,
pub func: xmlXPathAxisFunc,
}
#[test]
fn bindgen_test_layout__xmlXPathAxis() {
const UNINIT: ::std::mem::MaybeUninit<_xmlXPathAxis> = ::std::mem::MaybeUninit::uninit();
let ptr = UNINIT.as_ptr();
assert_eq!(
::std::mem::size_of::<_xmlXPathAxis>(),
16usize,
concat!("Size of: ", stringify!(_xmlXPathAxis))
);
assert_eq!(
::std::mem::align_of::<_xmlXPathAxis>(),
8usize,
concat!("Alignment of ", stringify!(_xmlXPathAxis))
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).name) as usize - ptr as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(_xmlXPathAxis),
"::",
stringify!(name)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).func) as usize - ptr as usize },
8usize,
concat!(
"Offset of field: ",
stringify!(_xmlXPathAxis),
"::",
stringify!(func)
)
);
}
pub type xmlXPathFunction = ::std::option::Option<
unsafe extern "C" fn(ctxt: xmlXPathParserContextPtr, nargs: ::std::os::raw::c_int),
>;
pub type xmlXPathVariableLookupFunc = ::std::option::Option<
unsafe extern "C" fn(
ctxt: *mut ::std::os::raw::c_void,
name: *const xmlChar,
ns_uri: *const xmlChar,
) -> xmlXPathObjectPtr,
>;
pub type xmlXPathFuncLookupFunc = ::std::option::Option<
unsafe extern "C" fn(
ctxt: *mut ::std::os::raw::c_void,
name: *const xmlChar,
ns_uri: *const xmlChar,
) -> xmlXPathFunction,
>;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct _xmlXPathContext {
pub doc: xmlDocPtr,
pub node: xmlNodePtr,
pub nb_variables_unused: ::std::os::raw::c_int,
pub max_variables_unused: ::std::os::raw::c_int,
pub varHash: xmlHashTablePtr,
pub nb_types: ::std::os::raw::c_int,
pub max_types: ::std::os::raw::c_int,
pub types: xmlXPathTypePtr,
pub nb_funcs_unused: ::std::os::raw::c_int,
pub max_funcs_unused: ::std::os::raw::c_int,
pub funcHash: xmlHashTablePtr,
pub nb_axis: ::std::os::raw::c_int,
pub max_axis: ::std::os::raw::c_int,
pub axis: xmlXPathAxisPtr,
pub namespaces: *mut xmlNsPtr,
pub nsNr: ::std::os::raw::c_int,
pub user: *mut ::std::os::raw::c_void,
pub contextSize: ::std::os::raw::c_int,
pub proximityPosition: ::std::os::raw::c_int,
pub xptr: ::std::os::raw::c_int,
pub here: xmlNodePtr,
pub origin: xmlNodePtr,
pub nsHash: xmlHashTablePtr,
pub varLookupFunc: xmlXPathVariableLookupFunc,
pub varLookupData: *mut ::std::os::raw::c_void,
pub extra: *mut ::std::os::raw::c_void,
pub function: *const xmlChar,
pub functionURI: *const xmlChar,
pub funcLookupFunc: xmlXPathFuncLookupFunc,
pub funcLookupData: *mut ::std::os::raw::c_void,
pub tmpNsList: *mut xmlNsPtr,
pub tmpNsNr: ::std::os::raw::c_int,
pub userData: *mut ::std::os::raw::c_void,
pub error: xmlStructuredErrorFunc,
pub lastError: xmlError,
pub debugNode: xmlNodePtr,
pub dict: xmlDictPtr,
pub flags: ::std::os::raw::c_int,
pub cache: *mut ::std::os::raw::c_void,
pub opLimit: ::std::os::raw::c_ulong,
pub opCount: ::std::os::raw::c_ulong,
pub depth: ::std::os::raw::c_int,
}
#[test]
fn bindgen_test_layout__xmlXPathContext() {
const UNINIT: ::std::mem::MaybeUninit<_xmlXPathContext> = ::std::mem::MaybeUninit::uninit();
let ptr = UNINIT.as_ptr();
assert_eq!(
::std::mem::size_of::<_xmlXPathContext>(),
376usize,
concat!("Size of: ", stringify!(_xmlXPathContext))
);
assert_eq!(
::std::mem::align_of::<_xmlXPathContext>(),
8usize,
concat!("Alignment of ", stringify!(_xmlXPathContext))
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).doc) as usize - ptr as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(_xmlXPathContext),
"::",
stringify!(doc)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).node) as usize - ptr as usize },
8usize,
concat!(
"Offset of field: ",
stringify!(_xmlXPathContext),
"::",
stringify!(node)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).nb_variables_unused) as usize - ptr as usize },
16usize,
concat!(
"Offset of field: ",
stringify!(_xmlXPathContext),
"::",
stringify!(nb_variables_unused)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).max_variables_unused) as usize - ptr as usize },
20usize,
concat!(
"Offset of field: ",
stringify!(_xmlXPathContext),
"::",
stringify!(max_variables_unused)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).varHash) as usize - ptr as usize },
24usize,
concat!(
"Offset of field: ",
stringify!(_xmlXPathContext),
"::",
stringify!(varHash)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).nb_types) as usize - ptr as usize },
32usize,
concat!(
"Offset of field: ",
stringify!(_xmlXPathContext),
"::",
stringify!(nb_types)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).max_types) as usize - ptr as usize },
36usize,
concat!(
"Offset of field: ",
stringify!(_xmlXPathContext),
"::",
stringify!(max_types)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).types) as usize - ptr as usize },
40usize,
concat!(
"Offset of field: ",
stringify!(_xmlXPathContext),
"::",
stringify!(types)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).nb_funcs_unused) as usize - ptr as usize },
48usize,
concat!(
"Offset of field: ",
stringify!(_xmlXPathContext),
"::",
stringify!(nb_funcs_unused)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).max_funcs_unused) as usize - ptr as usize },
52usize,
concat!(
"Offset of field: ",
stringify!(_xmlXPathContext),
"::",
stringify!(max_funcs_unused)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).funcHash) as usize - ptr as usize },
56usize,
concat!(
"Offset of field: ",
stringify!(_xmlXPathContext),
"::",
stringify!(funcHash)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).nb_axis) as usize - ptr as usize },
64usize,
concat!(
"Offset of field: ",
stringify!(_xmlXPathContext),
"::",
stringify!(nb_axis)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).max_axis) as usize - ptr as usize },
68usize,
concat!(
"Offset of field: ",
stringify!(_xmlXPathContext),
"::",
stringify!(max_axis)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).axis) as usize - ptr as usize },
72usize,
concat!(
"Offset of field: ",
stringify!(_xmlXPathContext),
"::",
stringify!(axis)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).namespaces) as usize - ptr as usize },
80usize,
concat!(
"Offset of field: ",
stringify!(_xmlXPathContext),
"::",
stringify!(namespaces)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).nsNr) as usize - ptr as usize },
88usize,
concat!(
"Offset of field: ",
stringify!(_xmlXPathContext),
"::",
stringify!(nsNr)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).user) as usize - ptr as usize },
96usize,
concat!(
"Offset of field: ",
stringify!(_xmlXPathContext),
"::",
stringify!(user)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).contextSize) as usize - ptr as usize },
104usize,
concat!(
"Offset of field: ",
stringify!(_xmlXPathContext),
"::",
stringify!(contextSize)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).proximityPosition) as usize - ptr as usize },
108usize,
concat!(
"Offset of field: ",
stringify!(_xmlXPathContext),
"::",
stringify!(proximityPosition)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).xptr) as usize - ptr as usize },
112usize,
concat!(
"Offset of field: ",
stringify!(_xmlXPathContext),
"::",
stringify!(xptr)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).here) as usize - ptr as usize },
120usize,
concat!(
"Offset of field: ",
stringify!(_xmlXPathContext),
"::",
stringify!(here)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).origin) as usize - ptr as usize },
128usize,
concat!(
"Offset of field: ",
stringify!(_xmlXPathContext),
"::",
stringify!(origin)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).nsHash) as usize - ptr as usize },
136usize,
concat!(
"Offset of field: ",
stringify!(_xmlXPathContext),
"::",
stringify!(nsHash)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).varLookupFunc) as usize - ptr as usize },
144usize,
concat!(
"Offset of field: ",
stringify!(_xmlXPathContext),
"::",
stringify!(varLookupFunc)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).varLookupData) as usize - ptr as usize },
152usize,
concat!(
"Offset of field: ",
stringify!(_xmlXPathContext),
"::",
stringify!(varLookupData)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).extra) as usize - ptr as usize },
160usize,
concat!(
"Offset of field: ",
stringify!(_xmlXPathContext),
"::",
stringify!(extra)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).function) as usize - ptr as usize },
168usize,
concat!(
"Offset of field: ",
stringify!(_xmlXPathContext),
"::",
stringify!(function)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).functionURI) as usize - ptr as usize },
176usize,
concat!(
"Offset of field: ",
stringify!(_xmlXPathContext),
"::",
stringify!(functionURI)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).funcLookupFunc) as usize - ptr as usize },
184usize,
concat!(
"Offset of field: ",
stringify!(_xmlXPathContext),
"::",
stringify!(funcLookupFunc)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).funcLookupData) as usize - ptr as usize },
192usize,
concat!(
"Offset of field: ",
stringify!(_xmlXPathContext),
"::",
stringify!(funcLookupData)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).tmpNsList) as usize - ptr as usize },
200usize,
concat!(
"Offset of field: ",
stringify!(_xmlXPathContext),
"::",
stringify!(tmpNsList)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).tmpNsNr) as usize - ptr as usize },
208usize,
concat!(
"Offset of field: ",
stringify!(_xmlXPathContext),
"::",
stringify!(tmpNsNr)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).userData) as usize - ptr as usize },
216usize,
concat!(
"Offset of field: ",
stringify!(_xmlXPathContext),
"::",
stringify!(userData)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).error) as usize - ptr as usize },
224usize,
concat!(
"Offset of field: ",
stringify!(_xmlXPathContext),
"::",
stringify!(error)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).lastError) as usize - ptr as usize },
232usize,
concat!(
"Offset of field: ",
stringify!(_xmlXPathContext),
"::",
stringify!(lastError)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).debugNode) as usize - ptr as usize },
320usize,
concat!(
"Offset of field: ",
stringify!(_xmlXPathContext),
"::",
stringify!(debugNode)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).dict) as usize - ptr as usize },
328usize,
concat!(
"Offset of field: ",
stringify!(_xmlXPathContext),
"::",
stringify!(dict)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).flags) as usize - ptr as usize },
336usize,
concat!(
"Offset of field: ",
stringify!(_xmlXPathContext),
"::",
stringify!(flags)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).cache) as usize - ptr as usize },
344usize,
concat!(
"Offset of field: ",
stringify!(_xmlXPathContext),
"::",
stringify!(cache)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).opLimit) as usize - ptr as usize },
352usize,
concat!(
"Offset of field: ",
stringify!(_xmlXPathContext),
"::",
stringify!(opLimit)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).opCount) as usize - ptr as usize },
360usize,
concat!(
"Offset of field: ",
stringify!(_xmlXPathContext),
"::",
stringify!(opCount)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).depth) as usize - ptr as usize },
368usize,
concat!(
"Offset of field: ",
stringify!(_xmlXPathContext),
"::",
stringify!(depth)
)
);
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct _xmlXPathCompExpr {
_unused: [u8; 0],
}
pub type xmlXPathCompExpr = _xmlXPathCompExpr;
pub type xmlXPathCompExprPtr = *mut xmlXPathCompExpr;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct _xmlXPathParserContext {
pub cur: *const xmlChar,
pub base: *const xmlChar,
pub error: ::std::os::raw::c_int,
pub context: xmlXPathContextPtr,
pub value: xmlXPathObjectPtr,
pub valueNr: ::std::os::raw::c_int,
pub valueMax: ::std::os::raw::c_int,
pub valueTab: *mut xmlXPathObjectPtr,
pub comp: xmlXPathCompExprPtr,
pub xptr: ::std::os::raw::c_int,
pub ancestor: xmlNodePtr,
pub valueFrame: ::std::os::raw::c_int,
}
#[test]
fn bindgen_test_layout__xmlXPathParserContext() {
const UNINIT: ::std::mem::MaybeUninit<_xmlXPathParserContext> =
::std::mem::MaybeUninit::uninit();
let ptr = UNINIT.as_ptr();
assert_eq!(
::std::mem::size_of::<_xmlXPathParserContext>(),
88usize,
concat!("Size of: ", stringify!(_xmlXPathParserContext))
);
assert_eq!(
::std::mem::align_of::<_xmlXPathParserContext>(),
8usize,
concat!("Alignment of ", stringify!(_xmlXPathParserContext))
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).cur) as usize - ptr as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(_xmlXPathParserContext),
"::",
stringify!(cur)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).base) as usize - ptr as usize },
8usize,
concat!(
"Offset of field: ",
stringify!(_xmlXPathParserContext),
"::",
stringify!(base)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).error) as usize - ptr as usize },
16usize,
concat!(
"Offset of field: ",
stringify!(_xmlXPathParserContext),
"::",
stringify!(error)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).context) as usize - ptr as usize },
24usize,
concat!(
"Offset of field: ",
stringify!(_xmlXPathParserContext),
"::",
stringify!(context)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).value) as usize - ptr as usize },
32usize,
concat!(
"Offset of field: ",
stringify!(_xmlXPathParserContext),
"::",
stringify!(value)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).valueNr) as usize - ptr as usize },
40usize,
concat!(
"Offset of field: ",
stringify!(_xmlXPathParserContext),
"::",
stringify!(valueNr)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).valueMax) as usize - ptr as usize },
44usize,
concat!(
"Offset of field: ",
stringify!(_xmlXPathParserContext),
"::",
stringify!(valueMax)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).valueTab) as usize - ptr as usize },
48usize,
concat!(
"Offset of field: ",
stringify!(_xmlXPathParserContext),
"::",
stringify!(valueTab)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).comp) as usize - ptr as usize },
56usize,
concat!(
"Offset of field: ",
stringify!(_xmlXPathParserContext),
"::",
stringify!(comp)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).xptr) as usize - ptr as usize },
64usize,
concat!(
"Offset of field: ",
stringify!(_xmlXPathParserContext),
"::",
stringify!(xptr)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).ancestor) as usize - ptr as usize },
72usize,
concat!(
"Offset of field: ",
stringify!(_xmlXPathParserContext),
"::",
stringify!(ancestor)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).valueFrame) as usize - ptr as usize },
80usize,
concat!(
"Offset of field: ",
stringify!(_xmlXPathParserContext),
"::",
stringify!(valueFrame)
)
);
}
extern "C" {
pub static mut xmlXPathNAN: f64;
}
extern "C" {
pub static mut xmlXPathPINF: f64;
}
extern "C" {
pub static mut xmlXPathNINF: f64;
}
extern "C" {
pub fn xmlXPathFreeObject(obj: xmlXPathObjectPtr);
}
extern "C" {
pub fn xmlXPathNodeSetCreate(val: xmlNodePtr) -> xmlNodeSetPtr;
}
extern "C" {
pub fn xmlXPathFreeNodeSetList(obj: xmlXPathObjectPtr);
}
extern "C" {
pub fn xmlXPathFreeNodeSet(obj: xmlNodeSetPtr);
}
extern "C" {
pub fn xmlXPathObjectCopy(val: xmlXPathObjectPtr) -> xmlXPathObjectPtr;
}
extern "C" {
pub fn xmlXPathCmpNodes(node1: xmlNodePtr, node2: xmlNodePtr) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn xmlXPathCastNumberToBoolean(val: f64) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn xmlXPathCastStringToBoolean(val: *const xmlChar) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn xmlXPathCastNodeSetToBoolean(ns: xmlNodeSetPtr) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn xmlXPathCastToBoolean(val: xmlXPathObjectPtr) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn xmlXPathCastBooleanToNumber(val: ::std::os::raw::c_int) -> f64;
}
extern "C" {
pub fn xmlXPathCastStringToNumber(val: *const xmlChar) -> f64;
}
extern "C" {
pub fn xmlXPathCastNodeToNumber(node: xmlNodePtr) -> f64;
}
extern "C" {
pub fn xmlXPathCastNodeSetToNumber(ns: xmlNodeSetPtr) -> f64;
}
extern "C" {
pub fn xmlXPathCastToNumber(val: xmlXPathObjectPtr) -> f64;
}
extern "C" {
pub fn xmlXPathCastBooleanToString(val: ::std::os::raw::c_int) -> *mut xmlChar;
}
extern "C" {
pub fn xmlXPathCastNumberToString(val: f64) -> *mut xmlChar;
}
extern "C" {
pub fn xmlXPathCastNodeToString(node: xmlNodePtr) -> *mut xmlChar;
}
extern "C" {
pub fn xmlXPathCastNodeSetToString(ns: xmlNodeSetPtr) -> *mut xmlChar;
}
extern "C" {
pub fn xmlXPathCastToString(val: xmlXPathObjectPtr) -> *mut xmlChar;
}
extern "C" {
pub fn xmlXPathConvertBoolean(val: xmlXPathObjectPtr) -> xmlXPathObjectPtr;
}
extern "C" {
pub fn xmlXPathConvertNumber(val: xmlXPathObjectPtr) -> xmlXPathObjectPtr;
}
extern "C" {
pub fn xmlXPathConvertString(val: xmlXPathObjectPtr) -> xmlXPathObjectPtr;
}
extern "C" {
pub fn xmlXPathNewContext(doc: xmlDocPtr) -> xmlXPathContextPtr;
}
extern "C" {
pub fn xmlXPathFreeContext(ctxt: xmlXPathContextPtr);
}
extern "C" {
pub fn xmlXPathContextSetCache(
ctxt: xmlXPathContextPtr,
active: ::std::os::raw::c_int,
value: ::std::os::raw::c_int,
options: ::std::os::raw::c_int,
) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn xmlXPathOrderDocElems(doc: xmlDocPtr) -> ::std::os::raw::c_long;
}
extern "C" {
pub fn xmlXPathSetContextNode(
node: xmlNodePtr,
ctx: xmlXPathContextPtr,
) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn xmlXPathNodeEval(
node: xmlNodePtr,
str_: *const xmlChar,
ctx: xmlXPathContextPtr,
) -> xmlXPathObjectPtr;
}
extern "C" {
pub fn xmlXPathEval(str_: *const xmlChar, ctx: xmlXPathContextPtr) -> xmlXPathObjectPtr;
}
extern "C" {
pub fn xmlXPathEvalExpression(
str_: *const xmlChar,
ctxt: xmlXPathContextPtr,
) -> xmlXPathObjectPtr;
}
extern "C" {
pub fn xmlXPathEvalPredicate(
ctxt: xmlXPathContextPtr,
res: xmlXPathObjectPtr,
) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn xmlXPathCompile(str_: *const xmlChar) -> xmlXPathCompExprPtr;
}
extern "C" {
pub fn xmlXPathCtxtCompile(
ctxt: xmlXPathContextPtr,
str_: *const xmlChar,
) -> xmlXPathCompExprPtr;
}
extern "C" {
pub fn xmlXPathCompiledEval(
comp: xmlXPathCompExprPtr,
ctx: xmlXPathContextPtr,
) -> xmlXPathObjectPtr;
}
extern "C" {
pub fn xmlXPathCompiledEvalToBoolean(
comp: xmlXPathCompExprPtr,
ctxt: xmlXPathContextPtr,
) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn xmlXPathFreeCompExpr(comp: xmlXPathCompExprPtr);
}
extern "C" {
pub fn xmlXPathInit();
}
extern "C" {
pub fn xmlXPathIsNaN(val: f64) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn xmlXPathIsInf(val: f64) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn xmlDebugDumpString(output: *mut FILE, str_: *const xmlChar);
}
extern "C" {
pub fn xmlDebugDumpAttr(output: *mut FILE, attr: xmlAttrPtr, depth: ::std::os::raw::c_int);
}
extern "C" {
pub fn xmlDebugDumpAttrList(output: *mut FILE, attr: xmlAttrPtr, depth: ::std::os::raw::c_int);
}
extern "C" {
pub fn xmlDebugDumpOneNode(output: *mut FILE, node: xmlNodePtr, depth: ::std::os::raw::c_int);
}
extern "C" {
pub fn xmlDebugDumpNode(output: *mut FILE, node: xmlNodePtr, depth: ::std::os::raw::c_int);
}
extern "C" {
pub fn xmlDebugDumpNodeList(output: *mut FILE, node: xmlNodePtr, depth: ::std::os::raw::c_int);
}
extern "C" {
pub fn xmlDebugDumpDocumentHead(output: *mut FILE, doc: xmlDocPtr);
}
extern "C" {
pub fn xmlDebugDumpDocument(output: *mut FILE, doc: xmlDocPtr);
}
extern "C" {
pub fn xmlDebugDumpDTD(output: *mut FILE, dtd: xmlDtdPtr);
}
extern "C" {
pub fn xmlDebugDumpEntities(output: *mut FILE, doc: xmlDocPtr);
}
extern "C" {
pub fn xmlDebugCheckDocument(output: *mut FILE, doc: xmlDocPtr) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn xmlLsOneNode(output: *mut FILE, node: xmlNodePtr);
}
extern "C" {
pub fn xmlLsCountNode(node: xmlNodePtr) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn xmlBoolToText(boolval: ::std::os::raw::c_int) -> *const ::std::os::raw::c_char;
}
pub type xmlShellReadlineFunc = ::std::option::Option<
unsafe extern "C" fn(prompt: *mut ::std::os::raw::c_char) -> *mut ::std::os::raw::c_char,
>;
pub type xmlShellCtxt = _xmlShellCtxt;
pub type xmlShellCtxtPtr = *mut xmlShellCtxt;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct _xmlShellCtxt {
pub filename: *mut ::std::os::raw::c_char,
pub doc: xmlDocPtr,
pub node: xmlNodePtr,
pub pctxt: xmlXPathContextPtr,
pub loaded: ::std::os::raw::c_int,
pub output: *mut FILE,
pub input: xmlShellReadlineFunc,
}
#[test]
fn bindgen_test_layout__xmlShellCtxt() {
const UNINIT: ::std::mem::MaybeUninit<_xmlShellCtxt> = ::std::mem::MaybeUninit::uninit();
let ptr = UNINIT.as_ptr();
assert_eq!(
::std::mem::size_of::<_xmlShellCtxt>(),
56usize,
concat!("Size of: ", stringify!(_xmlShellCtxt))
);
assert_eq!(
::std::mem::align_of::<_xmlShellCtxt>(),
8usize,
concat!("Alignment of ", stringify!(_xmlShellCtxt))
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).filename) as usize - ptr as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(_xmlShellCtxt),
"::",
stringify!(filename)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).doc) as usize - ptr as usize },
8usize,
concat!(
"Offset of field: ",
stringify!(_xmlShellCtxt),
"::",
stringify!(doc)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).node) as usize - ptr as usize },
16usize,
concat!(
"Offset of field: ",
stringify!(_xmlShellCtxt),
"::",
stringify!(node)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).pctxt) as usize - ptr as usize },
24usize,
concat!(
"Offset of field: ",
stringify!(_xmlShellCtxt),
"::",
stringify!(pctxt)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).loaded) as usize - ptr as usize },
32usize,
concat!(
"Offset of field: ",
stringify!(_xmlShellCtxt),
"::",
stringify!(loaded)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).output) as usize - ptr as usize },
40usize,
concat!(
"Offset of field: ",
stringify!(_xmlShellCtxt),
"::",
stringify!(output)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).input) as usize - ptr as usize },
48usize,
concat!(
"Offset of field: ",
stringify!(_xmlShellCtxt),
"::",
stringify!(input)
)
);
}
pub type xmlShellCmd = ::std::option::Option<
unsafe extern "C" fn(
ctxt: xmlShellCtxtPtr,
arg: *mut ::std::os::raw::c_char,
node: xmlNodePtr,
node2: xmlNodePtr,
) -> ::std::os::raw::c_int,
>;
extern "C" {
pub fn xmlShellPrintXPathError(
errorType: ::std::os::raw::c_int,
arg: *const ::std::os::raw::c_char,
);
}
extern "C" {
pub fn xmlShellPrintXPathResult(list: xmlXPathObjectPtr);
}
extern "C" {
pub fn xmlShellList(
ctxt: xmlShellCtxtPtr,
arg: *mut ::std::os::raw::c_char,
node: xmlNodePtr,
node2: xmlNodePtr,
) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn xmlShellBase(
ctxt: xmlShellCtxtPtr,
arg: *mut ::std::os::raw::c_char,
node: xmlNodePtr,
node2: xmlNodePtr,
) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn xmlShellDir(
ctxt: xmlShellCtxtPtr,
arg: *mut ::std::os::raw::c_char,
node: xmlNodePtr,
node2: xmlNodePtr,
) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn xmlShellLoad(
ctxt: xmlShellCtxtPtr,
filename: *mut ::std::os::raw::c_char,
node: xmlNodePtr,
node2: xmlNodePtr,
) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn xmlShellPrintNode(node: xmlNodePtr);
}
extern "C" {
pub fn xmlShellCat(
ctxt: xmlShellCtxtPtr,
arg: *mut ::std::os::raw::c_char,
node: xmlNodePtr,
node2: xmlNodePtr,
) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn xmlShellWrite(
ctxt: xmlShellCtxtPtr,
filename: *mut ::std::os::raw::c_char,
node: xmlNodePtr,
node2: xmlNodePtr,
) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn xmlShellSave(
ctxt: xmlShellCtxtPtr,
filename: *mut ::std::os::raw::c_char,
node: xmlNodePtr,
node2: xmlNodePtr,
) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn xmlShellValidate(
ctxt: xmlShellCtxtPtr,
dtd: *mut ::std::os::raw::c_char,
node: xmlNodePtr,
node2: xmlNodePtr,
) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn xmlShellDu(
ctxt: xmlShellCtxtPtr,
arg: *mut ::std::os::raw::c_char,
tree: xmlNodePtr,
node2: xmlNodePtr,
) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn xmlShellPwd(
ctxt: xmlShellCtxtPtr,
buffer: *mut ::std::os::raw::c_char,
node: xmlNodePtr,
node2: xmlNodePtr,
) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn xmlShell(
doc: xmlDocPtr,
filename: *mut ::std::os::raw::c_char,
input: xmlShellReadlineFunc,
output: *mut FILE,
);
}
pub type xmlChSRange = _xmlChSRange;
pub type xmlChSRangePtr = *mut xmlChSRange;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct _xmlChSRange {
pub low: ::std::os::raw::c_ushort,
pub high: ::std::os::raw::c_ushort,
}
#[test]
fn bindgen_test_layout__xmlChSRange() {
const UNINIT: ::std::mem::MaybeUninit<_xmlChSRange> = ::std::mem::MaybeUninit::uninit();
let ptr = UNINIT.as_ptr();
assert_eq!(
::std::mem::size_of::<_xmlChSRange>(),
4usize,
concat!("Size of: ", stringify!(_xmlChSRange))
);
assert_eq!(
::std::mem::align_of::<_xmlChSRange>(),
2usize,
concat!("Alignment of ", stringify!(_xmlChSRange))
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).low) as usize - ptr as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(_xmlChSRange),
"::",
stringify!(low)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).high) as usize - ptr as usize },
2usize,
concat!(
"Offset of field: ",
stringify!(_xmlChSRange),
"::",
stringify!(high)
)
);
}
pub type xmlChLRange = _xmlChLRange;
pub type xmlChLRangePtr = *mut xmlChLRange;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct _xmlChLRange {
pub low: ::std::os::raw::c_uint,
pub high: ::std::os::raw::c_uint,
}
#[test]
fn bindgen_test_layout__xmlChLRange() {
const UNINIT: ::std::mem::MaybeUninit<_xmlChLRange> = ::std::mem::MaybeUninit::uninit();
let ptr = UNINIT.as_ptr();
assert_eq!(
::std::mem::size_of::<_xmlChLRange>(),
8usize,
concat!("Size of: ", stringify!(_xmlChLRange))
);
assert_eq!(
::std::mem::align_of::<_xmlChLRange>(),
4usize,
concat!("Alignment of ", stringify!(_xmlChLRange))
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).low) as usize - ptr as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(_xmlChLRange),
"::",
stringify!(low)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).high) as usize - ptr as usize },
4usize,
concat!(
"Offset of field: ",
stringify!(_xmlChLRange),
"::",
stringify!(high)
)
);
}
pub type xmlChRangeGroup = _xmlChRangeGroup;
pub type xmlChRangeGroupPtr = *mut xmlChRangeGroup;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct _xmlChRangeGroup {
pub nbShortRange: ::std::os::raw::c_int,
pub nbLongRange: ::std::os::raw::c_int,
pub shortRange: *const xmlChSRange,
pub longRange: *const xmlChLRange,
}
#[test]
fn bindgen_test_layout__xmlChRangeGroup() {
const UNINIT: ::std::mem::MaybeUninit<_xmlChRangeGroup> = ::std::mem::MaybeUninit::uninit();
let ptr = UNINIT.as_ptr();
assert_eq!(
::std::mem::size_of::<_xmlChRangeGroup>(),
24usize,
concat!("Size of: ", stringify!(_xmlChRangeGroup))
);
assert_eq!(
::std::mem::align_of::<_xmlChRangeGroup>(),
8usize,
concat!("Alignment of ", stringify!(_xmlChRangeGroup))
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).nbShortRange) as usize - ptr as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(_xmlChRangeGroup),
"::",
stringify!(nbShortRange)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).nbLongRange) as usize - ptr as usize },
4usize,
concat!(
"Offset of field: ",
stringify!(_xmlChRangeGroup),
"::",
stringify!(nbLongRange)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).shortRange) as usize - ptr as usize },
8usize,
concat!(
"Offset of field: ",
stringify!(_xmlChRangeGroup),
"::",
stringify!(shortRange)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).longRange) as usize - ptr as usize },
16usize,
concat!(
"Offset of field: ",
stringify!(_xmlChRangeGroup),
"::",
stringify!(longRange)
)
);
}
extern "C" {
pub fn xmlCharInRange(
val: ::std::os::raw::c_uint,
group: *const xmlChRangeGroup,
) -> ::std::os::raw::c_int;
}
extern "C" {
pub static xmlIsBaseCharGroup: xmlChRangeGroup;
}
extern "C" {
pub static xmlIsCharGroup: xmlChRangeGroup;
}
extern "C" {
pub static xmlIsCombiningGroup: xmlChRangeGroup;
}
extern "C" {
pub static xmlIsDigitGroup: xmlChRangeGroup;
}
extern "C" {
pub static xmlIsExtenderGroup: xmlChRangeGroup;
}
extern "C" {
pub static xmlIsIdeographicGroup: xmlChRangeGroup;
}
extern "C" {
pub static xmlIsPubidChar_tab: [::std::os::raw::c_uchar; 256usize];
}
extern "C" {
pub fn xmlIsBaseChar(ch: ::std::os::raw::c_uint) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn xmlIsBlank(ch: ::std::os::raw::c_uint) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn xmlIsChar(ch: ::std::os::raw::c_uint) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn xmlIsCombining(ch: ::std::os::raw::c_uint) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn xmlIsDigit(ch: ::std::os::raw::c_uint) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn xmlIsExtender(ch: ::std::os::raw::c_uint) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn xmlIsIdeographic(ch: ::std::os::raw::c_uint) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn xmlIsPubidChar(ch: ::std::os::raw::c_uint) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn xmlXPtrNewContext(
doc: xmlDocPtr,
here: xmlNodePtr,
origin: xmlNodePtr,
) -> xmlXPathContextPtr;
}
extern "C" {
pub fn xmlXPtrEval(str_: *const xmlChar, ctx: xmlXPathContextPtr) -> xmlXPathObjectPtr;
}
pub const xmlSchematronValidOptions_XML_SCHEMATRON_OUT_QUIET: xmlSchematronValidOptions = 1;
pub const xmlSchematronValidOptions_XML_SCHEMATRON_OUT_TEXT: xmlSchematronValidOptions = 2;
pub const xmlSchematronValidOptions_XML_SCHEMATRON_OUT_XML: xmlSchematronValidOptions = 4;
pub const xmlSchematronValidOptions_XML_SCHEMATRON_OUT_ERROR: xmlSchematronValidOptions = 8;
pub const xmlSchematronValidOptions_XML_SCHEMATRON_OUT_FILE: xmlSchematronValidOptions = 256;
pub const xmlSchematronValidOptions_XML_SCHEMATRON_OUT_BUFFER: xmlSchematronValidOptions = 512;
pub const xmlSchematronValidOptions_XML_SCHEMATRON_OUT_IO: xmlSchematronValidOptions = 1024;
pub type xmlSchematronValidOptions = ::std::os::raw::c_uint;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct _xmlSchematron {
_unused: [u8; 0],
}
pub type xmlSchematron = _xmlSchematron;
pub type xmlSchematronPtr = *mut xmlSchematron;
pub type xmlSchematronValidityErrorFunc = ::std::option::Option<
unsafe extern "C" fn(ctx: *mut ::std::os::raw::c_void, msg: *const ::std::os::raw::c_char, ...),
>;
pub type xmlSchematronValidityWarningFunc = ::std::option::Option<
unsafe extern "C" fn(ctx: *mut ::std::os::raw::c_void, msg: *const ::std::os::raw::c_char, ...),
>;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct _xmlSchematronParserCtxt {
_unused: [u8; 0],
}
pub type xmlSchematronParserCtxt = _xmlSchematronParserCtxt;
pub type xmlSchematronParserCtxtPtr = *mut xmlSchematronParserCtxt;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct _xmlSchematronValidCtxt {
_unused: [u8; 0],
}
pub type xmlSchematronValidCtxt = _xmlSchematronValidCtxt;
pub type xmlSchematronValidCtxtPtr = *mut xmlSchematronValidCtxt;
extern "C" {
pub fn xmlSchematronNewParserCtxt(
URL: *const ::std::os::raw::c_char,
) -> xmlSchematronParserCtxtPtr;
}
extern "C" {
pub fn xmlSchematronNewMemParserCtxt(
buffer: *const ::std::os::raw::c_char,
size: ::std::os::raw::c_int,
) -> xmlSchematronParserCtxtPtr;
}
extern "C" {
pub fn xmlSchematronNewDocParserCtxt(doc: xmlDocPtr) -> xmlSchematronParserCtxtPtr;
}
extern "C" {
pub fn xmlSchematronFreeParserCtxt(ctxt: xmlSchematronParserCtxtPtr);
}
extern "C" {
pub fn xmlSchematronParse(ctxt: xmlSchematronParserCtxtPtr) -> xmlSchematronPtr;
}
extern "C" {
pub fn xmlSchematronFree(schema: xmlSchematronPtr);
}
extern "C" {
pub fn xmlSchematronSetValidStructuredErrors(
ctxt: xmlSchematronValidCtxtPtr,
serror: xmlStructuredErrorFunc,
ctx: *mut ::std::os::raw::c_void,
);
}
extern "C" {
pub fn xmlSchematronNewValidCtxt(
schema: xmlSchematronPtr,
options: ::std::os::raw::c_int,
) -> xmlSchematronValidCtxtPtr;
}
extern "C" {
pub fn xmlSchematronFreeValidCtxt(ctxt: xmlSchematronValidCtxtPtr);
}
extern "C" {
pub fn xmlSchematronValidateDoc(
ctxt: xmlSchematronValidCtxtPtr,
instance: xmlDocPtr,
) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn xmlXPathPopBoolean(ctxt: xmlXPathParserContextPtr) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn xmlXPathPopNumber(ctxt: xmlXPathParserContextPtr) -> f64;
}
extern "C" {
pub fn xmlXPathPopString(ctxt: xmlXPathParserContextPtr) -> *mut xmlChar;
}
extern "C" {
pub fn xmlXPathPopNodeSet(ctxt: xmlXPathParserContextPtr) -> xmlNodeSetPtr;
}
extern "C" {
pub fn xmlXPathPopExternal(ctxt: xmlXPathParserContextPtr) -> *mut ::std::os::raw::c_void;
}
extern "C" {
pub fn xmlXPathRegisterVariableLookup(
ctxt: xmlXPathContextPtr,
f: xmlXPathVariableLookupFunc,
data: *mut ::std::os::raw::c_void,
);
}
extern "C" {
pub fn xmlXPathRegisterFuncLookup(
ctxt: xmlXPathContextPtr,
f: xmlXPathFuncLookupFunc,
funcCtxt: *mut ::std::os::raw::c_void,
);
}
extern "C" {
pub fn xmlXPatherror(
ctxt: xmlXPathParserContextPtr,
file: *const ::std::os::raw::c_char,
line: ::std::os::raw::c_int,
no: ::std::os::raw::c_int,
);
}
extern "C" {
pub fn xmlXPathErr(ctxt: xmlXPathParserContextPtr, error: ::std::os::raw::c_int);
}
extern "C" {
pub fn xmlXPathDebugDumpObject(
output: *mut FILE,
cur: xmlXPathObjectPtr,
depth: ::std::os::raw::c_int,
);
}
extern "C" {
pub fn xmlXPathDebugDumpCompExpr(
output: *mut FILE,
comp: xmlXPathCompExprPtr,
depth: ::std::os::raw::c_int,
);
}
extern "C" {
pub fn xmlXPathNodeSetContains(cur: xmlNodeSetPtr, val: xmlNodePtr) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn xmlXPathDifference(nodes1: xmlNodeSetPtr, nodes2: xmlNodeSetPtr) -> xmlNodeSetPtr;
}
extern "C" {
pub fn xmlXPathIntersection(nodes1: xmlNodeSetPtr, nodes2: xmlNodeSetPtr) -> xmlNodeSetPtr;
}
extern "C" {
pub fn xmlXPathDistinctSorted(nodes: xmlNodeSetPtr) -> xmlNodeSetPtr;
}
extern "C" {
pub fn xmlXPathDistinct(nodes: xmlNodeSetPtr) -> xmlNodeSetPtr;
}
extern "C" {
pub fn xmlXPathHasSameNodes(
nodes1: xmlNodeSetPtr,
nodes2: xmlNodeSetPtr,
) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn xmlXPathNodeLeadingSorted(nodes: xmlNodeSetPtr, node: xmlNodePtr) -> xmlNodeSetPtr;
}
extern "C" {
pub fn xmlXPathLeadingSorted(nodes1: xmlNodeSetPtr, nodes2: xmlNodeSetPtr) -> xmlNodeSetPtr;
}
extern "C" {
pub fn xmlXPathNodeLeading(nodes: xmlNodeSetPtr, node: xmlNodePtr) -> xmlNodeSetPtr;
}
extern "C" {
pub fn xmlXPathLeading(nodes1: xmlNodeSetPtr, nodes2: xmlNodeSetPtr) -> xmlNodeSetPtr;
}
extern "C" {
pub fn xmlXPathNodeTrailingSorted(nodes: xmlNodeSetPtr, node: xmlNodePtr) -> xmlNodeSetPtr;
}
extern "C" {
pub fn xmlXPathTrailingSorted(nodes1: xmlNodeSetPtr, nodes2: xmlNodeSetPtr) -> xmlNodeSetPtr;
}
extern "C" {
pub fn xmlXPathNodeTrailing(nodes: xmlNodeSetPtr, node: xmlNodePtr) -> xmlNodeSetPtr;
}
extern "C" {
pub fn xmlXPathTrailing(nodes1: xmlNodeSetPtr, nodes2: xmlNodeSetPtr) -> xmlNodeSetPtr;
}
extern "C" {
pub fn xmlXPathRegisterNs(
ctxt: xmlXPathContextPtr,
prefix: *const xmlChar,
ns_uri: *const xmlChar,
) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn xmlXPathNsLookup(ctxt: xmlXPathContextPtr, prefix: *const xmlChar) -> *const xmlChar;
}
extern "C" {
pub fn xmlXPathRegisteredNsCleanup(ctxt: xmlXPathContextPtr);
}
extern "C" {
pub fn xmlXPathRegisterFunc(
ctxt: xmlXPathContextPtr,
name: *const xmlChar,
f: xmlXPathFunction,
) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn xmlXPathRegisterFuncNS(
ctxt: xmlXPathContextPtr,
name: *const xmlChar,
ns_uri: *const xmlChar,
f: xmlXPathFunction,
) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn xmlXPathRegisterVariable(
ctxt: xmlXPathContextPtr,
name: *const xmlChar,
value: xmlXPathObjectPtr,
) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn xmlXPathRegisterVariableNS(
ctxt: xmlXPathContextPtr,
name: *const xmlChar,
ns_uri: *const xmlChar,
value: xmlXPathObjectPtr,
) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn xmlXPathFunctionLookup(
ctxt: xmlXPathContextPtr,
name: *const xmlChar,
) -> xmlXPathFunction;
}
extern "C" {
pub fn xmlXPathFunctionLookupNS(
ctxt: xmlXPathContextPtr,
name: *const xmlChar,
ns_uri: *const xmlChar,
) -> xmlXPathFunction;
}
extern "C" {
pub fn xmlXPathRegisteredFuncsCleanup(ctxt: xmlXPathContextPtr);
}
extern "C" {
pub fn xmlXPathVariableLookup(
ctxt: xmlXPathContextPtr,
name: *const xmlChar,
) -> xmlXPathObjectPtr;
}
extern "C" {
pub fn xmlXPathVariableLookupNS(
ctxt: xmlXPathContextPtr,
name: *const xmlChar,
ns_uri: *const xmlChar,
) -> xmlXPathObjectPtr;
}
extern "C" {
pub fn xmlXPathRegisteredVariablesCleanup(ctxt: xmlXPathContextPtr);
}
extern "C" {
pub fn xmlXPathNewParserContext(
str_: *const xmlChar,
ctxt: xmlXPathContextPtr,
) -> xmlXPathParserContextPtr;
}
extern "C" {
pub fn xmlXPathFreeParserContext(ctxt: xmlXPathParserContextPtr);
}
extern "C" {
pub fn valuePop(ctxt: xmlXPathParserContextPtr) -> xmlXPathObjectPtr;
}
extern "C" {
pub fn valuePush(
ctxt: xmlXPathParserContextPtr,
value: xmlXPathObjectPtr,
) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn xmlXPathNewString(val: *const xmlChar) -> xmlXPathObjectPtr;
}
extern "C" {
pub fn xmlXPathNewCString(val: *const ::std::os::raw::c_char) -> xmlXPathObjectPtr;
}
extern "C" {
pub fn xmlXPathWrapString(val: *mut xmlChar) -> xmlXPathObjectPtr;
}
extern "C" {
pub fn xmlXPathWrapCString(val: *mut ::std::os::raw::c_char) -> xmlXPathObjectPtr;
}
extern "C" {
pub fn xmlXPathNewFloat(val: f64) -> xmlXPathObjectPtr;
}
extern "C" {
pub fn xmlXPathNewBoolean(val: ::std::os::raw::c_int) -> xmlXPathObjectPtr;
}
extern "C" {
pub fn xmlXPathNewNodeSet(val: xmlNodePtr) -> xmlXPathObjectPtr;
}
extern "C" {
pub fn xmlXPathNewValueTree(val: xmlNodePtr) -> xmlXPathObjectPtr;
}
extern "C" {
pub fn xmlXPathNodeSetAdd(cur: xmlNodeSetPtr, val: xmlNodePtr) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn xmlXPathNodeSetAddUnique(cur: xmlNodeSetPtr, val: xmlNodePtr) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn xmlXPathNodeSetAddNs(
cur: xmlNodeSetPtr,
node: xmlNodePtr,
ns: xmlNsPtr,
) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn xmlXPathNodeSetSort(set: xmlNodeSetPtr);
}
extern "C" {
pub fn xmlXPathRoot(ctxt: xmlXPathParserContextPtr);
}
extern "C" {
pub fn xmlXPathEvalExpr(ctxt: xmlXPathParserContextPtr);
}
extern "C" {
pub fn xmlXPathParseName(ctxt: xmlXPathParserContextPtr) -> *mut xmlChar;
}
extern "C" {
pub fn xmlXPathParseNCName(ctxt: xmlXPathParserContextPtr) -> *mut xmlChar;
}
extern "C" {
pub fn xmlXPathStringEvalNumber(str_: *const xmlChar) -> f64;
}
extern "C" {
pub fn xmlXPathEvaluatePredicateResult(
ctxt: xmlXPathParserContextPtr,
res: xmlXPathObjectPtr,
) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn xmlXPathRegisterAllFunctions(ctxt: xmlXPathContextPtr);
}
extern "C" {
pub fn xmlXPathNodeSetMerge(val1: xmlNodeSetPtr, val2: xmlNodeSetPtr) -> xmlNodeSetPtr;
}
extern "C" {
pub fn xmlXPathNodeSetDel(cur: xmlNodeSetPtr, val: xmlNodePtr);
}
extern "C" {
pub fn xmlXPathNodeSetRemove(cur: xmlNodeSetPtr, val: ::std::os::raw::c_int);
}
extern "C" {
pub fn xmlXPathNewNodeSetList(val: xmlNodeSetPtr) -> xmlXPathObjectPtr;
}
extern "C" {
pub fn xmlXPathWrapNodeSet(val: xmlNodeSetPtr) -> xmlXPathObjectPtr;
}
extern "C" {
pub fn xmlXPathWrapExternal(val: *mut ::std::os::raw::c_void) -> xmlXPathObjectPtr;
}
extern "C" {
pub fn xmlXPathEqualValues(ctxt: xmlXPathParserContextPtr) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn xmlXPathNotEqualValues(ctxt: xmlXPathParserContextPtr) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn xmlXPathCompareValues(
ctxt: xmlXPathParserContextPtr,
inf: ::std::os::raw::c_int,
strict: ::std::os::raw::c_int,
) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn xmlXPathValueFlipSign(ctxt: xmlXPathParserContextPtr);
}
extern "C" {
pub fn xmlXPathAddValues(ctxt: xmlXPathParserContextPtr);
}
extern "C" {
pub fn xmlXPathSubValues(ctxt: xmlXPathParserContextPtr);
}
extern "C" {
pub fn xmlXPathMultValues(ctxt: xmlXPathParserContextPtr);
}
extern "C" {
pub fn xmlXPathDivValues(ctxt: xmlXPathParserContextPtr);
}
extern "C" {
pub fn xmlXPathModValues(ctxt: xmlXPathParserContextPtr);
}
extern "C" {
pub fn xmlXPathIsNodeType(name: *const xmlChar) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn xmlXPathNextSelf(ctxt: xmlXPathParserContextPtr, cur: xmlNodePtr) -> xmlNodePtr;
}
extern "C" {
pub fn xmlXPathNextChild(ctxt: xmlXPathParserContextPtr, cur: xmlNodePtr) -> xmlNodePtr;
}
extern "C" {
pub fn xmlXPathNextDescendant(ctxt: xmlXPathParserContextPtr, cur: xmlNodePtr) -> xmlNodePtr;
}
extern "C" {
pub fn xmlXPathNextDescendantOrSelf(
ctxt: xmlXPathParserContextPtr,
cur: xmlNodePtr,
) -> xmlNodePtr;
}
extern "C" {
pub fn xmlXPathNextParent(ctxt: xmlXPathParserContextPtr, cur: xmlNodePtr) -> xmlNodePtr;
}
extern "C" {
pub fn xmlXPathNextAncestorOrSelf(
ctxt: xmlXPathParserContextPtr,
cur: xmlNodePtr,
) -> xmlNodePtr;
}
extern "C" {
pub fn xmlXPathNextFollowingSibling(
ctxt: xmlXPathParserContextPtr,
cur: xmlNodePtr,
) -> xmlNodePtr;
}
extern "C" {
pub fn xmlXPathNextFollowing(ctxt: xmlXPathParserContextPtr, cur: xmlNodePtr) -> xmlNodePtr;
}
extern "C" {
pub fn xmlXPathNextNamespace(ctxt: xmlXPathParserContextPtr, cur: xmlNodePtr) -> xmlNodePtr;
}
extern "C" {
pub fn xmlXPathNextAttribute(ctxt: xmlXPathParserContextPtr, cur: xmlNodePtr) -> xmlNodePtr;
}
extern "C" {
pub fn xmlXPathNextPreceding(ctxt: xmlXPathParserContextPtr, cur: xmlNodePtr) -> xmlNodePtr;
}
extern "C" {
pub fn xmlXPathNextAncestor(ctxt: xmlXPathParserContextPtr, cur: xmlNodePtr) -> xmlNodePtr;
}
extern "C" {
pub fn xmlXPathNextPrecedingSibling(
ctxt: xmlXPathParserContextPtr,
cur: xmlNodePtr,
) -> xmlNodePtr;
}
extern "C" {
pub fn xmlXPathLastFunction(ctxt: xmlXPathParserContextPtr, nargs: ::std::os::raw::c_int);
}
extern "C" {
pub fn xmlXPathPositionFunction(ctxt: xmlXPathParserContextPtr, nargs: ::std::os::raw::c_int);
}
extern "C" {
pub fn xmlXPathCountFunction(ctxt: xmlXPathParserContextPtr, nargs: ::std::os::raw::c_int);
}
extern "C" {
pub fn xmlXPathIdFunction(ctxt: xmlXPathParserContextPtr, nargs: ::std::os::raw::c_int);
}
extern "C" {
pub fn xmlXPathLocalNameFunction(ctxt: xmlXPathParserContextPtr, nargs: ::std::os::raw::c_int);
}
extern "C" {
pub fn xmlXPathNamespaceURIFunction(
ctxt: xmlXPathParserContextPtr,
nargs: ::std::os::raw::c_int,
);
}
extern "C" {
pub fn xmlXPathStringFunction(ctxt: xmlXPathParserContextPtr, nargs: ::std::os::raw::c_int);
}
extern "C" {
pub fn xmlXPathStringLengthFunction(
ctxt: xmlXPathParserContextPtr,
nargs: ::std::os::raw::c_int,
);
}
extern "C" {
pub fn xmlXPathConcatFunction(ctxt: xmlXPathParserContextPtr, nargs: ::std::os::raw::c_int);
}
extern "C" {
pub fn xmlXPathContainsFunction(ctxt: xmlXPathParserContextPtr, nargs: ::std::os::raw::c_int);
}
extern "C" {
pub fn xmlXPathStartsWithFunction(ctxt: xmlXPathParserContextPtr, nargs: ::std::os::raw::c_int);
}
extern "C" {
pub fn xmlXPathSubstringFunction(ctxt: xmlXPathParserContextPtr, nargs: ::std::os::raw::c_int);
}
extern "C" {
pub fn xmlXPathSubstringBeforeFunction(
ctxt: xmlXPathParserContextPtr,
nargs: ::std::os::raw::c_int,
);
}
extern "C" {
pub fn xmlXPathSubstringAfterFunction(
ctxt: xmlXPathParserContextPtr,
nargs: ::std::os::raw::c_int,
);
}
extern "C" {
pub fn xmlXPathNormalizeFunction(ctxt: xmlXPathParserContextPtr, nargs: ::std::os::raw::c_int);
}
extern "C" {
pub fn xmlXPathTranslateFunction(ctxt: xmlXPathParserContextPtr, nargs: ::std::os::raw::c_int);
}
extern "C" {
pub fn xmlXPathNotFunction(ctxt: xmlXPathParserContextPtr, nargs: ::std::os::raw::c_int);
}
extern "C" {
pub fn xmlXPathTrueFunction(ctxt: xmlXPathParserContextPtr, nargs: ::std::os::raw::c_int);
}
extern "C" {
pub fn xmlXPathFalseFunction(ctxt: xmlXPathParserContextPtr, nargs: ::std::os::raw::c_int);
}
extern "C" {
pub fn xmlXPathLangFunction(ctxt: xmlXPathParserContextPtr, nargs: ::std::os::raw::c_int);
}
extern "C" {
pub fn xmlXPathNumberFunction(ctxt: xmlXPathParserContextPtr, nargs: ::std::os::raw::c_int);
}
extern "C" {
pub fn xmlXPathSumFunction(ctxt: xmlXPathParserContextPtr, nargs: ::std::os::raw::c_int);
}
extern "C" {
pub fn xmlXPathFloorFunction(ctxt: xmlXPathParserContextPtr, nargs: ::std::os::raw::c_int);
}
extern "C" {
pub fn xmlXPathCeilingFunction(ctxt: xmlXPathParserContextPtr, nargs: ::std::os::raw::c_int);
}
extern "C" {
pub fn xmlXPathRoundFunction(ctxt: xmlXPathParserContextPtr, nargs: ::std::os::raw::c_int);
}
extern "C" {
pub fn xmlXPathBooleanFunction(ctxt: xmlXPathParserContextPtr, nargs: ::std::os::raw::c_int);
}
extern "C" {
pub fn xmlXPathNodeSetFreeNs(ns: xmlNsPtr);
}
pub type xmlURI = _xmlURI;
pub type xmlURIPtr = *mut xmlURI;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct _xmlURI {
pub scheme: *mut ::std::os::raw::c_char,
pub opaque: *mut ::std::os::raw::c_char,
pub authority: *mut ::std::os::raw::c_char,
pub server: *mut ::std::os::raw::c_char,
pub user: *mut ::std::os::raw::c_char,
pub port: ::std::os::raw::c_int,
pub path: *mut ::std::os::raw::c_char,
pub query: *mut ::std::os::raw::c_char,
pub fragment: *mut ::std::os::raw::c_char,
pub cleanup: ::std::os::raw::c_int,
pub query_raw: *mut ::std::os::raw::c_char,
}
#[test]
fn bindgen_test_layout__xmlURI() {
const UNINIT: ::std::mem::MaybeUninit<_xmlURI> = ::std::mem::MaybeUninit::uninit();
let ptr = UNINIT.as_ptr();
assert_eq!(
::std::mem::size_of::<_xmlURI>(),
88usize,
concat!("Size of: ", stringify!(_xmlURI))
);
assert_eq!(
::std::mem::align_of::<_xmlURI>(),
8usize,
concat!("Alignment of ", stringify!(_xmlURI))
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).scheme) as usize - ptr as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(_xmlURI),
"::",
stringify!(scheme)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).opaque) as usize - ptr as usize },
8usize,
concat!(
"Offset of field: ",
stringify!(_xmlURI),
"::",
stringify!(opaque)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).authority) as usize - ptr as usize },
16usize,
concat!(
"Offset of field: ",
stringify!(_xmlURI),
"::",
stringify!(authority)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).server) as usize - ptr as usize },
24usize,
concat!(
"Offset of field: ",
stringify!(_xmlURI),
"::",
stringify!(server)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).user) as usize - ptr as usize },
32usize,
concat!(
"Offset of field: ",
stringify!(_xmlURI),
"::",
stringify!(user)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).port) as usize - ptr as usize },
40usize,
concat!(
"Offset of field: ",
stringify!(_xmlURI),
"::",
stringify!(port)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).path) as usize - ptr as usize },
48usize,
concat!(
"Offset of field: ",
stringify!(_xmlURI),
"::",
stringify!(path)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).query) as usize - ptr as usize },
56usize,
concat!(
"Offset of field: ",
stringify!(_xmlURI),
"::",
stringify!(query)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).fragment) as usize - ptr as usize },
64usize,
concat!(
"Offset of field: ",
stringify!(_xmlURI),
"::",
stringify!(fragment)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).cleanup) as usize - ptr as usize },
72usize,
concat!(
"Offset of field: ",
stringify!(_xmlURI),
"::",
stringify!(cleanup)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).query_raw) as usize - ptr as usize },
80usize,
concat!(
"Offset of field: ",
stringify!(_xmlURI),
"::",
stringify!(query_raw)
)
);
}
extern "C" {
pub fn xmlCreateURI() -> xmlURIPtr;
}
extern "C" {
pub fn xmlBuildURI(URI: *const xmlChar, base: *const xmlChar) -> *mut xmlChar;
}
extern "C" {
pub fn xmlBuildRelativeURI(URI: *const xmlChar, base: *const xmlChar) -> *mut xmlChar;
}
extern "C" {
pub fn xmlParseURI(str_: *const ::std::os::raw::c_char) -> xmlURIPtr;
}
extern "C" {
pub fn xmlParseURIRaw(
str_: *const ::std::os::raw::c_char,
raw: ::std::os::raw::c_int,
) -> xmlURIPtr;
}
extern "C" {
pub fn xmlParseURIReference(
uri: xmlURIPtr,
str_: *const ::std::os::raw::c_char,
) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn xmlSaveUri(uri: xmlURIPtr) -> *mut xmlChar;
}
extern "C" {
pub fn xmlPrintURI(stream: *mut FILE, uri: xmlURIPtr);
}
extern "C" {
pub fn xmlURIEscapeStr(str_: *const xmlChar, list: *const xmlChar) -> *mut xmlChar;
}
extern "C" {
pub fn xmlURIUnescapeString(
str_: *const ::std::os::raw::c_char,
len: ::std::os::raw::c_int,
target: *mut ::std::os::raw::c_char,
) -> *mut ::std::os::raw::c_char;
}
extern "C" {
pub fn xmlNormalizeURIPath(path: *mut ::std::os::raw::c_char) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn xmlURIEscape(str_: *const xmlChar) -> *mut xmlChar;
}
extern "C" {
pub fn xmlFreeURI(uri: xmlURIPtr);
}
extern "C" {
pub fn xmlCanonicPath(path: *const xmlChar) -> *mut xmlChar;
}
extern "C" {
pub fn xmlPathToURI(path: *const xmlChar) -> *mut xmlChar;
}
pub const xmlSchemaValType_XML_SCHEMAS_UNKNOWN: xmlSchemaValType = 0;
pub const xmlSchemaValType_XML_SCHEMAS_STRING: xmlSchemaValType = 1;
pub const xmlSchemaValType_XML_SCHEMAS_NORMSTRING: xmlSchemaValType = 2;
pub const xmlSchemaValType_XML_SCHEMAS_DECIMAL: xmlSchemaValType = 3;
pub const xmlSchemaValType_XML_SCHEMAS_TIME: xmlSchemaValType = 4;
pub const xmlSchemaValType_XML_SCHEMAS_GDAY: xmlSchemaValType = 5;
pub const xmlSchemaValType_XML_SCHEMAS_GMONTH: xmlSchemaValType = 6;
pub const xmlSchemaValType_XML_SCHEMAS_GMONTHDAY: xmlSchemaValType = 7;
pub const xmlSchemaValType_XML_SCHEMAS_GYEAR: xmlSchemaValType = 8;
pub const xmlSchemaValType_XML_SCHEMAS_GYEARMONTH: xmlSchemaValType = 9;
pub const xmlSchemaValType_XML_SCHEMAS_DATE: xmlSchemaValType = 10;
pub const xmlSchemaValType_XML_SCHEMAS_DATETIME: xmlSchemaValType = 11;
pub const xmlSchemaValType_XML_SCHEMAS_DURATION: xmlSchemaValType = 12;
pub const xmlSchemaValType_XML_SCHEMAS_FLOAT: xmlSchemaValType = 13;
pub const xmlSchemaValType_XML_SCHEMAS_DOUBLE: xmlSchemaValType = 14;
pub const xmlSchemaValType_XML_SCHEMAS_BOOLEAN: xmlSchemaValType = 15;
pub const xmlSchemaValType_XML_SCHEMAS_TOKEN: xmlSchemaValType = 16;
pub const xmlSchemaValType_XML_SCHEMAS_LANGUAGE: xmlSchemaValType = 17;
pub const xmlSchemaValType_XML_SCHEMAS_NMTOKEN: xmlSchemaValType = 18;
pub const xmlSchemaValType_XML_SCHEMAS_NMTOKENS: xmlSchemaValType = 19;
pub const xmlSchemaValType_XML_SCHEMAS_NAME: xmlSchemaValType = 20;
pub const xmlSchemaValType_XML_SCHEMAS_QNAME: xmlSchemaValType = 21;
pub const xmlSchemaValType_XML_SCHEMAS_NCNAME: xmlSchemaValType = 22;
pub const xmlSchemaValType_XML_SCHEMAS_ID: xmlSchemaValType = 23;
pub const xmlSchemaValType_XML_SCHEMAS_IDREF: xmlSchemaValType = 24;
pub const xmlSchemaValType_XML_SCHEMAS_IDREFS: xmlSchemaValType = 25;
pub const xmlSchemaValType_XML_SCHEMAS_ENTITY: xmlSchemaValType = 26;
pub const xmlSchemaValType_XML_SCHEMAS_ENTITIES: xmlSchemaValType = 27;
pub const xmlSchemaValType_XML_SCHEMAS_NOTATION: xmlSchemaValType = 28;
pub const xmlSchemaValType_XML_SCHEMAS_ANYURI: xmlSchemaValType = 29;
pub const xmlSchemaValType_XML_SCHEMAS_INTEGER: xmlSchemaValType = 30;
pub const xmlSchemaValType_XML_SCHEMAS_NPINTEGER: xmlSchemaValType = 31;
pub const xmlSchemaValType_XML_SCHEMAS_NINTEGER: xmlSchemaValType = 32;
pub const xmlSchemaValType_XML_SCHEMAS_NNINTEGER: xmlSchemaValType = 33;
pub const xmlSchemaValType_XML_SCHEMAS_PINTEGER: xmlSchemaValType = 34;
pub const xmlSchemaValType_XML_SCHEMAS_INT: xmlSchemaValType = 35;
pub const xmlSchemaValType_XML_SCHEMAS_UINT: xmlSchemaValType = 36;
pub const xmlSchemaValType_XML_SCHEMAS_LONG: xmlSchemaValType = 37;
pub const xmlSchemaValType_XML_SCHEMAS_ULONG: xmlSchemaValType = 38;
pub const xmlSchemaValType_XML_SCHEMAS_SHORT: xmlSchemaValType = 39;
pub const xmlSchemaValType_XML_SCHEMAS_USHORT: xmlSchemaValType = 40;
pub const xmlSchemaValType_XML_SCHEMAS_BYTE: xmlSchemaValType = 41;
pub const xmlSchemaValType_XML_SCHEMAS_UBYTE: xmlSchemaValType = 42;
pub const xmlSchemaValType_XML_SCHEMAS_HEXBINARY: xmlSchemaValType = 43;
pub const xmlSchemaValType_XML_SCHEMAS_BASE64BINARY: xmlSchemaValType = 44;
pub const xmlSchemaValType_XML_SCHEMAS_ANYTYPE: xmlSchemaValType = 45;
pub const xmlSchemaValType_XML_SCHEMAS_ANYSIMPLETYPE: xmlSchemaValType = 46;
pub type xmlSchemaValType = ::std::os::raw::c_uint;
pub const xmlSchemaTypeType_XML_SCHEMA_TYPE_BASIC: xmlSchemaTypeType = 1;
pub const xmlSchemaTypeType_XML_SCHEMA_TYPE_ANY: xmlSchemaTypeType = 2;
pub const xmlSchemaTypeType_XML_SCHEMA_TYPE_FACET: xmlSchemaTypeType = 3;
pub const xmlSchemaTypeType_XML_SCHEMA_TYPE_SIMPLE: xmlSchemaTypeType = 4;
pub const xmlSchemaTypeType_XML_SCHEMA_TYPE_COMPLEX: xmlSchemaTypeType = 5;
pub const xmlSchemaTypeType_XML_SCHEMA_TYPE_SEQUENCE: xmlSchemaTypeType = 6;
pub const xmlSchemaTypeType_XML_SCHEMA_TYPE_CHOICE: xmlSchemaTypeType = 7;
pub const xmlSchemaTypeType_XML_SCHEMA_TYPE_ALL: xmlSchemaTypeType = 8;
pub const xmlSchemaTypeType_XML_SCHEMA_TYPE_SIMPLE_CONTENT: xmlSchemaTypeType = 9;
pub const xmlSchemaTypeType_XML_SCHEMA_TYPE_COMPLEX_CONTENT: xmlSchemaTypeType = 10;
pub const xmlSchemaTypeType_XML_SCHEMA_TYPE_UR: xmlSchemaTypeType = 11;
pub const xmlSchemaTypeType_XML_SCHEMA_TYPE_RESTRICTION: xmlSchemaTypeType = 12;
pub const xmlSchemaTypeType_XML_SCHEMA_TYPE_EXTENSION: xmlSchemaTypeType = 13;
pub const xmlSchemaTypeType_XML_SCHEMA_TYPE_ELEMENT: xmlSchemaTypeType = 14;
pub const xmlSchemaTypeType_XML_SCHEMA_TYPE_ATTRIBUTE: xmlSchemaTypeType = 15;
pub const xmlSchemaTypeType_XML_SCHEMA_TYPE_ATTRIBUTEGROUP: xmlSchemaTypeType = 16;
pub const xmlSchemaTypeType_XML_SCHEMA_TYPE_GROUP: xmlSchemaTypeType = 17;
pub const xmlSchemaTypeType_XML_SCHEMA_TYPE_NOTATION: xmlSchemaTypeType = 18;
pub const xmlSchemaTypeType_XML_SCHEMA_TYPE_LIST: xmlSchemaTypeType = 19;
pub const xmlSchemaTypeType_XML_SCHEMA_TYPE_UNION: xmlSchemaTypeType = 20;
pub const xmlSchemaTypeType_XML_SCHEMA_TYPE_ANY_ATTRIBUTE: xmlSchemaTypeType = 21;
pub const xmlSchemaTypeType_XML_SCHEMA_TYPE_IDC_UNIQUE: xmlSchemaTypeType = 22;
pub const xmlSchemaTypeType_XML_SCHEMA_TYPE_IDC_KEY: xmlSchemaTypeType = 23;
pub const xmlSchemaTypeType_XML_SCHEMA_TYPE_IDC_KEYREF: xmlSchemaTypeType = 24;
pub const xmlSchemaTypeType_XML_SCHEMA_TYPE_PARTICLE: xmlSchemaTypeType = 25;
pub const xmlSchemaTypeType_XML_SCHEMA_TYPE_ATTRIBUTE_USE: xmlSchemaTypeType = 26;
pub const xmlSchemaTypeType_XML_SCHEMA_FACET_MININCLUSIVE: xmlSchemaTypeType = 1000;
pub const xmlSchemaTypeType_XML_SCHEMA_FACET_MINEXCLUSIVE: xmlSchemaTypeType = 1001;
pub const xmlSchemaTypeType_XML_SCHEMA_FACET_MAXINCLUSIVE: xmlSchemaTypeType = 1002;
pub const xmlSchemaTypeType_XML_SCHEMA_FACET_MAXEXCLUSIVE: xmlSchemaTypeType = 1003;
pub const xmlSchemaTypeType_XML_SCHEMA_FACET_TOTALDIGITS: xmlSchemaTypeType = 1004;
pub const xmlSchemaTypeType_XML_SCHEMA_FACET_FRACTIONDIGITS: xmlSchemaTypeType = 1005;
pub const xmlSchemaTypeType_XML_SCHEMA_FACET_PATTERN: xmlSchemaTypeType = 1006;
pub const xmlSchemaTypeType_XML_SCHEMA_FACET_ENUMERATION: xmlSchemaTypeType = 1007;
pub const xmlSchemaTypeType_XML_SCHEMA_FACET_WHITESPACE: xmlSchemaTypeType = 1008;
pub const xmlSchemaTypeType_XML_SCHEMA_FACET_LENGTH: xmlSchemaTypeType = 1009;
pub const xmlSchemaTypeType_XML_SCHEMA_FACET_MAXLENGTH: xmlSchemaTypeType = 1010;
pub const xmlSchemaTypeType_XML_SCHEMA_FACET_MINLENGTH: xmlSchemaTypeType = 1011;
pub const xmlSchemaTypeType_XML_SCHEMA_EXTRA_QNAMEREF: xmlSchemaTypeType = 2000;
pub const xmlSchemaTypeType_XML_SCHEMA_EXTRA_ATTR_USE_PROHIB: xmlSchemaTypeType = 2001;
pub type xmlSchemaTypeType = ::std::os::raw::c_uint;
pub const xmlSchemaContentType_XML_SCHEMA_CONTENT_UNKNOWN: xmlSchemaContentType = 0;
pub const xmlSchemaContentType_XML_SCHEMA_CONTENT_EMPTY: xmlSchemaContentType = 1;
pub const xmlSchemaContentType_XML_SCHEMA_CONTENT_ELEMENTS: xmlSchemaContentType = 2;
pub const xmlSchemaContentType_XML_SCHEMA_CONTENT_MIXED: xmlSchemaContentType = 3;
pub const xmlSchemaContentType_XML_SCHEMA_CONTENT_SIMPLE: xmlSchemaContentType = 4;
pub const xmlSchemaContentType_XML_SCHEMA_CONTENT_MIXED_OR_ELEMENTS: xmlSchemaContentType = 5;
pub const xmlSchemaContentType_XML_SCHEMA_CONTENT_BASIC: xmlSchemaContentType = 6;
pub const xmlSchemaContentType_XML_SCHEMA_CONTENT_ANY: xmlSchemaContentType = 7;
pub type xmlSchemaContentType = ::std::os::raw::c_uint;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct _xmlSchemaVal {
_unused: [u8; 0],
}
pub type xmlSchemaVal = _xmlSchemaVal;
pub type xmlSchemaValPtr = *mut xmlSchemaVal;
pub type xmlSchemaType = _xmlSchemaType;
pub type xmlSchemaTypePtr = *mut xmlSchemaType;
pub type xmlSchemaFacet = _xmlSchemaFacet;
pub type xmlSchemaFacetPtr = *mut xmlSchemaFacet;
pub type xmlSchemaAnnot = _xmlSchemaAnnot;
pub type xmlSchemaAnnotPtr = *mut xmlSchemaAnnot;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct _xmlSchemaAnnot {
pub next: *mut _xmlSchemaAnnot,
pub content: xmlNodePtr,
}
#[test]
fn bindgen_test_layout__xmlSchemaAnnot() {
const UNINIT: ::std::mem::MaybeUninit<_xmlSchemaAnnot> = ::std::mem::MaybeUninit::uninit();
let ptr = UNINIT.as_ptr();
assert_eq!(
::std::mem::size_of::<_xmlSchemaAnnot>(),
16usize,
concat!("Size of: ", stringify!(_xmlSchemaAnnot))
);
assert_eq!(
::std::mem::align_of::<_xmlSchemaAnnot>(),
8usize,
concat!("Alignment of ", stringify!(_xmlSchemaAnnot))
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).next) as usize - ptr as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(_xmlSchemaAnnot),
"::",
stringify!(next)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).content) as usize - ptr as usize },
8usize,
concat!(
"Offset of field: ",
stringify!(_xmlSchemaAnnot),
"::",
stringify!(content)
)
);
}
pub type xmlSchemaAttribute = _xmlSchemaAttribute;
pub type xmlSchemaAttributePtr = *mut xmlSchemaAttribute;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct _xmlSchemaAttribute {
pub type_: xmlSchemaTypeType,
pub next: *mut _xmlSchemaAttribute,
pub name: *const xmlChar,
pub id: *const xmlChar,
pub ref_: *const xmlChar,
pub refNs: *const xmlChar,
pub typeName: *const xmlChar,
pub typeNs: *const xmlChar,
pub annot: xmlSchemaAnnotPtr,
pub base: xmlSchemaTypePtr,
pub occurs: ::std::os::raw::c_int,
pub defValue: *const xmlChar,
pub subtypes: xmlSchemaTypePtr,
pub node: xmlNodePtr,
pub targetNamespace: *const xmlChar,
pub flags: ::std::os::raw::c_int,
pub refPrefix: *const xmlChar,
pub defVal: xmlSchemaValPtr,
pub refDecl: xmlSchemaAttributePtr,
}
#[test]
fn bindgen_test_layout__xmlSchemaAttribute() {
const UNINIT: ::std::mem::MaybeUninit<_xmlSchemaAttribute> = ::std::mem::MaybeUninit::uninit();
let ptr = UNINIT.as_ptr();
assert_eq!(
::std::mem::size_of::<_xmlSchemaAttribute>(),
152usize,
concat!("Size of: ", stringify!(_xmlSchemaAttribute))
);
assert_eq!(
::std::mem::align_of::<_xmlSchemaAttribute>(),
8usize,
concat!("Alignment of ", stringify!(_xmlSchemaAttribute))
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).type_) as usize - ptr as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(_xmlSchemaAttribute),
"::",
stringify!(type_)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).next) as usize - ptr as usize },
8usize,
concat!(
"Offset of field: ",
stringify!(_xmlSchemaAttribute),
"::",
stringify!(next)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).name) as usize - ptr as usize },
16usize,
concat!(
"Offset of field: ",
stringify!(_xmlSchemaAttribute),
"::",
stringify!(name)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).id) as usize - ptr as usize },
24usize,
concat!(
"Offset of field: ",
stringify!(_xmlSchemaAttribute),
"::",
stringify!(id)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).ref_) as usize - ptr as usize },
32usize,
concat!(
"Offset of field: ",
stringify!(_xmlSchemaAttribute),
"::",
stringify!(ref_)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).refNs) as usize - ptr as usize },
40usize,
concat!(
"Offset of field: ",
stringify!(_xmlSchemaAttribute),
"::",
stringify!(refNs)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).typeName) as usize - ptr as usize },
48usize,
concat!(
"Offset of field: ",
stringify!(_xmlSchemaAttribute),
"::",
stringify!(typeName)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).typeNs) as usize - ptr as usize },
56usize,
concat!(
"Offset of field: ",
stringify!(_xmlSchemaAttribute),
"::",
stringify!(typeNs)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).annot) as usize - ptr as usize },
64usize,
concat!(
"Offset of field: ",
stringify!(_xmlSchemaAttribute),
"::",
stringify!(annot)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).base) as usize - ptr as usize },
72usize,
concat!(
"Offset of field: ",
stringify!(_xmlSchemaAttribute),
"::",
stringify!(base)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).occurs) as usize - ptr as usize },
80usize,
concat!(
"Offset of field: ",
stringify!(_xmlSchemaAttribute),
"::",
stringify!(occurs)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).defValue) as usize - ptr as usize },
88usize,
concat!(
"Offset of field: ",
stringify!(_xmlSchemaAttribute),
"::",
stringify!(defValue)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).subtypes) as usize - ptr as usize },
96usize,
concat!(
"Offset of field: ",
stringify!(_xmlSchemaAttribute),
"::",
stringify!(subtypes)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).node) as usize - ptr as usize },
104usize,
concat!(
"Offset of field: ",
stringify!(_xmlSchemaAttribute),
"::",
stringify!(node)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).targetNamespace) as usize - ptr as usize },
112usize,
concat!(
"Offset of field: ",
stringify!(_xmlSchemaAttribute),
"::",
stringify!(targetNamespace)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).flags) as usize - ptr as usize },
120usize,
concat!(
"Offset of field: ",
stringify!(_xmlSchemaAttribute),
"::",
stringify!(flags)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).refPrefix) as usize - ptr as usize },
128usize,
concat!(
"Offset of field: ",
stringify!(_xmlSchemaAttribute),
"::",
stringify!(refPrefix)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).defVal) as usize - ptr as usize },
136usize,
concat!(
"Offset of field: ",
stringify!(_xmlSchemaAttribute),
"::",
stringify!(defVal)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).refDecl) as usize - ptr as usize },
144usize,
concat!(
"Offset of field: ",
stringify!(_xmlSchemaAttribute),
"::",
stringify!(refDecl)
)
);
}
pub type xmlSchemaAttributeLink = _xmlSchemaAttributeLink;
pub type xmlSchemaAttributeLinkPtr = *mut xmlSchemaAttributeLink;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct _xmlSchemaAttributeLink {
pub next: *mut _xmlSchemaAttributeLink,
pub attr: *mut _xmlSchemaAttribute,
}
#[test]
fn bindgen_test_layout__xmlSchemaAttributeLink() {
const UNINIT: ::std::mem::MaybeUninit<_xmlSchemaAttributeLink> =
::std::mem::MaybeUninit::uninit();
let ptr = UNINIT.as_ptr();
assert_eq!(
::std::mem::size_of::<_xmlSchemaAttributeLink>(),
16usize,
concat!("Size of: ", stringify!(_xmlSchemaAttributeLink))
);
assert_eq!(
::std::mem::align_of::<_xmlSchemaAttributeLink>(),
8usize,
concat!("Alignment of ", stringify!(_xmlSchemaAttributeLink))
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).next) as usize - ptr as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(_xmlSchemaAttributeLink),
"::",
stringify!(next)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).attr) as usize - ptr as usize },
8usize,
concat!(
"Offset of field: ",
stringify!(_xmlSchemaAttributeLink),
"::",
stringify!(attr)
)
);
}
pub type xmlSchemaWildcardNs = _xmlSchemaWildcardNs;
pub type xmlSchemaWildcardNsPtr = *mut xmlSchemaWildcardNs;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct _xmlSchemaWildcardNs {
pub next: *mut _xmlSchemaWildcardNs,
pub value: *const xmlChar,
}
#[test]
fn bindgen_test_layout__xmlSchemaWildcardNs() {
const UNINIT: ::std::mem::MaybeUninit<_xmlSchemaWildcardNs> = ::std::mem::MaybeUninit::uninit();
let ptr = UNINIT.as_ptr();
assert_eq!(
::std::mem::size_of::<_xmlSchemaWildcardNs>(),
16usize,
concat!("Size of: ", stringify!(_xmlSchemaWildcardNs))
);
assert_eq!(
::std::mem::align_of::<_xmlSchemaWildcardNs>(),
8usize,
concat!("Alignment of ", stringify!(_xmlSchemaWildcardNs))
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).next) as usize - ptr as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(_xmlSchemaWildcardNs),
"::",
stringify!(next)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).value) as usize - ptr as usize },
8usize,
concat!(
"Offset of field: ",
stringify!(_xmlSchemaWildcardNs),
"::",
stringify!(value)
)
);
}
pub type xmlSchemaWildcard = _xmlSchemaWildcard;
pub type xmlSchemaWildcardPtr = *mut xmlSchemaWildcard;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct _xmlSchemaWildcard {
pub type_: xmlSchemaTypeType,
pub id: *const xmlChar,
pub annot: xmlSchemaAnnotPtr,
pub node: xmlNodePtr,
pub minOccurs: ::std::os::raw::c_int,
pub maxOccurs: ::std::os::raw::c_int,
pub processContents: ::std::os::raw::c_int,
pub any: ::std::os::raw::c_int,
pub nsSet: xmlSchemaWildcardNsPtr,
pub negNsSet: xmlSchemaWildcardNsPtr,
pub flags: ::std::os::raw::c_int,
}
#[test]
fn bindgen_test_layout__xmlSchemaWildcard() {
const UNINIT: ::std::mem::MaybeUninit<_xmlSchemaWildcard> = ::std::mem::MaybeUninit::uninit();
let ptr = UNINIT.as_ptr();
assert_eq!(
::std::mem::size_of::<_xmlSchemaWildcard>(),
72usize,
concat!("Size of: ", stringify!(_xmlSchemaWildcard))
);
assert_eq!(
::std::mem::align_of::<_xmlSchemaWildcard>(),
8usize,
concat!("Alignment of ", stringify!(_xmlSchemaWildcard))
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).type_) as usize - ptr as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(_xmlSchemaWildcard),
"::",
stringify!(type_)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).id) as usize - ptr as usize },
8usize,
concat!(
"Offset of field: ",
stringify!(_xmlSchemaWildcard),
"::",
stringify!(id)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).annot) as usize - ptr as usize },
16usize,
concat!(
"Offset of field: ",
stringify!(_xmlSchemaWildcard),
"::",
stringify!(annot)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).node) as usize - ptr as usize },
24usize,
concat!(
"Offset of field: ",
stringify!(_xmlSchemaWildcard),
"::",
stringify!(node)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).minOccurs) as usize - ptr as usize },
32usize,
concat!(
"Offset of field: ",
stringify!(_xmlSchemaWildcard),
"::",
stringify!(minOccurs)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).maxOccurs) as usize - ptr as usize },
36usize,
concat!(
"Offset of field: ",
stringify!(_xmlSchemaWildcard),
"::",
stringify!(maxOccurs)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).processContents) as usize - ptr as usize },
40usize,
concat!(
"Offset of field: ",
stringify!(_xmlSchemaWildcard),
"::",
stringify!(processContents)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).any) as usize - ptr as usize },
44usize,
concat!(
"Offset of field: ",
stringify!(_xmlSchemaWildcard),
"::",
stringify!(any)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).nsSet) as usize - ptr as usize },
48usize,
concat!(
"Offset of field: ",
stringify!(_xmlSchemaWildcard),
"::",
stringify!(nsSet)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).negNsSet) as usize - ptr as usize },
56usize,
concat!(
"Offset of field: ",
stringify!(_xmlSchemaWildcard),
"::",
stringify!(negNsSet)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).flags) as usize - ptr as usize },
64usize,
concat!(
"Offset of field: ",
stringify!(_xmlSchemaWildcard),
"::",
stringify!(flags)
)
);
}
pub type xmlSchemaAttributeGroup = _xmlSchemaAttributeGroup;
pub type xmlSchemaAttributeGroupPtr = *mut xmlSchemaAttributeGroup;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct _xmlSchemaAttributeGroup {
pub type_: xmlSchemaTypeType,
pub next: *mut _xmlSchemaAttribute,
pub name: *const xmlChar,
pub id: *const xmlChar,
pub ref_: *const xmlChar,
pub refNs: *const xmlChar,
pub annot: xmlSchemaAnnotPtr,
pub attributes: xmlSchemaAttributePtr,
pub node: xmlNodePtr,
pub flags: ::std::os::raw::c_int,
pub attributeWildcard: xmlSchemaWildcardPtr,
pub refPrefix: *const xmlChar,
pub refItem: xmlSchemaAttributeGroupPtr,
pub targetNamespace: *const xmlChar,
pub attrUses: *mut ::std::os::raw::c_void,
}
#[test]
fn bindgen_test_layout__xmlSchemaAttributeGroup() {
const UNINIT: ::std::mem::MaybeUninit<_xmlSchemaAttributeGroup> =
::std::mem::MaybeUninit::uninit();
let ptr = UNINIT.as_ptr();
assert_eq!(
::std::mem::size_of::<_xmlSchemaAttributeGroup>(),
120usize,
concat!("Size of: ", stringify!(_xmlSchemaAttributeGroup))
);
assert_eq!(
::std::mem::align_of::<_xmlSchemaAttributeGroup>(),
8usize,
concat!("Alignment of ", stringify!(_xmlSchemaAttributeGroup))
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).type_) as usize - ptr as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(_xmlSchemaAttributeGroup),
"::",
stringify!(type_)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).next) as usize - ptr as usize },
8usize,
concat!(
"Offset of field: ",
stringify!(_xmlSchemaAttributeGroup),
"::",
stringify!(next)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).name) as usize - ptr as usize },
16usize,
concat!(
"Offset of field: ",
stringify!(_xmlSchemaAttributeGroup),
"::",
stringify!(name)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).id) as usize - ptr as usize },
24usize,
concat!(
"Offset of field: ",
stringify!(_xmlSchemaAttributeGroup),
"::",
stringify!(id)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).ref_) as usize - ptr as usize },
32usize,
concat!(
"Offset of field: ",
stringify!(_xmlSchemaAttributeGroup),
"::",
stringify!(ref_)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).refNs) as usize - ptr as usize },
40usize,
concat!(
"Offset of field: ",
stringify!(_xmlSchemaAttributeGroup),
"::",
stringify!(refNs)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).annot) as usize - ptr as usize },
48usize,
concat!(
"Offset of field: ",
stringify!(_xmlSchemaAttributeGroup),
"::",
stringify!(annot)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).attributes) as usize - ptr as usize },
56usize,
concat!(
"Offset of field: ",
stringify!(_xmlSchemaAttributeGroup),
"::",
stringify!(attributes)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).node) as usize - ptr as usize },
64usize,
concat!(
"Offset of field: ",
stringify!(_xmlSchemaAttributeGroup),
"::",
stringify!(node)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).flags) as usize - ptr as usize },
72usize,
concat!(
"Offset of field: ",
stringify!(_xmlSchemaAttributeGroup),
"::",
stringify!(flags)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).attributeWildcard) as usize - ptr as usize },
80usize,
concat!(
"Offset of field: ",
stringify!(_xmlSchemaAttributeGroup),
"::",
stringify!(attributeWildcard)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).refPrefix) as usize - ptr as usize },
88usize,
concat!(
"Offset of field: ",
stringify!(_xmlSchemaAttributeGroup),
"::",
stringify!(refPrefix)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).refItem) as usize - ptr as usize },
96usize,
concat!(
"Offset of field: ",
stringify!(_xmlSchemaAttributeGroup),
"::",
stringify!(refItem)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).targetNamespace) as usize - ptr as usize },
104usize,
concat!(
"Offset of field: ",
stringify!(_xmlSchemaAttributeGroup),
"::",
stringify!(targetNamespace)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).attrUses) as usize - ptr as usize },
112usize,
concat!(
"Offset of field: ",
stringify!(_xmlSchemaAttributeGroup),
"::",
stringify!(attrUses)
)
);
}
pub type xmlSchemaTypeLink = _xmlSchemaTypeLink;
pub type xmlSchemaTypeLinkPtr = *mut xmlSchemaTypeLink;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct _xmlSchemaTypeLink {
pub next: *mut _xmlSchemaTypeLink,
pub type_: xmlSchemaTypePtr,
}
#[test]
fn bindgen_test_layout__xmlSchemaTypeLink() {
const UNINIT: ::std::mem::MaybeUninit<_xmlSchemaTypeLink> = ::std::mem::MaybeUninit::uninit();
let ptr = UNINIT.as_ptr();
assert_eq!(
::std::mem::size_of::<_xmlSchemaTypeLink>(),
16usize,
concat!("Size of: ", stringify!(_xmlSchemaTypeLink))
);
assert_eq!(
::std::mem::align_of::<_xmlSchemaTypeLink>(),
8usize,
concat!("Alignment of ", stringify!(_xmlSchemaTypeLink))
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).next) as usize - ptr as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(_xmlSchemaTypeLink),
"::",
stringify!(next)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).type_) as usize - ptr as usize },
8usize,
concat!(
"Offset of field: ",
stringify!(_xmlSchemaTypeLink),
"::",
stringify!(type_)
)
);
}
pub type xmlSchemaFacetLink = _xmlSchemaFacetLink;
pub type xmlSchemaFacetLinkPtr = *mut xmlSchemaFacetLink;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct _xmlSchemaFacetLink {
pub next: *mut _xmlSchemaFacetLink,
pub facet: xmlSchemaFacetPtr,
}
#[test]
fn bindgen_test_layout__xmlSchemaFacetLink() {
const UNINIT: ::std::mem::MaybeUninit<_xmlSchemaFacetLink> = ::std::mem::MaybeUninit::uninit();
let ptr = UNINIT.as_ptr();
assert_eq!(
::std::mem::size_of::<_xmlSchemaFacetLink>(),
16usize,
concat!("Size of: ", stringify!(_xmlSchemaFacetLink))
);
assert_eq!(
::std::mem::align_of::<_xmlSchemaFacetLink>(),
8usize,
concat!("Alignment of ", stringify!(_xmlSchemaFacetLink))
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).next) as usize - ptr as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(_xmlSchemaFacetLink),
"::",
stringify!(next)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).facet) as usize - ptr as usize },
8usize,
concat!(
"Offset of field: ",
stringify!(_xmlSchemaFacetLink),
"::",
stringify!(facet)
)
);
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct _xmlSchemaType {
pub type_: xmlSchemaTypeType,
pub next: *mut _xmlSchemaType,
pub name: *const xmlChar,
pub id: *const xmlChar,
pub ref_: *const xmlChar,
pub refNs: *const xmlChar,
pub annot: xmlSchemaAnnotPtr,
pub subtypes: xmlSchemaTypePtr,
pub attributes: xmlSchemaAttributePtr,
pub node: xmlNodePtr,
pub minOccurs: ::std::os::raw::c_int,
pub maxOccurs: ::std::os::raw::c_int,
pub flags: ::std::os::raw::c_int,
pub contentType: xmlSchemaContentType,
pub base: *const xmlChar,
pub baseNs: *const xmlChar,
pub baseType: xmlSchemaTypePtr,
pub facets: xmlSchemaFacetPtr,
pub redef: *mut _xmlSchemaType,
pub recurse: ::std::os::raw::c_int,
pub attributeUses: *mut xmlSchemaAttributeLinkPtr,
pub attributeWildcard: xmlSchemaWildcardPtr,
pub builtInType: ::std::os::raw::c_int,
pub memberTypes: xmlSchemaTypeLinkPtr,
pub facetSet: xmlSchemaFacetLinkPtr,
pub refPrefix: *const xmlChar,
pub contentTypeDef: xmlSchemaTypePtr,
pub contModel: xmlRegexpPtr,
pub targetNamespace: *const xmlChar,
pub attrUses: *mut ::std::os::raw::c_void,
}
#[test]
fn bindgen_test_layout__xmlSchemaType() {
const UNINIT: ::std::mem::MaybeUninit<_xmlSchemaType> = ::std::mem::MaybeUninit::uninit();
let ptr = UNINIT.as_ptr();
assert_eq!(
::std::mem::size_of::<_xmlSchemaType>(),
224usize,
concat!("Size of: ", stringify!(_xmlSchemaType))
);
assert_eq!(
::std::mem::align_of::<_xmlSchemaType>(),
8usize,
concat!("Alignment of ", stringify!(_xmlSchemaType))
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).type_) as usize - ptr as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(_xmlSchemaType),
"::",
stringify!(type_)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).next) as usize - ptr as usize },
8usize,
concat!(
"Offset of field: ",
stringify!(_xmlSchemaType),
"::",
stringify!(next)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).name) as usize - ptr as usize },
16usize,
concat!(
"Offset of field: ",
stringify!(_xmlSchemaType),
"::",
stringify!(name)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).id) as usize - ptr as usize },
24usize,
concat!(
"Offset of field: ",
stringify!(_xmlSchemaType),
"::",
stringify!(id)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).ref_) as usize - ptr as usize },
32usize,
concat!(
"Offset of field: ",
stringify!(_xmlSchemaType),
"::",
stringify!(ref_)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).refNs) as usize - ptr as usize },
40usize,
concat!(
"Offset of field: ",
stringify!(_xmlSchemaType),
"::",
stringify!(refNs)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).annot) as usize - ptr as usize },
48usize,
concat!(
"Offset of field: ",
stringify!(_xmlSchemaType),
"::",
stringify!(annot)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).subtypes) as usize - ptr as usize },
56usize,
concat!(
"Offset of field: ",
stringify!(_xmlSchemaType),
"::",
stringify!(subtypes)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).attributes) as usize - ptr as usize },
64usize,
concat!(
"Offset of field: ",
stringify!(_xmlSchemaType),
"::",
stringify!(attributes)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).node) as usize - ptr as usize },
72usize,
concat!(
"Offset of field: ",
stringify!(_xmlSchemaType),
"::",
stringify!(node)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).minOccurs) as usize - ptr as usize },
80usize,
concat!(
"Offset of field: ",
stringify!(_xmlSchemaType),
"::",
stringify!(minOccurs)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).maxOccurs) as usize - ptr as usize },
84usize,
concat!(
"Offset of field: ",
stringify!(_xmlSchemaType),
"::",
stringify!(maxOccurs)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).flags) as usize - ptr as usize },
88usize,
concat!(
"Offset of field: ",
stringify!(_xmlSchemaType),
"::",
stringify!(flags)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).contentType) as usize - ptr as usize },
92usize,
concat!(
"Offset of field: ",
stringify!(_xmlSchemaType),
"::",
stringify!(contentType)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).base) as usize - ptr as usize },
96usize,
concat!(
"Offset of field: ",
stringify!(_xmlSchemaType),
"::",
stringify!(base)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).baseNs) as usize - ptr as usize },
104usize,
concat!(
"Offset of field: ",
stringify!(_xmlSchemaType),
"::",
stringify!(baseNs)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).baseType) as usize - ptr as usize },
112usize,
concat!(
"Offset of field: ",
stringify!(_xmlSchemaType),
"::",
stringify!(baseType)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).facets) as usize - ptr as usize },
120usize,
concat!(
"Offset of field: ",
stringify!(_xmlSchemaType),
"::",
stringify!(facets)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).redef) as usize - ptr as usize },
128usize,
concat!(
"Offset of field: ",
stringify!(_xmlSchemaType),
"::",
stringify!(redef)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).recurse) as usize - ptr as usize },
136usize,
concat!(
"Offset of field: ",
stringify!(_xmlSchemaType),
"::",
stringify!(recurse)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).attributeUses) as usize - ptr as usize },
144usize,
concat!(
"Offset of field: ",
stringify!(_xmlSchemaType),
"::",
stringify!(attributeUses)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).attributeWildcard) as usize - ptr as usize },
152usize,
concat!(
"Offset of field: ",
stringify!(_xmlSchemaType),
"::",
stringify!(attributeWildcard)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).builtInType) as usize - ptr as usize },
160usize,
concat!(
"Offset of field: ",
stringify!(_xmlSchemaType),
"::",
stringify!(builtInType)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).memberTypes) as usize - ptr as usize },
168usize,
concat!(
"Offset of field: ",
stringify!(_xmlSchemaType),
"::",
stringify!(memberTypes)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).facetSet) as usize - ptr as usize },
176usize,
concat!(
"Offset of field: ",
stringify!(_xmlSchemaType),
"::",
stringify!(facetSet)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).refPrefix) as usize - ptr as usize },
184usize,
concat!(
"Offset of field: ",
stringify!(_xmlSchemaType),
"::",
stringify!(refPrefix)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).contentTypeDef) as usize - ptr as usize },
192usize,
concat!(
"Offset of field: ",
stringify!(_xmlSchemaType),
"::",
stringify!(contentTypeDef)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).contModel) as usize - ptr as usize },
200usize,
concat!(
"Offset of field: ",
stringify!(_xmlSchemaType),
"::",
stringify!(contModel)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).targetNamespace) as usize - ptr as usize },
208usize,
concat!(
"Offset of field: ",
stringify!(_xmlSchemaType),
"::",
stringify!(targetNamespace)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).attrUses) as usize - ptr as usize },
216usize,
concat!(
"Offset of field: ",
stringify!(_xmlSchemaType),
"::",
stringify!(attrUses)
)
);
}
pub type xmlSchemaElement = _xmlSchemaElement;
pub type xmlSchemaElementPtr = *mut xmlSchemaElement;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct _xmlSchemaElement {
pub type_: xmlSchemaTypeType,
pub next: *mut _xmlSchemaType,
pub name: *const xmlChar,
pub id: *const xmlChar,
pub ref_: *const xmlChar,
pub refNs: *const xmlChar,
pub annot: xmlSchemaAnnotPtr,
pub subtypes: xmlSchemaTypePtr,
pub attributes: xmlSchemaAttributePtr,
pub node: xmlNodePtr,
pub minOccurs: ::std::os::raw::c_int,
pub maxOccurs: ::std::os::raw::c_int,
pub flags: ::std::os::raw::c_int,
pub targetNamespace: *const xmlChar,
pub namedType: *const xmlChar,
pub namedTypeNs: *const xmlChar,
pub substGroup: *const xmlChar,
pub substGroupNs: *const xmlChar,
pub scope: *const xmlChar,
pub value: *const xmlChar,
pub refDecl: *mut _xmlSchemaElement,
pub contModel: xmlRegexpPtr,
pub contentType: xmlSchemaContentType,
pub refPrefix: *const xmlChar,
pub defVal: xmlSchemaValPtr,
pub idcs: *mut ::std::os::raw::c_void,
}
#[test]
fn bindgen_test_layout__xmlSchemaElement() {
const UNINIT: ::std::mem::MaybeUninit<_xmlSchemaElement> = ::std::mem::MaybeUninit::uninit();
let ptr = UNINIT.as_ptr();
assert_eq!(
::std::mem::size_of::<_xmlSchemaElement>(),
200usize,
concat!("Size of: ", stringify!(_xmlSchemaElement))
);
assert_eq!(
::std::mem::align_of::<_xmlSchemaElement>(),
8usize,
concat!("Alignment of ", stringify!(_xmlSchemaElement))
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).type_) as usize - ptr as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(_xmlSchemaElement),
"::",
stringify!(type_)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).next) as usize - ptr as usize },
8usize,
concat!(
"Offset of field: ",
stringify!(_xmlSchemaElement),
"::",
stringify!(next)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).name) as usize - ptr as usize },
16usize,
concat!(
"Offset of field: ",
stringify!(_xmlSchemaElement),
"::",
stringify!(name)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).id) as usize - ptr as usize },
24usize,
concat!(
"Offset of field: ",
stringify!(_xmlSchemaElement),
"::",
stringify!(id)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).ref_) as usize - ptr as usize },
32usize,
concat!(
"Offset of field: ",
stringify!(_xmlSchemaElement),
"::",
stringify!(ref_)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).refNs) as usize - ptr as usize },
40usize,
concat!(
"Offset of field: ",
stringify!(_xmlSchemaElement),
"::",
stringify!(refNs)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).annot) as usize - ptr as usize },
48usize,
concat!(
"Offset of field: ",
stringify!(_xmlSchemaElement),
"::",
stringify!(annot)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).subtypes) as usize - ptr as usize },
56usize,
concat!(
"Offset of field: ",
stringify!(_xmlSchemaElement),
"::",
stringify!(subtypes)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).attributes) as usize - ptr as usize },
64usize,
concat!(
"Offset of field: ",
stringify!(_xmlSchemaElement),
"::",
stringify!(attributes)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).node) as usize - ptr as usize },
72usize,
concat!(
"Offset of field: ",
stringify!(_xmlSchemaElement),
"::",
stringify!(node)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).minOccurs) as usize - ptr as usize },
80usize,
concat!(
"Offset of field: ",
stringify!(_xmlSchemaElement),
"::",
stringify!(minOccurs)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).maxOccurs) as usize - ptr as usize },
84usize,
concat!(
"Offset of field: ",
stringify!(_xmlSchemaElement),
"::",
stringify!(maxOccurs)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).flags) as usize - ptr as usize },
88usize,
concat!(
"Offset of field: ",
stringify!(_xmlSchemaElement),
"::",
stringify!(flags)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).targetNamespace) as usize - ptr as usize },
96usize,
concat!(
"Offset of field: ",
stringify!(_xmlSchemaElement),
"::",
stringify!(targetNamespace)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).namedType) as usize - ptr as usize },
104usize,
concat!(
"Offset of field: ",
stringify!(_xmlSchemaElement),
"::",
stringify!(namedType)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).namedTypeNs) as usize - ptr as usize },
112usize,
concat!(
"Offset of field: ",
stringify!(_xmlSchemaElement),
"::",
stringify!(namedTypeNs)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).substGroup) as usize - ptr as usize },
120usize,
concat!(
"Offset of field: ",
stringify!(_xmlSchemaElement),
"::",
stringify!(substGroup)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).substGroupNs) as usize - ptr as usize },
128usize,
concat!(
"Offset of field: ",
stringify!(_xmlSchemaElement),
"::",
stringify!(substGroupNs)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).scope) as usize - ptr as usize },
136usize,
concat!(
"Offset of field: ",
stringify!(_xmlSchemaElement),
"::",
stringify!(scope)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).value) as usize - ptr as usize },
144usize,
concat!(
"Offset of field: ",
stringify!(_xmlSchemaElement),
"::",
stringify!(value)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).refDecl) as usize - ptr as usize },
152usize,
concat!(
"Offset of field: ",
stringify!(_xmlSchemaElement),
"::",
stringify!(refDecl)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).contModel) as usize - ptr as usize },
160usize,
concat!(
"Offset of field: ",
stringify!(_xmlSchemaElement),
"::",
stringify!(contModel)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).contentType) as usize - ptr as usize },
168usize,
concat!(
"Offset of field: ",
stringify!(_xmlSchemaElement),
"::",
stringify!(contentType)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).refPrefix) as usize - ptr as usize },
176usize,
concat!(
"Offset of field: ",
stringify!(_xmlSchemaElement),
"::",
stringify!(refPrefix)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).defVal) as usize - ptr as usize },
184usize,
concat!(
"Offset of field: ",
stringify!(_xmlSchemaElement),
"::",
stringify!(defVal)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).idcs) as usize - ptr as usize },
192usize,
concat!(
"Offset of field: ",
stringify!(_xmlSchemaElement),
"::",
stringify!(idcs)
)
);
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct _xmlSchemaFacet {
pub type_: xmlSchemaTypeType,
pub next: *mut _xmlSchemaFacet,
pub value: *const xmlChar,
pub id: *const xmlChar,
pub annot: xmlSchemaAnnotPtr,
pub node: xmlNodePtr,
pub fixed: ::std::os::raw::c_int,
pub whitespace: ::std::os::raw::c_int,
pub val: xmlSchemaValPtr,
pub regexp: xmlRegexpPtr,
}
#[test]
fn bindgen_test_layout__xmlSchemaFacet() {
const UNINIT: ::std::mem::MaybeUninit<_xmlSchemaFacet> = ::std::mem::MaybeUninit::uninit();
let ptr = UNINIT.as_ptr();
assert_eq!(
::std::mem::size_of::<_xmlSchemaFacet>(),
72usize,
concat!("Size of: ", stringify!(_xmlSchemaFacet))
);
assert_eq!(
::std::mem::align_of::<_xmlSchemaFacet>(),
8usize,
concat!("Alignment of ", stringify!(_xmlSchemaFacet))
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).type_) as usize - ptr as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(_xmlSchemaFacet),
"::",
stringify!(type_)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).next) as usize - ptr as usize },
8usize,
concat!(
"Offset of field: ",
stringify!(_xmlSchemaFacet),
"::",
stringify!(next)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).value) as usize - ptr as usize },
16usize,
concat!(
"Offset of field: ",
stringify!(_xmlSchemaFacet),
"::",
stringify!(value)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).id) as usize - ptr as usize },
24usize,
concat!(
"Offset of field: ",
stringify!(_xmlSchemaFacet),
"::",
stringify!(id)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).annot) as usize - ptr as usize },
32usize,
concat!(
"Offset of field: ",
stringify!(_xmlSchemaFacet),
"::",
stringify!(annot)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).node) as usize - ptr as usize },
40usize,
concat!(
"Offset of field: ",
stringify!(_xmlSchemaFacet),
"::",
stringify!(node)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).fixed) as usize - ptr as usize },
48usize,
concat!(
"Offset of field: ",
stringify!(_xmlSchemaFacet),
"::",
stringify!(fixed)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).whitespace) as usize - ptr as usize },
52usize,
concat!(
"Offset of field: ",
stringify!(_xmlSchemaFacet),
"::",
stringify!(whitespace)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).val) as usize - ptr as usize },
56usize,
concat!(
"Offset of field: ",
stringify!(_xmlSchemaFacet),
"::",
stringify!(val)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).regexp) as usize - ptr as usize },
64usize,
concat!(
"Offset of field: ",
stringify!(_xmlSchemaFacet),
"::",
stringify!(regexp)
)
);
}
pub type xmlSchemaNotation = _xmlSchemaNotation;
pub type xmlSchemaNotationPtr = *mut xmlSchemaNotation;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct _xmlSchemaNotation {
pub type_: xmlSchemaTypeType,
pub name: *const xmlChar,
pub annot: xmlSchemaAnnotPtr,
pub identifier: *const xmlChar,
pub targetNamespace: *const xmlChar,
}
#[test]
fn bindgen_test_layout__xmlSchemaNotation() {
const UNINIT: ::std::mem::MaybeUninit<_xmlSchemaNotation> = ::std::mem::MaybeUninit::uninit();
let ptr = UNINIT.as_ptr();
assert_eq!(
::std::mem::size_of::<_xmlSchemaNotation>(),
40usize,
concat!("Size of: ", stringify!(_xmlSchemaNotation))
);
assert_eq!(
::std::mem::align_of::<_xmlSchemaNotation>(),
8usize,
concat!("Alignment of ", stringify!(_xmlSchemaNotation))
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).type_) as usize - ptr as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(_xmlSchemaNotation),
"::",
stringify!(type_)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).name) as usize - ptr as usize },
8usize,
concat!(
"Offset of field: ",
stringify!(_xmlSchemaNotation),
"::",
stringify!(name)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).annot) as usize - ptr as usize },
16usize,
concat!(
"Offset of field: ",
stringify!(_xmlSchemaNotation),
"::",
stringify!(annot)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).identifier) as usize - ptr as usize },
24usize,
concat!(
"Offset of field: ",
stringify!(_xmlSchemaNotation),
"::",
stringify!(identifier)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).targetNamespace) as usize - ptr as usize },
32usize,
concat!(
"Offset of field: ",
stringify!(_xmlSchemaNotation),
"::",
stringify!(targetNamespace)
)
);
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct _xmlSchema {
pub name: *const xmlChar,
pub targetNamespace: *const xmlChar,
pub version: *const xmlChar,
pub id: *const xmlChar,
pub doc: xmlDocPtr,
pub annot: xmlSchemaAnnotPtr,
pub flags: ::std::os::raw::c_int,
pub typeDecl: xmlHashTablePtr,
pub attrDecl: xmlHashTablePtr,
pub attrgrpDecl: xmlHashTablePtr,
pub elemDecl: xmlHashTablePtr,
pub notaDecl: xmlHashTablePtr,
pub schemasImports: xmlHashTablePtr,
pub _private: *mut ::std::os::raw::c_void,
pub groupDecl: xmlHashTablePtr,
pub dict: xmlDictPtr,
pub includes: *mut ::std::os::raw::c_void,
pub preserve: ::std::os::raw::c_int,
pub counter: ::std::os::raw::c_int,
pub idcDef: xmlHashTablePtr,
pub volatiles: *mut ::std::os::raw::c_void,
}
#[test]
fn bindgen_test_layout__xmlSchema() {
const UNINIT: ::std::mem::MaybeUninit<_xmlSchema> = ::std::mem::MaybeUninit::uninit();
let ptr = UNINIT.as_ptr();
assert_eq!(
::std::mem::size_of::<_xmlSchema>(),
160usize,
concat!("Size of: ", stringify!(_xmlSchema))
);
assert_eq!(
::std::mem::align_of::<_xmlSchema>(),
8usize,
concat!("Alignment of ", stringify!(_xmlSchema))
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).name) as usize - ptr as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(_xmlSchema),
"::",
stringify!(name)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).targetNamespace) as usize - ptr as usize },
8usize,
concat!(
"Offset of field: ",
stringify!(_xmlSchema),
"::",
stringify!(targetNamespace)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).version) as usize - ptr as usize },
16usize,
concat!(
"Offset of field: ",
stringify!(_xmlSchema),
"::",
stringify!(version)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).id) as usize - ptr as usize },
24usize,
concat!(
"Offset of field: ",
stringify!(_xmlSchema),
"::",
stringify!(id)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).doc) as usize - ptr as usize },
32usize,
concat!(
"Offset of field: ",
stringify!(_xmlSchema),
"::",
stringify!(doc)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).annot) as usize - ptr as usize },
40usize,
concat!(
"Offset of field: ",
stringify!(_xmlSchema),
"::",
stringify!(annot)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).flags) as usize - ptr as usize },
48usize,
concat!(
"Offset of field: ",
stringify!(_xmlSchema),
"::",
stringify!(flags)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).typeDecl) as usize - ptr as usize },
56usize,
concat!(
"Offset of field: ",
stringify!(_xmlSchema),
"::",
stringify!(typeDecl)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).attrDecl) as usize - ptr as usize },
64usize,
concat!(
"Offset of field: ",
stringify!(_xmlSchema),
"::",
stringify!(attrDecl)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).attrgrpDecl) as usize - ptr as usize },
72usize,
concat!(
"Offset of field: ",
stringify!(_xmlSchema),
"::",
stringify!(attrgrpDecl)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).elemDecl) as usize - ptr as usize },
80usize,
concat!(
"Offset of field: ",
stringify!(_xmlSchema),
"::",
stringify!(elemDecl)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).notaDecl) as usize - ptr as usize },
88usize,
concat!(
"Offset of field: ",
stringify!(_xmlSchema),
"::",
stringify!(notaDecl)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).schemasImports) as usize - ptr as usize },
96usize,
concat!(
"Offset of field: ",
stringify!(_xmlSchema),
"::",
stringify!(schemasImports)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr)._private) as usize - ptr as usize },
104usize,
concat!(
"Offset of field: ",
stringify!(_xmlSchema),
"::",
stringify!(_private)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).groupDecl) as usize - ptr as usize },
112usize,
concat!(
"Offset of field: ",
stringify!(_xmlSchema),
"::",
stringify!(groupDecl)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).dict) as usize - ptr as usize },
120usize,
concat!(
"Offset of field: ",
stringify!(_xmlSchema),
"::",
stringify!(dict)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).includes) as usize - ptr as usize },
128usize,
concat!(
"Offset of field: ",
stringify!(_xmlSchema),
"::",
stringify!(includes)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).preserve) as usize - ptr as usize },
136usize,
concat!(
"Offset of field: ",
stringify!(_xmlSchema),
"::",
stringify!(preserve)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).counter) as usize - ptr as usize },
140usize,
concat!(
"Offset of field: ",
stringify!(_xmlSchema),
"::",
stringify!(counter)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).idcDef) as usize - ptr as usize },
144usize,
concat!(
"Offset of field: ",
stringify!(_xmlSchema),
"::",
stringify!(idcDef)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).volatiles) as usize - ptr as usize },
152usize,
concat!(
"Offset of field: ",
stringify!(_xmlSchema),
"::",
stringify!(volatiles)
)
);
}
extern "C" {
pub fn xmlSchemaFreeType(type_: xmlSchemaTypePtr);
}
extern "C" {
pub fn xmlSchemaFreeWildcard(wildcard: xmlSchemaWildcardPtr);
}
pub const xmlCatalogPrefer_XML_CATA_PREFER_NONE: xmlCatalogPrefer = 0;
pub const xmlCatalogPrefer_XML_CATA_PREFER_PUBLIC: xmlCatalogPrefer = 1;
pub const xmlCatalogPrefer_XML_CATA_PREFER_SYSTEM: xmlCatalogPrefer = 2;
pub type xmlCatalogPrefer = ::std::os::raw::c_uint;
pub const xmlCatalogAllow_XML_CATA_ALLOW_NONE: xmlCatalogAllow = 0;
pub const xmlCatalogAllow_XML_CATA_ALLOW_GLOBAL: xmlCatalogAllow = 1;
pub const xmlCatalogAllow_XML_CATA_ALLOW_DOCUMENT: xmlCatalogAllow = 2;
pub const xmlCatalogAllow_XML_CATA_ALLOW_ALL: xmlCatalogAllow = 3;
pub type xmlCatalogAllow = ::std::os::raw::c_uint;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct _xmlCatalog {
_unused: [u8; 0],
}
pub type xmlCatalog = _xmlCatalog;
pub type xmlCatalogPtr = *mut xmlCatalog;
extern "C" {
pub fn xmlNewCatalog(sgml: ::std::os::raw::c_int) -> xmlCatalogPtr;
}
extern "C" {
pub fn xmlLoadACatalog(filename: *const ::std::os::raw::c_char) -> xmlCatalogPtr;
}
extern "C" {
pub fn xmlLoadSGMLSuperCatalog(filename: *const ::std::os::raw::c_char) -> xmlCatalogPtr;
}
extern "C" {
pub fn xmlConvertSGMLCatalog(catal: xmlCatalogPtr) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn xmlACatalogAdd(
catal: xmlCatalogPtr,
type_: *const xmlChar,
orig: *const xmlChar,
replace: *const xmlChar,
) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn xmlACatalogRemove(catal: xmlCatalogPtr, value: *const xmlChar) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn xmlACatalogResolve(
catal: xmlCatalogPtr,
pubID: *const xmlChar,
sysID: *const xmlChar,
) -> *mut xmlChar;
}
extern "C" {
pub fn xmlACatalogResolveSystem(catal: xmlCatalogPtr, sysID: *const xmlChar) -> *mut xmlChar;
}
extern "C" {
pub fn xmlACatalogResolvePublic(catal: xmlCatalogPtr, pubID: *const xmlChar) -> *mut xmlChar;
}
extern "C" {
pub fn xmlACatalogResolveURI(catal: xmlCatalogPtr, URI: *const xmlChar) -> *mut xmlChar;
}
extern "C" {
pub fn xmlACatalogDump(catal: xmlCatalogPtr, out: *mut FILE);
}
extern "C" {
pub fn xmlFreeCatalog(catal: xmlCatalogPtr);
}
extern "C" {
pub fn xmlCatalogIsEmpty(catal: xmlCatalogPtr) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn xmlInitializeCatalog();
}
extern "C" {
pub fn xmlLoadCatalog(filename: *const ::std::os::raw::c_char) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn xmlLoadCatalogs(paths: *const ::std::os::raw::c_char);
}
extern "C" {
pub fn xmlCatalogCleanup();
}
extern "C" {
pub fn xmlCatalogDump(out: *mut FILE);
}
extern "C" {
pub fn xmlCatalogResolve(pubID: *const xmlChar, sysID: *const xmlChar) -> *mut xmlChar;
}
extern "C" {
pub fn xmlCatalogResolveSystem(sysID: *const xmlChar) -> *mut xmlChar;
}
extern "C" {
pub fn xmlCatalogResolvePublic(pubID: *const xmlChar) -> *mut xmlChar;
}
extern "C" {
pub fn xmlCatalogResolveURI(URI: *const xmlChar) -> *mut xmlChar;
}
extern "C" {
pub fn xmlCatalogAdd(
type_: *const xmlChar,
orig: *const xmlChar,
replace: *const xmlChar,
) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn xmlCatalogRemove(value: *const xmlChar) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn xmlParseCatalogFile(filename: *const ::std::os::raw::c_char) -> xmlDocPtr;
}
extern "C" {
pub fn xmlCatalogConvert() -> ::std::os::raw::c_int;
}
extern "C" {
pub fn xmlCatalogFreeLocal(catalogs: *mut ::std::os::raw::c_void);
}
extern "C" {
pub fn xmlCatalogAddLocal(
catalogs: *mut ::std::os::raw::c_void,
URL: *const xmlChar,
) -> *mut ::std::os::raw::c_void;
}
extern "C" {
pub fn xmlCatalogLocalResolve(
catalogs: *mut ::std::os::raw::c_void,
pubID: *const xmlChar,
sysID: *const xmlChar,
) -> *mut xmlChar;
}
extern "C" {
pub fn xmlCatalogLocalResolveURI(
catalogs: *mut ::std::os::raw::c_void,
URI: *const xmlChar,
) -> *mut xmlChar;
}
extern "C" {
pub fn xmlCatalogSetDebug(level: ::std::os::raw::c_int) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn xmlCatalogSetDefaultPrefer(prefer: xmlCatalogPrefer) -> xmlCatalogPrefer;
}
extern "C" {
pub fn xmlCatalogSetDefaults(allow: xmlCatalogAllow);
}
extern "C" {
pub fn xmlCatalogGetDefaults() -> xmlCatalogAllow;
}
extern "C" {
pub fn xmlCatalogGetSystem(sysID: *const xmlChar) -> *const xmlChar;
}
extern "C" {
pub fn xmlCatalogGetPublic(pubID: *const xmlChar) -> *const xmlChar;
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct _xmlPattern {
_unused: [u8; 0],
}
pub type xmlPattern = _xmlPattern;
pub type xmlPatternPtr = *mut xmlPattern;
pub const xmlPatternFlags_XML_PATTERN_DEFAULT: xmlPatternFlags = 0;
pub const xmlPatternFlags_XML_PATTERN_XPATH: xmlPatternFlags = 1;
pub const xmlPatternFlags_XML_PATTERN_XSSEL: xmlPatternFlags = 2;
pub const xmlPatternFlags_XML_PATTERN_XSFIELD: xmlPatternFlags = 4;
pub type xmlPatternFlags = ::std::os::raw::c_uint;
extern "C" {
pub fn xmlFreePattern(comp: xmlPatternPtr);
}
extern "C" {
pub fn xmlFreePatternList(comp: xmlPatternPtr);
}
extern "C" {
pub fn xmlPatterncompile(
pattern: *const xmlChar,
dict: *mut xmlDict,
flags: ::std::os::raw::c_int,
namespaces: *mut *const xmlChar,
) -> xmlPatternPtr;
}
extern "C" {
pub fn xmlPatternMatch(comp: xmlPatternPtr, node: xmlNodePtr) -> ::std::os::raw::c_int;
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct _xmlStreamCtxt {
_unused: [u8; 0],
}
pub type xmlStreamCtxt = _xmlStreamCtxt;
pub type xmlStreamCtxtPtr = *mut xmlStreamCtxt;
extern "C" {
pub fn xmlPatternStreamable(comp: xmlPatternPtr) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn xmlPatternMaxDepth(comp: xmlPatternPtr) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn xmlPatternMinDepth(comp: xmlPatternPtr) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn xmlPatternFromRoot(comp: xmlPatternPtr) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn xmlPatternGetStreamCtxt(comp: xmlPatternPtr) -> xmlStreamCtxtPtr;
}
extern "C" {
pub fn xmlFreeStreamCtxt(stream: xmlStreamCtxtPtr);
}
extern "C" {
pub fn xmlStreamPushNode(
stream: xmlStreamCtxtPtr,
name: *const xmlChar,
ns: *const xmlChar,
nodeType: ::std::os::raw::c_int,
) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn xmlStreamPush(
stream: xmlStreamCtxtPtr,
name: *const xmlChar,
ns: *const xmlChar,
) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn xmlStreamPushAttr(
stream: xmlStreamCtxtPtr,
name: *const xmlChar,
ns: *const xmlChar,
) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn xmlStreamPop(stream: xmlStreamCtxtPtr) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn xmlStreamWantsAnyNode(stream: xmlStreamCtxtPtr) -> ::std::os::raw::c_int;
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct _xmlRelaxNG {
_unused: [u8; 0],
}
pub type xmlRelaxNG = _xmlRelaxNG;
pub type xmlRelaxNGPtr = *mut xmlRelaxNG;
pub type xmlRelaxNGValidityErrorFunc = ::std::option::Option<
unsafe extern "C" fn(ctx: *mut ::std::os::raw::c_void, msg: *const ::std::os::raw::c_char, ...),
>;
pub type xmlRelaxNGValidityWarningFunc = ::std::option::Option<
unsafe extern "C" fn(ctx: *mut ::std::os::raw::c_void, msg: *const ::std::os::raw::c_char, ...),
>;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct _xmlRelaxNGParserCtxt {
_unused: [u8; 0],
}
pub type xmlRelaxNGParserCtxt = _xmlRelaxNGParserCtxt;
pub type xmlRelaxNGParserCtxtPtr = *mut xmlRelaxNGParserCtxt;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct _xmlRelaxNGValidCtxt {
_unused: [u8; 0],
}
pub type xmlRelaxNGValidCtxt = _xmlRelaxNGValidCtxt;
pub type xmlRelaxNGValidCtxtPtr = *mut xmlRelaxNGValidCtxt;
pub const xmlRelaxNGValidErr_XML_RELAXNG_OK: xmlRelaxNGValidErr = 0;
pub const xmlRelaxNGValidErr_XML_RELAXNG_ERR_MEMORY: xmlRelaxNGValidErr = 1;
pub const xmlRelaxNGValidErr_XML_RELAXNG_ERR_TYPE: xmlRelaxNGValidErr = 2;
pub const xmlRelaxNGValidErr_XML_RELAXNG_ERR_TYPEVAL: xmlRelaxNGValidErr = 3;
pub const xmlRelaxNGValidErr_XML_RELAXNG_ERR_DUPID: xmlRelaxNGValidErr = 4;
pub const xmlRelaxNGValidErr_XML_RELAXNG_ERR_TYPECMP: xmlRelaxNGValidErr = 5;
pub const xmlRelaxNGValidErr_XML_RELAXNG_ERR_NOSTATE: xmlRelaxNGValidErr = 6;
pub const xmlRelaxNGValidErr_XML_RELAXNG_ERR_NODEFINE: xmlRelaxNGValidErr = 7;
pub const xmlRelaxNGValidErr_XML_RELAXNG_ERR_LISTEXTRA: xmlRelaxNGValidErr = 8;
pub const xmlRelaxNGValidErr_XML_RELAXNG_ERR_LISTEMPTY: xmlRelaxNGValidErr = 9;
pub const xmlRelaxNGValidErr_XML_RELAXNG_ERR_INTERNODATA: xmlRelaxNGValidErr = 10;
pub const xmlRelaxNGValidErr_XML_RELAXNG_ERR_INTERSEQ: xmlRelaxNGValidErr = 11;
pub const xmlRelaxNGValidErr_XML_RELAXNG_ERR_INTEREXTRA: xmlRelaxNGValidErr = 12;
pub const xmlRelaxNGValidErr_XML_RELAXNG_ERR_ELEMNAME: xmlRelaxNGValidErr = 13;
pub const xmlRelaxNGValidErr_XML_RELAXNG_ERR_ATTRNAME: xmlRelaxNGValidErr = 14;
pub const xmlRelaxNGValidErr_XML_RELAXNG_ERR_ELEMNONS: xmlRelaxNGValidErr = 15;
pub const xmlRelaxNGValidErr_XML_RELAXNG_ERR_ATTRNONS: xmlRelaxNGValidErr = 16;
pub const xmlRelaxNGValidErr_XML_RELAXNG_ERR_ELEMWRONGNS: xmlRelaxNGValidErr = 17;
pub const xmlRelaxNGValidErr_XML_RELAXNG_ERR_ATTRWRONGNS: xmlRelaxNGValidErr = 18;
pub const xmlRelaxNGValidErr_XML_RELAXNG_ERR_ELEMEXTRANS: xmlRelaxNGValidErr = 19;
pub const xmlRelaxNGValidErr_XML_RELAXNG_ERR_ATTREXTRANS: xmlRelaxNGValidErr = 20;
pub const xmlRelaxNGValidErr_XML_RELAXNG_ERR_ELEMNOTEMPTY: xmlRelaxNGValidErr = 21;
pub const xmlRelaxNGValidErr_XML_RELAXNG_ERR_NOELEM: xmlRelaxNGValidErr = 22;
pub const xmlRelaxNGValidErr_XML_RELAXNG_ERR_NOTELEM: xmlRelaxNGValidErr = 23;
pub const xmlRelaxNGValidErr_XML_RELAXNG_ERR_ATTRVALID: xmlRelaxNGValidErr = 24;
pub const xmlRelaxNGValidErr_XML_RELAXNG_ERR_CONTENTVALID: xmlRelaxNGValidErr = 25;
pub const xmlRelaxNGValidErr_XML_RELAXNG_ERR_EXTRACONTENT: xmlRelaxNGValidErr = 26;
pub const xmlRelaxNGValidErr_XML_RELAXNG_ERR_INVALIDATTR: xmlRelaxNGValidErr = 27;
pub const xmlRelaxNGValidErr_XML_RELAXNG_ERR_DATAELEM: xmlRelaxNGValidErr = 28;
pub const xmlRelaxNGValidErr_XML_RELAXNG_ERR_VALELEM: xmlRelaxNGValidErr = 29;
pub const xmlRelaxNGValidErr_XML_RELAXNG_ERR_LISTELEM: xmlRelaxNGValidErr = 30;
pub const xmlRelaxNGValidErr_XML_RELAXNG_ERR_DATATYPE: xmlRelaxNGValidErr = 31;
pub const xmlRelaxNGValidErr_XML_RELAXNG_ERR_VALUE: xmlRelaxNGValidErr = 32;
pub const xmlRelaxNGValidErr_XML_RELAXNG_ERR_LIST: xmlRelaxNGValidErr = 33;
pub const xmlRelaxNGValidErr_XML_RELAXNG_ERR_NOGRAMMAR: xmlRelaxNGValidErr = 34;
pub const xmlRelaxNGValidErr_XML_RELAXNG_ERR_EXTRADATA: xmlRelaxNGValidErr = 35;
pub const xmlRelaxNGValidErr_XML_RELAXNG_ERR_LACKDATA: xmlRelaxNGValidErr = 36;
pub const xmlRelaxNGValidErr_XML_RELAXNG_ERR_INTERNAL: xmlRelaxNGValidErr = 37;
pub const xmlRelaxNGValidErr_XML_RELAXNG_ERR_ELEMWRONG: xmlRelaxNGValidErr = 38;
pub const xmlRelaxNGValidErr_XML_RELAXNG_ERR_TEXTWRONG: xmlRelaxNGValidErr = 39;
pub type xmlRelaxNGValidErr = ::std::os::raw::c_uint;
pub const xmlRelaxNGParserFlag_XML_RELAXNGP_NONE: xmlRelaxNGParserFlag = 0;
pub const xmlRelaxNGParserFlag_XML_RELAXNGP_FREE_DOC: xmlRelaxNGParserFlag = 1;
pub const xmlRelaxNGParserFlag_XML_RELAXNGP_CRNG: xmlRelaxNGParserFlag = 2;
pub type xmlRelaxNGParserFlag = ::std::os::raw::c_uint;
extern "C" {
pub fn xmlRelaxNGInitTypes() -> ::std::os::raw::c_int;
}
extern "C" {
pub fn xmlRelaxNGCleanupTypes();
}
extern "C" {
pub fn xmlRelaxNGNewParserCtxt(URL: *const ::std::os::raw::c_char) -> xmlRelaxNGParserCtxtPtr;
}
extern "C" {
pub fn xmlRelaxNGNewMemParserCtxt(
buffer: *const ::std::os::raw::c_char,
size: ::std::os::raw::c_int,
) -> xmlRelaxNGParserCtxtPtr;
}
extern "C" {
pub fn xmlRelaxNGNewDocParserCtxt(doc: xmlDocPtr) -> xmlRelaxNGParserCtxtPtr;
}
extern "C" {
pub fn xmlRelaxParserSetFlag(
ctxt: xmlRelaxNGParserCtxtPtr,
flag: ::std::os::raw::c_int,
) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn xmlRelaxNGFreeParserCtxt(ctxt: xmlRelaxNGParserCtxtPtr);
}
extern "C" {
pub fn xmlRelaxNGSetParserErrors(
ctxt: xmlRelaxNGParserCtxtPtr,
err: xmlRelaxNGValidityErrorFunc,
warn: xmlRelaxNGValidityWarningFunc,
ctx: *mut ::std::os::raw::c_void,
);
}
extern "C" {
pub fn xmlRelaxNGGetParserErrors(
ctxt: xmlRelaxNGParserCtxtPtr,
err: *mut xmlRelaxNGValidityErrorFunc,
warn: *mut xmlRelaxNGValidityWarningFunc,
ctx: *mut *mut ::std::os::raw::c_void,
) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn xmlRelaxNGSetParserStructuredErrors(
ctxt: xmlRelaxNGParserCtxtPtr,
serror: xmlStructuredErrorFunc,
ctx: *mut ::std::os::raw::c_void,
);
}
extern "C" {
pub fn xmlRelaxNGParse(ctxt: xmlRelaxNGParserCtxtPtr) -> xmlRelaxNGPtr;
}
extern "C" {
pub fn xmlRelaxNGFree(schema: xmlRelaxNGPtr);
}
extern "C" {
pub fn xmlRelaxNGDump(output: *mut FILE, schema: xmlRelaxNGPtr);
}
extern "C" {
pub fn xmlRelaxNGDumpTree(output: *mut FILE, schema: xmlRelaxNGPtr);
}
extern "C" {
pub fn xmlRelaxNGSetValidErrors(
ctxt: xmlRelaxNGValidCtxtPtr,
err: xmlRelaxNGValidityErrorFunc,
warn: xmlRelaxNGValidityWarningFunc,
ctx: *mut ::std::os::raw::c_void,
);
}
extern "C" {
pub fn xmlRelaxNGGetValidErrors(
ctxt: xmlRelaxNGValidCtxtPtr,
err: *mut xmlRelaxNGValidityErrorFunc,
warn: *mut xmlRelaxNGValidityWarningFunc,
ctx: *mut *mut ::std::os::raw::c_void,
) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn xmlRelaxNGSetValidStructuredErrors(
ctxt: xmlRelaxNGValidCtxtPtr,
serror: xmlStructuredErrorFunc,
ctx: *mut ::std::os::raw::c_void,
);
}
extern "C" {
pub fn xmlRelaxNGNewValidCtxt(schema: xmlRelaxNGPtr) -> xmlRelaxNGValidCtxtPtr;
}
extern "C" {
pub fn xmlRelaxNGFreeValidCtxt(ctxt: xmlRelaxNGValidCtxtPtr);
}
extern "C" {
pub fn xmlRelaxNGValidateDoc(
ctxt: xmlRelaxNGValidCtxtPtr,
doc: xmlDocPtr,
) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn xmlRelaxNGValidatePushElement(
ctxt: xmlRelaxNGValidCtxtPtr,
doc: xmlDocPtr,
elem: xmlNodePtr,
) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn xmlRelaxNGValidatePushCData(
ctxt: xmlRelaxNGValidCtxtPtr,
data: *const xmlChar,
len: ::std::os::raw::c_int,
) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn xmlRelaxNGValidatePopElement(
ctxt: xmlRelaxNGValidCtxtPtr,
doc: xmlDocPtr,
elem: xmlNodePtr,
) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn xmlRelaxNGValidateFullElement(
ctxt: xmlRelaxNGValidCtxtPtr,
doc: xmlDocPtr,
elem: xmlNodePtr,
) -> ::std::os::raw::c_int;
}
pub const xmlSchemaValidError_XML_SCHEMAS_ERR_OK: xmlSchemaValidError = 0;
pub const xmlSchemaValidError_XML_SCHEMAS_ERR_NOROOT: xmlSchemaValidError = 1;
pub const xmlSchemaValidError_XML_SCHEMAS_ERR_UNDECLAREDELEM: xmlSchemaValidError = 2;
pub const xmlSchemaValidError_XML_SCHEMAS_ERR_NOTTOPLEVEL: xmlSchemaValidError = 3;
pub const xmlSchemaValidError_XML_SCHEMAS_ERR_MISSING: xmlSchemaValidError = 4;
pub const xmlSchemaValidError_XML_SCHEMAS_ERR_WRONGELEM: xmlSchemaValidError = 5;
pub const xmlSchemaValidError_XML_SCHEMAS_ERR_NOTYPE: xmlSchemaValidError = 6;
pub const xmlSchemaValidError_XML_SCHEMAS_ERR_NOROLLBACK: xmlSchemaValidError = 7;
pub const xmlSchemaValidError_XML_SCHEMAS_ERR_ISABSTRACT: xmlSchemaValidError = 8;
pub const xmlSchemaValidError_XML_SCHEMAS_ERR_NOTEMPTY: xmlSchemaValidError = 9;
pub const xmlSchemaValidError_XML_SCHEMAS_ERR_ELEMCONT: xmlSchemaValidError = 10;
pub const xmlSchemaValidError_XML_SCHEMAS_ERR_HAVEDEFAULT: xmlSchemaValidError = 11;
pub const xmlSchemaValidError_XML_SCHEMAS_ERR_NOTNILLABLE: xmlSchemaValidError = 12;
pub const xmlSchemaValidError_XML_SCHEMAS_ERR_EXTRACONTENT: xmlSchemaValidError = 13;
pub const xmlSchemaValidError_XML_SCHEMAS_ERR_INVALIDATTR: xmlSchemaValidError = 14;
pub const xmlSchemaValidError_XML_SCHEMAS_ERR_INVALIDELEM: xmlSchemaValidError = 15;
pub const xmlSchemaValidError_XML_SCHEMAS_ERR_NOTDETERMINIST: xmlSchemaValidError = 16;
pub const xmlSchemaValidError_XML_SCHEMAS_ERR_CONSTRUCT: xmlSchemaValidError = 17;
pub const xmlSchemaValidError_XML_SCHEMAS_ERR_INTERNAL: xmlSchemaValidError = 18;
pub const xmlSchemaValidError_XML_SCHEMAS_ERR_NOTSIMPLE: xmlSchemaValidError = 19;
pub const xmlSchemaValidError_XML_SCHEMAS_ERR_ATTRUNKNOWN: xmlSchemaValidError = 20;
pub const xmlSchemaValidError_XML_SCHEMAS_ERR_ATTRINVALID: xmlSchemaValidError = 21;
pub const xmlSchemaValidError_XML_SCHEMAS_ERR_VALUE: xmlSchemaValidError = 22;
pub const xmlSchemaValidError_XML_SCHEMAS_ERR_FACET: xmlSchemaValidError = 23;
pub const xmlSchemaValidError_XML_SCHEMAS_ERR_: xmlSchemaValidError = 24;
pub const xmlSchemaValidError_XML_SCHEMAS_ERR_XXX: xmlSchemaValidError = 25;
pub type xmlSchemaValidError = ::std::os::raw::c_uint;
pub const xmlSchemaValidOption_XML_SCHEMA_VAL_VC_I_CREATE: xmlSchemaValidOption = 1;
pub type xmlSchemaValidOption = ::std::os::raw::c_uint;
pub type xmlSchema = _xmlSchema;
pub type xmlSchemaPtr = *mut xmlSchema;
pub type xmlSchemaValidityErrorFunc = ::std::option::Option<
unsafe extern "C" fn(ctx: *mut ::std::os::raw::c_void, msg: *const ::std::os::raw::c_char, ...),
>;
pub type xmlSchemaValidityWarningFunc = ::std::option::Option<
unsafe extern "C" fn(ctx: *mut ::std::os::raw::c_void, msg: *const ::std::os::raw::c_char, ...),
>;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct _xmlSchemaParserCtxt {
_unused: [u8; 0],
}
pub type xmlSchemaParserCtxt = _xmlSchemaParserCtxt;
pub type xmlSchemaParserCtxtPtr = *mut xmlSchemaParserCtxt;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct _xmlSchemaValidCtxt {
_unused: [u8; 0],
}
pub type xmlSchemaValidCtxt = _xmlSchemaValidCtxt;
pub type xmlSchemaValidCtxtPtr = *mut xmlSchemaValidCtxt;
pub type xmlSchemaValidityLocatorFunc = ::std::option::Option<
unsafe extern "C" fn(
ctx: *mut ::std::os::raw::c_void,
file: *mut *const ::std::os::raw::c_char,
line: *mut ::std::os::raw::c_ulong,
) -> ::std::os::raw::c_int,
>;
extern "C" {
pub fn xmlSchemaNewParserCtxt(URL: *const ::std::os::raw::c_char) -> xmlSchemaParserCtxtPtr;
}
extern "C" {
pub fn xmlSchemaNewMemParserCtxt(
buffer: *const ::std::os::raw::c_char,
size: ::std::os::raw::c_int,
) -> xmlSchemaParserCtxtPtr;
}
extern "C" {
pub fn xmlSchemaNewDocParserCtxt(doc: xmlDocPtr) -> xmlSchemaParserCtxtPtr;
}
extern "C" {
pub fn xmlSchemaFreeParserCtxt(ctxt: xmlSchemaParserCtxtPtr);
}
extern "C" {
pub fn xmlSchemaSetParserErrors(
ctxt: xmlSchemaParserCtxtPtr,
err: xmlSchemaValidityErrorFunc,
warn: xmlSchemaValidityWarningFunc,
ctx: *mut ::std::os::raw::c_void,
);
}
extern "C" {
pub fn xmlSchemaSetParserStructuredErrors(
ctxt: xmlSchemaParserCtxtPtr,
serror: xmlStructuredErrorFunc,
ctx: *mut ::std::os::raw::c_void,
);
}
extern "C" {
pub fn xmlSchemaGetParserErrors(
ctxt: xmlSchemaParserCtxtPtr,
err: *mut xmlSchemaValidityErrorFunc,
warn: *mut xmlSchemaValidityWarningFunc,
ctx: *mut *mut ::std::os::raw::c_void,
) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn xmlSchemaIsValid(ctxt: xmlSchemaValidCtxtPtr) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn xmlSchemaParse(ctxt: xmlSchemaParserCtxtPtr) -> xmlSchemaPtr;
}
extern "C" {
pub fn xmlSchemaFree(schema: xmlSchemaPtr);
}
extern "C" {
pub fn xmlSchemaDump(output: *mut FILE, schema: xmlSchemaPtr);
}
extern "C" {
pub fn xmlSchemaSetValidErrors(
ctxt: xmlSchemaValidCtxtPtr,
err: xmlSchemaValidityErrorFunc,
warn: xmlSchemaValidityWarningFunc,
ctx: *mut ::std::os::raw::c_void,
);
}
extern "C" {
pub fn xmlSchemaSetValidStructuredErrors(
ctxt: xmlSchemaValidCtxtPtr,
serror: xmlStructuredErrorFunc,
ctx: *mut ::std::os::raw::c_void,
);
}
extern "C" {
pub fn xmlSchemaGetValidErrors(
ctxt: xmlSchemaValidCtxtPtr,
err: *mut xmlSchemaValidityErrorFunc,
warn: *mut xmlSchemaValidityWarningFunc,
ctx: *mut *mut ::std::os::raw::c_void,
) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn xmlSchemaSetValidOptions(
ctxt: xmlSchemaValidCtxtPtr,
options: ::std::os::raw::c_int,
) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn xmlSchemaValidateSetFilename(
vctxt: xmlSchemaValidCtxtPtr,
filename: *const ::std::os::raw::c_char,
);
}
extern "C" {
pub fn xmlSchemaValidCtxtGetOptions(ctxt: xmlSchemaValidCtxtPtr) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn xmlSchemaNewValidCtxt(schema: xmlSchemaPtr) -> xmlSchemaValidCtxtPtr;
}
extern "C" {
pub fn xmlSchemaFreeValidCtxt(ctxt: xmlSchemaValidCtxtPtr);
}
extern "C" {
pub fn xmlSchemaValidateDoc(
ctxt: xmlSchemaValidCtxtPtr,
instance: xmlDocPtr,
) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn xmlSchemaValidateOneElement(
ctxt: xmlSchemaValidCtxtPtr,
elem: xmlNodePtr,
) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn xmlSchemaValidateStream(
ctxt: xmlSchemaValidCtxtPtr,
input: xmlParserInputBufferPtr,
enc: xmlCharEncoding,
sax: xmlSAXHandlerPtr,
user_data: *mut ::std::os::raw::c_void,
) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn xmlSchemaValidateFile(
ctxt: xmlSchemaValidCtxtPtr,
filename: *const ::std::os::raw::c_char,
options: ::std::os::raw::c_int,
) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn xmlSchemaValidCtxtGetParserCtxt(ctxt: xmlSchemaValidCtxtPtr) -> xmlParserCtxtPtr;
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct _xmlSchemaSAXPlug {
_unused: [u8; 0],
}
pub type xmlSchemaSAXPlugStruct = _xmlSchemaSAXPlug;
pub type xmlSchemaSAXPlugPtr = *mut xmlSchemaSAXPlugStruct;
extern "C" {
pub fn xmlSchemaSAXPlug(
ctxt: xmlSchemaValidCtxtPtr,
sax: *mut xmlSAXHandlerPtr,
user_data: *mut *mut ::std::os::raw::c_void,
) -> xmlSchemaSAXPlugPtr;
}
extern "C" {
pub fn xmlSchemaSAXUnplug(plug: xmlSchemaSAXPlugPtr) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn xmlSchemaValidateSetLocator(
vctxt: xmlSchemaValidCtxtPtr,
f: xmlSchemaValidityLocatorFunc,
ctxt: *mut ::std::os::raw::c_void,
);
}
pub const xmlParserSeverities_XML_PARSER_SEVERITY_VALIDITY_WARNING: xmlParserSeverities = 1;
pub const xmlParserSeverities_XML_PARSER_SEVERITY_VALIDITY_ERROR: xmlParserSeverities = 2;
pub const xmlParserSeverities_XML_PARSER_SEVERITY_WARNING: xmlParserSeverities = 3;
pub const xmlParserSeverities_XML_PARSER_SEVERITY_ERROR: xmlParserSeverities = 4;
pub type xmlParserSeverities = ::std::os::raw::c_uint;
pub const xmlTextReaderMode_XML_TEXTREADER_MODE_INITIAL: xmlTextReaderMode = 0;
pub const xmlTextReaderMode_XML_TEXTREADER_MODE_INTERACTIVE: xmlTextReaderMode = 1;
pub const xmlTextReaderMode_XML_TEXTREADER_MODE_ERROR: xmlTextReaderMode = 2;
pub const xmlTextReaderMode_XML_TEXTREADER_MODE_EOF: xmlTextReaderMode = 3;
pub const xmlTextReaderMode_XML_TEXTREADER_MODE_CLOSED: xmlTextReaderMode = 4;
pub const xmlTextReaderMode_XML_TEXTREADER_MODE_READING: xmlTextReaderMode = 5;
pub type xmlTextReaderMode = ::std::os::raw::c_uint;
pub const xmlParserProperties_XML_PARSER_LOADDTD: xmlParserProperties = 1;
pub const xmlParserProperties_XML_PARSER_DEFAULTATTRS: xmlParserProperties = 2;
pub const xmlParserProperties_XML_PARSER_VALIDATE: xmlParserProperties = 3;
pub const xmlParserProperties_XML_PARSER_SUBST_ENTITIES: xmlParserProperties = 4;
pub type xmlParserProperties = ::std::os::raw::c_uint;
pub const xmlReaderTypes_XML_READER_TYPE_NONE: xmlReaderTypes = 0;
pub const xmlReaderTypes_XML_READER_TYPE_ELEMENT: xmlReaderTypes = 1;
pub const xmlReaderTypes_XML_READER_TYPE_ATTRIBUTE: xmlReaderTypes = 2;
pub const xmlReaderTypes_XML_READER_TYPE_TEXT: xmlReaderTypes = 3;
pub const xmlReaderTypes_XML_READER_TYPE_CDATA: xmlReaderTypes = 4;
pub const xmlReaderTypes_XML_READER_TYPE_ENTITY_REFERENCE: xmlReaderTypes = 5;
pub const xmlReaderTypes_XML_READER_TYPE_ENTITY: xmlReaderTypes = 6;
pub const xmlReaderTypes_XML_READER_TYPE_PROCESSING_INSTRUCTION: xmlReaderTypes = 7;
pub const xmlReaderTypes_XML_READER_TYPE_COMMENT: xmlReaderTypes = 8;
pub const xmlReaderTypes_XML_READER_TYPE_DOCUMENT: xmlReaderTypes = 9;
pub const xmlReaderTypes_XML_READER_TYPE_DOCUMENT_TYPE: xmlReaderTypes = 10;
pub const xmlReaderTypes_XML_READER_TYPE_DOCUMENT_FRAGMENT: xmlReaderTypes = 11;
pub const xmlReaderTypes_XML_READER_TYPE_NOTATION: xmlReaderTypes = 12;
pub const xmlReaderTypes_XML_READER_TYPE_WHITESPACE: xmlReaderTypes = 13;
pub const xmlReaderTypes_XML_READER_TYPE_SIGNIFICANT_WHITESPACE: xmlReaderTypes = 14;
pub const xmlReaderTypes_XML_READER_TYPE_END_ELEMENT: xmlReaderTypes = 15;
pub const xmlReaderTypes_XML_READER_TYPE_END_ENTITY: xmlReaderTypes = 16;
pub const xmlReaderTypes_XML_READER_TYPE_XML_DECLARATION: xmlReaderTypes = 17;
pub type xmlReaderTypes = ::std::os::raw::c_uint;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct _xmlTextReader {
_unused: [u8; 0],
}
pub type xmlTextReader = _xmlTextReader;
pub type xmlTextReaderPtr = *mut xmlTextReader;
extern "C" {
pub fn xmlNewTextReader(
input: xmlParserInputBufferPtr,
URI: *const ::std::os::raw::c_char,
) -> xmlTextReaderPtr;
}
extern "C" {
pub fn xmlNewTextReaderFilename(URI: *const ::std::os::raw::c_char) -> xmlTextReaderPtr;
}
extern "C" {
pub fn xmlFreeTextReader(reader: xmlTextReaderPtr);
}
extern "C" {
pub fn xmlTextReaderSetup(
reader: xmlTextReaderPtr,
input: xmlParserInputBufferPtr,
URL: *const ::std::os::raw::c_char,
encoding: *const ::std::os::raw::c_char,
options: ::std::os::raw::c_int,
) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn xmlTextReaderRead(reader: xmlTextReaderPtr) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn xmlTextReaderReadInnerXml(reader: xmlTextReaderPtr) -> *mut xmlChar;
}
extern "C" {
pub fn xmlTextReaderReadOuterXml(reader: xmlTextReaderPtr) -> *mut xmlChar;
}
extern "C" {
pub fn xmlTextReaderReadString(reader: xmlTextReaderPtr) -> *mut xmlChar;
}
extern "C" {
pub fn xmlTextReaderReadAttributeValue(reader: xmlTextReaderPtr) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn xmlTextReaderAttributeCount(reader: xmlTextReaderPtr) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn xmlTextReaderDepth(reader: xmlTextReaderPtr) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn xmlTextReaderHasAttributes(reader: xmlTextReaderPtr) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn xmlTextReaderHasValue(reader: xmlTextReaderPtr) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn xmlTextReaderIsDefault(reader: xmlTextReaderPtr) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn xmlTextReaderIsEmptyElement(reader: xmlTextReaderPtr) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn xmlTextReaderNodeType(reader: xmlTextReaderPtr) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn xmlTextReaderQuoteChar(reader: xmlTextReaderPtr) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn xmlTextReaderReadState(reader: xmlTextReaderPtr) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn xmlTextReaderIsNamespaceDecl(reader: xmlTextReaderPtr) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn xmlTextReaderConstBaseUri(reader: xmlTextReaderPtr) -> *const xmlChar;
}
extern "C" {
pub fn xmlTextReaderConstLocalName(reader: xmlTextReaderPtr) -> *const xmlChar;
}
extern "C" {
pub fn xmlTextReaderConstName(reader: xmlTextReaderPtr) -> *const xmlChar;
}
extern "C" {
pub fn xmlTextReaderConstNamespaceUri(reader: xmlTextReaderPtr) -> *const xmlChar;
}
extern "C" {
pub fn xmlTextReaderConstPrefix(reader: xmlTextReaderPtr) -> *const xmlChar;
}
extern "C" {
pub fn xmlTextReaderConstXmlLang(reader: xmlTextReaderPtr) -> *const xmlChar;
}
extern "C" {
pub fn xmlTextReaderConstString(
reader: xmlTextReaderPtr,
str_: *const xmlChar,
) -> *const xmlChar;
}
extern "C" {
pub fn xmlTextReaderConstValue(reader: xmlTextReaderPtr) -> *const xmlChar;
}
extern "C" {
pub fn xmlTextReaderBaseUri(reader: xmlTextReaderPtr) -> *mut xmlChar;
}
extern "C" {
pub fn xmlTextReaderLocalName(reader: xmlTextReaderPtr) -> *mut xmlChar;
}
extern "C" {
pub fn xmlTextReaderName(reader: xmlTextReaderPtr) -> *mut xmlChar;
}
extern "C" {
pub fn xmlTextReaderNamespaceUri(reader: xmlTextReaderPtr) -> *mut xmlChar;
}
extern "C" {
pub fn xmlTextReaderPrefix(reader: xmlTextReaderPtr) -> *mut xmlChar;
}
extern "C" {
pub fn xmlTextReaderXmlLang(reader: xmlTextReaderPtr) -> *mut xmlChar;
}
extern "C" {
pub fn xmlTextReaderValue(reader: xmlTextReaderPtr) -> *mut xmlChar;
}
extern "C" {
pub fn xmlTextReaderClose(reader: xmlTextReaderPtr) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn xmlTextReaderGetAttributeNo(
reader: xmlTextReaderPtr,
no: ::std::os::raw::c_int,
) -> *mut xmlChar;
}
extern "C" {
pub fn xmlTextReaderGetAttribute(
reader: xmlTextReaderPtr,
name: *const xmlChar,
) -> *mut xmlChar;
}
extern "C" {
pub fn xmlTextReaderGetAttributeNs(
reader: xmlTextReaderPtr,
localName: *const xmlChar,
namespaceURI: *const xmlChar,
) -> *mut xmlChar;
}
extern "C" {
pub fn xmlTextReaderGetRemainder(reader: xmlTextReaderPtr) -> xmlParserInputBufferPtr;
}
extern "C" {
pub fn xmlTextReaderLookupNamespace(
reader: xmlTextReaderPtr,
prefix: *const xmlChar,
) -> *mut xmlChar;
}
extern "C" {
pub fn xmlTextReaderMoveToAttributeNo(
reader: xmlTextReaderPtr,
no: ::std::os::raw::c_int,
) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn xmlTextReaderMoveToAttribute(
reader: xmlTextReaderPtr,
name: *const xmlChar,
) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn xmlTextReaderMoveToAttributeNs(
reader: xmlTextReaderPtr,
localName: *const xmlChar,
namespaceURI: *const xmlChar,
) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn xmlTextReaderMoveToFirstAttribute(reader: xmlTextReaderPtr) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn xmlTextReaderMoveToNextAttribute(reader: xmlTextReaderPtr) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn xmlTextReaderMoveToElement(reader: xmlTextReaderPtr) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn xmlTextReaderNormalization(reader: xmlTextReaderPtr) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn xmlTextReaderConstEncoding(reader: xmlTextReaderPtr) -> *const xmlChar;
}
extern "C" {
pub fn xmlTextReaderSetParserProp(
reader: xmlTextReaderPtr,
prop: ::std::os::raw::c_int,
value: ::std::os::raw::c_int,
) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn xmlTextReaderGetParserProp(
reader: xmlTextReaderPtr,
prop: ::std::os::raw::c_int,
) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn xmlTextReaderCurrentNode(reader: xmlTextReaderPtr) -> xmlNodePtr;
}
extern "C" {
pub fn xmlTextReaderGetParserLineNumber(reader: xmlTextReaderPtr) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn xmlTextReaderGetParserColumnNumber(reader: xmlTextReaderPtr) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn xmlTextReaderPreserve(reader: xmlTextReaderPtr) -> xmlNodePtr;
}
extern "C" {
pub fn xmlTextReaderPreservePattern(
reader: xmlTextReaderPtr,
pattern: *const xmlChar,
namespaces: *mut *const xmlChar,
) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn xmlTextReaderCurrentDoc(reader: xmlTextReaderPtr) -> xmlDocPtr;
}
extern "C" {
pub fn xmlTextReaderExpand(reader: xmlTextReaderPtr) -> xmlNodePtr;
}
extern "C" {
pub fn xmlTextReaderNext(reader: xmlTextReaderPtr) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn xmlTextReaderNextSibling(reader: xmlTextReaderPtr) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn xmlTextReaderIsValid(reader: xmlTextReaderPtr) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn xmlTextReaderRelaxNGValidate(
reader: xmlTextReaderPtr,
rng: *const ::std::os::raw::c_char,
) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn xmlTextReaderRelaxNGValidateCtxt(
reader: xmlTextReaderPtr,
ctxt: xmlRelaxNGValidCtxtPtr,
options: ::std::os::raw::c_int,
) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn xmlTextReaderRelaxNGSetSchema(
reader: xmlTextReaderPtr,
schema: xmlRelaxNGPtr,
) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn xmlTextReaderSchemaValidate(
reader: xmlTextReaderPtr,
xsd: *const ::std::os::raw::c_char,
) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn xmlTextReaderSchemaValidateCtxt(
reader: xmlTextReaderPtr,
ctxt: xmlSchemaValidCtxtPtr,
options: ::std::os::raw::c_int,
) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn xmlTextReaderSetSchema(
reader: xmlTextReaderPtr,
schema: xmlSchemaPtr,
) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn xmlTextReaderConstXmlVersion(reader: xmlTextReaderPtr) -> *const xmlChar;
}
extern "C" {
pub fn xmlTextReaderStandalone(reader: xmlTextReaderPtr) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn xmlTextReaderByteConsumed(reader: xmlTextReaderPtr) -> ::std::os::raw::c_long;
}
extern "C" {
pub fn xmlReaderWalker(doc: xmlDocPtr) -> xmlTextReaderPtr;
}
extern "C" {
pub fn xmlReaderForDoc(
cur: *const xmlChar,
URL: *const ::std::os::raw::c_char,
encoding: *const ::std::os::raw::c_char,
options: ::std::os::raw::c_int,
) -> xmlTextReaderPtr;
}
extern "C" {
pub fn xmlReaderForFile(
filename: *const ::std::os::raw::c_char,
encoding: *const ::std::os::raw::c_char,
options: ::std::os::raw::c_int,
) -> xmlTextReaderPtr;
}
extern "C" {
pub fn xmlReaderForMemory(
buffer: *const ::std::os::raw::c_char,
size: ::std::os::raw::c_int,
URL: *const ::std::os::raw::c_char,
encoding: *const ::std::os::raw::c_char,
options: ::std::os::raw::c_int,
) -> xmlTextReaderPtr;
}
extern "C" {
pub fn xmlReaderForFd(
fd: ::std::os::raw::c_int,
URL: *const ::std::os::raw::c_char,
encoding: *const ::std::os::raw::c_char,
options: ::std::os::raw::c_int,
) -> xmlTextReaderPtr;
}
extern "C" {
pub fn xmlReaderForIO(
ioread: xmlInputReadCallback,
ioclose: xmlInputCloseCallback,
ioctx: *mut ::std::os::raw::c_void,
URL: *const ::std::os::raw::c_char,
encoding: *const ::std::os::raw::c_char,
options: ::std::os::raw::c_int,
) -> xmlTextReaderPtr;
}
extern "C" {
pub fn xmlReaderNewWalker(reader: xmlTextReaderPtr, doc: xmlDocPtr) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn xmlReaderNewDoc(
reader: xmlTextReaderPtr,
cur: *const xmlChar,
URL: *const ::std::os::raw::c_char,
encoding: *const ::std::os::raw::c_char,
options: ::std::os::raw::c_int,
) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn xmlReaderNewFile(
reader: xmlTextReaderPtr,
filename: *const ::std::os::raw::c_char,
encoding: *const ::std::os::raw::c_char,
options: ::std::os::raw::c_int,
) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn xmlReaderNewMemory(
reader: xmlTextReaderPtr,
buffer: *const ::std::os::raw::c_char,
size: ::std::os::raw::c_int,
URL: *const ::std::os::raw::c_char,
encoding: *const ::std::os::raw::c_char,
options: ::std::os::raw::c_int,
) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn xmlReaderNewFd(
reader: xmlTextReaderPtr,
fd: ::std::os::raw::c_int,
URL: *const ::std::os::raw::c_char,
encoding: *const ::std::os::raw::c_char,
options: ::std::os::raw::c_int,
) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn xmlReaderNewIO(
reader: xmlTextReaderPtr,
ioread: xmlInputReadCallback,
ioclose: xmlInputCloseCallback,
ioctx: *mut ::std::os::raw::c_void,
URL: *const ::std::os::raw::c_char,
encoding: *const ::std::os::raw::c_char,
options: ::std::os::raw::c_int,
) -> ::std::os::raw::c_int;
}
pub type xmlTextReaderLocatorPtr = *mut ::std::os::raw::c_void;
pub type xmlTextReaderErrorFunc = ::std::option::Option<
unsafe extern "C" fn(
arg: *mut ::std::os::raw::c_void,
msg: *const ::std::os::raw::c_char,
severity: xmlParserSeverities,
locator: xmlTextReaderLocatorPtr,
),
>;
extern "C" {
pub fn xmlTextReaderLocatorLineNumber(
locator: xmlTextReaderLocatorPtr,
) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn xmlTextReaderLocatorBaseURI(locator: xmlTextReaderLocatorPtr) -> *mut xmlChar;
}
extern "C" {
pub fn xmlTextReaderSetErrorHandler(
reader: xmlTextReaderPtr,
f: xmlTextReaderErrorFunc,
arg: *mut ::std::os::raw::c_void,
);
}
extern "C" {
pub fn xmlTextReaderSetStructuredErrorHandler(
reader: xmlTextReaderPtr,
f: xmlStructuredErrorFunc,
arg: *mut ::std::os::raw::c_void,
);
}
extern "C" {
pub fn xmlTextReaderGetErrorHandler(
reader: xmlTextReaderPtr,
f: *mut xmlTextReaderErrorFunc,
arg: *mut *mut ::std::os::raw::c_void,
);
}
pub type xlinkHRef = *mut xmlChar;
pub type xlinkRole = *mut xmlChar;
pub type xlinkTitle = *mut xmlChar;
pub const xlinkType_XLINK_TYPE_NONE: xlinkType = 0;
pub const xlinkType_XLINK_TYPE_SIMPLE: xlinkType = 1;
pub const xlinkType_XLINK_TYPE_EXTENDED: xlinkType = 2;
pub const xlinkType_XLINK_TYPE_EXTENDED_SET: xlinkType = 3;
pub type xlinkType = ::std::os::raw::c_uint;
pub const xlinkShow_XLINK_SHOW_NONE: xlinkShow = 0;
pub const xlinkShow_XLINK_SHOW_NEW: xlinkShow = 1;
pub const xlinkShow_XLINK_SHOW_EMBED: xlinkShow = 2;
pub const xlinkShow_XLINK_SHOW_REPLACE: xlinkShow = 3;
pub type xlinkShow = ::std::os::raw::c_uint;
pub const xlinkActuate_XLINK_ACTUATE_NONE: xlinkActuate = 0;
pub const xlinkActuate_XLINK_ACTUATE_AUTO: xlinkActuate = 1;
pub const xlinkActuate_XLINK_ACTUATE_ONREQUEST: xlinkActuate = 2;
pub type xlinkActuate = ::std::os::raw::c_uint;
pub type xlinkNodeDetectFunc =
::std::option::Option<unsafe extern "C" fn(ctx: *mut ::std::os::raw::c_void, node: xmlNodePtr)>;
pub type xlinkSimpleLinkFunk = ::std::option::Option<
unsafe extern "C" fn(
ctx: *mut ::std::os::raw::c_void,
node: xmlNodePtr,
href: xlinkHRef,
role: xlinkRole,
title: xlinkTitle,
),
>;
pub type xlinkExtendedLinkFunk = ::std::option::Option<
unsafe extern "C" fn(
ctx: *mut ::std::os::raw::c_void,
node: xmlNodePtr,
nbLocators: ::std::os::raw::c_int,
hrefs: *const xlinkHRef,
roles: *const xlinkRole,
nbArcs: ::std::os::raw::c_int,
from: *const xlinkRole,
to: *const xlinkRole,
show: *mut xlinkShow,
actuate: *mut xlinkActuate,
nbTitles: ::std::os::raw::c_int,
titles: *const xlinkTitle,
langs: *mut *const xmlChar,
),
>;
pub type xlinkExtendedLinkSetFunk = ::std::option::Option<
unsafe extern "C" fn(
ctx: *mut ::std::os::raw::c_void,
node: xmlNodePtr,
nbLocators: ::std::os::raw::c_int,
hrefs: *const xlinkHRef,
roles: *const xlinkRole,
nbTitles: ::std::os::raw::c_int,
titles: *const xlinkTitle,
langs: *mut *const xmlChar,
),
>;
pub type xlinkHandler = _xlinkHandler;
pub type xlinkHandlerPtr = *mut xlinkHandler;
#[repr(C)]
#[derive(Copy, Clone)]
pub struct _xlinkHandler {
pub simple: xlinkSimpleLinkFunk,
pub extended: xlinkExtendedLinkFunk,
pub set: xlinkExtendedLinkSetFunk,
}
#[test]
fn bindgen_test_layout__xlinkHandler() {
const UNINIT: ::std::mem::MaybeUninit<_xlinkHandler> = ::std::mem::MaybeUninit::uninit();
let ptr = UNINIT.as_ptr();
assert_eq!(
::std::mem::size_of::<_xlinkHandler>(),
24usize,
concat!("Size of: ", stringify!(_xlinkHandler))
);
assert_eq!(
::std::mem::align_of::<_xlinkHandler>(),
8usize,
concat!("Alignment of ", stringify!(_xlinkHandler))
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).simple) as usize - ptr as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(_xlinkHandler),
"::",
stringify!(simple)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).extended) as usize - ptr as usize },
8usize,
concat!(
"Offset of field: ",
stringify!(_xlinkHandler),
"::",
stringify!(extended)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).set) as usize - ptr as usize },
16usize,
concat!(
"Offset of field: ",
stringify!(_xlinkHandler),
"::",
stringify!(set)
)
);
}
extern "C" {
pub fn xlinkGetDefaultDetect() -> xlinkNodeDetectFunc;
}
extern "C" {
pub fn xlinkSetDefaultDetect(func: xlinkNodeDetectFunc);
}
extern "C" {
pub fn xlinkGetDefaultHandler() -> xlinkHandlerPtr;
}
extern "C" {
pub fn xlinkSetDefaultHandler(handler: xlinkHandlerPtr);
}
extern "C" {
pub fn xlinkIsLink(doc: xmlDocPtr, node: xmlNodePtr) -> xlinkType;
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct _xmlXIncludeCtxt {
_unused: [u8; 0],
}
pub type xmlXIncludeCtxt = _xmlXIncludeCtxt;
pub type xmlXIncludeCtxtPtr = *mut xmlXIncludeCtxt;
extern "C" {
pub fn xmlXIncludeProcess(doc: xmlDocPtr) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn xmlXIncludeProcessFlags(
doc: xmlDocPtr,
flags: ::std::os::raw::c_int,
) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn xmlXIncludeProcessFlagsData(
doc: xmlDocPtr,
flags: ::std::os::raw::c_int,
data: *mut ::std::os::raw::c_void,
) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn xmlXIncludeProcessTreeFlagsData(
tree: xmlNodePtr,
flags: ::std::os::raw::c_int,
data: *mut ::std::os::raw::c_void,
) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn xmlXIncludeProcessTree(tree: xmlNodePtr) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn xmlXIncludeProcessTreeFlags(
tree: xmlNodePtr,
flags: ::std::os::raw::c_int,
) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn xmlXIncludeNewContext(doc: xmlDocPtr) -> xmlXIncludeCtxtPtr;
}
extern "C" {
pub fn xmlXIncludeSetFlags(
ctxt: xmlXIncludeCtxtPtr,
flags: ::std::os::raw::c_int,
) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn xmlXIncludeFreeContext(ctxt: xmlXIncludeCtxtPtr);
}
extern "C" {
pub fn xmlXIncludeProcessNode(
ctxt: xmlXIncludeCtxtPtr,
tree: xmlNodePtr,
) -> ::std::os::raw::c_int;
}
pub const xmlSaveOption_XML_SAVE_FORMAT: xmlSaveOption = 1;
pub const xmlSaveOption_XML_SAVE_NO_DECL: xmlSaveOption = 2;
pub const xmlSaveOption_XML_SAVE_NO_EMPTY: xmlSaveOption = 4;
pub const xmlSaveOption_XML_SAVE_NO_XHTML: xmlSaveOption = 8;
pub const xmlSaveOption_XML_SAVE_XHTML: xmlSaveOption = 16;
pub const xmlSaveOption_XML_SAVE_AS_XML: xmlSaveOption = 32;
pub const xmlSaveOption_XML_SAVE_AS_HTML: xmlSaveOption = 64;
pub const xmlSaveOption_XML_SAVE_WSNONSIG: xmlSaveOption = 128;
pub type xmlSaveOption = ::std::os::raw::c_uint;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct _xmlSaveCtxt {
_unused: [u8; 0],
}
pub type xmlSaveCtxt = _xmlSaveCtxt;
pub type xmlSaveCtxtPtr = *mut xmlSaveCtxt;
extern "C" {
pub fn xmlSaveToFd(
fd: ::std::os::raw::c_int,
encoding: *const ::std::os::raw::c_char,
options: ::std::os::raw::c_int,
) -> xmlSaveCtxtPtr;
}
extern "C" {
pub fn xmlSaveToFilename(
filename: *const ::std::os::raw::c_char,
encoding: *const ::std::os::raw::c_char,
options: ::std::os::raw::c_int,
) -> xmlSaveCtxtPtr;
}
extern "C" {
pub fn xmlSaveToBuffer(
buffer: xmlBufferPtr,
encoding: *const ::std::os::raw::c_char,
options: ::std::os::raw::c_int,
) -> xmlSaveCtxtPtr;
}
extern "C" {
pub fn xmlSaveToIO(
iowrite: xmlOutputWriteCallback,
ioclose: xmlOutputCloseCallback,
ioctx: *mut ::std::os::raw::c_void,
encoding: *const ::std::os::raw::c_char,
options: ::std::os::raw::c_int,
) -> xmlSaveCtxtPtr;
}
extern "C" {
pub fn xmlSaveDoc(ctxt: xmlSaveCtxtPtr, doc: xmlDocPtr) -> ::std::os::raw::c_long;
}
extern "C" {
pub fn xmlSaveTree(ctxt: xmlSaveCtxtPtr, node: xmlNodePtr) -> ::std::os::raw::c_long;
}
extern "C" {
pub fn xmlSaveFlush(ctxt: xmlSaveCtxtPtr) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn xmlSaveClose(ctxt: xmlSaveCtxtPtr) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn xmlSaveSetEscape(
ctxt: xmlSaveCtxtPtr,
escape: xmlCharEncodingOutputFunc,
) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn xmlSaveSetAttrEscape(
ctxt: xmlSaveCtxtPtr,
escape: xmlCharEncodingOutputFunc,
) -> ::std::os::raw::c_int;
}
pub type htmlParserCtxt = xmlParserCtxt;
pub type htmlParserCtxtPtr = xmlParserCtxtPtr;
pub type htmlParserNodeInfo = xmlParserNodeInfo;
pub type htmlSAXHandler = xmlSAXHandler;
pub type htmlSAXHandlerPtr = xmlSAXHandlerPtr;
pub type htmlParserInput = xmlParserInput;
pub type htmlParserInputPtr = xmlParserInputPtr;
pub type htmlDocPtr = xmlDocPtr;
pub type htmlNodePtr = xmlNodePtr;
pub type htmlElemDesc = _htmlElemDesc;
pub type htmlElemDescPtr = *mut htmlElemDesc;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct _htmlElemDesc {
pub name: *const ::std::os::raw::c_char,
pub startTag: ::std::os::raw::c_char,
pub endTag: ::std::os::raw::c_char,
pub saveEndTag: ::std::os::raw::c_char,
pub empty: ::std::os::raw::c_char,
pub depr: ::std::os::raw::c_char,
pub dtd: ::std::os::raw::c_char,
pub isinline: ::std::os::raw::c_char,
pub desc: *const ::std::os::raw::c_char,
pub subelts: *mut *const ::std::os::raw::c_char,
pub defaultsubelt: *const ::std::os::raw::c_char,
pub attrs_opt: *mut *const ::std::os::raw::c_char,
pub attrs_depr: *mut *const ::std::os::raw::c_char,
pub attrs_req: *mut *const ::std::os::raw::c_char,
}
#[test]
fn bindgen_test_layout__htmlElemDesc() {
const UNINIT: ::std::mem::MaybeUninit<_htmlElemDesc> = ::std::mem::MaybeUninit::uninit();
let ptr = UNINIT.as_ptr();
assert_eq!(
::std::mem::size_of::<_htmlElemDesc>(),
64usize,
concat!("Size of: ", stringify!(_htmlElemDesc))
);
assert_eq!(
::std::mem::align_of::<_htmlElemDesc>(),
8usize,
concat!("Alignment of ", stringify!(_htmlElemDesc))
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).name) as usize - ptr as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(_htmlElemDesc),
"::",
stringify!(name)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).startTag) as usize - ptr as usize },
8usize,
concat!(
"Offset of field: ",
stringify!(_htmlElemDesc),
"::",
stringify!(startTag)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).endTag) as usize - ptr as usize },
9usize,
concat!(
"Offset of field: ",
stringify!(_htmlElemDesc),
"::",
stringify!(endTag)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).saveEndTag) as usize - ptr as usize },
10usize,
concat!(
"Offset of field: ",
stringify!(_htmlElemDesc),
"::",
stringify!(saveEndTag)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).empty) as usize - ptr as usize },
11usize,
concat!(
"Offset of field: ",
stringify!(_htmlElemDesc),
"::",
stringify!(empty)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).depr) as usize - ptr as usize },
12usize,
concat!(
"Offset of field: ",
stringify!(_htmlElemDesc),
"::",
stringify!(depr)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).dtd) as usize - ptr as usize },
13usize,
concat!(
"Offset of field: ",
stringify!(_htmlElemDesc),
"::",
stringify!(dtd)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).isinline) as usize - ptr as usize },
14usize,
concat!(
"Offset of field: ",
stringify!(_htmlElemDesc),
"::",
stringify!(isinline)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).desc) as usize - ptr as usize },
16usize,
concat!(
"Offset of field: ",
stringify!(_htmlElemDesc),
"::",
stringify!(desc)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).subelts) as usize - ptr as usize },
24usize,
concat!(
"Offset of field: ",
stringify!(_htmlElemDesc),
"::",
stringify!(subelts)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).defaultsubelt) as usize - ptr as usize },
32usize,
concat!(
"Offset of field: ",
stringify!(_htmlElemDesc),
"::",
stringify!(defaultsubelt)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).attrs_opt) as usize - ptr as usize },
40usize,
concat!(
"Offset of field: ",
stringify!(_htmlElemDesc),
"::",
stringify!(attrs_opt)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).attrs_depr) as usize - ptr as usize },
48usize,
concat!(
"Offset of field: ",
stringify!(_htmlElemDesc),
"::",
stringify!(attrs_depr)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).attrs_req) as usize - ptr as usize },
56usize,
concat!(
"Offset of field: ",
stringify!(_htmlElemDesc),
"::",
stringify!(attrs_req)
)
);
}
pub type htmlEntityDesc = _htmlEntityDesc;
pub type htmlEntityDescPtr = *mut htmlEntityDesc;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct _htmlEntityDesc {
pub value: ::std::os::raw::c_uint,
pub name: *const ::std::os::raw::c_char,
pub desc: *const ::std::os::raw::c_char,
}
#[test]
fn bindgen_test_layout__htmlEntityDesc() {
const UNINIT: ::std::mem::MaybeUninit<_htmlEntityDesc> = ::std::mem::MaybeUninit::uninit();
let ptr = UNINIT.as_ptr();
assert_eq!(
::std::mem::size_of::<_htmlEntityDesc>(),
24usize,
concat!("Size of: ", stringify!(_htmlEntityDesc))
);
assert_eq!(
::std::mem::align_of::<_htmlEntityDesc>(),
8usize,
concat!("Alignment of ", stringify!(_htmlEntityDesc))
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).value) as usize - ptr as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(_htmlEntityDesc),
"::",
stringify!(value)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).name) as usize - ptr as usize },
8usize,
concat!(
"Offset of field: ",
stringify!(_htmlEntityDesc),
"::",
stringify!(name)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).desc) as usize - ptr as usize },
16usize,
concat!(
"Offset of field: ",
stringify!(_htmlEntityDesc),
"::",
stringify!(desc)
)
);
}
extern "C" {
pub fn htmlTagLookup(tag: *const xmlChar) -> *const htmlElemDesc;
}
extern "C" {
pub fn htmlEntityLookup(name: *const xmlChar) -> *const htmlEntityDesc;
}
extern "C" {
pub fn htmlEntityValueLookup(value: ::std::os::raw::c_uint) -> *const htmlEntityDesc;
}
extern "C" {
pub fn htmlIsAutoClosed(doc: htmlDocPtr, elem: htmlNodePtr) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn htmlAutoCloseTag(
doc: htmlDocPtr,
name: *const xmlChar,
elem: htmlNodePtr,
) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn htmlParseEntityRef(
ctxt: htmlParserCtxtPtr,
str_: *mut *const xmlChar,
) -> *const htmlEntityDesc;
}
extern "C" {
pub fn htmlParseCharRef(ctxt: htmlParserCtxtPtr) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn htmlParseElement(ctxt: htmlParserCtxtPtr);
}
extern "C" {
pub fn htmlNewParserCtxt() -> htmlParserCtxtPtr;
}
extern "C" {
pub fn htmlCreateMemoryParserCtxt(
buffer: *const ::std::os::raw::c_char,
size: ::std::os::raw::c_int,
) -> htmlParserCtxtPtr;
}
extern "C" {
pub fn htmlParseDocument(ctxt: htmlParserCtxtPtr) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn htmlSAXParseDoc(
cur: *const xmlChar,
encoding: *const ::std::os::raw::c_char,
sax: htmlSAXHandlerPtr,
userData: *mut ::std::os::raw::c_void,
) -> htmlDocPtr;
}
extern "C" {
pub fn htmlParseDoc(cur: *const xmlChar, encoding: *const ::std::os::raw::c_char)
-> htmlDocPtr;
}
extern "C" {
pub fn htmlSAXParseFile(
filename: *const ::std::os::raw::c_char,
encoding: *const ::std::os::raw::c_char,
sax: htmlSAXHandlerPtr,
userData: *mut ::std::os::raw::c_void,
) -> htmlDocPtr;
}
extern "C" {
pub fn htmlParseFile(
filename: *const ::std::os::raw::c_char,
encoding: *const ::std::os::raw::c_char,
) -> htmlDocPtr;
}
extern "C" {
pub fn UTF8ToHtml(
out: *mut ::std::os::raw::c_uchar,
outlen: *mut ::std::os::raw::c_int,
in_: *const ::std::os::raw::c_uchar,
inlen: *mut ::std::os::raw::c_int,
) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn htmlEncodeEntities(
out: *mut ::std::os::raw::c_uchar,
outlen: *mut ::std::os::raw::c_int,
in_: *const ::std::os::raw::c_uchar,
inlen: *mut ::std::os::raw::c_int,
quoteChar: ::std::os::raw::c_int,
) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn htmlIsScriptAttribute(name: *const xmlChar) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn htmlHandleOmittedElem(val: ::std::os::raw::c_int) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn htmlCreatePushParserCtxt(
sax: htmlSAXHandlerPtr,
user_data: *mut ::std::os::raw::c_void,
chunk: *const ::std::os::raw::c_char,
size: ::std::os::raw::c_int,
filename: *const ::std::os::raw::c_char,
enc: xmlCharEncoding,
) -> htmlParserCtxtPtr;
}
extern "C" {
pub fn htmlParseChunk(
ctxt: htmlParserCtxtPtr,
chunk: *const ::std::os::raw::c_char,
size: ::std::os::raw::c_int,
terminate: ::std::os::raw::c_int,
) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn htmlFreeParserCtxt(ctxt: htmlParserCtxtPtr);
}
pub const htmlParserOption_HTML_PARSE_RECOVER: htmlParserOption = 1;
pub const htmlParserOption_HTML_PARSE_NODEFDTD: htmlParserOption = 4;
pub const htmlParserOption_HTML_PARSE_NOERROR: htmlParserOption = 32;
pub const htmlParserOption_HTML_PARSE_NOWARNING: htmlParserOption = 64;
pub const htmlParserOption_HTML_PARSE_PEDANTIC: htmlParserOption = 128;
pub const htmlParserOption_HTML_PARSE_NOBLANKS: htmlParserOption = 256;
pub const htmlParserOption_HTML_PARSE_NONET: htmlParserOption = 2048;
pub const htmlParserOption_HTML_PARSE_NOIMPLIED: htmlParserOption = 8192;
pub const htmlParserOption_HTML_PARSE_COMPACT: htmlParserOption = 65536;
pub const htmlParserOption_HTML_PARSE_IGNORE_ENC: htmlParserOption = 2097152;
pub type htmlParserOption = ::std::os::raw::c_uint;
extern "C" {
pub fn htmlCtxtReset(ctxt: htmlParserCtxtPtr);
}
extern "C" {
pub fn htmlCtxtUseOptions(
ctxt: htmlParserCtxtPtr,
options: ::std::os::raw::c_int,
) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn htmlReadDoc(
cur: *const xmlChar,
URL: *const ::std::os::raw::c_char,
encoding: *const ::std::os::raw::c_char,
options: ::std::os::raw::c_int,
) -> htmlDocPtr;
}
extern "C" {
pub fn htmlReadFile(
URL: *const ::std::os::raw::c_char,
encoding: *const ::std::os::raw::c_char,
options: ::std::os::raw::c_int,
) -> htmlDocPtr;
}
extern "C" {
pub fn htmlReadMemory(
buffer: *const ::std::os::raw::c_char,
size: ::std::os::raw::c_int,
URL: *const ::std::os::raw::c_char,
encoding: *const ::std::os::raw::c_char,
options: ::std::os::raw::c_int,
) -> htmlDocPtr;
}
extern "C" {
pub fn htmlReadFd(
fd: ::std::os::raw::c_int,
URL: *const ::std::os::raw::c_char,
encoding: *const ::std::os::raw::c_char,
options: ::std::os::raw::c_int,
) -> htmlDocPtr;
}
extern "C" {
pub fn htmlReadIO(
ioread: xmlInputReadCallback,
ioclose: xmlInputCloseCallback,
ioctx: *mut ::std::os::raw::c_void,
URL: *const ::std::os::raw::c_char,
encoding: *const ::std::os::raw::c_char,
options: ::std::os::raw::c_int,
) -> htmlDocPtr;
}
extern "C" {
pub fn htmlCtxtReadDoc(
ctxt: xmlParserCtxtPtr,
cur: *const xmlChar,
URL: *const ::std::os::raw::c_char,
encoding: *const ::std::os::raw::c_char,
options: ::std::os::raw::c_int,
) -> htmlDocPtr;
}
extern "C" {
pub fn htmlCtxtReadFile(
ctxt: xmlParserCtxtPtr,
filename: *const ::std::os::raw::c_char,
encoding: *const ::std::os::raw::c_char,
options: ::std::os::raw::c_int,
) -> htmlDocPtr;
}
extern "C" {
pub fn htmlCtxtReadMemory(
ctxt: xmlParserCtxtPtr,
buffer: *const ::std::os::raw::c_char,
size: ::std::os::raw::c_int,
URL: *const ::std::os::raw::c_char,
encoding: *const ::std::os::raw::c_char,
options: ::std::os::raw::c_int,
) -> htmlDocPtr;
}
extern "C" {
pub fn htmlCtxtReadFd(
ctxt: xmlParserCtxtPtr,
fd: ::std::os::raw::c_int,
URL: *const ::std::os::raw::c_char,
encoding: *const ::std::os::raw::c_char,
options: ::std::os::raw::c_int,
) -> htmlDocPtr;
}
extern "C" {
pub fn htmlCtxtReadIO(
ctxt: xmlParserCtxtPtr,
ioread: xmlInputReadCallback,
ioclose: xmlInputCloseCallback,
ioctx: *mut ::std::os::raw::c_void,
URL: *const ::std::os::raw::c_char,
encoding: *const ::std::os::raw::c_char,
options: ::std::os::raw::c_int,
) -> htmlDocPtr;
}
pub const htmlStatus_HTML_NA: htmlStatus = 0;
pub const htmlStatus_HTML_INVALID: htmlStatus = 1;
pub const htmlStatus_HTML_DEPRECATED: htmlStatus = 2;
pub const htmlStatus_HTML_VALID: htmlStatus = 4;
pub const htmlStatus_HTML_REQUIRED: htmlStatus = 12;
pub type htmlStatus = ::std::os::raw::c_uint;
extern "C" {
pub fn htmlAttrAllowed(
arg1: *const htmlElemDesc,
arg2: *const xmlChar,
arg3: ::std::os::raw::c_int,
) -> htmlStatus;
}
extern "C" {
pub fn htmlElementAllowedHere(
arg1: *const htmlElemDesc,
arg2: *const xmlChar,
) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn htmlElementStatusHere(
arg1: *const htmlElemDesc,
arg2: *const htmlElemDesc,
) -> htmlStatus;
}
extern "C" {
pub fn htmlNodeStatus(arg1: htmlNodePtr, arg2: ::std::os::raw::c_int) -> htmlStatus;
}
extern "C" {
pub fn htmlNewDoc(URI: *const xmlChar, ExternalID: *const xmlChar) -> htmlDocPtr;
}
extern "C" {
pub fn htmlNewDocNoDtD(URI: *const xmlChar, ExternalID: *const xmlChar) -> htmlDocPtr;
}
extern "C" {
pub fn htmlGetMetaEncoding(doc: htmlDocPtr) -> *const xmlChar;
}
extern "C" {
pub fn htmlSetMetaEncoding(doc: htmlDocPtr, encoding: *const xmlChar) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn htmlDocDumpMemory(
cur: xmlDocPtr,
mem: *mut *mut xmlChar,
size: *mut ::std::os::raw::c_int,
);
}
extern "C" {
pub fn htmlDocDumpMemoryFormat(
cur: xmlDocPtr,
mem: *mut *mut xmlChar,
size: *mut ::std::os::raw::c_int,
format: ::std::os::raw::c_int,
);
}
extern "C" {
pub fn htmlDocDump(f: *mut FILE, cur: xmlDocPtr) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn htmlSaveFile(
filename: *const ::std::os::raw::c_char,
cur: xmlDocPtr,
) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn htmlNodeDump(
buf: xmlBufferPtr,
doc: xmlDocPtr,
cur: xmlNodePtr,
) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn htmlNodeDumpFile(out: *mut FILE, doc: xmlDocPtr, cur: xmlNodePtr);
}
extern "C" {
pub fn htmlNodeDumpFileFormat(
out: *mut FILE,
doc: xmlDocPtr,
cur: xmlNodePtr,
encoding: *const ::std::os::raw::c_char,
format: ::std::os::raw::c_int,
) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn htmlSaveFileEnc(
filename: *const ::std::os::raw::c_char,
cur: xmlDocPtr,
encoding: *const ::std::os::raw::c_char,
) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn htmlSaveFileFormat(
filename: *const ::std::os::raw::c_char,
cur: xmlDocPtr,
encoding: *const ::std::os::raw::c_char,
format: ::std::os::raw::c_int,
) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn htmlNodeDumpFormatOutput(
buf: xmlOutputBufferPtr,
doc: xmlDocPtr,
cur: xmlNodePtr,
encoding: *const ::std::os::raw::c_char,
format: ::std::os::raw::c_int,
);
}
extern "C" {
pub fn htmlDocContentDumpOutput(
buf: xmlOutputBufferPtr,
cur: xmlDocPtr,
encoding: *const ::std::os::raw::c_char,
);
}
extern "C" {
pub fn htmlDocContentDumpFormatOutput(
buf: xmlOutputBufferPtr,
cur: xmlDocPtr,
encoding: *const ::std::os::raw::c_char,
format: ::std::os::raw::c_int,
);
}
extern "C" {
pub fn htmlNodeDumpOutput(
buf: xmlOutputBufferPtr,
doc: xmlDocPtr,
cur: xmlNodePtr,
encoding: *const ::std::os::raw::c_char,
);
}
extern "C" {
pub fn htmlIsBooleanAttr(name: *const xmlChar) -> ::std::os::raw::c_int;
}
pub const xmlSchemaWhitespaceValueType_XML_SCHEMA_WHITESPACE_UNKNOWN: xmlSchemaWhitespaceValueType =
0;
pub const xmlSchemaWhitespaceValueType_XML_SCHEMA_WHITESPACE_PRESERVE:
xmlSchemaWhitespaceValueType = 1;
pub const xmlSchemaWhitespaceValueType_XML_SCHEMA_WHITESPACE_REPLACE: xmlSchemaWhitespaceValueType =
2;
pub const xmlSchemaWhitespaceValueType_XML_SCHEMA_WHITESPACE_COLLAPSE:
xmlSchemaWhitespaceValueType = 3;
pub type xmlSchemaWhitespaceValueType = ::std::os::raw::c_uint;
extern "C" {
pub fn xmlSchemaInitTypes();
}
extern "C" {
pub fn xmlSchemaCleanupTypes();
}
extern "C" {
pub fn xmlSchemaGetPredefinedType(name: *const xmlChar, ns: *const xmlChar)
-> xmlSchemaTypePtr;
}
extern "C" {
pub fn xmlSchemaValidatePredefinedType(
type_: xmlSchemaTypePtr,
value: *const xmlChar,
val: *mut xmlSchemaValPtr,
) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn xmlSchemaValPredefTypeNode(
type_: xmlSchemaTypePtr,
value: *const xmlChar,
val: *mut xmlSchemaValPtr,
node: xmlNodePtr,
) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn xmlSchemaValidateFacet(
base: xmlSchemaTypePtr,
facet: xmlSchemaFacetPtr,
value: *const xmlChar,
val: xmlSchemaValPtr,
) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn xmlSchemaValidateFacetWhtsp(
facet: xmlSchemaFacetPtr,
fws: xmlSchemaWhitespaceValueType,
valType: xmlSchemaValType,
value: *const xmlChar,
val: xmlSchemaValPtr,
ws: xmlSchemaWhitespaceValueType,
) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn xmlSchemaFreeValue(val: xmlSchemaValPtr);
}
extern "C" {
pub fn xmlSchemaNewFacet() -> xmlSchemaFacetPtr;
}
extern "C" {
pub fn xmlSchemaCheckFacet(
facet: xmlSchemaFacetPtr,
typeDecl: xmlSchemaTypePtr,
ctxt: xmlSchemaParserCtxtPtr,
name: *const xmlChar,
) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn xmlSchemaFreeFacet(facet: xmlSchemaFacetPtr);
}
extern "C" {
pub fn xmlSchemaCompareValues(x: xmlSchemaValPtr, y: xmlSchemaValPtr) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn xmlSchemaGetBuiltInListSimpleTypeItemType(type_: xmlSchemaTypePtr) -> xmlSchemaTypePtr;
}
extern "C" {
pub fn xmlSchemaValidateListSimpleTypeFacet(
facet: xmlSchemaFacetPtr,
value: *const xmlChar,
actualLen: ::std::os::raw::c_ulong,
expectedLen: *mut ::std::os::raw::c_ulong,
) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn xmlSchemaGetBuiltInType(type_: xmlSchemaValType) -> xmlSchemaTypePtr;
}
extern "C" {
pub fn xmlSchemaIsBuiltInTypeFacet(
type_: xmlSchemaTypePtr,
facetType: ::std::os::raw::c_int,
) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn xmlSchemaCollapseString(value: *const xmlChar) -> *mut xmlChar;
}
extern "C" {
pub fn xmlSchemaWhiteSpaceReplace(value: *const xmlChar) -> *mut xmlChar;
}
extern "C" {
pub fn xmlSchemaGetFacetValueAsULong(facet: xmlSchemaFacetPtr) -> ::std::os::raw::c_ulong;
}
extern "C" {
pub fn xmlSchemaValidateLengthFacet(
type_: xmlSchemaTypePtr,
facet: xmlSchemaFacetPtr,
value: *const xmlChar,
val: xmlSchemaValPtr,
length: *mut ::std::os::raw::c_ulong,
) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn xmlSchemaValidateLengthFacetWhtsp(
facet: xmlSchemaFacetPtr,
valType: xmlSchemaValType,
value: *const xmlChar,
val: xmlSchemaValPtr,
length: *mut ::std::os::raw::c_ulong,
ws: xmlSchemaWhitespaceValueType,
) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn xmlSchemaValPredefTypeNodeNoNorm(
type_: xmlSchemaTypePtr,
value: *const xmlChar,
val: *mut xmlSchemaValPtr,
node: xmlNodePtr,
) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn xmlSchemaGetCanonValue(
val: xmlSchemaValPtr,
retValue: *mut *const xmlChar,
) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn xmlSchemaGetCanonValueWhtsp(
val: xmlSchemaValPtr,
retValue: *mut *const xmlChar,
ws: xmlSchemaWhitespaceValueType,
) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn xmlSchemaValueAppend(
prev: xmlSchemaValPtr,
cur: xmlSchemaValPtr,
) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn xmlSchemaValueGetNext(cur: xmlSchemaValPtr) -> xmlSchemaValPtr;
}
extern "C" {
pub fn xmlSchemaValueGetAsString(val: xmlSchemaValPtr) -> *const xmlChar;
}
extern "C" {
pub fn xmlSchemaValueGetAsBoolean(val: xmlSchemaValPtr) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn xmlSchemaNewStringValue(
type_: xmlSchemaValType,
value: *const xmlChar,
) -> xmlSchemaValPtr;
}
extern "C" {
pub fn xmlSchemaNewNOTATIONValue(name: *const xmlChar, ns: *const xmlChar) -> xmlSchemaValPtr;
}
extern "C" {
pub fn xmlSchemaNewQNameValue(
namespaceName: *const xmlChar,
localName: *const xmlChar,
) -> xmlSchemaValPtr;
}
extern "C" {
pub fn xmlSchemaCompareValuesWhtsp(
x: xmlSchemaValPtr,
xws: xmlSchemaWhitespaceValueType,
y: xmlSchemaValPtr,
yws: xmlSchemaWhitespaceValueType,
) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn xmlSchemaCopyValue(val: xmlSchemaValPtr) -> xmlSchemaValPtr;
}
extern "C" {
pub fn xmlSchemaGetValType(val: xmlSchemaValPtr) -> xmlSchemaValType;
}
pub const xmlC14NMode_XML_C14N_1_0: xmlC14NMode = 0;
pub const xmlC14NMode_XML_C14N_EXCLUSIVE_1_0: xmlC14NMode = 1;
pub const xmlC14NMode_XML_C14N_1_1: xmlC14NMode = 2;
pub type xmlC14NMode = ::std::os::raw::c_uint;
extern "C" {
pub fn xmlC14NDocSaveTo(
doc: xmlDocPtr,
nodes: xmlNodeSetPtr,
mode: ::std::os::raw::c_int,
inclusive_ns_prefixes: *mut *mut xmlChar,
with_comments: ::std::os::raw::c_int,
buf: xmlOutputBufferPtr,
) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn xmlC14NDocDumpMemory(
doc: xmlDocPtr,
nodes: xmlNodeSetPtr,
mode: ::std::os::raw::c_int,
inclusive_ns_prefixes: *mut *mut xmlChar,
with_comments: ::std::os::raw::c_int,
doc_txt_ptr: *mut *mut xmlChar,
) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn xmlC14NDocSave(
doc: xmlDocPtr,
nodes: xmlNodeSetPtr,
mode: ::std::os::raw::c_int,
inclusive_ns_prefixes: *mut *mut xmlChar,
with_comments: ::std::os::raw::c_int,
filename: *const ::std::os::raw::c_char,
compression: ::std::os::raw::c_int,
) -> ::std::os::raw::c_int;
}
pub type xmlC14NIsVisibleCallback = ::std::option::Option<
unsafe extern "C" fn(
user_data: *mut ::std::os::raw::c_void,
node: xmlNodePtr,
parent: xmlNodePtr,
) -> ::std::os::raw::c_int,
>;
extern "C" {
pub fn xmlC14NExecute(
doc: xmlDocPtr,
is_visible_callback: xmlC14NIsVisibleCallback,
user_data: *mut ::std::os::raw::c_void,
mode: ::std::os::raw::c_int,
inclusive_ns_prefixes: *mut *mut xmlChar,
with_comments: ::std::os::raw::c_int,
buf: xmlOutputBufferPtr,
) -> ::std::os::raw::c_int;
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct _xmlModule {
_unused: [u8; 0],
}
pub type xmlModule = _xmlModule;
pub type xmlModulePtr = *mut xmlModule;
pub const xmlModuleOption_XML_MODULE_LAZY: xmlModuleOption = 1;
pub const xmlModuleOption_XML_MODULE_LOCAL: xmlModuleOption = 2;
pub type xmlModuleOption = ::std::os::raw::c_uint;
extern "C" {
pub fn xmlModuleOpen(
filename: *const ::std::os::raw::c_char,
options: ::std::os::raw::c_int,
) -> xmlModulePtr;
}
extern "C" {
pub fn xmlModuleSymbol(
module: xmlModulePtr,
name: *const ::std::os::raw::c_char,
result: *mut *mut ::std::os::raw::c_void,
) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn xmlModuleClose(module: xmlModulePtr) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn xmlModuleFree(module: xmlModulePtr) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn xmlNanoHTTPInit();
}
extern "C" {
pub fn xmlNanoHTTPCleanup();
}
extern "C" {
pub fn xmlNanoHTTPScanProxy(URL: *const ::std::os::raw::c_char);
}
extern "C" {
pub fn xmlNanoHTTPFetch(
URL: *const ::std::os::raw::c_char,
filename: *const ::std::os::raw::c_char,
contentType: *mut *mut ::std::os::raw::c_char,
) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn xmlNanoHTTPMethod(
URL: *const ::std::os::raw::c_char,
method: *const ::std::os::raw::c_char,
input: *const ::std::os::raw::c_char,
contentType: *mut *mut ::std::os::raw::c_char,
headers: *const ::std::os::raw::c_char,
ilen: ::std::os::raw::c_int,
) -> *mut ::std::os::raw::c_void;
}
extern "C" {
pub fn xmlNanoHTTPMethodRedir(
URL: *const ::std::os::raw::c_char,
method: *const ::std::os::raw::c_char,
input: *const ::std::os::raw::c_char,
contentType: *mut *mut ::std::os::raw::c_char,
redir: *mut *mut ::std::os::raw::c_char,
headers: *const ::std::os::raw::c_char,
ilen: ::std::os::raw::c_int,
) -> *mut ::std::os::raw::c_void;
}
extern "C" {
pub fn xmlNanoHTTPOpen(
URL: *const ::std::os::raw::c_char,
contentType: *mut *mut ::std::os::raw::c_char,
) -> *mut ::std::os::raw::c_void;
}
extern "C" {
pub fn xmlNanoHTTPOpenRedir(
URL: *const ::std::os::raw::c_char,
contentType: *mut *mut ::std::os::raw::c_char,
redir: *mut *mut ::std::os::raw::c_char,
) -> *mut ::std::os::raw::c_void;
}
extern "C" {
pub fn xmlNanoHTTPReturnCode(ctx: *mut ::std::os::raw::c_void) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn xmlNanoHTTPAuthHeader(ctx: *mut ::std::os::raw::c_void)
-> *const ::std::os::raw::c_char;
}
extern "C" {
pub fn xmlNanoHTTPRedir(ctx: *mut ::std::os::raw::c_void) -> *const ::std::os::raw::c_char;
}
extern "C" {
pub fn xmlNanoHTTPContentLength(ctx: *mut ::std::os::raw::c_void) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn xmlNanoHTTPEncoding(ctx: *mut ::std::os::raw::c_void) -> *const ::std::os::raw::c_char;
}
extern "C" {
pub fn xmlNanoHTTPMimeType(ctx: *mut ::std::os::raw::c_void) -> *const ::std::os::raw::c_char;
}
extern "C" {
pub fn xmlNanoHTTPRead(
ctx: *mut ::std::os::raw::c_void,
dest: *mut ::std::os::raw::c_void,
len: ::std::os::raw::c_int,
) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn xmlNanoHTTPSave(
ctxt: *mut ::std::os::raw::c_void,
filename: *const ::std::os::raw::c_char,
) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn xmlNanoHTTPClose(ctx: *mut ::std::os::raw::c_void);
}
extern "C" {
pub fn xmlUCSIsAegeanNumbers(code: ::std::os::raw::c_int) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn xmlUCSIsAlphabeticPresentationForms(
code: ::std::os::raw::c_int,
) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn xmlUCSIsArabic(code: ::std::os::raw::c_int) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn xmlUCSIsArabicPresentationFormsA(code: ::std::os::raw::c_int) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn xmlUCSIsArabicPresentationFormsB(code: ::std::os::raw::c_int) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn xmlUCSIsArmenian(code: ::std::os::raw::c_int) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn xmlUCSIsArrows(code: ::std::os::raw::c_int) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn xmlUCSIsBasicLatin(code: ::std::os::raw::c_int) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn xmlUCSIsBengali(code: ::std::os::raw::c_int) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn xmlUCSIsBlockElements(code: ::std::os::raw::c_int) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn xmlUCSIsBopomofo(code: ::std::os::raw::c_int) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn xmlUCSIsBopomofoExtended(code: ::std::os::raw::c_int) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn xmlUCSIsBoxDrawing(code: ::std::os::raw::c_int) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn xmlUCSIsBraillePatterns(code: ::std::os::raw::c_int) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn xmlUCSIsBuhid(code: ::std::os::raw::c_int) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn xmlUCSIsByzantineMusicalSymbols(code: ::std::os::raw::c_int) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn xmlUCSIsCJKCompatibility(code: ::std::os::raw::c_int) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn xmlUCSIsCJKCompatibilityForms(code: ::std::os::raw::c_int) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn xmlUCSIsCJKCompatibilityIdeographs(code: ::std::os::raw::c_int)
-> ::std::os::raw::c_int;
}
extern "C" {
pub fn xmlUCSIsCJKCompatibilityIdeographsSupplement(
code: ::std::os::raw::c_int,
) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn xmlUCSIsCJKRadicalsSupplement(code: ::std::os::raw::c_int) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn xmlUCSIsCJKSymbolsandPunctuation(code: ::std::os::raw::c_int) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn xmlUCSIsCJKUnifiedIdeographs(code: ::std::os::raw::c_int) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn xmlUCSIsCJKUnifiedIdeographsExtensionA(
code: ::std::os::raw::c_int,
) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn xmlUCSIsCJKUnifiedIdeographsExtensionB(
code: ::std::os::raw::c_int,
) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn xmlUCSIsCherokee(code: ::std::os::raw::c_int) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn xmlUCSIsCombiningDiacriticalMarks(code: ::std::os::raw::c_int) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn xmlUCSIsCombiningDiacriticalMarksforSymbols(
code: ::std::os::raw::c_int,
) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn xmlUCSIsCombiningHalfMarks(code: ::std::os::raw::c_int) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn xmlUCSIsCombiningMarksforSymbols(code: ::std::os::raw::c_int) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn xmlUCSIsControlPictures(code: ::std::os::raw::c_int) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn xmlUCSIsCurrencySymbols(code: ::std::os::raw::c_int) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn xmlUCSIsCypriotSyllabary(code: ::std::os::raw::c_int) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn xmlUCSIsCyrillic(code: ::std::os::raw::c_int) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn xmlUCSIsCyrillicSupplement(code: ::std::os::raw::c_int) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn xmlUCSIsDeseret(code: ::std::os::raw::c_int) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn xmlUCSIsDevanagari(code: ::std::os::raw::c_int) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn xmlUCSIsDingbats(code: ::std::os::raw::c_int) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn xmlUCSIsEnclosedAlphanumerics(code: ::std::os::raw::c_int) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn xmlUCSIsEnclosedCJKLettersandMonths(
code: ::std::os::raw::c_int,
) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn xmlUCSIsEthiopic(code: ::std::os::raw::c_int) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn xmlUCSIsGeneralPunctuation(code: ::std::os::raw::c_int) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn xmlUCSIsGeometricShapes(code: ::std::os::raw::c_int) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn xmlUCSIsGeorgian(code: ::std::os::raw::c_int) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn xmlUCSIsGothic(code: ::std::os::raw::c_int) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn xmlUCSIsGreek(code: ::std::os::raw::c_int) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn xmlUCSIsGreekExtended(code: ::std::os::raw::c_int) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn xmlUCSIsGreekandCoptic(code: ::std::os::raw::c_int) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn xmlUCSIsGujarati(code: ::std::os::raw::c_int) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn xmlUCSIsGurmukhi(code: ::std::os::raw::c_int) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn xmlUCSIsHalfwidthandFullwidthForms(code: ::std::os::raw::c_int)
-> ::std::os::raw::c_int;
}
extern "C" {
pub fn xmlUCSIsHangulCompatibilityJamo(code: ::std::os::raw::c_int) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn xmlUCSIsHangulJamo(code: ::std::os::raw::c_int) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn xmlUCSIsHangulSyllables(code: ::std::os::raw::c_int) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn xmlUCSIsHanunoo(code: ::std::os::raw::c_int) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn xmlUCSIsHebrew(code: ::std::os::raw::c_int) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn xmlUCSIsHighPrivateUseSurrogates(code: ::std::os::raw::c_int) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn xmlUCSIsHighSurrogates(code: ::std::os::raw::c_int) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn xmlUCSIsHiragana(code: ::std::os::raw::c_int) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn xmlUCSIsIPAExtensions(code: ::std::os::raw::c_int) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn xmlUCSIsIdeographicDescriptionCharacters(
code: ::std::os::raw::c_int,
) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn xmlUCSIsKanbun(code: ::std::os::raw::c_int) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn xmlUCSIsKangxiRadicals(code: ::std::os::raw::c_int) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn xmlUCSIsKannada(code: ::std::os::raw::c_int) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn xmlUCSIsKatakana(code: ::std::os::raw::c_int) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn xmlUCSIsKatakanaPhoneticExtensions(code: ::std::os::raw::c_int)
-> ::std::os::raw::c_int;
}
extern "C" {
pub fn xmlUCSIsKhmer(code: ::std::os::raw::c_int) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn xmlUCSIsKhmerSymbols(code: ::std::os::raw::c_int) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn xmlUCSIsLao(code: ::std::os::raw::c_int) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn xmlUCSIsLatin1Supplement(code: ::std::os::raw::c_int) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn xmlUCSIsLatinExtendedA(code: ::std::os::raw::c_int) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn xmlUCSIsLatinExtendedB(code: ::std::os::raw::c_int) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn xmlUCSIsLatinExtendedAdditional(code: ::std::os::raw::c_int) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn xmlUCSIsLetterlikeSymbols(code: ::std::os::raw::c_int) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn xmlUCSIsLimbu(code: ::std::os::raw::c_int) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn xmlUCSIsLinearBIdeograms(code: ::std::os::raw::c_int) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn xmlUCSIsLinearBSyllabary(code: ::std::os::raw::c_int) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn xmlUCSIsLowSurrogates(code: ::std::os::raw::c_int) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn xmlUCSIsMalayalam(code: ::std::os::raw::c_int) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn xmlUCSIsMathematicalAlphanumericSymbols(
code: ::std::os::raw::c_int,
) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn xmlUCSIsMathematicalOperators(code: ::std::os::raw::c_int) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn xmlUCSIsMiscellaneousMathematicalSymbolsA(
code: ::std::os::raw::c_int,
) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn xmlUCSIsMiscellaneousMathematicalSymbolsB(
code: ::std::os::raw::c_int,
) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn xmlUCSIsMiscellaneousSymbols(code: ::std::os::raw::c_int) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn xmlUCSIsMiscellaneousSymbolsandArrows(
code: ::std::os::raw::c_int,
) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn xmlUCSIsMiscellaneousTechnical(code: ::std::os::raw::c_int) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn xmlUCSIsMongolian(code: ::std::os::raw::c_int) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn xmlUCSIsMusicalSymbols(code: ::std::os::raw::c_int) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn xmlUCSIsMyanmar(code: ::std::os::raw::c_int) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn xmlUCSIsNumberForms(code: ::std::os::raw::c_int) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn xmlUCSIsOgham(code: ::std::os::raw::c_int) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn xmlUCSIsOldItalic(code: ::std::os::raw::c_int) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn xmlUCSIsOpticalCharacterRecognition(
code: ::std::os::raw::c_int,
) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn xmlUCSIsOriya(code: ::std::os::raw::c_int) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn xmlUCSIsOsmanya(code: ::std::os::raw::c_int) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn xmlUCSIsPhoneticExtensions(code: ::std::os::raw::c_int) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn xmlUCSIsPrivateUse(code: ::std::os::raw::c_int) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn xmlUCSIsPrivateUseArea(code: ::std::os::raw::c_int) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn xmlUCSIsRunic(code: ::std::os::raw::c_int) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn xmlUCSIsShavian(code: ::std::os::raw::c_int) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn xmlUCSIsSinhala(code: ::std::os::raw::c_int) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn xmlUCSIsSmallFormVariants(code: ::std::os::raw::c_int) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn xmlUCSIsSpacingModifierLetters(code: ::std::os::raw::c_int) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn xmlUCSIsSpecials(code: ::std::os::raw::c_int) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn xmlUCSIsSuperscriptsandSubscripts(code: ::std::os::raw::c_int) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn xmlUCSIsSupplementalArrowsA(code: ::std::os::raw::c_int) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn xmlUCSIsSupplementalArrowsB(code: ::std::os::raw::c_int) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn xmlUCSIsSupplementalMathematicalOperators(
code: ::std::os::raw::c_int,
) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn xmlUCSIsSupplementaryPrivateUseAreaA(
code: ::std::os::raw::c_int,
) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn xmlUCSIsSupplementaryPrivateUseAreaB(
code: ::std::os::raw::c_int,
) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn xmlUCSIsSyriac(code: ::std::os::raw::c_int) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn xmlUCSIsTagalog(code: ::std::os::raw::c_int) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn xmlUCSIsTagbanwa(code: ::std::os::raw::c_int) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn xmlUCSIsTags(code: ::std::os::raw::c_int) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn xmlUCSIsTaiLe(code: ::std::os::raw::c_int) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn xmlUCSIsTaiXuanJingSymbols(code: ::std::os::raw::c_int) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn xmlUCSIsTamil(code: ::std::os::raw::c_int) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn xmlUCSIsTelugu(code: ::std::os::raw::c_int) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn xmlUCSIsThaana(code: ::std::os::raw::c_int) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn xmlUCSIsThai(code: ::std::os::raw::c_int) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn xmlUCSIsTibetan(code: ::std::os::raw::c_int) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn xmlUCSIsUgaritic(code: ::std::os::raw::c_int) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn xmlUCSIsUnifiedCanadianAboriginalSyllabics(
code: ::std::os::raw::c_int,
) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn xmlUCSIsVariationSelectors(code: ::std::os::raw::c_int) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn xmlUCSIsVariationSelectorsSupplement(
code: ::std::os::raw::c_int,
) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn xmlUCSIsYiRadicals(code: ::std::os::raw::c_int) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn xmlUCSIsYiSyllables(code: ::std::os::raw::c_int) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn xmlUCSIsYijingHexagramSymbols(code: ::std::os::raw::c_int) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn xmlUCSIsBlock(
code: ::std::os::raw::c_int,
block: *const ::std::os::raw::c_char,
) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn xmlUCSIsCatC(code: ::std::os::raw::c_int) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn xmlUCSIsCatCc(code: ::std::os::raw::c_int) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn xmlUCSIsCatCf(code: ::std::os::raw::c_int) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn xmlUCSIsCatCo(code: ::std::os::raw::c_int) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn xmlUCSIsCatCs(code: ::std::os::raw::c_int) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn xmlUCSIsCatL(code: ::std::os::raw::c_int) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn xmlUCSIsCatLl(code: ::std::os::raw::c_int) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn xmlUCSIsCatLm(code: ::std::os::raw::c_int) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn xmlUCSIsCatLo(code: ::std::os::raw::c_int) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn xmlUCSIsCatLt(code: ::std::os::raw::c_int) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn xmlUCSIsCatLu(code: ::std::os::raw::c_int) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn xmlUCSIsCatM(code: ::std::os::raw::c_int) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn xmlUCSIsCatMc(code: ::std::os::raw::c_int) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn xmlUCSIsCatMe(code: ::std::os::raw::c_int) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn xmlUCSIsCatMn(code: ::std::os::raw::c_int) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn xmlUCSIsCatN(code: ::std::os::raw::c_int) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn xmlUCSIsCatNd(code: ::std::os::raw::c_int) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn xmlUCSIsCatNl(code: ::std::os::raw::c_int) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn xmlUCSIsCatNo(code: ::std::os::raw::c_int) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn xmlUCSIsCatP(code: ::std::os::raw::c_int) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn xmlUCSIsCatPc(code: ::std::os::raw::c_int) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn xmlUCSIsCatPd(code: ::std::os::raw::c_int) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn xmlUCSIsCatPe(code: ::std::os::raw::c_int) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn xmlUCSIsCatPf(code: ::std::os::raw::c_int) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn xmlUCSIsCatPi(code: ::std::os::raw::c_int) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn xmlUCSIsCatPo(code: ::std::os::raw::c_int) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn xmlUCSIsCatPs(code: ::std::os::raw::c_int) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn xmlUCSIsCatS(code: ::std::os::raw::c_int) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn xmlUCSIsCatSc(code: ::std::os::raw::c_int) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn xmlUCSIsCatSk(code: ::std::os::raw::c_int) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn xmlUCSIsCatSm(code: ::std::os::raw::c_int) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn xmlUCSIsCatSo(code: ::std::os::raw::c_int) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn xmlUCSIsCatZ(code: ::std::os::raw::c_int) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn xmlUCSIsCatZl(code: ::std::os::raw::c_int) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn xmlUCSIsCatZp(code: ::std::os::raw::c_int) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn xmlUCSIsCatZs(code: ::std::os::raw::c_int) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn xmlUCSIsCat(
code: ::std::os::raw::c_int,
cat: *const ::std::os::raw::c_char,
) -> ::std::os::raw::c_int;
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct _xmlTextWriter {
_unused: [u8; 0],
}
pub type xmlTextWriter = _xmlTextWriter;
pub type xmlTextWriterPtr = *mut xmlTextWriter;
extern "C" {
pub fn xmlNewTextWriter(out: xmlOutputBufferPtr) -> xmlTextWriterPtr;
}
extern "C" {
pub fn xmlNewTextWriterFilename(
uri: *const ::std::os::raw::c_char,
compression: ::std::os::raw::c_int,
) -> xmlTextWriterPtr;
}
extern "C" {
pub fn xmlNewTextWriterMemory(
buf: xmlBufferPtr,
compression: ::std::os::raw::c_int,
) -> xmlTextWriterPtr;
}
extern "C" {
pub fn xmlNewTextWriterPushParser(
ctxt: xmlParserCtxtPtr,
compression: ::std::os::raw::c_int,
) -> xmlTextWriterPtr;
}
extern "C" {
pub fn xmlNewTextWriterDoc(
doc: *mut xmlDocPtr,
compression: ::std::os::raw::c_int,
) -> xmlTextWriterPtr;
}
extern "C" {
pub fn xmlNewTextWriterTree(
doc: xmlDocPtr,
node: xmlNodePtr,
compression: ::std::os::raw::c_int,
) -> xmlTextWriterPtr;
}
extern "C" {
pub fn xmlFreeTextWriter(writer: xmlTextWriterPtr);
}
extern "C" {
pub fn xmlTextWriterStartDocument(
writer: xmlTextWriterPtr,
version: *const ::std::os::raw::c_char,
encoding: *const ::std::os::raw::c_char,
standalone: *const ::std::os::raw::c_char,
) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn xmlTextWriterEndDocument(writer: xmlTextWriterPtr) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn xmlTextWriterStartComment(writer: xmlTextWriterPtr) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn xmlTextWriterEndComment(writer: xmlTextWriterPtr) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn xmlTextWriterWriteFormatComment(
writer: xmlTextWriterPtr,
format: *const ::std::os::raw::c_char,
...
) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn xmlTextWriterWriteVFormatComment(
writer: xmlTextWriterPtr,
format: *const ::std::os::raw::c_char,
argptr: va_list,
) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn xmlTextWriterWriteComment(
writer: xmlTextWriterPtr,
content: *const xmlChar,
) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn xmlTextWriterStartElement(
writer: xmlTextWriterPtr,
name: *const xmlChar,
) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn xmlTextWriterStartElementNS(
writer: xmlTextWriterPtr,
prefix: *const xmlChar,
name: *const xmlChar,
namespaceURI: *const xmlChar,
) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn xmlTextWriterEndElement(writer: xmlTextWriterPtr) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn xmlTextWriterFullEndElement(writer: xmlTextWriterPtr) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn xmlTextWriterWriteFormatElement(
writer: xmlTextWriterPtr,
name: *const xmlChar,
format: *const ::std::os::raw::c_char,
...
) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn xmlTextWriterWriteVFormatElement(
writer: xmlTextWriterPtr,
name: *const xmlChar,
format: *const ::std::os::raw::c_char,
argptr: va_list,
) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn xmlTextWriterWriteElement(
writer: xmlTextWriterPtr,
name: *const xmlChar,
content: *const xmlChar,
) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn xmlTextWriterWriteFormatElementNS(
writer: xmlTextWriterPtr,
prefix: *const xmlChar,
name: *const xmlChar,
namespaceURI: *const xmlChar,
format: *const ::std::os::raw::c_char,
...
) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn xmlTextWriterWriteVFormatElementNS(
writer: xmlTextWriterPtr,
prefix: *const xmlChar,
name: *const xmlChar,
namespaceURI: *const xmlChar,
format: *const ::std::os::raw::c_char,
argptr: va_list,
) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn xmlTextWriterWriteElementNS(
writer: xmlTextWriterPtr,
prefix: *const xmlChar,
name: *const xmlChar,
namespaceURI: *const xmlChar,
content: *const xmlChar,
) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn xmlTextWriterWriteFormatRaw(
writer: xmlTextWriterPtr,
format: *const ::std::os::raw::c_char,
...
) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn xmlTextWriterWriteVFormatRaw(
writer: xmlTextWriterPtr,
format: *const ::std::os::raw::c_char,
argptr: va_list,
) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn xmlTextWriterWriteRawLen(
writer: xmlTextWriterPtr,
content: *const xmlChar,
len: ::std::os::raw::c_int,
) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn xmlTextWriterWriteRaw(
writer: xmlTextWriterPtr,
content: *const xmlChar,
) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn xmlTextWriterWriteFormatString(
writer: xmlTextWriterPtr,
format: *const ::std::os::raw::c_char,
...
) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn xmlTextWriterWriteVFormatString(
writer: xmlTextWriterPtr,
format: *const ::std::os::raw::c_char,
argptr: va_list,
) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn xmlTextWriterWriteString(
writer: xmlTextWriterPtr,
content: *const xmlChar,
) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn xmlTextWriterWriteBase64(
writer: xmlTextWriterPtr,
data: *const ::std::os::raw::c_char,
start: ::std::os::raw::c_int,
len: ::std::os::raw::c_int,
) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn xmlTextWriterWriteBinHex(
writer: xmlTextWriterPtr,
data: *const ::std::os::raw::c_char,
start: ::std::os::raw::c_int,
len: ::std::os::raw::c_int,
) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn xmlTextWriterStartAttribute(
writer: xmlTextWriterPtr,
name: *const xmlChar,
) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn xmlTextWriterStartAttributeNS(
writer: xmlTextWriterPtr,
prefix: *const xmlChar,
name: *const xmlChar,
namespaceURI: *const xmlChar,
) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn xmlTextWriterEndAttribute(writer: xmlTextWriterPtr) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn xmlTextWriterWriteFormatAttribute(
writer: xmlTextWriterPtr,
name: *const xmlChar,
format: *const ::std::os::raw::c_char,
...
) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn xmlTextWriterWriteVFormatAttribute(
writer: xmlTextWriterPtr,
name: *const xmlChar,
format: *const ::std::os::raw::c_char,
argptr: va_list,
) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn xmlTextWriterWriteAttribute(
writer: xmlTextWriterPtr,
name: *const xmlChar,
content: *const xmlChar,
) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn xmlTextWriterWriteFormatAttributeNS(
writer: xmlTextWriterPtr,
prefix: *const xmlChar,
name: *const xmlChar,
namespaceURI: *const xmlChar,
format: *const ::std::os::raw::c_char,
...
) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn xmlTextWriterWriteVFormatAttributeNS(
writer: xmlTextWriterPtr,
prefix: *const xmlChar,
name: *const xmlChar,
namespaceURI: *const xmlChar,
format: *const ::std::os::raw::c_char,
argptr: va_list,
) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn xmlTextWriterWriteAttributeNS(
writer: xmlTextWriterPtr,
prefix: *const xmlChar,
name: *const xmlChar,
namespaceURI: *const xmlChar,
content: *const xmlChar,
) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn xmlTextWriterStartPI(
writer: xmlTextWriterPtr,
target: *const xmlChar,
) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn xmlTextWriterEndPI(writer: xmlTextWriterPtr) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn xmlTextWriterWriteFormatPI(
writer: xmlTextWriterPtr,
target: *const xmlChar,
format: *const ::std::os::raw::c_char,
...
) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn xmlTextWriterWriteVFormatPI(
writer: xmlTextWriterPtr,
target: *const xmlChar,
format: *const ::std::os::raw::c_char,
argptr: va_list,
) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn xmlTextWriterWritePI(
writer: xmlTextWriterPtr,
target: *const xmlChar,
content: *const xmlChar,
) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn xmlTextWriterStartCDATA(writer: xmlTextWriterPtr) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn xmlTextWriterEndCDATA(writer: xmlTextWriterPtr) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn xmlTextWriterWriteFormatCDATA(
writer: xmlTextWriterPtr,
format: *const ::std::os::raw::c_char,
...
) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn xmlTextWriterWriteVFormatCDATA(
writer: xmlTextWriterPtr,
format: *const ::std::os::raw::c_char,
argptr: va_list,
) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn xmlTextWriterWriteCDATA(
writer: xmlTextWriterPtr,
content: *const xmlChar,
) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn xmlTextWriterStartDTD(
writer: xmlTextWriterPtr,
name: *const xmlChar,
pubid: *const xmlChar,
sysid: *const xmlChar,
) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn xmlTextWriterEndDTD(writer: xmlTextWriterPtr) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn xmlTextWriterWriteFormatDTD(
writer: xmlTextWriterPtr,
name: *const xmlChar,
pubid: *const xmlChar,
sysid: *const xmlChar,
format: *const ::std::os::raw::c_char,
...
) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn xmlTextWriterWriteVFormatDTD(
writer: xmlTextWriterPtr,
name: *const xmlChar,
pubid: *const xmlChar,
sysid: *const xmlChar,
format: *const ::std::os::raw::c_char,
argptr: va_list,
) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn xmlTextWriterWriteDTD(
writer: xmlTextWriterPtr,
name: *const xmlChar,
pubid: *const xmlChar,
sysid: *const xmlChar,
subset: *const xmlChar,
) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn xmlTextWriterStartDTDElement(
writer: xmlTextWriterPtr,
name: *const xmlChar,
) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn xmlTextWriterEndDTDElement(writer: xmlTextWriterPtr) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn xmlTextWriterWriteFormatDTDElement(
writer: xmlTextWriterPtr,
name: *const xmlChar,
format: *const ::std::os::raw::c_char,
...
) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn xmlTextWriterWriteVFormatDTDElement(
writer: xmlTextWriterPtr,
name: *const xmlChar,
format: *const ::std::os::raw::c_char,
argptr: va_list,
) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn xmlTextWriterWriteDTDElement(
writer: xmlTextWriterPtr,
name: *const xmlChar,
content: *const xmlChar,
) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn xmlTextWriterStartDTDAttlist(
writer: xmlTextWriterPtr,
name: *const xmlChar,
) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn xmlTextWriterEndDTDAttlist(writer: xmlTextWriterPtr) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn xmlTextWriterWriteFormatDTDAttlist(
writer: xmlTextWriterPtr,
name: *const xmlChar,
format: *const ::std::os::raw::c_char,
...
) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn xmlTextWriterWriteVFormatDTDAttlist(
writer: xmlTextWriterPtr,
name: *const xmlChar,
format: *const ::std::os::raw::c_char,
argptr: va_list,
) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn xmlTextWriterWriteDTDAttlist(
writer: xmlTextWriterPtr,
name: *const xmlChar,
content: *const xmlChar,
) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn xmlTextWriterStartDTDEntity(
writer: xmlTextWriterPtr,
pe: ::std::os::raw::c_int,
name: *const xmlChar,
) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn xmlTextWriterEndDTDEntity(writer: xmlTextWriterPtr) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn xmlTextWriterWriteFormatDTDInternalEntity(
writer: xmlTextWriterPtr,
pe: ::std::os::raw::c_int,
name: *const xmlChar,
format: *const ::std::os::raw::c_char,
...
) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn xmlTextWriterWriteVFormatDTDInternalEntity(
writer: xmlTextWriterPtr,
pe: ::std::os::raw::c_int,
name: *const xmlChar,
format: *const ::std::os::raw::c_char,
argptr: va_list,
) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn xmlTextWriterWriteDTDInternalEntity(
writer: xmlTextWriterPtr,
pe: ::std::os::raw::c_int,
name: *const xmlChar,
content: *const xmlChar,
) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn xmlTextWriterWriteDTDExternalEntity(
writer: xmlTextWriterPtr,
pe: ::std::os::raw::c_int,
name: *const xmlChar,
pubid: *const xmlChar,
sysid: *const xmlChar,
ndataid: *const xmlChar,
) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn xmlTextWriterWriteDTDExternalEntityContents(
writer: xmlTextWriterPtr,
pubid: *const xmlChar,
sysid: *const xmlChar,
ndataid: *const xmlChar,
) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn xmlTextWriterWriteDTDEntity(
writer: xmlTextWriterPtr,
pe: ::std::os::raw::c_int,
name: *const xmlChar,
pubid: *const xmlChar,
sysid: *const xmlChar,
ndataid: *const xmlChar,
content: *const xmlChar,
) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn xmlTextWriterWriteDTDNotation(
writer: xmlTextWriterPtr,
name: *const xmlChar,
pubid: *const xmlChar,
sysid: *const xmlChar,
) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn xmlTextWriterSetIndent(
writer: xmlTextWriterPtr,
indent: ::std::os::raw::c_int,
) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn xmlTextWriterSetIndentString(
writer: xmlTextWriterPtr,
str_: *const xmlChar,
) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn xmlTextWriterSetQuoteChar(
writer: xmlTextWriterPtr,
quotechar: xmlChar,
) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn xmlTextWriterFlush(writer: xmlTextWriterPtr) -> ::std::os::raw::c_int;
}
extern "C" {
pub static mut xmlParserMaxDepth: ::std::os::raw::c_uint;
}
extern "C" {
pub static xmlStringText: [xmlChar; 0usize];
}
extern "C" {
pub static xmlStringTextNoenc: [xmlChar; 0usize];
}
extern "C" {
pub static xmlStringComment: [xmlChar; 0usize];
}
extern "C" {
pub fn xmlIsLetter(c: ::std::os::raw::c_int) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn xmlCreateFileParserCtxt(filename: *const ::std::os::raw::c_char) -> xmlParserCtxtPtr;
}
extern "C" {
pub fn xmlCreateURLParserCtxt(
filename: *const ::std::os::raw::c_char,
options: ::std::os::raw::c_int,
) -> xmlParserCtxtPtr;
}
extern "C" {
pub fn xmlCreateMemoryParserCtxt(
buffer: *const ::std::os::raw::c_char,
size: ::std::os::raw::c_int,
) -> xmlParserCtxtPtr;
}
extern "C" {
pub fn xmlCreateEntityParserCtxt(
URL: *const xmlChar,
ID: *const xmlChar,
base: *const xmlChar,
) -> xmlParserCtxtPtr;
}
extern "C" {
pub fn xmlSwitchEncoding(ctxt: xmlParserCtxtPtr, enc: xmlCharEncoding)
-> ::std::os::raw::c_int;
}
extern "C" {
pub fn xmlSwitchToEncoding(
ctxt: xmlParserCtxtPtr,
handler: xmlCharEncodingHandlerPtr,
) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn xmlSwitchInputEncoding(
ctxt: xmlParserCtxtPtr,
input: xmlParserInputPtr,
handler: xmlCharEncodingHandlerPtr,
) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn xmlNewStringInputStream(
ctxt: xmlParserCtxtPtr,
buffer: *const xmlChar,
) -> xmlParserInputPtr;
}
extern "C" {
pub fn xmlNewEntityInputStream(
ctxt: xmlParserCtxtPtr,
entity: xmlEntityPtr,
) -> xmlParserInputPtr;
}
extern "C" {
pub fn xmlPushInput(ctxt: xmlParserCtxtPtr, input: xmlParserInputPtr) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn xmlPopInput(ctxt: xmlParserCtxtPtr) -> xmlChar;
}
extern "C" {
pub fn xmlFreeInputStream(input: xmlParserInputPtr);
}
extern "C" {
pub fn xmlNewInputFromFile(
ctxt: xmlParserCtxtPtr,
filename: *const ::std::os::raw::c_char,
) -> xmlParserInputPtr;
}
extern "C" {
pub fn xmlNewInputStream(ctxt: xmlParserCtxtPtr) -> xmlParserInputPtr;
}
extern "C" {
pub fn xmlSplitQName(
ctxt: xmlParserCtxtPtr,
name: *const xmlChar,
prefix: *mut *mut xmlChar,
) -> *mut xmlChar;
}
extern "C" {
pub fn xmlParseName(ctxt: xmlParserCtxtPtr) -> *const xmlChar;
}
extern "C" {
pub fn xmlParseNmtoken(ctxt: xmlParserCtxtPtr) -> *mut xmlChar;
}
extern "C" {
pub fn xmlParseEntityValue(ctxt: xmlParserCtxtPtr, orig: *mut *mut xmlChar) -> *mut xmlChar;
}
extern "C" {
pub fn xmlParseAttValue(ctxt: xmlParserCtxtPtr) -> *mut xmlChar;
}
extern "C" {
pub fn xmlParseSystemLiteral(ctxt: xmlParserCtxtPtr) -> *mut xmlChar;
}
extern "C" {
pub fn xmlParsePubidLiteral(ctxt: xmlParserCtxtPtr) -> *mut xmlChar;
}
extern "C" {
pub fn xmlParseCharData(ctxt: xmlParserCtxtPtr, cdata: ::std::os::raw::c_int);
}
extern "C" {
pub fn xmlParseExternalID(
ctxt: xmlParserCtxtPtr,
publicID: *mut *mut xmlChar,
strict: ::std::os::raw::c_int,
) -> *mut xmlChar;
}
extern "C" {
pub fn xmlParseComment(ctxt: xmlParserCtxtPtr);
}
extern "C" {
pub fn xmlParsePITarget(ctxt: xmlParserCtxtPtr) -> *const xmlChar;
}
extern "C" {
pub fn xmlParsePI(ctxt: xmlParserCtxtPtr);
}
extern "C" {
pub fn xmlParseNotationDecl(ctxt: xmlParserCtxtPtr);
}
extern "C" {
pub fn xmlParseEntityDecl(ctxt: xmlParserCtxtPtr);
}
extern "C" {
pub fn xmlParseDefaultDecl(
ctxt: xmlParserCtxtPtr,
value: *mut *mut xmlChar,
) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn xmlParseNotationType(ctxt: xmlParserCtxtPtr) -> xmlEnumerationPtr;
}
extern "C" {
pub fn xmlParseEnumerationType(ctxt: xmlParserCtxtPtr) -> xmlEnumerationPtr;
}
extern "C" {
pub fn xmlParseEnumeratedType(
ctxt: xmlParserCtxtPtr,
tree: *mut xmlEnumerationPtr,
) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn xmlParseAttributeType(
ctxt: xmlParserCtxtPtr,
tree: *mut xmlEnumerationPtr,
) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn xmlParseAttributeListDecl(ctxt: xmlParserCtxtPtr);
}
extern "C" {
pub fn xmlParseElementMixedContentDecl(
ctxt: xmlParserCtxtPtr,
inputchk: ::std::os::raw::c_int,
) -> xmlElementContentPtr;
}
extern "C" {
pub fn xmlParseElementChildrenContentDecl(
ctxt: xmlParserCtxtPtr,
inputchk: ::std::os::raw::c_int,
) -> xmlElementContentPtr;
}
extern "C" {
pub fn xmlParseElementContentDecl(
ctxt: xmlParserCtxtPtr,
name: *const xmlChar,
result: *mut xmlElementContentPtr,
) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn xmlParseElementDecl(ctxt: xmlParserCtxtPtr) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn xmlParseMarkupDecl(ctxt: xmlParserCtxtPtr);
}
extern "C" {
pub fn xmlParseCharRef(ctxt: xmlParserCtxtPtr) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn xmlParseEntityRef(ctxt: xmlParserCtxtPtr) -> xmlEntityPtr;
}
extern "C" {
pub fn xmlParseReference(ctxt: xmlParserCtxtPtr);
}
extern "C" {
pub fn xmlParsePEReference(ctxt: xmlParserCtxtPtr);
}
extern "C" {
pub fn xmlParseDocTypeDecl(ctxt: xmlParserCtxtPtr);
}
extern "C" {
pub fn xmlParseAttribute(ctxt: xmlParserCtxtPtr, value: *mut *mut xmlChar) -> *const xmlChar;
}
extern "C" {
pub fn xmlParseStartTag(ctxt: xmlParserCtxtPtr) -> *const xmlChar;
}
extern "C" {
pub fn xmlParseEndTag(ctxt: xmlParserCtxtPtr);
}
extern "C" {
pub fn xmlParseCDSect(ctxt: xmlParserCtxtPtr);
}
extern "C" {
pub fn xmlParseContent(ctxt: xmlParserCtxtPtr);
}
extern "C" {
pub fn xmlParseElement(ctxt: xmlParserCtxtPtr);
}
extern "C" {
pub fn xmlParseVersionNum(ctxt: xmlParserCtxtPtr) -> *mut xmlChar;
}
extern "C" {
pub fn xmlParseVersionInfo(ctxt: xmlParserCtxtPtr) -> *mut xmlChar;
}
extern "C" {
pub fn xmlParseEncName(ctxt: xmlParserCtxtPtr) -> *mut xmlChar;
}
extern "C" {
pub fn xmlParseEncodingDecl(ctxt: xmlParserCtxtPtr) -> *const xmlChar;
}
extern "C" {
pub fn xmlParseSDDecl(ctxt: xmlParserCtxtPtr) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn xmlParseXMLDecl(ctxt: xmlParserCtxtPtr);
}
extern "C" {
pub fn xmlParseTextDecl(ctxt: xmlParserCtxtPtr);
}
extern "C" {
pub fn xmlParseMisc(ctxt: xmlParserCtxtPtr);
}
extern "C" {
pub fn xmlParseExternalSubset(
ctxt: xmlParserCtxtPtr,
ExternalID: *const xmlChar,
SystemID: *const xmlChar,
);
}
extern "C" {
pub fn xmlStringDecodeEntities(
ctxt: xmlParserCtxtPtr,
str_: *const xmlChar,
what: ::std::os::raw::c_int,
end: xmlChar,
end2: xmlChar,
end3: xmlChar,
) -> *mut xmlChar;
}
extern "C" {
pub fn xmlStringLenDecodeEntities(
ctxt: xmlParserCtxtPtr,
str_: *const xmlChar,
len: ::std::os::raw::c_int,
what: ::std::os::raw::c_int,
end: xmlChar,
end2: xmlChar,
end3: xmlChar,
) -> *mut xmlChar;
}
extern "C" {
pub fn nodePush(ctxt: xmlParserCtxtPtr, value: xmlNodePtr) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn nodePop(ctxt: xmlParserCtxtPtr) -> xmlNodePtr;
}
extern "C" {
pub fn inputPush(ctxt: xmlParserCtxtPtr, value: xmlParserInputPtr) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn inputPop(ctxt: xmlParserCtxtPtr) -> xmlParserInputPtr;
}
extern "C" {
pub fn namePop(ctxt: xmlParserCtxtPtr) -> *const xmlChar;
}
extern "C" {
pub fn namePush(ctxt: xmlParserCtxtPtr, value: *const xmlChar) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn xmlSkipBlankChars(ctxt: xmlParserCtxtPtr) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn xmlStringCurrentChar(
ctxt: xmlParserCtxtPtr,
cur: *const xmlChar,
len: *mut ::std::os::raw::c_int,
) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn xmlParserHandlePEReference(ctxt: xmlParserCtxtPtr);
}
extern "C" {
pub fn xmlCheckLanguageID(lang: *const xmlChar) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn xmlCurrentChar(
ctxt: xmlParserCtxtPtr,
len: *mut ::std::os::raw::c_int,
) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn xmlCopyCharMultiByte(
out: *mut xmlChar,
val: ::std::os::raw::c_int,
) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn xmlCopyChar(
len: ::std::os::raw::c_int,
out: *mut xmlChar,
val: ::std::os::raw::c_int,
) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn xmlNextChar(ctxt: xmlParserCtxtPtr);
}
extern "C" {
pub fn xmlParserInputShrink(in_: xmlParserInputPtr);
}
extern "C" {
pub fn htmlInitAutoClose();
}
extern "C" {
pub fn htmlCreateFileParserCtxt(
filename: *const ::std::os::raw::c_char,
encoding: *const ::std::os::raw::c_char,
) -> htmlParserCtxtPtr;
}
pub type __builtin_va_list = *mut ::std::os::raw::c_char;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct _uconv_t {
pub _address: u8,
}