3935 lines
111 KiB
Rust
3935 lines
111 KiB
Rust
/* automatically generated by rust-bindgen 0.55.1 */
|
|
|
|
pub const _STDIO_H: u32 = 1;
|
|
pub const _FEATURES_H: u32 = 1;
|
|
pub const _DEFAULT_SOURCE: u32 = 1;
|
|
pub const __GLIBC_USE_ISOC2X: u32 = 0;
|
|
pub const __USE_ISOC11: u32 = 1;
|
|
pub const __USE_ISOC99: u32 = 1;
|
|
pub const __USE_ISOC95: u32 = 1;
|
|
pub const __USE_POSIX_IMPLICITLY: u32 = 1;
|
|
pub const _POSIX_SOURCE: u32 = 1;
|
|
pub const _POSIX_C_SOURCE: u32 = 200809;
|
|
pub const __USE_POSIX: u32 = 1;
|
|
pub const __USE_POSIX2: u32 = 1;
|
|
pub const __USE_POSIX199309: u32 = 1;
|
|
pub const __USE_POSIX199506: u32 = 1;
|
|
pub const __USE_XOPEN2K: u32 = 1;
|
|
pub const __USE_XOPEN2K8: u32 = 1;
|
|
pub const _ATFILE_SOURCE: u32 = 1;
|
|
pub const __USE_MISC: u32 = 1;
|
|
pub const __USE_ATFILE: u32 = 1;
|
|
pub const __USE_FORTIFY_LEVEL: u32 = 0;
|
|
pub const __GLIBC_USE_DEPRECATED_GETS: u32 = 0;
|
|
pub const __GLIBC_USE_DEPRECATED_SCANF: u32 = 0;
|
|
pub const _STDC_PREDEF_H: u32 = 1;
|
|
pub const __STDC_IEC_559__: u32 = 1;
|
|
pub const __STDC_IEC_559_COMPLEX__: u32 = 1;
|
|
pub const __STDC_ISO_10646__: u32 = 201706;
|
|
pub const __GNU_LIBRARY__: u32 = 6;
|
|
pub const __GLIBC__: u32 = 2;
|
|
pub const __GLIBC_MINOR__: u32 = 32;
|
|
pub const _SYS_CDEFS_H: u32 = 1;
|
|
pub const __glibc_c99_flexarr_available: u32 = 1;
|
|
pub const __WORDSIZE: u32 = 64;
|
|
pub const __WORDSIZE_TIME64_COMPAT32: u32 = 1;
|
|
pub const __SYSCALL_WORDSIZE: u32 = 64;
|
|
pub const __LDOUBLE_REDIRECTS_TO_FLOAT128_ABI: u32 = 0;
|
|
pub const __HAVE_GENERIC_SELECTION: u32 = 1;
|
|
pub const __GLIBC_USE_LIB_EXT2: u32 = 0;
|
|
pub const __GLIBC_USE_IEC_60559_BFP_EXT: u32 = 0;
|
|
pub const __GLIBC_USE_IEC_60559_BFP_EXT_C2X: u32 = 0;
|
|
pub const __GLIBC_USE_IEC_60559_FUNCS_EXT: u32 = 0;
|
|
pub const __GLIBC_USE_IEC_60559_FUNCS_EXT_C2X: u32 = 0;
|
|
pub const __GLIBC_USE_IEC_60559_TYPES_EXT: u32 = 0;
|
|
pub const __GNUC_VA_LIST: u32 = 1;
|
|
pub const _BITS_TYPES_H: u32 = 1;
|
|
pub const __TIMESIZE: u32 = 64;
|
|
pub const _BITS_TYPESIZES_H: u32 = 1;
|
|
pub const __OFF_T_MATCHES_OFF64_T: u32 = 1;
|
|
pub const __INO_T_MATCHES_INO64_T: u32 = 1;
|
|
pub const __RLIM_T_MATCHES_RLIM64_T: u32 = 1;
|
|
pub const __STATFS_MATCHES_STATFS64: u32 = 1;
|
|
pub const __KERNEL_OLD_TIMEVAL_MATCHES_TIMEVAL64: u32 = 1;
|
|
pub const __FD_SETSIZE: u32 = 1024;
|
|
pub const _BITS_TIME64_H: u32 = 1;
|
|
pub const _____fpos_t_defined: u32 = 1;
|
|
pub const ____mbstate_t_defined: u32 = 1;
|
|
pub const _____fpos64_t_defined: u32 = 1;
|
|
pub const ____FILE_defined: u32 = 1;
|
|
pub const __FILE_defined: u32 = 1;
|
|
pub const __struct_FILE_defined: u32 = 1;
|
|
pub const _IO_EOF_SEEN: u32 = 16;
|
|
pub const _IO_ERR_SEEN: u32 = 32;
|
|
pub const _IO_USER_LOCK: u32 = 32768;
|
|
pub const _IOFBF: u32 = 0;
|
|
pub const _IOLBF: u32 = 1;
|
|
pub const _IONBF: u32 = 2;
|
|
pub const BUFSIZ: u32 = 8192;
|
|
pub const EOF: i32 = -1;
|
|
pub const SEEK_SET: u32 = 0;
|
|
pub const SEEK_CUR: u32 = 1;
|
|
pub const SEEK_END: u32 = 2;
|
|
pub const P_tmpdir: &'static [u8; 5usize] = b"/tmp\0";
|
|
pub const _BITS_STDIO_LIM_H: u32 = 1;
|
|
pub const L_tmpnam: u32 = 20;
|
|
pub const TMP_MAX: u32 = 238328;
|
|
pub const FILENAME_MAX: u32 = 4096;
|
|
pub const L_ctermid: u32 = 9;
|
|
pub const FOPEN_MAX: u32 = 16;
|
|
pub const __HAVE_FLOAT128: u32 = 0;
|
|
pub const __HAVE_DISTINCT_FLOAT128: u32 = 0;
|
|
pub const __HAVE_FLOAT64X: u32 = 1;
|
|
pub const __HAVE_FLOAT64X_LONG_DOUBLE: u32 = 1;
|
|
pub const __HAVE_FLOAT16: u32 = 0;
|
|
pub const __HAVE_FLOAT32: u32 = 1;
|
|
pub const __HAVE_FLOAT64: u32 = 1;
|
|
pub const __HAVE_FLOAT32X: u32 = 1;
|
|
pub const __HAVE_FLOAT128X: u32 = 0;
|
|
pub const __HAVE_DISTINCT_FLOAT16: u32 = 0;
|
|
pub const __HAVE_DISTINCT_FLOAT32: u32 = 0;
|
|
pub const __HAVE_DISTINCT_FLOAT64: u32 = 0;
|
|
pub const __HAVE_DISTINCT_FLOAT32X: u32 = 0;
|
|
pub const __HAVE_DISTINCT_FLOAT64X: u32 = 0;
|
|
pub const __HAVE_DISTINCT_FLOAT128X: u32 = 0;
|
|
pub const __HAVE_FLOATN_NOT_TYPEDEF: u32 = 0;
|
|
pub const _STDINT_H: u32 = 1;
|
|
pub const _BITS_WCHAR_H: u32 = 1;
|
|
pub const _BITS_STDINT_INTN_H: u32 = 1;
|
|
pub const _BITS_STDINT_UINTN_H: u32 = 1;
|
|
pub const INT8_MIN: i32 = -128;
|
|
pub const INT16_MIN: i32 = -32768;
|
|
pub const INT32_MIN: i32 = -2147483648;
|
|
pub const INT8_MAX: u32 = 127;
|
|
pub const INT16_MAX: u32 = 32767;
|
|
pub const INT32_MAX: u32 = 2147483647;
|
|
pub const UINT8_MAX: u32 = 255;
|
|
pub const UINT16_MAX: u32 = 65535;
|
|
pub const UINT32_MAX: u32 = 4294967295;
|
|
pub const INT_LEAST8_MIN: i32 = -128;
|
|
pub const INT_LEAST16_MIN: i32 = -32768;
|
|
pub const INT_LEAST32_MIN: i32 = -2147483648;
|
|
pub const INT_LEAST8_MAX: u32 = 127;
|
|
pub const INT_LEAST16_MAX: u32 = 32767;
|
|
pub const INT_LEAST32_MAX: u32 = 2147483647;
|
|
pub const UINT_LEAST8_MAX: u32 = 255;
|
|
pub const UINT_LEAST16_MAX: u32 = 65535;
|
|
pub const UINT_LEAST32_MAX: u32 = 4294967295;
|
|
pub const INT_FAST8_MIN: i32 = -128;
|
|
pub const INT_FAST16_MIN: i64 = -9223372036854775808;
|
|
pub const INT_FAST32_MIN: i64 = -9223372036854775808;
|
|
pub const INT_FAST8_MAX: u32 = 127;
|
|
pub const INT_FAST16_MAX: u64 = 9223372036854775807;
|
|
pub const INT_FAST32_MAX: u64 = 9223372036854775807;
|
|
pub const UINT_FAST8_MAX: u32 = 255;
|
|
pub const UINT_FAST16_MAX: i32 = -1;
|
|
pub const UINT_FAST32_MAX: i32 = -1;
|
|
pub const INTPTR_MIN: i64 = -9223372036854775808;
|
|
pub const INTPTR_MAX: u64 = 9223372036854775807;
|
|
pub const UINTPTR_MAX: i32 = -1;
|
|
pub const PTRDIFF_MIN: i64 = -9223372036854775808;
|
|
pub const PTRDIFF_MAX: u64 = 9223372036854775807;
|
|
pub const SIG_ATOMIC_MIN: i32 = -2147483648;
|
|
pub const SIG_ATOMIC_MAX: u32 = 2147483647;
|
|
pub const SIZE_MAX: i32 = -1;
|
|
pub const WINT_MIN: u32 = 0;
|
|
pub const WINT_MAX: u32 = 4294967295;
|
|
pub const JS_PROP_CONFIGURABLE: u32 = 1;
|
|
pub const JS_PROP_WRITABLE: u32 = 2;
|
|
pub const JS_PROP_ENUMERABLE: u32 = 4;
|
|
pub const JS_PROP_C_W_E: u32 = 7;
|
|
pub const JS_PROP_LENGTH: u32 = 8;
|
|
pub const JS_PROP_TMASK: u32 = 48;
|
|
pub const JS_PROP_NORMAL: u32 = 0;
|
|
pub const JS_PROP_GETSET: u32 = 16;
|
|
pub const JS_PROP_VARREF: u32 = 32;
|
|
pub const JS_PROP_AUTOINIT: u32 = 48;
|
|
pub const JS_PROP_HAS_SHIFT: u32 = 8;
|
|
pub const JS_PROP_HAS_CONFIGURABLE: u32 = 256;
|
|
pub const JS_PROP_HAS_WRITABLE: u32 = 512;
|
|
pub const JS_PROP_HAS_ENUMERABLE: u32 = 1024;
|
|
pub const JS_PROP_HAS_GET: u32 = 2048;
|
|
pub const JS_PROP_HAS_SET: u32 = 4096;
|
|
pub const JS_PROP_HAS_VALUE: u32 = 8192;
|
|
pub const JS_PROP_THROW: u32 = 16384;
|
|
pub const JS_PROP_THROW_STRICT: u32 = 32768;
|
|
pub const JS_PROP_NO_ADD: u32 = 65536;
|
|
pub const JS_PROP_NO_EXOTIC: u32 = 131072;
|
|
pub const JS_DEFAULT_STACK_SIZE: u32 = 262144;
|
|
pub const JS_EVAL_TYPE_GLOBAL: u32 = 0;
|
|
pub const JS_EVAL_TYPE_MODULE: u32 = 1;
|
|
pub const JS_EVAL_TYPE_DIRECT: u32 = 2;
|
|
pub const JS_EVAL_TYPE_INDIRECT: u32 = 3;
|
|
pub const JS_EVAL_TYPE_MASK: u32 = 3;
|
|
pub const JS_EVAL_FLAG_STRICT: u32 = 8;
|
|
pub const JS_EVAL_FLAG_STRIP: u32 = 16;
|
|
pub const JS_EVAL_FLAG_COMPILE_ONLY: u32 = 32;
|
|
pub const JS_EVAL_FLAG_BACKTRACE_BARRIER: u32 = 64;
|
|
pub const JS_ATOM_NULL: u32 = 0;
|
|
pub const JS_CALL_FLAG_CONSTRUCTOR: u32 = 1;
|
|
pub const JS_GPN_STRING_MASK: u32 = 1;
|
|
pub const JS_GPN_SYMBOL_MASK: u32 = 2;
|
|
pub const JS_GPN_PRIVATE_MASK: u32 = 4;
|
|
pub const JS_GPN_ENUM_ONLY: u32 = 16;
|
|
pub const JS_GPN_SET_ENUM: u32 = 32;
|
|
pub const JS_PARSE_JSON_EXT: u32 = 1;
|
|
pub const JS_WRITE_OBJ_BYTECODE: u32 = 1;
|
|
pub const JS_WRITE_OBJ_BSWAP: u32 = 2;
|
|
pub const JS_WRITE_OBJ_SAB: u32 = 4;
|
|
pub const JS_WRITE_OBJ_REFERENCE: u32 = 8;
|
|
pub const JS_READ_OBJ_BYTECODE: u32 = 1;
|
|
pub const JS_READ_OBJ_ROM_DATA: u32 = 2;
|
|
pub const JS_READ_OBJ_SAB: u32 = 4;
|
|
pub const JS_READ_OBJ_REFERENCE: u32 = 8;
|
|
pub const JS_DEF_CFUNC: u32 = 0;
|
|
pub const JS_DEF_CGETSET: u32 = 1;
|
|
pub const JS_DEF_CGETSET_MAGIC: u32 = 2;
|
|
pub const JS_DEF_PROP_STRING: u32 = 3;
|
|
pub const JS_DEF_PROP_INT32: u32 = 4;
|
|
pub const JS_DEF_PROP_INT64: u32 = 5;
|
|
pub const JS_DEF_PROP_DOUBLE: u32 = 6;
|
|
pub const JS_DEF_PROP_UNDEFINED: u32 = 7;
|
|
pub const JS_DEF_OBJECT: u32 = 8;
|
|
pub const JS_DEF_ALIAS: u32 = 9;
|
|
pub type size_t = ::std::os::raw::c_ulong;
|
|
pub type va_list = __builtin_va_list;
|
|
pub type __gnuc_va_list = __builtin_va_list;
|
|
pub type __u_char = ::std::os::raw::c_uchar;
|
|
pub type __u_short = ::std::os::raw::c_ushort;
|
|
pub type __u_int = ::std::os::raw::c_uint;
|
|
pub type __u_long = ::std::os::raw::c_ulong;
|
|
pub type __int8_t = ::std::os::raw::c_schar;
|
|
pub type __uint8_t = ::std::os::raw::c_uchar;
|
|
pub type __int16_t = ::std::os::raw::c_short;
|
|
pub type __uint16_t = ::std::os::raw::c_ushort;
|
|
pub type __int32_t = ::std::os::raw::c_int;
|
|
pub type __uint32_t = ::std::os::raw::c_uint;
|
|
pub type __int64_t = ::std::os::raw::c_long;
|
|
pub type __uint64_t = ::std::os::raw::c_ulong;
|
|
pub type __int_least8_t = __int8_t;
|
|
pub type __uint_least8_t = __uint8_t;
|
|
pub type __int_least16_t = __int16_t;
|
|
pub type __uint_least16_t = __uint16_t;
|
|
pub type __int_least32_t = __int32_t;
|
|
pub type __uint_least32_t = __uint32_t;
|
|
pub type __int_least64_t = __int64_t;
|
|
pub type __uint_least64_t = __uint64_t;
|
|
pub type __quad_t = ::std::os::raw::c_long;
|
|
pub type __u_quad_t = ::std::os::raw::c_ulong;
|
|
pub type __intmax_t = ::std::os::raw::c_long;
|
|
pub type __uintmax_t = ::std::os::raw::c_ulong;
|
|
pub type __dev_t = ::std::os::raw::c_ulong;
|
|
pub type __uid_t = ::std::os::raw::c_uint;
|
|
pub type __gid_t = ::std::os::raw::c_uint;
|
|
pub type __ino_t = ::std::os::raw::c_ulong;
|
|
pub type __ino64_t = ::std::os::raw::c_ulong;
|
|
pub type __mode_t = ::std::os::raw::c_uint;
|
|
pub type __nlink_t = ::std::os::raw::c_ulong;
|
|
pub type __off_t = ::std::os::raw::c_long;
|
|
pub type __off64_t = ::std::os::raw::c_long;
|
|
pub type __pid_t = ::std::os::raw::c_int;
|
|
#[repr(C)]
|
|
#[derive(Debug, Copy, Clone)]
|
|
pub struct __fsid_t {
|
|
pub __val: [::std::os::raw::c_int; 2usize],
|
|
}
|
|
#[test]
|
|
fn bindgen_test_layout___fsid_t() {
|
|
assert_eq!(
|
|
::std::mem::size_of::<__fsid_t>(),
|
|
8usize,
|
|
concat!("Size of: ", stringify!(__fsid_t))
|
|
);
|
|
assert_eq!(
|
|
::std::mem::align_of::<__fsid_t>(),
|
|
4usize,
|
|
concat!("Alignment of ", stringify!(__fsid_t))
|
|
);
|
|
assert_eq!(
|
|
unsafe { &(*(::std::ptr::null::<__fsid_t>())).__val as *const _ as usize },
|
|
0usize,
|
|
concat!(
|
|
"Offset of field: ",
|
|
stringify!(__fsid_t),
|
|
"::",
|
|
stringify!(__val)
|
|
)
|
|
);
|
|
}
|
|
pub type __clock_t = ::std::os::raw::c_long;
|
|
pub type __rlim_t = ::std::os::raw::c_ulong;
|
|
pub type __rlim64_t = ::std::os::raw::c_ulong;
|
|
pub type __id_t = ::std::os::raw::c_uint;
|
|
pub type __time_t = ::std::os::raw::c_long;
|
|
pub type __useconds_t = ::std::os::raw::c_uint;
|
|
pub type __suseconds_t = ::std::os::raw::c_long;
|
|
pub type __suseconds64_t = ::std::os::raw::c_long;
|
|
pub type __daddr_t = ::std::os::raw::c_int;
|
|
pub type __key_t = ::std::os::raw::c_int;
|
|
pub type __clockid_t = ::std::os::raw::c_int;
|
|
pub type __timer_t = *mut ::std::os::raw::c_void;
|
|
pub type __blksize_t = ::std::os::raw::c_long;
|
|
pub type __blkcnt_t = ::std::os::raw::c_long;
|
|
pub type __blkcnt64_t = ::std::os::raw::c_long;
|
|
pub type __fsblkcnt_t = ::std::os::raw::c_ulong;
|
|
pub type __fsblkcnt64_t = ::std::os::raw::c_ulong;
|
|
pub type __fsfilcnt_t = ::std::os::raw::c_ulong;
|
|
pub type __fsfilcnt64_t = ::std::os::raw::c_ulong;
|
|
pub type __fsword_t = ::std::os::raw::c_long;
|
|
pub type __ssize_t = ::std::os::raw::c_long;
|
|
pub type __syscall_slong_t = ::std::os::raw::c_long;
|
|
pub type __syscall_ulong_t = ::std::os::raw::c_ulong;
|
|
pub type __loff_t = __off64_t;
|
|
pub type __caddr_t = *mut ::std::os::raw::c_char;
|
|
pub type __intptr_t = ::std::os::raw::c_long;
|
|
pub type __socklen_t = ::std::os::raw::c_uint;
|
|
pub type __sig_atomic_t = ::std::os::raw::c_int;
|
|
#[repr(C)]
|
|
#[derive(Copy, Clone)]
|
|
pub struct __mbstate_t {
|
|
pub __count: ::std::os::raw::c_int,
|
|
pub __value: __mbstate_t__bindgen_ty_1,
|
|
}
|
|
#[repr(C)]
|
|
#[derive(Copy, Clone)]
|
|
pub union __mbstate_t__bindgen_ty_1 {
|
|
pub __wch: ::std::os::raw::c_uint,
|
|
pub __wchb: [::std::os::raw::c_char; 4usize],
|
|
_bindgen_union_align: u32,
|
|
}
|
|
#[test]
|
|
fn bindgen_test_layout___mbstate_t__bindgen_ty_1() {
|
|
assert_eq!(
|
|
::std::mem::size_of::<__mbstate_t__bindgen_ty_1>(),
|
|
4usize,
|
|
concat!("Size of: ", stringify!(__mbstate_t__bindgen_ty_1))
|
|
);
|
|
assert_eq!(
|
|
::std::mem::align_of::<__mbstate_t__bindgen_ty_1>(),
|
|
4usize,
|
|
concat!("Alignment of ", stringify!(__mbstate_t__bindgen_ty_1))
|
|
);
|
|
assert_eq!(
|
|
unsafe { &(*(::std::ptr::null::<__mbstate_t__bindgen_ty_1>())).__wch as *const _ as usize },
|
|
0usize,
|
|
concat!(
|
|
"Offset of field: ",
|
|
stringify!(__mbstate_t__bindgen_ty_1),
|
|
"::",
|
|
stringify!(__wch)
|
|
)
|
|
);
|
|
assert_eq!(
|
|
unsafe {
|
|
&(*(::std::ptr::null::<__mbstate_t__bindgen_ty_1>())).__wchb as *const _ as usize
|
|
},
|
|
0usize,
|
|
concat!(
|
|
"Offset of field: ",
|
|
stringify!(__mbstate_t__bindgen_ty_1),
|
|
"::",
|
|
stringify!(__wchb)
|
|
)
|
|
);
|
|
}
|
|
#[test]
|
|
fn bindgen_test_layout___mbstate_t() {
|
|
assert_eq!(
|
|
::std::mem::size_of::<__mbstate_t>(),
|
|
8usize,
|
|
concat!("Size of: ", stringify!(__mbstate_t))
|
|
);
|
|
assert_eq!(
|
|
::std::mem::align_of::<__mbstate_t>(),
|
|
4usize,
|
|
concat!("Alignment of ", stringify!(__mbstate_t))
|
|
);
|
|
assert_eq!(
|
|
unsafe { &(*(::std::ptr::null::<__mbstate_t>())).__count as *const _ as usize },
|
|
0usize,
|
|
concat!(
|
|
"Offset of field: ",
|
|
stringify!(__mbstate_t),
|
|
"::",
|
|
stringify!(__count)
|
|
)
|
|
);
|
|
assert_eq!(
|
|
unsafe { &(*(::std::ptr::null::<__mbstate_t>())).__value as *const _ as usize },
|
|
4usize,
|
|
concat!(
|
|
"Offset of field: ",
|
|
stringify!(__mbstate_t),
|
|
"::",
|
|
stringify!(__value)
|
|
)
|
|
);
|
|
}
|
|
#[repr(C)]
|
|
#[derive(Copy, Clone)]
|
|
pub struct _G_fpos_t {
|
|
pub __pos: __off_t,
|
|
pub __state: __mbstate_t,
|
|
}
|
|
#[test]
|
|
fn bindgen_test_layout__G_fpos_t() {
|
|
assert_eq!(
|
|
::std::mem::size_of::<_G_fpos_t>(),
|
|
16usize,
|
|
concat!("Size of: ", stringify!(_G_fpos_t))
|
|
);
|
|
assert_eq!(
|
|
::std::mem::align_of::<_G_fpos_t>(),
|
|
8usize,
|
|
concat!("Alignment of ", stringify!(_G_fpos_t))
|
|
);
|
|
assert_eq!(
|
|
unsafe { &(*(::std::ptr::null::<_G_fpos_t>())).__pos as *const _ as usize },
|
|
0usize,
|
|
concat!(
|
|
"Offset of field: ",
|
|
stringify!(_G_fpos_t),
|
|
"::",
|
|
stringify!(__pos)
|
|
)
|
|
);
|
|
assert_eq!(
|
|
unsafe { &(*(::std::ptr::null::<_G_fpos_t>())).__state as *const _ as usize },
|
|
8usize,
|
|
concat!(
|
|
"Offset of field: ",
|
|
stringify!(_G_fpos_t),
|
|
"::",
|
|
stringify!(__state)
|
|
)
|
|
);
|
|
}
|
|
pub type __fpos_t = _G_fpos_t;
|
|
#[repr(C)]
|
|
#[derive(Copy, Clone)]
|
|
pub struct _G_fpos64_t {
|
|
pub __pos: __off64_t,
|
|
pub __state: __mbstate_t,
|
|
}
|
|
#[test]
|
|
fn bindgen_test_layout__G_fpos64_t() {
|
|
assert_eq!(
|
|
::std::mem::size_of::<_G_fpos64_t>(),
|
|
16usize,
|
|
concat!("Size of: ", stringify!(_G_fpos64_t))
|
|
);
|
|
assert_eq!(
|
|
::std::mem::align_of::<_G_fpos64_t>(),
|
|
8usize,
|
|
concat!("Alignment of ", stringify!(_G_fpos64_t))
|
|
);
|
|
assert_eq!(
|
|
unsafe { &(*(::std::ptr::null::<_G_fpos64_t>())).__pos as *const _ as usize },
|
|
0usize,
|
|
concat!(
|
|
"Offset of field: ",
|
|
stringify!(_G_fpos64_t),
|
|
"::",
|
|
stringify!(__pos)
|
|
)
|
|
);
|
|
assert_eq!(
|
|
unsafe { &(*(::std::ptr::null::<_G_fpos64_t>())).__state as *const _ as usize },
|
|
8usize,
|
|
concat!(
|
|
"Offset of field: ",
|
|
stringify!(_G_fpos64_t),
|
|
"::",
|
|
stringify!(__state)
|
|
)
|
|
);
|
|
}
|
|
pub type __fpos64_t = _G_fpos64_t;
|
|
pub type __FILE = _IO_FILE;
|
|
pub type FILE = _IO_FILE;
|
|
#[repr(C)]
|
|
#[derive(Debug, Copy, Clone)]
|
|
pub struct _IO_marker {
|
|
_unused: [u8; 0],
|
|
}
|
|
#[repr(C)]
|
|
#[derive(Debug, Copy, Clone)]
|
|
pub struct _IO_codecvt {
|
|
_unused: [u8; 0],
|
|
}
|
|
#[repr(C)]
|
|
#[derive(Debug, Copy, Clone)]
|
|
pub struct _IO_wide_data {
|
|
_unused: [u8; 0],
|
|
}
|
|
pub type _IO_lock_t = ::std::os::raw::c_void;
|
|
#[repr(C)]
|
|
#[derive(Debug, Copy, Clone)]
|
|
pub struct _IO_FILE {
|
|
pub _flags: ::std::os::raw::c_int,
|
|
pub _IO_read_ptr: *mut ::std::os::raw::c_char,
|
|
pub _IO_read_end: *mut ::std::os::raw::c_char,
|
|
pub _IO_read_base: *mut ::std::os::raw::c_char,
|
|
pub _IO_write_base: *mut ::std::os::raw::c_char,
|
|
pub _IO_write_ptr: *mut ::std::os::raw::c_char,
|
|
pub _IO_write_end: *mut ::std::os::raw::c_char,
|
|
pub _IO_buf_base: *mut ::std::os::raw::c_char,
|
|
pub _IO_buf_end: *mut ::std::os::raw::c_char,
|
|
pub _IO_save_base: *mut ::std::os::raw::c_char,
|
|
pub _IO_backup_base: *mut ::std::os::raw::c_char,
|
|
pub _IO_save_end: *mut ::std::os::raw::c_char,
|
|
pub _markers: *mut _IO_marker,
|
|
pub _chain: *mut _IO_FILE,
|
|
pub _fileno: ::std::os::raw::c_int,
|
|
pub _flags2: ::std::os::raw::c_int,
|
|
pub _old_offset: __off_t,
|
|
pub _cur_column: ::std::os::raw::c_ushort,
|
|
pub _vtable_offset: ::std::os::raw::c_schar,
|
|
pub _shortbuf: [::std::os::raw::c_char; 1usize],
|
|
pub _lock: *mut _IO_lock_t,
|
|
pub _offset: __off64_t,
|
|
pub _codecvt: *mut _IO_codecvt,
|
|
pub _wide_data: *mut _IO_wide_data,
|
|
pub _freeres_list: *mut _IO_FILE,
|
|
pub _freeres_buf: *mut ::std::os::raw::c_void,
|
|
pub __pad5: size_t,
|
|
pub _mode: ::std::os::raw::c_int,
|
|
pub _unused2: [::std::os::raw::c_char; 20usize],
|
|
}
|
|
#[test]
|
|
fn bindgen_test_layout__IO_FILE() {
|
|
assert_eq!(
|
|
::std::mem::size_of::<_IO_FILE>(),
|
|
216usize,
|
|
concat!("Size of: ", stringify!(_IO_FILE))
|
|
);
|
|
assert_eq!(
|
|
::std::mem::align_of::<_IO_FILE>(),
|
|
8usize,
|
|
concat!("Alignment of ", stringify!(_IO_FILE))
|
|
);
|
|
assert_eq!(
|
|
unsafe { &(*(::std::ptr::null::<_IO_FILE>()))._flags as *const _ as usize },
|
|
0usize,
|
|
concat!(
|
|
"Offset of field: ",
|
|
stringify!(_IO_FILE),
|
|
"::",
|
|
stringify!(_flags)
|
|
)
|
|
);
|
|
assert_eq!(
|
|
unsafe { &(*(::std::ptr::null::<_IO_FILE>()))._IO_read_ptr as *const _ as usize },
|
|
8usize,
|
|
concat!(
|
|
"Offset of field: ",
|
|
stringify!(_IO_FILE),
|
|
"::",
|
|
stringify!(_IO_read_ptr)
|
|
)
|
|
);
|
|
assert_eq!(
|
|
unsafe { &(*(::std::ptr::null::<_IO_FILE>()))._IO_read_end as *const _ as usize },
|
|
16usize,
|
|
concat!(
|
|
"Offset of field: ",
|
|
stringify!(_IO_FILE),
|
|
"::",
|
|
stringify!(_IO_read_end)
|
|
)
|
|
);
|
|
assert_eq!(
|
|
unsafe { &(*(::std::ptr::null::<_IO_FILE>()))._IO_read_base as *const _ as usize },
|
|
24usize,
|
|
concat!(
|
|
"Offset of field: ",
|
|
stringify!(_IO_FILE),
|
|
"::",
|
|
stringify!(_IO_read_base)
|
|
)
|
|
);
|
|
assert_eq!(
|
|
unsafe { &(*(::std::ptr::null::<_IO_FILE>()))._IO_write_base as *const _ as usize },
|
|
32usize,
|
|
concat!(
|
|
"Offset of field: ",
|
|
stringify!(_IO_FILE),
|
|
"::",
|
|
stringify!(_IO_write_base)
|
|
)
|
|
);
|
|
assert_eq!(
|
|
unsafe { &(*(::std::ptr::null::<_IO_FILE>()))._IO_write_ptr as *const _ as usize },
|
|
40usize,
|
|
concat!(
|
|
"Offset of field: ",
|
|
stringify!(_IO_FILE),
|
|
"::",
|
|
stringify!(_IO_write_ptr)
|
|
)
|
|
);
|
|
assert_eq!(
|
|
unsafe { &(*(::std::ptr::null::<_IO_FILE>()))._IO_write_end as *const _ as usize },
|
|
48usize,
|
|
concat!(
|
|
"Offset of field: ",
|
|
stringify!(_IO_FILE),
|
|
"::",
|
|
stringify!(_IO_write_end)
|
|
)
|
|
);
|
|
assert_eq!(
|
|
unsafe { &(*(::std::ptr::null::<_IO_FILE>()))._IO_buf_base as *const _ as usize },
|
|
56usize,
|
|
concat!(
|
|
"Offset of field: ",
|
|
stringify!(_IO_FILE),
|
|
"::",
|
|
stringify!(_IO_buf_base)
|
|
)
|
|
);
|
|
assert_eq!(
|
|
unsafe { &(*(::std::ptr::null::<_IO_FILE>()))._IO_buf_end as *const _ as usize },
|
|
64usize,
|
|
concat!(
|
|
"Offset of field: ",
|
|
stringify!(_IO_FILE),
|
|
"::",
|
|
stringify!(_IO_buf_end)
|
|
)
|
|
);
|
|
assert_eq!(
|
|
unsafe { &(*(::std::ptr::null::<_IO_FILE>()))._IO_save_base as *const _ as usize },
|
|
72usize,
|
|
concat!(
|
|
"Offset of field: ",
|
|
stringify!(_IO_FILE),
|
|
"::",
|
|
stringify!(_IO_save_base)
|
|
)
|
|
);
|
|
assert_eq!(
|
|
unsafe { &(*(::std::ptr::null::<_IO_FILE>()))._IO_backup_base as *const _ as usize },
|
|
80usize,
|
|
concat!(
|
|
"Offset of field: ",
|
|
stringify!(_IO_FILE),
|
|
"::",
|
|
stringify!(_IO_backup_base)
|
|
)
|
|
);
|
|
assert_eq!(
|
|
unsafe { &(*(::std::ptr::null::<_IO_FILE>()))._IO_save_end as *const _ as usize },
|
|
88usize,
|
|
concat!(
|
|
"Offset of field: ",
|
|
stringify!(_IO_FILE),
|
|
"::",
|
|
stringify!(_IO_save_end)
|
|
)
|
|
);
|
|
assert_eq!(
|
|
unsafe { &(*(::std::ptr::null::<_IO_FILE>()))._markers as *const _ as usize },
|
|
96usize,
|
|
concat!(
|
|
"Offset of field: ",
|
|
stringify!(_IO_FILE),
|
|
"::",
|
|
stringify!(_markers)
|
|
)
|
|
);
|
|
assert_eq!(
|
|
unsafe { &(*(::std::ptr::null::<_IO_FILE>()))._chain as *const _ as usize },
|
|
104usize,
|
|
concat!(
|
|
"Offset of field: ",
|
|
stringify!(_IO_FILE),
|
|
"::",
|
|
stringify!(_chain)
|
|
)
|
|
);
|
|
assert_eq!(
|
|
unsafe { &(*(::std::ptr::null::<_IO_FILE>()))._fileno as *const _ as usize },
|
|
112usize,
|
|
concat!(
|
|
"Offset of field: ",
|
|
stringify!(_IO_FILE),
|
|
"::",
|
|
stringify!(_fileno)
|
|
)
|
|
);
|
|
assert_eq!(
|
|
unsafe { &(*(::std::ptr::null::<_IO_FILE>()))._flags2 as *const _ as usize },
|
|
116usize,
|
|
concat!(
|
|
"Offset of field: ",
|
|
stringify!(_IO_FILE),
|
|
"::",
|
|
stringify!(_flags2)
|
|
)
|
|
);
|
|
assert_eq!(
|
|
unsafe { &(*(::std::ptr::null::<_IO_FILE>()))._old_offset as *const _ as usize },
|
|
120usize,
|
|
concat!(
|
|
"Offset of field: ",
|
|
stringify!(_IO_FILE),
|
|
"::",
|
|
stringify!(_old_offset)
|
|
)
|
|
);
|
|
assert_eq!(
|
|
unsafe { &(*(::std::ptr::null::<_IO_FILE>()))._cur_column as *const _ as usize },
|
|
128usize,
|
|
concat!(
|
|
"Offset of field: ",
|
|
stringify!(_IO_FILE),
|
|
"::",
|
|
stringify!(_cur_column)
|
|
)
|
|
);
|
|
assert_eq!(
|
|
unsafe { &(*(::std::ptr::null::<_IO_FILE>()))._vtable_offset as *const _ as usize },
|
|
130usize,
|
|
concat!(
|
|
"Offset of field: ",
|
|
stringify!(_IO_FILE),
|
|
"::",
|
|
stringify!(_vtable_offset)
|
|
)
|
|
);
|
|
assert_eq!(
|
|
unsafe { &(*(::std::ptr::null::<_IO_FILE>()))._shortbuf as *const _ as usize },
|
|
131usize,
|
|
concat!(
|
|
"Offset of field: ",
|
|
stringify!(_IO_FILE),
|
|
"::",
|
|
stringify!(_shortbuf)
|
|
)
|
|
);
|
|
assert_eq!(
|
|
unsafe { &(*(::std::ptr::null::<_IO_FILE>()))._lock as *const _ as usize },
|
|
136usize,
|
|
concat!(
|
|
"Offset of field: ",
|
|
stringify!(_IO_FILE),
|
|
"::",
|
|
stringify!(_lock)
|
|
)
|
|
);
|
|
assert_eq!(
|
|
unsafe { &(*(::std::ptr::null::<_IO_FILE>()))._offset as *const _ as usize },
|
|
144usize,
|
|
concat!(
|
|
"Offset of field: ",
|
|
stringify!(_IO_FILE),
|
|
"::",
|
|
stringify!(_offset)
|
|
)
|
|
);
|
|
assert_eq!(
|
|
unsafe { &(*(::std::ptr::null::<_IO_FILE>()))._codecvt as *const _ as usize },
|
|
152usize,
|
|
concat!(
|
|
"Offset of field: ",
|
|
stringify!(_IO_FILE),
|
|
"::",
|
|
stringify!(_codecvt)
|
|
)
|
|
);
|
|
assert_eq!(
|
|
unsafe { &(*(::std::ptr::null::<_IO_FILE>()))._wide_data as *const _ as usize },
|
|
160usize,
|
|
concat!(
|
|
"Offset of field: ",
|
|
stringify!(_IO_FILE),
|
|
"::",
|
|
stringify!(_wide_data)
|
|
)
|
|
);
|
|
assert_eq!(
|
|
unsafe { &(*(::std::ptr::null::<_IO_FILE>()))._freeres_list as *const _ as usize },
|
|
168usize,
|
|
concat!(
|
|
"Offset of field: ",
|
|
stringify!(_IO_FILE),
|
|
"::",
|
|
stringify!(_freeres_list)
|
|
)
|
|
);
|
|
assert_eq!(
|
|
unsafe { &(*(::std::ptr::null::<_IO_FILE>()))._freeres_buf as *const _ as usize },
|
|
176usize,
|
|
concat!(
|
|
"Offset of field: ",
|
|
stringify!(_IO_FILE),
|
|
"::",
|
|
stringify!(_freeres_buf)
|
|
)
|
|
);
|
|
assert_eq!(
|
|
unsafe { &(*(::std::ptr::null::<_IO_FILE>())).__pad5 as *const _ as usize },
|
|
184usize,
|
|
concat!(
|
|
"Offset of field: ",
|
|
stringify!(_IO_FILE),
|
|
"::",
|
|
stringify!(__pad5)
|
|
)
|
|
);
|
|
assert_eq!(
|
|
unsafe { &(*(::std::ptr::null::<_IO_FILE>()))._mode as *const _ as usize },
|
|
192usize,
|
|
concat!(
|
|
"Offset of field: ",
|
|
stringify!(_IO_FILE),
|
|
"::",
|
|
stringify!(_mode)
|
|
)
|
|
);
|
|
assert_eq!(
|
|
unsafe { &(*(::std::ptr::null::<_IO_FILE>()))._unused2 as *const _ as usize },
|
|
196usize,
|
|
concat!(
|
|
"Offset of field: ",
|
|
stringify!(_IO_FILE),
|
|
"::",
|
|
stringify!(_unused2)
|
|
)
|
|
);
|
|
}
|
|
pub type off_t = __off_t;
|
|
pub type ssize_t = __ssize_t;
|
|
pub type fpos_t = __fpos_t;
|
|
extern "C" {
|
|
pub static mut stdin: *mut FILE;
|
|
}
|
|
extern "C" {
|
|
pub static mut stdout: *mut FILE;
|
|
}
|
|
extern "C" {
|
|
pub static mut stderr: *mut FILE;
|
|
}
|
|
extern "C" {
|
|
pub fn remove(__filename: *const ::std::os::raw::c_char) -> ::std::os::raw::c_int;
|
|
}
|
|
extern "C" {
|
|
pub fn rename(
|
|
__old: *const ::std::os::raw::c_char,
|
|
__new: *const ::std::os::raw::c_char,
|
|
) -> ::std::os::raw::c_int;
|
|
}
|
|
extern "C" {
|
|
pub fn renameat(
|
|
__oldfd: ::std::os::raw::c_int,
|
|
__old: *const ::std::os::raw::c_char,
|
|
__newfd: ::std::os::raw::c_int,
|
|
__new: *const ::std::os::raw::c_char,
|
|
) -> ::std::os::raw::c_int;
|
|
}
|
|
extern "C" {
|
|
pub fn tmpfile() -> *mut FILE;
|
|
}
|
|
extern "C" {
|
|
pub fn tmpnam(__s: *mut ::std::os::raw::c_char) -> *mut ::std::os::raw::c_char;
|
|
}
|
|
extern "C" {
|
|
pub fn tmpnam_r(__s: *mut ::std::os::raw::c_char) -> *mut ::std::os::raw::c_char;
|
|
}
|
|
extern "C" {
|
|
pub fn tempnam(
|
|
__dir: *const ::std::os::raw::c_char,
|
|
__pfx: *const ::std::os::raw::c_char,
|
|
) -> *mut ::std::os::raw::c_char;
|
|
}
|
|
extern "C" {
|
|
pub fn fclose(__stream: *mut FILE) -> ::std::os::raw::c_int;
|
|
}
|
|
extern "C" {
|
|
pub fn fflush(__stream: *mut FILE) -> ::std::os::raw::c_int;
|
|
}
|
|
extern "C" {
|
|
pub fn fflush_unlocked(__stream: *mut FILE) -> ::std::os::raw::c_int;
|
|
}
|
|
extern "C" {
|
|
pub fn fopen(
|
|
__filename: *const ::std::os::raw::c_char,
|
|
__modes: *const ::std::os::raw::c_char,
|
|
) -> *mut FILE;
|
|
}
|
|
extern "C" {
|
|
pub fn freopen(
|
|
__filename: *const ::std::os::raw::c_char,
|
|
__modes: *const ::std::os::raw::c_char,
|
|
__stream: *mut FILE,
|
|
) -> *mut FILE;
|
|
}
|
|
extern "C" {
|
|
pub fn fdopen(__fd: ::std::os::raw::c_int, __modes: *const ::std::os::raw::c_char)
|
|
-> *mut FILE;
|
|
}
|
|
extern "C" {
|
|
pub fn fmemopen(
|
|
__s: *mut ::std::os::raw::c_void,
|
|
__len: size_t,
|
|
__modes: *const ::std::os::raw::c_char,
|
|
) -> *mut FILE;
|
|
}
|
|
extern "C" {
|
|
pub fn open_memstream(
|
|
__bufloc: *mut *mut ::std::os::raw::c_char,
|
|
__sizeloc: *mut size_t,
|
|
) -> *mut FILE;
|
|
}
|
|
extern "C" {
|
|
pub fn setbuf(__stream: *mut FILE, __buf: *mut ::std::os::raw::c_char);
|
|
}
|
|
extern "C" {
|
|
pub fn setvbuf(
|
|
__stream: *mut FILE,
|
|
__buf: *mut ::std::os::raw::c_char,
|
|
__modes: ::std::os::raw::c_int,
|
|
__n: size_t,
|
|
) -> ::std::os::raw::c_int;
|
|
}
|
|
extern "C" {
|
|
pub fn setbuffer(__stream: *mut FILE, __buf: *mut ::std::os::raw::c_char, __size: size_t);
|
|
}
|
|
extern "C" {
|
|
pub fn setlinebuf(__stream: *mut FILE);
|
|
}
|
|
extern "C" {
|
|
pub fn fprintf(
|
|
__stream: *mut FILE,
|
|
__format: *const ::std::os::raw::c_char,
|
|
...
|
|
) -> ::std::os::raw::c_int;
|
|
}
|
|
extern "C" {
|
|
pub fn printf(__format: *const ::std::os::raw::c_char, ...) -> ::std::os::raw::c_int;
|
|
}
|
|
extern "C" {
|
|
pub fn sprintf(
|
|
__s: *mut ::std::os::raw::c_char,
|
|
__format: *const ::std::os::raw::c_char,
|
|
...
|
|
) -> ::std::os::raw::c_int;
|
|
}
|
|
extern "C" {
|
|
pub fn vfprintf(
|
|
__s: *mut FILE,
|
|
__format: *const ::std::os::raw::c_char,
|
|
__arg: *mut __va_list_tag,
|
|
) -> ::std::os::raw::c_int;
|
|
}
|
|
extern "C" {
|
|
pub fn vprintf(
|
|
__format: *const ::std::os::raw::c_char,
|
|
__arg: *mut __va_list_tag,
|
|
) -> ::std::os::raw::c_int;
|
|
}
|
|
extern "C" {
|
|
pub fn vsprintf(
|
|
__s: *mut ::std::os::raw::c_char,
|
|
__format: *const ::std::os::raw::c_char,
|
|
__arg: *mut __va_list_tag,
|
|
) -> ::std::os::raw::c_int;
|
|
}
|
|
extern "C" {
|
|
pub fn snprintf(
|
|
__s: *mut ::std::os::raw::c_char,
|
|
__maxlen: ::std::os::raw::c_ulong,
|
|
__format: *const ::std::os::raw::c_char,
|
|
...
|
|
) -> ::std::os::raw::c_int;
|
|
}
|
|
extern "C" {
|
|
pub fn vsnprintf(
|
|
__s: *mut ::std::os::raw::c_char,
|
|
__maxlen: ::std::os::raw::c_ulong,
|
|
__format: *const ::std::os::raw::c_char,
|
|
__arg: *mut __va_list_tag,
|
|
) -> ::std::os::raw::c_int;
|
|
}
|
|
extern "C" {
|
|
pub fn vdprintf(
|
|
__fd: ::std::os::raw::c_int,
|
|
__fmt: *const ::std::os::raw::c_char,
|
|
__arg: *mut __va_list_tag,
|
|
) -> ::std::os::raw::c_int;
|
|
}
|
|
extern "C" {
|
|
pub fn dprintf(
|
|
__fd: ::std::os::raw::c_int,
|
|
__fmt: *const ::std::os::raw::c_char,
|
|
...
|
|
) -> ::std::os::raw::c_int;
|
|
}
|
|
extern "C" {
|
|
pub fn fscanf(
|
|
__stream: *mut FILE,
|
|
__format: *const ::std::os::raw::c_char,
|
|
...
|
|
) -> ::std::os::raw::c_int;
|
|
}
|
|
extern "C" {
|
|
pub fn scanf(__format: *const ::std::os::raw::c_char, ...) -> ::std::os::raw::c_int;
|
|
}
|
|
extern "C" {
|
|
pub fn sscanf(
|
|
__s: *const ::std::os::raw::c_char,
|
|
__format: *const ::std::os::raw::c_char,
|
|
...
|
|
) -> ::std::os::raw::c_int;
|
|
}
|
|
pub type _Float32 = f32;
|
|
pub type _Float64 = f64;
|
|
pub type _Float32x = f64;
|
|
pub type _Float64x = u128;
|
|
extern "C" {
|
|
#[link_name = "\u{1}__isoc99_fscanf"]
|
|
pub fn fscanf1(
|
|
__stream: *mut FILE,
|
|
__format: *const ::std::os::raw::c_char,
|
|
...
|
|
) -> ::std::os::raw::c_int;
|
|
}
|
|
extern "C" {
|
|
#[link_name = "\u{1}__isoc99_scanf"]
|
|
pub fn scanf1(__format: *const ::std::os::raw::c_char, ...) -> ::std::os::raw::c_int;
|
|
}
|
|
extern "C" {
|
|
#[link_name = "\u{1}__isoc99_sscanf"]
|
|
pub fn sscanf1(
|
|
__s: *const ::std::os::raw::c_char,
|
|
__format: *const ::std::os::raw::c_char,
|
|
...
|
|
) -> ::std::os::raw::c_int;
|
|
}
|
|
extern "C" {
|
|
pub fn vfscanf(
|
|
__s: *mut FILE,
|
|
__format: *const ::std::os::raw::c_char,
|
|
__arg: *mut __va_list_tag,
|
|
) -> ::std::os::raw::c_int;
|
|
}
|
|
extern "C" {
|
|
pub fn vscanf(
|
|
__format: *const ::std::os::raw::c_char,
|
|
__arg: *mut __va_list_tag,
|
|
) -> ::std::os::raw::c_int;
|
|
}
|
|
extern "C" {
|
|
pub fn vsscanf(
|
|
__s: *const ::std::os::raw::c_char,
|
|
__format: *const ::std::os::raw::c_char,
|
|
__arg: *mut __va_list_tag,
|
|
) -> ::std::os::raw::c_int;
|
|
}
|
|
extern "C" {
|
|
#[link_name = "\u{1}__isoc99_vfscanf"]
|
|
pub fn vfscanf1(
|
|
__s: *mut FILE,
|
|
__format: *const ::std::os::raw::c_char,
|
|
__arg: *mut __va_list_tag,
|
|
) -> ::std::os::raw::c_int;
|
|
}
|
|
extern "C" {
|
|
#[link_name = "\u{1}__isoc99_vscanf"]
|
|
pub fn vscanf1(
|
|
__format: *const ::std::os::raw::c_char,
|
|
__arg: *mut __va_list_tag,
|
|
) -> ::std::os::raw::c_int;
|
|
}
|
|
extern "C" {
|
|
#[link_name = "\u{1}__isoc99_vsscanf"]
|
|
pub fn vsscanf1(
|
|
__s: *const ::std::os::raw::c_char,
|
|
__format: *const ::std::os::raw::c_char,
|
|
__arg: *mut __va_list_tag,
|
|
) -> ::std::os::raw::c_int;
|
|
}
|
|
extern "C" {
|
|
pub fn fgetc(__stream: *mut FILE) -> ::std::os::raw::c_int;
|
|
}
|
|
extern "C" {
|
|
pub fn getc(__stream: *mut FILE) -> ::std::os::raw::c_int;
|
|
}
|
|
extern "C" {
|
|
pub fn getchar() -> ::std::os::raw::c_int;
|
|
}
|
|
extern "C" {
|
|
pub fn getc_unlocked(__stream: *mut FILE) -> ::std::os::raw::c_int;
|
|
}
|
|
extern "C" {
|
|
pub fn getchar_unlocked() -> ::std::os::raw::c_int;
|
|
}
|
|
extern "C" {
|
|
pub fn fgetc_unlocked(__stream: *mut FILE) -> ::std::os::raw::c_int;
|
|
}
|
|
extern "C" {
|
|
pub fn fputc(__c: ::std::os::raw::c_int, __stream: *mut FILE) -> ::std::os::raw::c_int;
|
|
}
|
|
extern "C" {
|
|
pub fn putc(__c: ::std::os::raw::c_int, __stream: *mut FILE) -> ::std::os::raw::c_int;
|
|
}
|
|
extern "C" {
|
|
pub fn putchar(__c: ::std::os::raw::c_int) -> ::std::os::raw::c_int;
|
|
}
|
|
extern "C" {
|
|
pub fn fputc_unlocked(__c: ::std::os::raw::c_int, __stream: *mut FILE)
|
|
-> ::std::os::raw::c_int;
|
|
}
|
|
extern "C" {
|
|
pub fn putc_unlocked(__c: ::std::os::raw::c_int, __stream: *mut FILE) -> ::std::os::raw::c_int;
|
|
}
|
|
extern "C" {
|
|
pub fn putchar_unlocked(__c: ::std::os::raw::c_int) -> ::std::os::raw::c_int;
|
|
}
|
|
extern "C" {
|
|
pub fn getw(__stream: *mut FILE) -> ::std::os::raw::c_int;
|
|
}
|
|
extern "C" {
|
|
pub fn putw(__w: ::std::os::raw::c_int, __stream: *mut FILE) -> ::std::os::raw::c_int;
|
|
}
|
|
extern "C" {
|
|
pub fn fgets(
|
|
__s: *mut ::std::os::raw::c_char,
|
|
__n: ::std::os::raw::c_int,
|
|
__stream: *mut FILE,
|
|
) -> *mut ::std::os::raw::c_char;
|
|
}
|
|
extern "C" {
|
|
pub fn __getdelim(
|
|
__lineptr: *mut *mut ::std::os::raw::c_char,
|
|
__n: *mut size_t,
|
|
__delimiter: ::std::os::raw::c_int,
|
|
__stream: *mut FILE,
|
|
) -> __ssize_t;
|
|
}
|
|
extern "C" {
|
|
pub fn getdelim(
|
|
__lineptr: *mut *mut ::std::os::raw::c_char,
|
|
__n: *mut size_t,
|
|
__delimiter: ::std::os::raw::c_int,
|
|
__stream: *mut FILE,
|
|
) -> __ssize_t;
|
|
}
|
|
extern "C" {
|
|
pub fn getline(
|
|
__lineptr: *mut *mut ::std::os::raw::c_char,
|
|
__n: *mut size_t,
|
|
__stream: *mut FILE,
|
|
) -> __ssize_t;
|
|
}
|
|
extern "C" {
|
|
pub fn fputs(__s: *const ::std::os::raw::c_char, __stream: *mut FILE) -> ::std::os::raw::c_int;
|
|
}
|
|
extern "C" {
|
|
pub fn puts(__s: *const ::std::os::raw::c_char) -> ::std::os::raw::c_int;
|
|
}
|
|
extern "C" {
|
|
pub fn ungetc(__c: ::std::os::raw::c_int, __stream: *mut FILE) -> ::std::os::raw::c_int;
|
|
}
|
|
extern "C" {
|
|
pub fn fread(
|
|
__ptr: *mut ::std::os::raw::c_void,
|
|
__size: ::std::os::raw::c_ulong,
|
|
__n: ::std::os::raw::c_ulong,
|
|
__stream: *mut FILE,
|
|
) -> ::std::os::raw::c_ulong;
|
|
}
|
|
extern "C" {
|
|
pub fn fwrite(
|
|
__ptr: *const ::std::os::raw::c_void,
|
|
__size: ::std::os::raw::c_ulong,
|
|
__n: ::std::os::raw::c_ulong,
|
|
__s: *mut FILE,
|
|
) -> ::std::os::raw::c_ulong;
|
|
}
|
|
extern "C" {
|
|
pub fn fread_unlocked(
|
|
__ptr: *mut ::std::os::raw::c_void,
|
|
__size: size_t,
|
|
__n: size_t,
|
|
__stream: *mut FILE,
|
|
) -> size_t;
|
|
}
|
|
extern "C" {
|
|
pub fn fwrite_unlocked(
|
|
__ptr: *const ::std::os::raw::c_void,
|
|
__size: size_t,
|
|
__n: size_t,
|
|
__stream: *mut FILE,
|
|
) -> size_t;
|
|
}
|
|
extern "C" {
|
|
pub fn fseek(
|
|
__stream: *mut FILE,
|
|
__off: ::std::os::raw::c_long,
|
|
__whence: ::std::os::raw::c_int,
|
|
) -> ::std::os::raw::c_int;
|
|
}
|
|
extern "C" {
|
|
pub fn ftell(__stream: *mut FILE) -> ::std::os::raw::c_long;
|
|
}
|
|
extern "C" {
|
|
pub fn rewind(__stream: *mut FILE);
|
|
}
|
|
extern "C" {
|
|
pub fn fseeko(
|
|
__stream: *mut FILE,
|
|
__off: __off_t,
|
|
__whence: ::std::os::raw::c_int,
|
|
) -> ::std::os::raw::c_int;
|
|
}
|
|
extern "C" {
|
|
pub fn ftello(__stream: *mut FILE) -> __off_t;
|
|
}
|
|
extern "C" {
|
|
pub fn fgetpos(__stream: *mut FILE, __pos: *mut fpos_t) -> ::std::os::raw::c_int;
|
|
}
|
|
extern "C" {
|
|
pub fn fsetpos(__stream: *mut FILE, __pos: *const fpos_t) -> ::std::os::raw::c_int;
|
|
}
|
|
extern "C" {
|
|
pub fn clearerr(__stream: *mut FILE);
|
|
}
|
|
extern "C" {
|
|
pub fn feof(__stream: *mut FILE) -> ::std::os::raw::c_int;
|
|
}
|
|
extern "C" {
|
|
pub fn ferror(__stream: *mut FILE) -> ::std::os::raw::c_int;
|
|
}
|
|
extern "C" {
|
|
pub fn clearerr_unlocked(__stream: *mut FILE);
|
|
}
|
|
extern "C" {
|
|
pub fn feof_unlocked(__stream: *mut FILE) -> ::std::os::raw::c_int;
|
|
}
|
|
extern "C" {
|
|
pub fn ferror_unlocked(__stream: *mut FILE) -> ::std::os::raw::c_int;
|
|
}
|
|
extern "C" {
|
|
pub fn perror(__s: *const ::std::os::raw::c_char);
|
|
}
|
|
extern "C" {
|
|
pub fn fileno(__stream: *mut FILE) -> ::std::os::raw::c_int;
|
|
}
|
|
extern "C" {
|
|
pub fn fileno_unlocked(__stream: *mut FILE) -> ::std::os::raw::c_int;
|
|
}
|
|
extern "C" {
|
|
pub fn popen(
|
|
__command: *const ::std::os::raw::c_char,
|
|
__modes: *const ::std::os::raw::c_char,
|
|
) -> *mut FILE;
|
|
}
|
|
extern "C" {
|
|
pub fn pclose(__stream: *mut FILE) -> ::std::os::raw::c_int;
|
|
}
|
|
extern "C" {
|
|
pub fn ctermid(__s: *mut ::std::os::raw::c_char) -> *mut ::std::os::raw::c_char;
|
|
}
|
|
extern "C" {
|
|
pub fn flockfile(__stream: *mut FILE);
|
|
}
|
|
extern "C" {
|
|
pub fn ftrylockfile(__stream: *mut FILE) -> ::std::os::raw::c_int;
|
|
}
|
|
extern "C" {
|
|
pub fn funlockfile(__stream: *mut FILE);
|
|
}
|
|
extern "C" {
|
|
pub fn __uflow(arg1: *mut FILE) -> ::std::os::raw::c_int;
|
|
}
|
|
extern "C" {
|
|
pub fn __overflow(arg1: *mut FILE, arg2: ::std::os::raw::c_int) -> ::std::os::raw::c_int;
|
|
}
|
|
pub type int_least8_t = __int_least8_t;
|
|
pub type int_least16_t = __int_least16_t;
|
|
pub type int_least32_t = __int_least32_t;
|
|
pub type int_least64_t = __int_least64_t;
|
|
pub type uint_least8_t = __uint_least8_t;
|
|
pub type uint_least16_t = __uint_least16_t;
|
|
pub type uint_least32_t = __uint_least32_t;
|
|
pub type uint_least64_t = __uint_least64_t;
|
|
pub type int_fast8_t = ::std::os::raw::c_schar;
|
|
pub type int_fast16_t = ::std::os::raw::c_long;
|
|
pub type int_fast32_t = ::std::os::raw::c_long;
|
|
pub type int_fast64_t = ::std::os::raw::c_long;
|
|
pub type uint_fast8_t = ::std::os::raw::c_uchar;
|
|
pub type uint_fast16_t = ::std::os::raw::c_ulong;
|
|
pub type uint_fast32_t = ::std::os::raw::c_ulong;
|
|
pub type uint_fast64_t = ::std::os::raw::c_ulong;
|
|
pub type intmax_t = __intmax_t;
|
|
pub type uintmax_t = __uintmax_t;
|
|
#[repr(C)]
|
|
#[derive(Debug, Copy, Clone)]
|
|
pub struct JSRuntime {
|
|
_unused: [u8; 0],
|
|
}
|
|
#[repr(C)]
|
|
#[derive(Debug, Copy, Clone)]
|
|
pub struct JSContext {
|
|
_unused: [u8; 0],
|
|
}
|
|
#[repr(C)]
|
|
#[derive(Debug, Copy, Clone)]
|
|
pub struct JSObject {
|
|
_unused: [u8; 0],
|
|
}
|
|
#[repr(C)]
|
|
#[derive(Debug, Copy, Clone)]
|
|
pub struct JSClass {
|
|
_unused: [u8; 0],
|
|
}
|
|
pub type JSClassID = u32;
|
|
pub type JSAtom = u32;
|
|
pub const JS_TAG_FIRST: ::std::os::raw::c_int = -11;
|
|
pub const JS_TAG_BIG_DECIMAL: ::std::os::raw::c_int = -11;
|
|
pub const JS_TAG_BIG_INT: ::std::os::raw::c_int = -10;
|
|
pub const JS_TAG_BIG_FLOAT: ::std::os::raw::c_int = -9;
|
|
pub const JS_TAG_SYMBOL: ::std::os::raw::c_int = -8;
|
|
pub const JS_TAG_STRING: ::std::os::raw::c_int = -7;
|
|
pub const JS_TAG_MODULE: ::std::os::raw::c_int = -3;
|
|
pub const JS_TAG_FUNCTION_BYTECODE: ::std::os::raw::c_int = -2;
|
|
pub const JS_TAG_OBJECT: ::std::os::raw::c_int = -1;
|
|
pub const JS_TAG_INT: ::std::os::raw::c_int = 0;
|
|
pub const JS_TAG_BOOL: ::std::os::raw::c_int = 1;
|
|
pub const JS_TAG_NULL: ::std::os::raw::c_int = 2;
|
|
pub const JS_TAG_UNDEFINED: ::std::os::raw::c_int = 3;
|
|
pub const JS_TAG_UNINITIALIZED: ::std::os::raw::c_int = 4;
|
|
pub const JS_TAG_CATCH_OFFSET: ::std::os::raw::c_int = 5;
|
|
pub const JS_TAG_EXCEPTION: ::std::os::raw::c_int = 6;
|
|
pub const JS_TAG_FLOAT64: ::std::os::raw::c_int = 7;
|
|
pub type _bindgen_ty_1 = ::std::os::raw::c_int;
|
|
#[repr(C)]
|
|
#[derive(Debug, Copy, Clone)]
|
|
pub struct JSRefCountHeader {
|
|
pub ref_count: ::std::os::raw::c_int,
|
|
}
|
|
#[test]
|
|
fn bindgen_test_layout_JSRefCountHeader() {
|
|
assert_eq!(
|
|
::std::mem::size_of::<JSRefCountHeader>(),
|
|
4usize,
|
|
concat!("Size of: ", stringify!(JSRefCountHeader))
|
|
);
|
|
assert_eq!(
|
|
::std::mem::align_of::<JSRefCountHeader>(),
|
|
4usize,
|
|
concat!("Alignment of ", stringify!(JSRefCountHeader))
|
|
);
|
|
assert_eq!(
|
|
unsafe { &(*(::std::ptr::null::<JSRefCountHeader>())).ref_count as *const _ as usize },
|
|
0usize,
|
|
concat!(
|
|
"Offset of field: ",
|
|
stringify!(JSRefCountHeader),
|
|
"::",
|
|
stringify!(ref_count)
|
|
)
|
|
);
|
|
}
|
|
#[repr(C)]
|
|
#[derive(Copy, Clone)]
|
|
pub union JSValueUnion {
|
|
pub int32: i32,
|
|
pub float64: f64,
|
|
pub ptr: *mut ::std::os::raw::c_void,
|
|
_bindgen_union_align: u64,
|
|
}
|
|
#[test]
|
|
fn bindgen_test_layout_JSValueUnion() {
|
|
assert_eq!(
|
|
::std::mem::size_of::<JSValueUnion>(),
|
|
8usize,
|
|
concat!("Size of: ", stringify!(JSValueUnion))
|
|
);
|
|
assert_eq!(
|
|
::std::mem::align_of::<JSValueUnion>(),
|
|
8usize,
|
|
concat!("Alignment of ", stringify!(JSValueUnion))
|
|
);
|
|
assert_eq!(
|
|
unsafe { &(*(::std::ptr::null::<JSValueUnion>())).int32 as *const _ as usize },
|
|
0usize,
|
|
concat!(
|
|
"Offset of field: ",
|
|
stringify!(JSValueUnion),
|
|
"::",
|
|
stringify!(int32)
|
|
)
|
|
);
|
|
assert_eq!(
|
|
unsafe { &(*(::std::ptr::null::<JSValueUnion>())).float64 as *const _ as usize },
|
|
0usize,
|
|
concat!(
|
|
"Offset of field: ",
|
|
stringify!(JSValueUnion),
|
|
"::",
|
|
stringify!(float64)
|
|
)
|
|
);
|
|
assert_eq!(
|
|
unsafe { &(*(::std::ptr::null::<JSValueUnion>())).ptr as *const _ as usize },
|
|
0usize,
|
|
concat!(
|
|
"Offset of field: ",
|
|
stringify!(JSValueUnion),
|
|
"::",
|
|
stringify!(ptr)
|
|
)
|
|
);
|
|
}
|
|
#[repr(C)]
|
|
#[derive(Copy, Clone)]
|
|
pub struct JSValue {
|
|
pub u: JSValueUnion,
|
|
pub tag: i64,
|
|
}
|
|
#[test]
|
|
fn bindgen_test_layout_JSValue() {
|
|
assert_eq!(
|
|
::std::mem::size_of::<JSValue>(),
|
|
16usize,
|
|
concat!("Size of: ", stringify!(JSValue))
|
|
);
|
|
assert_eq!(
|
|
::std::mem::align_of::<JSValue>(),
|
|
8usize,
|
|
concat!("Alignment of ", stringify!(JSValue))
|
|
);
|
|
assert_eq!(
|
|
unsafe { &(*(::std::ptr::null::<JSValue>())).u as *const _ as usize },
|
|
0usize,
|
|
concat!(
|
|
"Offset of field: ",
|
|
stringify!(JSValue),
|
|
"::",
|
|
stringify!(u)
|
|
)
|
|
);
|
|
assert_eq!(
|
|
unsafe { &(*(::std::ptr::null::<JSValue>())).tag as *const _ as usize },
|
|
8usize,
|
|
concat!(
|
|
"Offset of field: ",
|
|
stringify!(JSValue),
|
|
"::",
|
|
stringify!(tag)
|
|
)
|
|
);
|
|
}
|
|
pub type JSCFunction = ::std::option::Option<
|
|
unsafe extern "C" fn(
|
|
ctx: *mut JSContext,
|
|
this_val: JSValue,
|
|
argc: ::std::os::raw::c_int,
|
|
argv: *mut JSValue,
|
|
) -> JSValue,
|
|
>;
|
|
pub type JSCFunctionMagic = ::std::option::Option<
|
|
unsafe extern "C" fn(
|
|
ctx: *mut JSContext,
|
|
this_val: JSValue,
|
|
argc: ::std::os::raw::c_int,
|
|
argv: *mut JSValue,
|
|
magic: ::std::os::raw::c_int,
|
|
) -> JSValue,
|
|
>;
|
|
pub type JSCFunctionData = ::std::option::Option<
|
|
unsafe extern "C" fn(
|
|
ctx: *mut JSContext,
|
|
this_val: JSValue,
|
|
argc: ::std::os::raw::c_int,
|
|
argv: *mut JSValue,
|
|
magic: ::std::os::raw::c_int,
|
|
func_data: *mut JSValue,
|
|
) -> JSValue,
|
|
>;
|
|
#[repr(C)]
|
|
#[derive(Debug, Copy, Clone)]
|
|
pub struct JSMallocState {
|
|
pub malloc_count: size_t,
|
|
pub malloc_size: size_t,
|
|
pub malloc_limit: size_t,
|
|
pub opaque: *mut ::std::os::raw::c_void,
|
|
}
|
|
#[test]
|
|
fn bindgen_test_layout_JSMallocState() {
|
|
assert_eq!(
|
|
::std::mem::size_of::<JSMallocState>(),
|
|
32usize,
|
|
concat!("Size of: ", stringify!(JSMallocState))
|
|
);
|
|
assert_eq!(
|
|
::std::mem::align_of::<JSMallocState>(),
|
|
8usize,
|
|
concat!("Alignment of ", stringify!(JSMallocState))
|
|
);
|
|
assert_eq!(
|
|
unsafe { &(*(::std::ptr::null::<JSMallocState>())).malloc_count as *const _ as usize },
|
|
0usize,
|
|
concat!(
|
|
"Offset of field: ",
|
|
stringify!(JSMallocState),
|
|
"::",
|
|
stringify!(malloc_count)
|
|
)
|
|
);
|
|
assert_eq!(
|
|
unsafe { &(*(::std::ptr::null::<JSMallocState>())).malloc_size as *const _ as usize },
|
|
8usize,
|
|
concat!(
|
|
"Offset of field: ",
|
|
stringify!(JSMallocState),
|
|
"::",
|
|
stringify!(malloc_size)
|
|
)
|
|
);
|
|
assert_eq!(
|
|
unsafe { &(*(::std::ptr::null::<JSMallocState>())).malloc_limit as *const _ as usize },
|
|
16usize,
|
|
concat!(
|
|
"Offset of field: ",
|
|
stringify!(JSMallocState),
|
|
"::",
|
|
stringify!(malloc_limit)
|
|
)
|
|
);
|
|
assert_eq!(
|
|
unsafe { &(*(::std::ptr::null::<JSMallocState>())).opaque as *const _ as usize },
|
|
24usize,
|
|
concat!(
|
|
"Offset of field: ",
|
|
stringify!(JSMallocState),
|
|
"::",
|
|
stringify!(opaque)
|
|
)
|
|
);
|
|
}
|
|
#[repr(C)]
|
|
#[derive(Debug, Copy, Clone)]
|
|
pub struct JSMallocFunctions {
|
|
pub js_malloc: ::std::option::Option<
|
|
unsafe extern "C" fn(s: *mut JSMallocState, size: size_t) -> *mut ::std::os::raw::c_void,
|
|
>,
|
|
pub js_free: ::std::option::Option<
|
|
unsafe extern "C" fn(s: *mut JSMallocState, ptr: *mut ::std::os::raw::c_void),
|
|
>,
|
|
pub js_realloc: ::std::option::Option<
|
|
unsafe extern "C" fn(
|
|
s: *mut JSMallocState,
|
|
ptr: *mut ::std::os::raw::c_void,
|
|
size: size_t,
|
|
) -> *mut ::std::os::raw::c_void,
|
|
>,
|
|
pub js_malloc_usable_size:
|
|
::std::option::Option<unsafe extern "C" fn(ptr: *const ::std::os::raw::c_void) -> size_t>,
|
|
}
|
|
#[test]
|
|
fn bindgen_test_layout_JSMallocFunctions() {
|
|
assert_eq!(
|
|
::std::mem::size_of::<JSMallocFunctions>(),
|
|
32usize,
|
|
concat!("Size of: ", stringify!(JSMallocFunctions))
|
|
);
|
|
assert_eq!(
|
|
::std::mem::align_of::<JSMallocFunctions>(),
|
|
8usize,
|
|
concat!("Alignment of ", stringify!(JSMallocFunctions))
|
|
);
|
|
assert_eq!(
|
|
unsafe { &(*(::std::ptr::null::<JSMallocFunctions>())).js_malloc as *const _ as usize },
|
|
0usize,
|
|
concat!(
|
|
"Offset of field: ",
|
|
stringify!(JSMallocFunctions),
|
|
"::",
|
|
stringify!(js_malloc)
|
|
)
|
|
);
|
|
assert_eq!(
|
|
unsafe { &(*(::std::ptr::null::<JSMallocFunctions>())).js_free as *const _ as usize },
|
|
8usize,
|
|
concat!(
|
|
"Offset of field: ",
|
|
stringify!(JSMallocFunctions),
|
|
"::",
|
|
stringify!(js_free)
|
|
)
|
|
);
|
|
assert_eq!(
|
|
unsafe { &(*(::std::ptr::null::<JSMallocFunctions>())).js_realloc as *const _ as usize },
|
|
16usize,
|
|
concat!(
|
|
"Offset of field: ",
|
|
stringify!(JSMallocFunctions),
|
|
"::",
|
|
stringify!(js_realloc)
|
|
)
|
|
);
|
|
assert_eq!(
|
|
unsafe {
|
|
&(*(::std::ptr::null::<JSMallocFunctions>())).js_malloc_usable_size as *const _ as usize
|
|
},
|
|
24usize,
|
|
concat!(
|
|
"Offset of field: ",
|
|
stringify!(JSMallocFunctions),
|
|
"::",
|
|
stringify!(js_malloc_usable_size)
|
|
)
|
|
);
|
|
}
|
|
#[repr(C)]
|
|
#[derive(Debug, Copy, Clone)]
|
|
pub struct JSGCObjectHeader {
|
|
_unused: [u8; 0],
|
|
}
|
|
extern "C" {
|
|
pub fn JS_NewRuntime() -> *mut JSRuntime;
|
|
}
|
|
extern "C" {
|
|
pub fn JS_SetRuntimeInfo(rt: *mut JSRuntime, info: *const ::std::os::raw::c_char);
|
|
}
|
|
extern "C" {
|
|
pub fn JS_SetMemoryLimit(rt: *mut JSRuntime, limit: size_t);
|
|
}
|
|
extern "C" {
|
|
pub fn JS_SetGCThreshold(rt: *mut JSRuntime, gc_threshold: size_t);
|
|
}
|
|
extern "C" {
|
|
pub fn JS_SetMaxStackSize(rt: *mut JSRuntime, stack_size: size_t);
|
|
}
|
|
extern "C" {
|
|
pub fn JS_UpdateStackTop(rt: *mut JSRuntime);
|
|
}
|
|
extern "C" {
|
|
pub fn JS_NewRuntime2(
|
|
mf: *const JSMallocFunctions,
|
|
opaque: *mut ::std::os::raw::c_void,
|
|
) -> *mut JSRuntime;
|
|
}
|
|
extern "C" {
|
|
pub fn JS_FreeRuntime(rt: *mut JSRuntime);
|
|
}
|
|
extern "C" {
|
|
pub fn JS_GetRuntimeOpaque(rt: *mut JSRuntime) -> *mut ::std::os::raw::c_void;
|
|
}
|
|
extern "C" {
|
|
pub fn JS_SetRuntimeOpaque(rt: *mut JSRuntime, opaque: *mut ::std::os::raw::c_void);
|
|
}
|
|
pub type JS_MarkFunc =
|
|
::std::option::Option<unsafe extern "C" fn(rt: *mut JSRuntime, gp: *mut JSGCObjectHeader)>;
|
|
extern "C" {
|
|
pub fn JS_MarkValue(rt: *mut JSRuntime, val: JSValue, mark_func: JS_MarkFunc);
|
|
}
|
|
extern "C" {
|
|
pub fn JS_RunGC(rt: *mut JSRuntime);
|
|
}
|
|
extern "C" {
|
|
pub fn JS_IsLiveObject(rt: *mut JSRuntime, obj: JSValue) -> ::std::os::raw::c_int;
|
|
}
|
|
extern "C" {
|
|
pub fn JS_NewContext(rt: *mut JSRuntime) -> *mut JSContext;
|
|
}
|
|
extern "C" {
|
|
pub fn JS_FreeContext(s: *mut JSContext);
|
|
}
|
|
extern "C" {
|
|
pub fn JS_DupContext(ctx: *mut JSContext) -> *mut JSContext;
|
|
}
|
|
extern "C" {
|
|
pub fn JS_GetContextOpaque(ctx: *mut JSContext) -> *mut ::std::os::raw::c_void;
|
|
}
|
|
extern "C" {
|
|
pub fn JS_SetContextOpaque(ctx: *mut JSContext, opaque: *mut ::std::os::raw::c_void);
|
|
}
|
|
extern "C" {
|
|
pub fn JS_GetRuntime(ctx: *mut JSContext) -> *mut JSRuntime;
|
|
}
|
|
extern "C" {
|
|
pub fn JS_SetClassProto(ctx: *mut JSContext, class_id: JSClassID, obj: JSValue);
|
|
}
|
|
extern "C" {
|
|
pub fn JS_GetClassProto(ctx: *mut JSContext, class_id: JSClassID) -> JSValue;
|
|
}
|
|
extern "C" {
|
|
pub fn JS_NewContextRaw(rt: *mut JSRuntime) -> *mut JSContext;
|
|
}
|
|
extern "C" {
|
|
pub fn JS_AddIntrinsicBaseObjects(ctx: *mut JSContext);
|
|
}
|
|
extern "C" {
|
|
pub fn JS_AddIntrinsicDate(ctx: *mut JSContext);
|
|
}
|
|
extern "C" {
|
|
pub fn JS_AddIntrinsicEval(ctx: *mut JSContext);
|
|
}
|
|
extern "C" {
|
|
pub fn JS_AddIntrinsicStringNormalize(ctx: *mut JSContext);
|
|
}
|
|
extern "C" {
|
|
pub fn JS_AddIntrinsicRegExpCompiler(ctx: *mut JSContext);
|
|
}
|
|
extern "C" {
|
|
pub fn JS_AddIntrinsicRegExp(ctx: *mut JSContext);
|
|
}
|
|
extern "C" {
|
|
pub fn JS_AddIntrinsicJSON(ctx: *mut JSContext);
|
|
}
|
|
extern "C" {
|
|
pub fn JS_AddIntrinsicProxy(ctx: *mut JSContext);
|
|
}
|
|
extern "C" {
|
|
pub fn JS_AddIntrinsicMapSet(ctx: *mut JSContext);
|
|
}
|
|
extern "C" {
|
|
pub fn JS_AddIntrinsicTypedArrays(ctx: *mut JSContext);
|
|
}
|
|
extern "C" {
|
|
pub fn JS_AddIntrinsicPromise(ctx: *mut JSContext);
|
|
}
|
|
extern "C" {
|
|
pub fn JS_AddIntrinsicBigInt(ctx: *mut JSContext);
|
|
}
|
|
extern "C" {
|
|
pub fn JS_AddIntrinsicBigFloat(ctx: *mut JSContext);
|
|
}
|
|
extern "C" {
|
|
pub fn JS_AddIntrinsicBigDecimal(ctx: *mut JSContext);
|
|
}
|
|
extern "C" {
|
|
pub fn JS_AddIntrinsicOperators(ctx: *mut JSContext);
|
|
}
|
|
extern "C" {
|
|
pub fn JS_EnableBignumExt(ctx: *mut JSContext, enable: ::std::os::raw::c_int);
|
|
}
|
|
extern "C" {
|
|
pub fn js_string_codePointRange(
|
|
ctx: *mut JSContext,
|
|
this_val: JSValue,
|
|
argc: ::std::os::raw::c_int,
|
|
argv: *mut JSValue,
|
|
) -> JSValue;
|
|
}
|
|
extern "C" {
|
|
pub fn js_malloc_rt(rt: *mut JSRuntime, size: size_t) -> *mut ::std::os::raw::c_void;
|
|
}
|
|
extern "C" {
|
|
pub fn js_free_rt(rt: *mut JSRuntime, ptr: *mut ::std::os::raw::c_void);
|
|
}
|
|
extern "C" {
|
|
pub fn js_realloc_rt(
|
|
rt: *mut JSRuntime,
|
|
ptr: *mut ::std::os::raw::c_void,
|
|
size: size_t,
|
|
) -> *mut ::std::os::raw::c_void;
|
|
}
|
|
extern "C" {
|
|
pub fn js_malloc_usable_size_rt(
|
|
rt: *mut JSRuntime,
|
|
ptr: *const ::std::os::raw::c_void,
|
|
) -> size_t;
|
|
}
|
|
extern "C" {
|
|
pub fn js_mallocz_rt(rt: *mut JSRuntime, size: size_t) -> *mut ::std::os::raw::c_void;
|
|
}
|
|
extern "C" {
|
|
pub fn js_malloc(ctx: *mut JSContext, size: size_t) -> *mut ::std::os::raw::c_void;
|
|
}
|
|
extern "C" {
|
|
pub fn js_free(ctx: *mut JSContext, ptr: *mut ::std::os::raw::c_void);
|
|
}
|
|
extern "C" {
|
|
pub fn js_realloc(
|
|
ctx: *mut JSContext,
|
|
ptr: *mut ::std::os::raw::c_void,
|
|
size: size_t,
|
|
) -> *mut ::std::os::raw::c_void;
|
|
}
|
|
extern "C" {
|
|
pub fn js_malloc_usable_size(ctx: *mut JSContext, ptr: *const ::std::os::raw::c_void)
|
|
-> size_t;
|
|
}
|
|
extern "C" {
|
|
pub fn js_realloc2(
|
|
ctx: *mut JSContext,
|
|
ptr: *mut ::std::os::raw::c_void,
|
|
size: size_t,
|
|
pslack: *mut size_t,
|
|
) -> *mut ::std::os::raw::c_void;
|
|
}
|
|
extern "C" {
|
|
pub fn js_mallocz(ctx: *mut JSContext, size: size_t) -> *mut ::std::os::raw::c_void;
|
|
}
|
|
extern "C" {
|
|
pub fn js_strdup(
|
|
ctx: *mut JSContext,
|
|
str_: *const ::std::os::raw::c_char,
|
|
) -> *mut ::std::os::raw::c_char;
|
|
}
|
|
extern "C" {
|
|
pub fn js_strndup(
|
|
ctx: *mut JSContext,
|
|
s: *const ::std::os::raw::c_char,
|
|
n: size_t,
|
|
) -> *mut ::std::os::raw::c_char;
|
|
}
|
|
#[repr(C)]
|
|
#[derive(Debug, Copy, Clone)]
|
|
pub struct JSMemoryUsage {
|
|
pub malloc_size: i64,
|
|
pub malloc_limit: i64,
|
|
pub memory_used_size: i64,
|
|
pub malloc_count: i64,
|
|
pub memory_used_count: i64,
|
|
pub atom_count: i64,
|
|
pub atom_size: i64,
|
|
pub str_count: i64,
|
|
pub str_size: i64,
|
|
pub obj_count: i64,
|
|
pub obj_size: i64,
|
|
pub prop_count: i64,
|
|
pub prop_size: i64,
|
|
pub shape_count: i64,
|
|
pub shape_size: i64,
|
|
pub js_func_count: i64,
|
|
pub js_func_size: i64,
|
|
pub js_func_code_size: i64,
|
|
pub js_func_pc2line_count: i64,
|
|
pub js_func_pc2line_size: i64,
|
|
pub c_func_count: i64,
|
|
pub array_count: i64,
|
|
pub fast_array_count: i64,
|
|
pub fast_array_elements: i64,
|
|
pub binary_object_count: i64,
|
|
pub binary_object_size: i64,
|
|
}
|
|
#[test]
|
|
fn bindgen_test_layout_JSMemoryUsage() {
|
|
assert_eq!(
|
|
::std::mem::size_of::<JSMemoryUsage>(),
|
|
208usize,
|
|
concat!("Size of: ", stringify!(JSMemoryUsage))
|
|
);
|
|
assert_eq!(
|
|
::std::mem::align_of::<JSMemoryUsage>(),
|
|
8usize,
|
|
concat!("Alignment of ", stringify!(JSMemoryUsage))
|
|
);
|
|
assert_eq!(
|
|
unsafe { &(*(::std::ptr::null::<JSMemoryUsage>())).malloc_size as *const _ as usize },
|
|
0usize,
|
|
concat!(
|
|
"Offset of field: ",
|
|
stringify!(JSMemoryUsage),
|
|
"::",
|
|
stringify!(malloc_size)
|
|
)
|
|
);
|
|
assert_eq!(
|
|
unsafe { &(*(::std::ptr::null::<JSMemoryUsage>())).malloc_limit as *const _ as usize },
|
|
8usize,
|
|
concat!(
|
|
"Offset of field: ",
|
|
stringify!(JSMemoryUsage),
|
|
"::",
|
|
stringify!(malloc_limit)
|
|
)
|
|
);
|
|
assert_eq!(
|
|
unsafe { &(*(::std::ptr::null::<JSMemoryUsage>())).memory_used_size as *const _ as usize },
|
|
16usize,
|
|
concat!(
|
|
"Offset of field: ",
|
|
stringify!(JSMemoryUsage),
|
|
"::",
|
|
stringify!(memory_used_size)
|
|
)
|
|
);
|
|
assert_eq!(
|
|
unsafe { &(*(::std::ptr::null::<JSMemoryUsage>())).malloc_count as *const _ as usize },
|
|
24usize,
|
|
concat!(
|
|
"Offset of field: ",
|
|
stringify!(JSMemoryUsage),
|
|
"::",
|
|
stringify!(malloc_count)
|
|
)
|
|
);
|
|
assert_eq!(
|
|
unsafe { &(*(::std::ptr::null::<JSMemoryUsage>())).memory_used_count as *const _ as usize },
|
|
32usize,
|
|
concat!(
|
|
"Offset of field: ",
|
|
stringify!(JSMemoryUsage),
|
|
"::",
|
|
stringify!(memory_used_count)
|
|
)
|
|
);
|
|
assert_eq!(
|
|
unsafe { &(*(::std::ptr::null::<JSMemoryUsage>())).atom_count as *const _ as usize },
|
|
40usize,
|
|
concat!(
|
|
"Offset of field: ",
|
|
stringify!(JSMemoryUsage),
|
|
"::",
|
|
stringify!(atom_count)
|
|
)
|
|
);
|
|
assert_eq!(
|
|
unsafe { &(*(::std::ptr::null::<JSMemoryUsage>())).atom_size as *const _ as usize },
|
|
48usize,
|
|
concat!(
|
|
"Offset of field: ",
|
|
stringify!(JSMemoryUsage),
|
|
"::",
|
|
stringify!(atom_size)
|
|
)
|
|
);
|
|
assert_eq!(
|
|
unsafe { &(*(::std::ptr::null::<JSMemoryUsage>())).str_count as *const _ as usize },
|
|
56usize,
|
|
concat!(
|
|
"Offset of field: ",
|
|
stringify!(JSMemoryUsage),
|
|
"::",
|
|
stringify!(str_count)
|
|
)
|
|
);
|
|
assert_eq!(
|
|
unsafe { &(*(::std::ptr::null::<JSMemoryUsage>())).str_size as *const _ as usize },
|
|
64usize,
|
|
concat!(
|
|
"Offset of field: ",
|
|
stringify!(JSMemoryUsage),
|
|
"::",
|
|
stringify!(str_size)
|
|
)
|
|
);
|
|
assert_eq!(
|
|
unsafe { &(*(::std::ptr::null::<JSMemoryUsage>())).obj_count as *const _ as usize },
|
|
72usize,
|
|
concat!(
|
|
"Offset of field: ",
|
|
stringify!(JSMemoryUsage),
|
|
"::",
|
|
stringify!(obj_count)
|
|
)
|
|
);
|
|
assert_eq!(
|
|
unsafe { &(*(::std::ptr::null::<JSMemoryUsage>())).obj_size as *const _ as usize },
|
|
80usize,
|
|
concat!(
|
|
"Offset of field: ",
|
|
stringify!(JSMemoryUsage),
|
|
"::",
|
|
stringify!(obj_size)
|
|
)
|
|
);
|
|
assert_eq!(
|
|
unsafe { &(*(::std::ptr::null::<JSMemoryUsage>())).prop_count as *const _ as usize },
|
|
88usize,
|
|
concat!(
|
|
"Offset of field: ",
|
|
stringify!(JSMemoryUsage),
|
|
"::",
|
|
stringify!(prop_count)
|
|
)
|
|
);
|
|
assert_eq!(
|
|
unsafe { &(*(::std::ptr::null::<JSMemoryUsage>())).prop_size as *const _ as usize },
|
|
96usize,
|
|
concat!(
|
|
"Offset of field: ",
|
|
stringify!(JSMemoryUsage),
|
|
"::",
|
|
stringify!(prop_size)
|
|
)
|
|
);
|
|
assert_eq!(
|
|
unsafe { &(*(::std::ptr::null::<JSMemoryUsage>())).shape_count as *const _ as usize },
|
|
104usize,
|
|
concat!(
|
|
"Offset of field: ",
|
|
stringify!(JSMemoryUsage),
|
|
"::",
|
|
stringify!(shape_count)
|
|
)
|
|
);
|
|
assert_eq!(
|
|
unsafe { &(*(::std::ptr::null::<JSMemoryUsage>())).shape_size as *const _ as usize },
|
|
112usize,
|
|
concat!(
|
|
"Offset of field: ",
|
|
stringify!(JSMemoryUsage),
|
|
"::",
|
|
stringify!(shape_size)
|
|
)
|
|
);
|
|
assert_eq!(
|
|
unsafe { &(*(::std::ptr::null::<JSMemoryUsage>())).js_func_count as *const _ as usize },
|
|
120usize,
|
|
concat!(
|
|
"Offset of field: ",
|
|
stringify!(JSMemoryUsage),
|
|
"::",
|
|
stringify!(js_func_count)
|
|
)
|
|
);
|
|
assert_eq!(
|
|
unsafe { &(*(::std::ptr::null::<JSMemoryUsage>())).js_func_size as *const _ as usize },
|
|
128usize,
|
|
concat!(
|
|
"Offset of field: ",
|
|
stringify!(JSMemoryUsage),
|
|
"::",
|
|
stringify!(js_func_size)
|
|
)
|
|
);
|
|
assert_eq!(
|
|
unsafe { &(*(::std::ptr::null::<JSMemoryUsage>())).js_func_code_size as *const _ as usize },
|
|
136usize,
|
|
concat!(
|
|
"Offset of field: ",
|
|
stringify!(JSMemoryUsage),
|
|
"::",
|
|
stringify!(js_func_code_size)
|
|
)
|
|
);
|
|
assert_eq!(
|
|
unsafe {
|
|
&(*(::std::ptr::null::<JSMemoryUsage>())).js_func_pc2line_count as *const _ as usize
|
|
},
|
|
144usize,
|
|
concat!(
|
|
"Offset of field: ",
|
|
stringify!(JSMemoryUsage),
|
|
"::",
|
|
stringify!(js_func_pc2line_count)
|
|
)
|
|
);
|
|
assert_eq!(
|
|
unsafe {
|
|
&(*(::std::ptr::null::<JSMemoryUsage>())).js_func_pc2line_size as *const _ as usize
|
|
},
|
|
152usize,
|
|
concat!(
|
|
"Offset of field: ",
|
|
stringify!(JSMemoryUsage),
|
|
"::",
|
|
stringify!(js_func_pc2line_size)
|
|
)
|
|
);
|
|
assert_eq!(
|
|
unsafe { &(*(::std::ptr::null::<JSMemoryUsage>())).c_func_count as *const _ as usize },
|
|
160usize,
|
|
concat!(
|
|
"Offset of field: ",
|
|
stringify!(JSMemoryUsage),
|
|
"::",
|
|
stringify!(c_func_count)
|
|
)
|
|
);
|
|
assert_eq!(
|
|
unsafe { &(*(::std::ptr::null::<JSMemoryUsage>())).array_count as *const _ as usize },
|
|
168usize,
|
|
concat!(
|
|
"Offset of field: ",
|
|
stringify!(JSMemoryUsage),
|
|
"::",
|
|
stringify!(array_count)
|
|
)
|
|
);
|
|
assert_eq!(
|
|
unsafe { &(*(::std::ptr::null::<JSMemoryUsage>())).fast_array_count as *const _ as usize },
|
|
176usize,
|
|
concat!(
|
|
"Offset of field: ",
|
|
stringify!(JSMemoryUsage),
|
|
"::",
|
|
stringify!(fast_array_count)
|
|
)
|
|
);
|
|
assert_eq!(
|
|
unsafe {
|
|
&(*(::std::ptr::null::<JSMemoryUsage>())).fast_array_elements as *const _ as usize
|
|
},
|
|
184usize,
|
|
concat!(
|
|
"Offset of field: ",
|
|
stringify!(JSMemoryUsage),
|
|
"::",
|
|
stringify!(fast_array_elements)
|
|
)
|
|
);
|
|
assert_eq!(
|
|
unsafe {
|
|
&(*(::std::ptr::null::<JSMemoryUsage>())).binary_object_count as *const _ as usize
|
|
},
|
|
192usize,
|
|
concat!(
|
|
"Offset of field: ",
|
|
stringify!(JSMemoryUsage),
|
|
"::",
|
|
stringify!(binary_object_count)
|
|
)
|
|
);
|
|
assert_eq!(
|
|
unsafe {
|
|
&(*(::std::ptr::null::<JSMemoryUsage>())).binary_object_size as *const _ as usize
|
|
},
|
|
200usize,
|
|
concat!(
|
|
"Offset of field: ",
|
|
stringify!(JSMemoryUsage),
|
|
"::",
|
|
stringify!(binary_object_size)
|
|
)
|
|
);
|
|
}
|
|
extern "C" {
|
|
pub fn JS_ComputeMemoryUsage(rt: *mut JSRuntime, s: *mut JSMemoryUsage);
|
|
}
|
|
extern "C" {
|
|
pub fn JS_DumpMemoryUsage(fp: *mut FILE, s: *const JSMemoryUsage, rt: *mut JSRuntime);
|
|
}
|
|
extern "C" {
|
|
pub fn JS_NewAtomLen(
|
|
ctx: *mut JSContext,
|
|
str_: *const ::std::os::raw::c_char,
|
|
len: size_t,
|
|
) -> JSAtom;
|
|
}
|
|
extern "C" {
|
|
pub fn JS_NewAtom(ctx: *mut JSContext, str_: *const ::std::os::raw::c_char) -> JSAtom;
|
|
}
|
|
extern "C" {
|
|
pub fn JS_NewAtomUInt32(ctx: *mut JSContext, n: u32) -> JSAtom;
|
|
}
|
|
extern "C" {
|
|
pub fn JS_DupAtom(ctx: *mut JSContext, v: JSAtom) -> JSAtom;
|
|
}
|
|
extern "C" {
|
|
pub fn JS_FreeAtom(ctx: *mut JSContext, v: JSAtom);
|
|
}
|
|
extern "C" {
|
|
pub fn JS_FreeAtomRT(rt: *mut JSRuntime, v: JSAtom);
|
|
}
|
|
extern "C" {
|
|
pub fn JS_AtomToValue(ctx: *mut JSContext, atom: JSAtom) -> JSValue;
|
|
}
|
|
extern "C" {
|
|
pub fn JS_AtomToString(ctx: *mut JSContext, atom: JSAtom) -> JSValue;
|
|
}
|
|
extern "C" {
|
|
pub fn JS_AtomToCString(ctx: *mut JSContext, atom: JSAtom) -> *const ::std::os::raw::c_char;
|
|
}
|
|
extern "C" {
|
|
pub fn JS_ValueToAtom(ctx: *mut JSContext, val: JSValue) -> JSAtom;
|
|
}
|
|
#[repr(C)]
|
|
#[derive(Debug, Copy, Clone)]
|
|
pub struct JSPropertyEnum {
|
|
pub is_enumerable: ::std::os::raw::c_int,
|
|
pub atom: JSAtom,
|
|
}
|
|
#[test]
|
|
fn bindgen_test_layout_JSPropertyEnum() {
|
|
assert_eq!(
|
|
::std::mem::size_of::<JSPropertyEnum>(),
|
|
8usize,
|
|
concat!("Size of: ", stringify!(JSPropertyEnum))
|
|
);
|
|
assert_eq!(
|
|
::std::mem::align_of::<JSPropertyEnum>(),
|
|
4usize,
|
|
concat!("Alignment of ", stringify!(JSPropertyEnum))
|
|
);
|
|
assert_eq!(
|
|
unsafe { &(*(::std::ptr::null::<JSPropertyEnum>())).is_enumerable as *const _ as usize },
|
|
0usize,
|
|
concat!(
|
|
"Offset of field: ",
|
|
stringify!(JSPropertyEnum),
|
|
"::",
|
|
stringify!(is_enumerable)
|
|
)
|
|
);
|
|
assert_eq!(
|
|
unsafe { &(*(::std::ptr::null::<JSPropertyEnum>())).atom as *const _ as usize },
|
|
4usize,
|
|
concat!(
|
|
"Offset of field: ",
|
|
stringify!(JSPropertyEnum),
|
|
"::",
|
|
stringify!(atom)
|
|
)
|
|
);
|
|
}
|
|
#[repr(C)]
|
|
#[derive(Copy, Clone)]
|
|
pub struct JSPropertyDescriptor {
|
|
pub flags: ::std::os::raw::c_int,
|
|
pub value: JSValue,
|
|
pub getter: JSValue,
|
|
pub setter: JSValue,
|
|
}
|
|
#[test]
|
|
fn bindgen_test_layout_JSPropertyDescriptor() {
|
|
assert_eq!(
|
|
::std::mem::size_of::<JSPropertyDescriptor>(),
|
|
56usize,
|
|
concat!("Size of: ", stringify!(JSPropertyDescriptor))
|
|
);
|
|
assert_eq!(
|
|
::std::mem::align_of::<JSPropertyDescriptor>(),
|
|
8usize,
|
|
concat!("Alignment of ", stringify!(JSPropertyDescriptor))
|
|
);
|
|
assert_eq!(
|
|
unsafe { &(*(::std::ptr::null::<JSPropertyDescriptor>())).flags as *const _ as usize },
|
|
0usize,
|
|
concat!(
|
|
"Offset of field: ",
|
|
stringify!(JSPropertyDescriptor),
|
|
"::",
|
|
stringify!(flags)
|
|
)
|
|
);
|
|
assert_eq!(
|
|
unsafe { &(*(::std::ptr::null::<JSPropertyDescriptor>())).value as *const _ as usize },
|
|
8usize,
|
|
concat!(
|
|
"Offset of field: ",
|
|
stringify!(JSPropertyDescriptor),
|
|
"::",
|
|
stringify!(value)
|
|
)
|
|
);
|
|
assert_eq!(
|
|
unsafe { &(*(::std::ptr::null::<JSPropertyDescriptor>())).getter as *const _ as usize },
|
|
24usize,
|
|
concat!(
|
|
"Offset of field: ",
|
|
stringify!(JSPropertyDescriptor),
|
|
"::",
|
|
stringify!(getter)
|
|
)
|
|
);
|
|
assert_eq!(
|
|
unsafe { &(*(::std::ptr::null::<JSPropertyDescriptor>())).setter as *const _ as usize },
|
|
40usize,
|
|
concat!(
|
|
"Offset of field: ",
|
|
stringify!(JSPropertyDescriptor),
|
|
"::",
|
|
stringify!(setter)
|
|
)
|
|
);
|
|
}
|
|
#[repr(C)]
|
|
#[derive(Debug, Copy, Clone)]
|
|
pub struct JSClassExoticMethods {
|
|
pub get_own_property: ::std::option::Option<
|
|
unsafe extern "C" fn(
|
|
ctx: *mut JSContext,
|
|
desc: *mut JSPropertyDescriptor,
|
|
obj: JSValue,
|
|
prop: JSAtom,
|
|
) -> ::std::os::raw::c_int,
|
|
>,
|
|
pub get_own_property_names: ::std::option::Option<
|
|
unsafe extern "C" fn(
|
|
ctx: *mut JSContext,
|
|
ptab: *mut *mut JSPropertyEnum,
|
|
plen: *mut u32,
|
|
obj: JSValue,
|
|
) -> ::std::os::raw::c_int,
|
|
>,
|
|
pub delete_property: ::std::option::Option<
|
|
unsafe extern "C" fn(
|
|
ctx: *mut JSContext,
|
|
obj: JSValue,
|
|
prop: JSAtom,
|
|
) -> ::std::os::raw::c_int,
|
|
>,
|
|
pub define_own_property: ::std::option::Option<
|
|
unsafe extern "C" fn(
|
|
ctx: *mut JSContext,
|
|
this_obj: JSValue,
|
|
prop: JSAtom,
|
|
val: JSValue,
|
|
getter: JSValue,
|
|
setter: JSValue,
|
|
flags: ::std::os::raw::c_int,
|
|
) -> ::std::os::raw::c_int,
|
|
>,
|
|
pub has_property: ::std::option::Option<
|
|
unsafe extern "C" fn(
|
|
ctx: *mut JSContext,
|
|
obj: JSValue,
|
|
atom: JSAtom,
|
|
) -> ::std::os::raw::c_int,
|
|
>,
|
|
pub get_property: ::std::option::Option<
|
|
unsafe extern "C" fn(
|
|
ctx: *mut JSContext,
|
|
obj: JSValue,
|
|
atom: JSAtom,
|
|
receiver: JSValue,
|
|
) -> JSValue,
|
|
>,
|
|
pub set_property: ::std::option::Option<
|
|
unsafe extern "C" fn(
|
|
ctx: *mut JSContext,
|
|
obj: JSValue,
|
|
atom: JSAtom,
|
|
value: JSValue,
|
|
receiver: JSValue,
|
|
flags: ::std::os::raw::c_int,
|
|
) -> ::std::os::raw::c_int,
|
|
>,
|
|
}
|
|
#[test]
|
|
fn bindgen_test_layout_JSClassExoticMethods() {
|
|
assert_eq!(
|
|
::std::mem::size_of::<JSClassExoticMethods>(),
|
|
56usize,
|
|
concat!("Size of: ", stringify!(JSClassExoticMethods))
|
|
);
|
|
assert_eq!(
|
|
::std::mem::align_of::<JSClassExoticMethods>(),
|
|
8usize,
|
|
concat!("Alignment of ", stringify!(JSClassExoticMethods))
|
|
);
|
|
assert_eq!(
|
|
unsafe {
|
|
&(*(::std::ptr::null::<JSClassExoticMethods>())).get_own_property as *const _ as usize
|
|
},
|
|
0usize,
|
|
concat!(
|
|
"Offset of field: ",
|
|
stringify!(JSClassExoticMethods),
|
|
"::",
|
|
stringify!(get_own_property)
|
|
)
|
|
);
|
|
assert_eq!(
|
|
unsafe {
|
|
&(*(::std::ptr::null::<JSClassExoticMethods>())).get_own_property_names as *const _
|
|
as usize
|
|
},
|
|
8usize,
|
|
concat!(
|
|
"Offset of field: ",
|
|
stringify!(JSClassExoticMethods),
|
|
"::",
|
|
stringify!(get_own_property_names)
|
|
)
|
|
);
|
|
assert_eq!(
|
|
unsafe {
|
|
&(*(::std::ptr::null::<JSClassExoticMethods>())).delete_property as *const _ as usize
|
|
},
|
|
16usize,
|
|
concat!(
|
|
"Offset of field: ",
|
|
stringify!(JSClassExoticMethods),
|
|
"::",
|
|
stringify!(delete_property)
|
|
)
|
|
);
|
|
assert_eq!(
|
|
unsafe {
|
|
&(*(::std::ptr::null::<JSClassExoticMethods>())).define_own_property as *const _
|
|
as usize
|
|
},
|
|
24usize,
|
|
concat!(
|
|
"Offset of field: ",
|
|
stringify!(JSClassExoticMethods),
|
|
"::",
|
|
stringify!(define_own_property)
|
|
)
|
|
);
|
|
assert_eq!(
|
|
unsafe {
|
|
&(*(::std::ptr::null::<JSClassExoticMethods>())).has_property as *const _ as usize
|
|
},
|
|
32usize,
|
|
concat!(
|
|
"Offset of field: ",
|
|
stringify!(JSClassExoticMethods),
|
|
"::",
|
|
stringify!(has_property)
|
|
)
|
|
);
|
|
assert_eq!(
|
|
unsafe {
|
|
&(*(::std::ptr::null::<JSClassExoticMethods>())).get_property as *const _ as usize
|
|
},
|
|
40usize,
|
|
concat!(
|
|
"Offset of field: ",
|
|
stringify!(JSClassExoticMethods),
|
|
"::",
|
|
stringify!(get_property)
|
|
)
|
|
);
|
|
assert_eq!(
|
|
unsafe {
|
|
&(*(::std::ptr::null::<JSClassExoticMethods>())).set_property as *const _ as usize
|
|
},
|
|
48usize,
|
|
concat!(
|
|
"Offset of field: ",
|
|
stringify!(JSClassExoticMethods),
|
|
"::",
|
|
stringify!(set_property)
|
|
)
|
|
);
|
|
}
|
|
pub type JSClassFinalizer =
|
|
::std::option::Option<unsafe extern "C" fn(rt: *mut JSRuntime, val: JSValue)>;
|
|
pub type JSClassGCMark = ::std::option::Option<
|
|
unsafe extern "C" fn(rt: *mut JSRuntime, val: JSValue, mark_func: JS_MarkFunc),
|
|
>;
|
|
pub type JSClassCall = ::std::option::Option<
|
|
unsafe extern "C" fn(
|
|
ctx: *mut JSContext,
|
|
func_obj: JSValue,
|
|
this_val: JSValue,
|
|
argc: ::std::os::raw::c_int,
|
|
argv: *mut JSValue,
|
|
flags: ::std::os::raw::c_int,
|
|
) -> JSValue,
|
|
>;
|
|
#[repr(C)]
|
|
#[derive(Debug, Copy, Clone)]
|
|
pub struct JSClassDef {
|
|
pub class_name: *const ::std::os::raw::c_char,
|
|
pub finalizer: JSClassFinalizer,
|
|
pub gc_mark: JSClassGCMark,
|
|
pub call: JSClassCall,
|
|
pub exotic: *mut JSClassExoticMethods,
|
|
}
|
|
#[test]
|
|
fn bindgen_test_layout_JSClassDef() {
|
|
assert_eq!(
|
|
::std::mem::size_of::<JSClassDef>(),
|
|
40usize,
|
|
concat!("Size of: ", stringify!(JSClassDef))
|
|
);
|
|
assert_eq!(
|
|
::std::mem::align_of::<JSClassDef>(),
|
|
8usize,
|
|
concat!("Alignment of ", stringify!(JSClassDef))
|
|
);
|
|
assert_eq!(
|
|
unsafe { &(*(::std::ptr::null::<JSClassDef>())).class_name as *const _ as usize },
|
|
0usize,
|
|
concat!(
|
|
"Offset of field: ",
|
|
stringify!(JSClassDef),
|
|
"::",
|
|
stringify!(class_name)
|
|
)
|
|
);
|
|
assert_eq!(
|
|
unsafe { &(*(::std::ptr::null::<JSClassDef>())).finalizer as *const _ as usize },
|
|
8usize,
|
|
concat!(
|
|
"Offset of field: ",
|
|
stringify!(JSClassDef),
|
|
"::",
|
|
stringify!(finalizer)
|
|
)
|
|
);
|
|
assert_eq!(
|
|
unsafe { &(*(::std::ptr::null::<JSClassDef>())).gc_mark as *const _ as usize },
|
|
16usize,
|
|
concat!(
|
|
"Offset of field: ",
|
|
stringify!(JSClassDef),
|
|
"::",
|
|
stringify!(gc_mark)
|
|
)
|
|
);
|
|
assert_eq!(
|
|
unsafe { &(*(::std::ptr::null::<JSClassDef>())).call as *const _ as usize },
|
|
24usize,
|
|
concat!(
|
|
"Offset of field: ",
|
|
stringify!(JSClassDef),
|
|
"::",
|
|
stringify!(call)
|
|
)
|
|
);
|
|
assert_eq!(
|
|
unsafe { &(*(::std::ptr::null::<JSClassDef>())).exotic as *const _ as usize },
|
|
32usize,
|
|
concat!(
|
|
"Offset of field: ",
|
|
stringify!(JSClassDef),
|
|
"::",
|
|
stringify!(exotic)
|
|
)
|
|
);
|
|
}
|
|
extern "C" {
|
|
pub fn JS_NewClassID(pclass_id: *mut JSClassID) -> JSClassID;
|
|
}
|
|
extern "C" {
|
|
pub fn JS_NewClass(
|
|
rt: *mut JSRuntime,
|
|
class_id: JSClassID,
|
|
class_def: *const JSClassDef,
|
|
) -> ::std::os::raw::c_int;
|
|
}
|
|
extern "C" {
|
|
pub fn JS_IsRegisteredClass(rt: *mut JSRuntime, class_id: JSClassID) -> ::std::os::raw::c_int;
|
|
}
|
|
extern "C" {
|
|
pub fn JS_NewBigInt64(ctx: *mut JSContext, v: i64) -> JSValue;
|
|
}
|
|
extern "C" {
|
|
pub fn JS_NewBigUint64(ctx: *mut JSContext, v: u64) -> JSValue;
|
|
}
|
|
extern "C" {
|
|
pub fn JS_Throw(ctx: *mut JSContext, obj: JSValue) -> JSValue;
|
|
}
|
|
extern "C" {
|
|
pub fn JS_GetException(ctx: *mut JSContext) -> JSValue;
|
|
}
|
|
extern "C" {
|
|
pub fn JS_IsError(ctx: *mut JSContext, val: JSValue) -> ::std::os::raw::c_int;
|
|
}
|
|
extern "C" {
|
|
pub fn JS_ResetUncatchableError(ctx: *mut JSContext);
|
|
}
|
|
extern "C" {
|
|
pub fn JS_NewError(ctx: *mut JSContext) -> JSValue;
|
|
}
|
|
extern "C" {
|
|
pub fn JS_ThrowSyntaxError(
|
|
ctx: *mut JSContext,
|
|
fmt: *const ::std::os::raw::c_char,
|
|
...
|
|
) -> JSValue;
|
|
}
|
|
extern "C" {
|
|
pub fn JS_ThrowTypeError(
|
|
ctx: *mut JSContext,
|
|
fmt: *const ::std::os::raw::c_char,
|
|
...
|
|
) -> JSValue;
|
|
}
|
|
extern "C" {
|
|
pub fn JS_ThrowReferenceError(
|
|
ctx: *mut JSContext,
|
|
fmt: *const ::std::os::raw::c_char,
|
|
...
|
|
) -> JSValue;
|
|
}
|
|
extern "C" {
|
|
pub fn JS_ThrowRangeError(
|
|
ctx: *mut JSContext,
|
|
fmt: *const ::std::os::raw::c_char,
|
|
...
|
|
) -> JSValue;
|
|
}
|
|
extern "C" {
|
|
pub fn JS_ThrowInternalError(
|
|
ctx: *mut JSContext,
|
|
fmt: *const ::std::os::raw::c_char,
|
|
...
|
|
) -> JSValue;
|
|
}
|
|
extern "C" {
|
|
pub fn JS_ThrowOutOfMemory(ctx: *mut JSContext) -> JSValue;
|
|
}
|
|
extern "C" {
|
|
pub fn __JS_FreeValue(ctx: *mut JSContext, v: JSValue);
|
|
}
|
|
extern "C" {
|
|
pub fn __JS_FreeValueRT(rt: *mut JSRuntime, v: JSValue);
|
|
}
|
|
extern "C" {
|
|
pub fn JS_ToBool(ctx: *mut JSContext, val: JSValue) -> ::std::os::raw::c_int;
|
|
}
|
|
extern "C" {
|
|
pub fn JS_ToInt32(ctx: *mut JSContext, pres: *mut i32, val: JSValue) -> ::std::os::raw::c_int;
|
|
}
|
|
extern "C" {
|
|
pub fn JS_ToInt64(ctx: *mut JSContext, pres: *mut i64, val: JSValue) -> ::std::os::raw::c_int;
|
|
}
|
|
extern "C" {
|
|
pub fn JS_ToIndex(ctx: *mut JSContext, plen: *mut u64, val: JSValue) -> ::std::os::raw::c_int;
|
|
}
|
|
extern "C" {
|
|
pub fn JS_ToFloat64(ctx: *mut JSContext, pres: *mut f64, val: JSValue)
|
|
-> ::std::os::raw::c_int;
|
|
}
|
|
extern "C" {
|
|
pub fn JS_ToBigInt64(
|
|
ctx: *mut JSContext,
|
|
pres: *mut i64,
|
|
val: JSValue,
|
|
) -> ::std::os::raw::c_int;
|
|
}
|
|
extern "C" {
|
|
pub fn JS_ToInt64Ext(
|
|
ctx: *mut JSContext,
|
|
pres: *mut i64,
|
|
val: JSValue,
|
|
) -> ::std::os::raw::c_int;
|
|
}
|
|
extern "C" {
|
|
pub fn JS_NewStringLen(
|
|
ctx: *mut JSContext,
|
|
str1: *const ::std::os::raw::c_char,
|
|
len1: size_t,
|
|
) -> JSValue;
|
|
}
|
|
extern "C" {
|
|
pub fn JS_NewString(ctx: *mut JSContext, str_: *const ::std::os::raw::c_char) -> JSValue;
|
|
}
|
|
extern "C" {
|
|
pub fn JS_NewAtomString(ctx: *mut JSContext, str_: *const ::std::os::raw::c_char) -> JSValue;
|
|
}
|
|
extern "C" {
|
|
pub fn JS_ToString(ctx: *mut JSContext, val: JSValue) -> JSValue;
|
|
}
|
|
extern "C" {
|
|
pub fn JS_ToPropertyKey(ctx: *mut JSContext, val: JSValue) -> JSValue;
|
|
}
|
|
extern "C" {
|
|
pub fn JS_ToCStringLen2(
|
|
ctx: *mut JSContext,
|
|
plen: *mut size_t,
|
|
val1: JSValue,
|
|
cesu8: ::std::os::raw::c_int,
|
|
) -> *const ::std::os::raw::c_char;
|
|
}
|
|
extern "C" {
|
|
pub fn JS_FreeCString(ctx: *mut JSContext, ptr: *const ::std::os::raw::c_char);
|
|
}
|
|
extern "C" {
|
|
pub fn JS_NewObjectProtoClass(
|
|
ctx: *mut JSContext,
|
|
proto: JSValue,
|
|
class_id: JSClassID,
|
|
) -> JSValue;
|
|
}
|
|
extern "C" {
|
|
pub fn JS_NewObjectClass(ctx: *mut JSContext, class_id: ::std::os::raw::c_int) -> JSValue;
|
|
}
|
|
extern "C" {
|
|
pub fn JS_NewObjectProto(ctx: *mut JSContext, proto: JSValue) -> JSValue;
|
|
}
|
|
extern "C" {
|
|
pub fn JS_NewObject(ctx: *mut JSContext) -> JSValue;
|
|
}
|
|
extern "C" {
|
|
pub fn JS_IsFunction(ctx: *mut JSContext, val: JSValue) -> ::std::os::raw::c_int;
|
|
}
|
|
extern "C" {
|
|
pub fn JS_IsConstructor(ctx: *mut JSContext, val: JSValue) -> ::std::os::raw::c_int;
|
|
}
|
|
extern "C" {
|
|
pub fn JS_SetConstructorBit(
|
|
ctx: *mut JSContext,
|
|
func_obj: JSValue,
|
|
val: ::std::os::raw::c_int,
|
|
) -> ::std::os::raw::c_int;
|
|
}
|
|
extern "C" {
|
|
pub fn JS_NewArray(ctx: *mut JSContext) -> JSValue;
|
|
}
|
|
extern "C" {
|
|
pub fn JS_IsArray(ctx: *mut JSContext, val: JSValue) -> ::std::os::raw::c_int;
|
|
}
|
|
extern "C" {
|
|
pub fn JS_GetPropertyInternal(
|
|
ctx: *mut JSContext,
|
|
obj: JSValue,
|
|
prop: JSAtom,
|
|
receiver: JSValue,
|
|
throw_ref_error: ::std::os::raw::c_int,
|
|
) -> JSValue;
|
|
}
|
|
extern "C" {
|
|
pub fn JS_GetPropertyStr(
|
|
ctx: *mut JSContext,
|
|
this_obj: JSValue,
|
|
prop: *const ::std::os::raw::c_char,
|
|
) -> JSValue;
|
|
}
|
|
extern "C" {
|
|
pub fn JS_GetPropertyUint32(ctx: *mut JSContext, this_obj: JSValue, idx: u32) -> JSValue;
|
|
}
|
|
extern "C" {
|
|
pub fn JS_SetPropertyInternal(
|
|
ctx: *mut JSContext,
|
|
this_obj: JSValue,
|
|
prop: JSAtom,
|
|
val: JSValue,
|
|
flags: ::std::os::raw::c_int,
|
|
) -> ::std::os::raw::c_int;
|
|
}
|
|
extern "C" {
|
|
pub fn JS_SetPropertyUint32(
|
|
ctx: *mut JSContext,
|
|
this_obj: JSValue,
|
|
idx: u32,
|
|
val: JSValue,
|
|
) -> ::std::os::raw::c_int;
|
|
}
|
|
extern "C" {
|
|
pub fn JS_SetPropertyInt64(
|
|
ctx: *mut JSContext,
|
|
this_obj: JSValue,
|
|
idx: i64,
|
|
val: JSValue,
|
|
) -> ::std::os::raw::c_int;
|
|
}
|
|
extern "C" {
|
|
pub fn JS_SetPropertyStr(
|
|
ctx: *mut JSContext,
|
|
this_obj: JSValue,
|
|
prop: *const ::std::os::raw::c_char,
|
|
val: JSValue,
|
|
) -> ::std::os::raw::c_int;
|
|
}
|
|
extern "C" {
|
|
pub fn JS_HasProperty(
|
|
ctx: *mut JSContext,
|
|
this_obj: JSValue,
|
|
prop: JSAtom,
|
|
) -> ::std::os::raw::c_int;
|
|
}
|
|
extern "C" {
|
|
pub fn JS_IsExtensible(ctx: *mut JSContext, obj: JSValue) -> ::std::os::raw::c_int;
|
|
}
|
|
extern "C" {
|
|
pub fn JS_PreventExtensions(ctx: *mut JSContext, obj: JSValue) -> ::std::os::raw::c_int;
|
|
}
|
|
extern "C" {
|
|
pub fn JS_DeleteProperty(
|
|
ctx: *mut JSContext,
|
|
obj: JSValue,
|
|
prop: JSAtom,
|
|
flags: ::std::os::raw::c_int,
|
|
) -> ::std::os::raw::c_int;
|
|
}
|
|
extern "C" {
|
|
pub fn JS_SetPrototype(
|
|
ctx: *mut JSContext,
|
|
obj: JSValue,
|
|
proto_val: JSValue,
|
|
) -> ::std::os::raw::c_int;
|
|
}
|
|
extern "C" {
|
|
pub fn JS_GetPrototype(ctx: *mut JSContext, val: JSValue) -> JSValue;
|
|
}
|
|
extern "C" {
|
|
pub fn JS_GetOwnPropertyNames(
|
|
ctx: *mut JSContext,
|
|
ptab: *mut *mut JSPropertyEnum,
|
|
plen: *mut u32,
|
|
obj: JSValue,
|
|
flags: ::std::os::raw::c_int,
|
|
) -> ::std::os::raw::c_int;
|
|
}
|
|
extern "C" {
|
|
pub fn JS_GetOwnProperty(
|
|
ctx: *mut JSContext,
|
|
desc: *mut JSPropertyDescriptor,
|
|
obj: JSValue,
|
|
prop: JSAtom,
|
|
) -> ::std::os::raw::c_int;
|
|
}
|
|
extern "C" {
|
|
pub fn JS_Call(
|
|
ctx: *mut JSContext,
|
|
func_obj: JSValue,
|
|
this_obj: JSValue,
|
|
argc: ::std::os::raw::c_int,
|
|
argv: *mut JSValue,
|
|
) -> JSValue;
|
|
}
|
|
extern "C" {
|
|
pub fn JS_Invoke(
|
|
ctx: *mut JSContext,
|
|
this_val: JSValue,
|
|
atom: JSAtom,
|
|
argc: ::std::os::raw::c_int,
|
|
argv: *mut JSValue,
|
|
) -> JSValue;
|
|
}
|
|
extern "C" {
|
|
pub fn JS_CallConstructor(
|
|
ctx: *mut JSContext,
|
|
func_obj: JSValue,
|
|
argc: ::std::os::raw::c_int,
|
|
argv: *mut JSValue,
|
|
) -> JSValue;
|
|
}
|
|
extern "C" {
|
|
pub fn JS_CallConstructor2(
|
|
ctx: *mut JSContext,
|
|
func_obj: JSValue,
|
|
new_target: JSValue,
|
|
argc: ::std::os::raw::c_int,
|
|
argv: *mut JSValue,
|
|
) -> JSValue;
|
|
}
|
|
extern "C" {
|
|
pub fn JS_DetectModule(
|
|
input: *const ::std::os::raw::c_char,
|
|
input_len: size_t,
|
|
) -> ::std::os::raw::c_int;
|
|
}
|
|
extern "C" {
|
|
pub fn JS_Eval(
|
|
ctx: *mut JSContext,
|
|
input: *const ::std::os::raw::c_char,
|
|
input_len: size_t,
|
|
filename: *const ::std::os::raw::c_char,
|
|
eval_flags: ::std::os::raw::c_int,
|
|
) -> JSValue;
|
|
}
|
|
extern "C" {
|
|
pub fn JS_EvalThis(
|
|
ctx: *mut JSContext,
|
|
this_obj: JSValue,
|
|
input: *const ::std::os::raw::c_char,
|
|
input_len: size_t,
|
|
filename: *const ::std::os::raw::c_char,
|
|
eval_flags: ::std::os::raw::c_int,
|
|
) -> JSValue;
|
|
}
|
|
extern "C" {
|
|
pub fn JS_GetGlobalObject(ctx: *mut JSContext) -> JSValue;
|
|
}
|
|
extern "C" {
|
|
pub fn JS_IsInstanceOf(
|
|
ctx: *mut JSContext,
|
|
val: JSValue,
|
|
obj: JSValue,
|
|
) -> ::std::os::raw::c_int;
|
|
}
|
|
extern "C" {
|
|
pub fn JS_DefineProperty(
|
|
ctx: *mut JSContext,
|
|
this_obj: JSValue,
|
|
prop: JSAtom,
|
|
val: JSValue,
|
|
getter: JSValue,
|
|
setter: JSValue,
|
|
flags: ::std::os::raw::c_int,
|
|
) -> ::std::os::raw::c_int;
|
|
}
|
|
extern "C" {
|
|
pub fn JS_DefinePropertyValue(
|
|
ctx: *mut JSContext,
|
|
this_obj: JSValue,
|
|
prop: JSAtom,
|
|
val: JSValue,
|
|
flags: ::std::os::raw::c_int,
|
|
) -> ::std::os::raw::c_int;
|
|
}
|
|
extern "C" {
|
|
pub fn JS_DefinePropertyValueUint32(
|
|
ctx: *mut JSContext,
|
|
this_obj: JSValue,
|
|
idx: u32,
|
|
val: JSValue,
|
|
flags: ::std::os::raw::c_int,
|
|
) -> ::std::os::raw::c_int;
|
|
}
|
|
extern "C" {
|
|
pub fn JS_DefinePropertyValueStr(
|
|
ctx: *mut JSContext,
|
|
this_obj: JSValue,
|
|
prop: *const ::std::os::raw::c_char,
|
|
val: JSValue,
|
|
flags: ::std::os::raw::c_int,
|
|
) -> ::std::os::raw::c_int;
|
|
}
|
|
extern "C" {
|
|
pub fn JS_DefinePropertyGetSet(
|
|
ctx: *mut JSContext,
|
|
this_obj: JSValue,
|
|
prop: JSAtom,
|
|
getter: JSValue,
|
|
setter: JSValue,
|
|
flags: ::std::os::raw::c_int,
|
|
) -> ::std::os::raw::c_int;
|
|
}
|
|
extern "C" {
|
|
pub fn JS_SetOpaque(obj: JSValue, opaque: *mut ::std::os::raw::c_void);
|
|
}
|
|
extern "C" {
|
|
pub fn JS_GetOpaque(obj: JSValue, class_id: JSClassID) -> *mut ::std::os::raw::c_void;
|
|
}
|
|
extern "C" {
|
|
pub fn JS_GetOpaque2(
|
|
ctx: *mut JSContext,
|
|
obj: JSValue,
|
|
class_id: JSClassID,
|
|
) -> *mut ::std::os::raw::c_void;
|
|
}
|
|
extern "C" {
|
|
pub fn JS_ParseJSON(
|
|
ctx: *mut JSContext,
|
|
buf: *const ::std::os::raw::c_char,
|
|
buf_len: size_t,
|
|
filename: *const ::std::os::raw::c_char,
|
|
) -> JSValue;
|
|
}
|
|
extern "C" {
|
|
pub fn JS_ParseJSON2(
|
|
ctx: *mut JSContext,
|
|
buf: *const ::std::os::raw::c_char,
|
|
buf_len: size_t,
|
|
filename: *const ::std::os::raw::c_char,
|
|
flags: ::std::os::raw::c_int,
|
|
) -> JSValue;
|
|
}
|
|
extern "C" {
|
|
pub fn JS_JSONStringify(
|
|
ctx: *mut JSContext,
|
|
obj: JSValue,
|
|
replacer: JSValue,
|
|
space0: JSValue,
|
|
) -> JSValue;
|
|
}
|
|
pub type JSFreeArrayBufferDataFunc = ::std::option::Option<
|
|
unsafe extern "C" fn(
|
|
rt: *mut JSRuntime,
|
|
opaque: *mut ::std::os::raw::c_void,
|
|
ptr: *mut ::std::os::raw::c_void,
|
|
),
|
|
>;
|
|
extern "C" {
|
|
pub fn JS_NewArrayBuffer(
|
|
ctx: *mut JSContext,
|
|
buf: *mut u8,
|
|
len: size_t,
|
|
free_func: JSFreeArrayBufferDataFunc,
|
|
opaque: *mut ::std::os::raw::c_void,
|
|
is_shared: ::std::os::raw::c_int,
|
|
) -> JSValue;
|
|
}
|
|
extern "C" {
|
|
pub fn JS_NewArrayBufferCopy(ctx: *mut JSContext, buf: *const u8, len: size_t) -> JSValue;
|
|
}
|
|
extern "C" {
|
|
pub fn JS_DetachArrayBuffer(ctx: *mut JSContext, obj: JSValue);
|
|
}
|
|
extern "C" {
|
|
pub fn JS_GetArrayBuffer(ctx: *mut JSContext, psize: *mut size_t, obj: JSValue) -> *mut u8;
|
|
}
|
|
extern "C" {
|
|
pub fn JS_GetTypedArrayBuffer(
|
|
ctx: *mut JSContext,
|
|
obj: JSValue,
|
|
pbyte_offset: *mut size_t,
|
|
pbyte_length: *mut size_t,
|
|
pbytes_per_element: *mut size_t,
|
|
) -> JSValue;
|
|
}
|
|
#[repr(C)]
|
|
#[derive(Debug, Copy, Clone)]
|
|
pub struct JSSharedArrayBufferFunctions {
|
|
pub sab_alloc: ::std::option::Option<
|
|
unsafe extern "C" fn(
|
|
opaque: *mut ::std::os::raw::c_void,
|
|
size: size_t,
|
|
) -> *mut ::std::os::raw::c_void,
|
|
>,
|
|
pub sab_free: ::std::option::Option<
|
|
unsafe extern "C" fn(opaque: *mut ::std::os::raw::c_void, ptr: *mut ::std::os::raw::c_void),
|
|
>,
|
|
pub sab_dup: ::std::option::Option<
|
|
unsafe extern "C" fn(opaque: *mut ::std::os::raw::c_void, ptr: *mut ::std::os::raw::c_void),
|
|
>,
|
|
pub sab_opaque: *mut ::std::os::raw::c_void,
|
|
}
|
|
#[test]
|
|
fn bindgen_test_layout_JSSharedArrayBufferFunctions() {
|
|
assert_eq!(
|
|
::std::mem::size_of::<JSSharedArrayBufferFunctions>(),
|
|
32usize,
|
|
concat!("Size of: ", stringify!(JSSharedArrayBufferFunctions))
|
|
);
|
|
assert_eq!(
|
|
::std::mem::align_of::<JSSharedArrayBufferFunctions>(),
|
|
8usize,
|
|
concat!("Alignment of ", stringify!(JSSharedArrayBufferFunctions))
|
|
);
|
|
assert_eq!(
|
|
unsafe {
|
|
&(*(::std::ptr::null::<JSSharedArrayBufferFunctions>())).sab_alloc as *const _ as usize
|
|
},
|
|
0usize,
|
|
concat!(
|
|
"Offset of field: ",
|
|
stringify!(JSSharedArrayBufferFunctions),
|
|
"::",
|
|
stringify!(sab_alloc)
|
|
)
|
|
);
|
|
assert_eq!(
|
|
unsafe {
|
|
&(*(::std::ptr::null::<JSSharedArrayBufferFunctions>())).sab_free as *const _ as usize
|
|
},
|
|
8usize,
|
|
concat!(
|
|
"Offset of field: ",
|
|
stringify!(JSSharedArrayBufferFunctions),
|
|
"::",
|
|
stringify!(sab_free)
|
|
)
|
|
);
|
|
assert_eq!(
|
|
unsafe {
|
|
&(*(::std::ptr::null::<JSSharedArrayBufferFunctions>())).sab_dup as *const _ as usize
|
|
},
|
|
16usize,
|
|
concat!(
|
|
"Offset of field: ",
|
|
stringify!(JSSharedArrayBufferFunctions),
|
|
"::",
|
|
stringify!(sab_dup)
|
|
)
|
|
);
|
|
assert_eq!(
|
|
unsafe {
|
|
&(*(::std::ptr::null::<JSSharedArrayBufferFunctions>())).sab_opaque as *const _ as usize
|
|
},
|
|
24usize,
|
|
concat!(
|
|
"Offset of field: ",
|
|
stringify!(JSSharedArrayBufferFunctions),
|
|
"::",
|
|
stringify!(sab_opaque)
|
|
)
|
|
);
|
|
}
|
|
extern "C" {
|
|
pub fn JS_SetSharedArrayBufferFunctions(
|
|
rt: *mut JSRuntime,
|
|
sf: *const JSSharedArrayBufferFunctions,
|
|
);
|
|
}
|
|
extern "C" {
|
|
pub fn JS_NewPromiseCapability(ctx: *mut JSContext, resolving_funcs: *mut JSValue) -> JSValue;
|
|
}
|
|
pub type JSHostPromiseRejectionTracker = ::std::option::Option<
|
|
unsafe extern "C" fn(
|
|
ctx: *mut JSContext,
|
|
promise: JSValue,
|
|
reason: JSValue,
|
|
is_handled: ::std::os::raw::c_int,
|
|
opaque: *mut ::std::os::raw::c_void,
|
|
),
|
|
>;
|
|
extern "C" {
|
|
pub fn JS_SetHostPromiseRejectionTracker(
|
|
rt: *mut JSRuntime,
|
|
cb: JSHostPromiseRejectionTracker,
|
|
opaque: *mut ::std::os::raw::c_void,
|
|
);
|
|
}
|
|
pub type JSInterruptHandler = ::std::option::Option<
|
|
unsafe extern "C" fn(
|
|
rt: *mut JSRuntime,
|
|
opaque: *mut ::std::os::raw::c_void,
|
|
) -> ::std::os::raw::c_int,
|
|
>;
|
|
extern "C" {
|
|
pub fn JS_SetInterruptHandler(
|
|
rt: *mut JSRuntime,
|
|
cb: JSInterruptHandler,
|
|
opaque: *mut ::std::os::raw::c_void,
|
|
);
|
|
}
|
|
extern "C" {
|
|
pub fn JS_SetCanBlock(rt: *mut JSRuntime, can_block: ::std::os::raw::c_int);
|
|
}
|
|
extern "C" {
|
|
pub fn JS_SetIsHTMLDDA(ctx: *mut JSContext, obj: JSValue);
|
|
}
|
|
#[repr(C)]
|
|
#[derive(Debug, Copy, Clone)]
|
|
pub struct JSModuleDef {
|
|
_unused: [u8; 0],
|
|
}
|
|
pub type JSModuleNormalizeFunc = ::std::option::Option<
|
|
unsafe extern "C" fn(
|
|
ctx: *mut JSContext,
|
|
module_base_name: *const ::std::os::raw::c_char,
|
|
module_name: *const ::std::os::raw::c_char,
|
|
opaque: *mut ::std::os::raw::c_void,
|
|
) -> *mut ::std::os::raw::c_char,
|
|
>;
|
|
pub type JSModuleLoaderFunc = ::std::option::Option<
|
|
unsafe extern "C" fn(
|
|
ctx: *mut JSContext,
|
|
module_name: *const ::std::os::raw::c_char,
|
|
opaque: *mut ::std::os::raw::c_void,
|
|
) -> *mut JSModuleDef,
|
|
>;
|
|
extern "C" {
|
|
pub fn JS_SetModuleLoaderFunc(
|
|
rt: *mut JSRuntime,
|
|
module_normalize: JSModuleNormalizeFunc,
|
|
module_loader: JSModuleLoaderFunc,
|
|
opaque: *mut ::std::os::raw::c_void,
|
|
);
|
|
}
|
|
extern "C" {
|
|
pub fn JS_GetImportMeta(ctx: *mut JSContext, m: *mut JSModuleDef) -> JSValue;
|
|
}
|
|
extern "C" {
|
|
pub fn JS_GetModuleName(ctx: *mut JSContext, m: *mut JSModuleDef) -> JSAtom;
|
|
}
|
|
pub type JSJobFunc = ::std::option::Option<
|
|
unsafe extern "C" fn(
|
|
ctx: *mut JSContext,
|
|
argc: ::std::os::raw::c_int,
|
|
argv: *mut JSValue,
|
|
) -> JSValue,
|
|
>;
|
|
extern "C" {
|
|
pub fn JS_EnqueueJob(
|
|
ctx: *mut JSContext,
|
|
job_func: JSJobFunc,
|
|
argc: ::std::os::raw::c_int,
|
|
argv: *mut JSValue,
|
|
) -> ::std::os::raw::c_int;
|
|
}
|
|
extern "C" {
|
|
pub fn JS_IsJobPending(rt: *mut JSRuntime) -> ::std::os::raw::c_int;
|
|
}
|
|
extern "C" {
|
|
pub fn JS_ExecutePendingJob(
|
|
rt: *mut JSRuntime,
|
|
pctx: *mut *mut JSContext,
|
|
) -> ::std::os::raw::c_int;
|
|
}
|
|
extern "C" {
|
|
pub fn JS_WriteObject(
|
|
ctx: *mut JSContext,
|
|
psize: *mut size_t,
|
|
obj: JSValue,
|
|
flags: ::std::os::raw::c_int,
|
|
) -> *mut u8;
|
|
}
|
|
extern "C" {
|
|
pub fn JS_WriteObject2(
|
|
ctx: *mut JSContext,
|
|
psize: *mut size_t,
|
|
obj: JSValue,
|
|
flags: ::std::os::raw::c_int,
|
|
psab_tab: *mut *mut *mut u8,
|
|
psab_tab_len: *mut size_t,
|
|
) -> *mut u8;
|
|
}
|
|
extern "C" {
|
|
pub fn JS_ReadObject(
|
|
ctx: *mut JSContext,
|
|
buf: *const u8,
|
|
buf_len: size_t,
|
|
flags: ::std::os::raw::c_int,
|
|
) -> JSValue;
|
|
}
|
|
extern "C" {
|
|
pub fn JS_EvalFunction(ctx: *mut JSContext, fun_obj: JSValue) -> JSValue;
|
|
}
|
|
extern "C" {
|
|
pub fn JS_ResolveModule(ctx: *mut JSContext, obj: JSValue) -> ::std::os::raw::c_int;
|
|
}
|
|
extern "C" {
|
|
pub fn JS_GetScriptOrModuleName(
|
|
ctx: *mut JSContext,
|
|
n_stack_levels: ::std::os::raw::c_int,
|
|
) -> JSAtom;
|
|
}
|
|
extern "C" {
|
|
pub fn JS_RunModule(
|
|
ctx: *mut JSContext,
|
|
basename: *const ::std::os::raw::c_char,
|
|
filename: *const ::std::os::raw::c_char,
|
|
) -> *mut JSModuleDef;
|
|
}
|
|
pub const JSCFunctionEnum_JS_CFUNC_generic: JSCFunctionEnum = 0;
|
|
pub const JSCFunctionEnum_JS_CFUNC_generic_magic: JSCFunctionEnum = 1;
|
|
pub const JSCFunctionEnum_JS_CFUNC_constructor: JSCFunctionEnum = 2;
|
|
pub const JSCFunctionEnum_JS_CFUNC_constructor_magic: JSCFunctionEnum = 3;
|
|
pub const JSCFunctionEnum_JS_CFUNC_constructor_or_func: JSCFunctionEnum = 4;
|
|
pub const JSCFunctionEnum_JS_CFUNC_constructor_or_func_magic: JSCFunctionEnum = 5;
|
|
pub const JSCFunctionEnum_JS_CFUNC_f_f: JSCFunctionEnum = 6;
|
|
pub const JSCFunctionEnum_JS_CFUNC_f_f_f: JSCFunctionEnum = 7;
|
|
pub const JSCFunctionEnum_JS_CFUNC_getter: JSCFunctionEnum = 8;
|
|
pub const JSCFunctionEnum_JS_CFUNC_setter: JSCFunctionEnum = 9;
|
|
pub const JSCFunctionEnum_JS_CFUNC_getter_magic: JSCFunctionEnum = 10;
|
|
pub const JSCFunctionEnum_JS_CFUNC_setter_magic: JSCFunctionEnum = 11;
|
|
pub const JSCFunctionEnum_JS_CFUNC_iterator_next: JSCFunctionEnum = 12;
|
|
pub type JSCFunctionEnum = ::std::os::raw::c_uint;
|
|
#[repr(C)]
|
|
#[derive(Copy, Clone)]
|
|
pub union JSCFunctionType {
|
|
pub generic: JSCFunction,
|
|
pub generic_magic: ::std::option::Option<
|
|
unsafe extern "C" fn(
|
|
ctx: *mut JSContext,
|
|
this_val: JSValue,
|
|
argc: ::std::os::raw::c_int,
|
|
argv: *mut JSValue,
|
|
magic: ::std::os::raw::c_int,
|
|
) -> JSValue,
|
|
>,
|
|
pub constructor: JSCFunction,
|
|
pub constructor_magic: ::std::option::Option<
|
|
unsafe extern "C" fn(
|
|
ctx: *mut JSContext,
|
|
new_target: JSValue,
|
|
argc: ::std::os::raw::c_int,
|
|
argv: *mut JSValue,
|
|
magic: ::std::os::raw::c_int,
|
|
) -> JSValue,
|
|
>,
|
|
pub constructor_or_func: JSCFunction,
|
|
pub f_f: ::std::option::Option<unsafe extern "C" fn(arg1: f64) -> f64>,
|
|
pub f_f_f: ::std::option::Option<unsafe extern "C" fn(arg1: f64, arg2: f64) -> f64>,
|
|
pub getter: ::std::option::Option<
|
|
unsafe extern "C" fn(ctx: *mut JSContext, this_val: JSValue) -> JSValue,
|
|
>,
|
|
pub setter: ::std::option::Option<
|
|
unsafe extern "C" fn(ctx: *mut JSContext, this_val: JSValue, val: JSValue) -> JSValue,
|
|
>,
|
|
pub getter_magic: ::std::option::Option<
|
|
unsafe extern "C" fn(
|
|
ctx: *mut JSContext,
|
|
this_val: JSValue,
|
|
magic: ::std::os::raw::c_int,
|
|
) -> JSValue,
|
|
>,
|
|
pub setter_magic: ::std::option::Option<
|
|
unsafe extern "C" fn(
|
|
ctx: *mut JSContext,
|
|
this_val: JSValue,
|
|
val: JSValue,
|
|
magic: ::std::os::raw::c_int,
|
|
) -> JSValue,
|
|
>,
|
|
pub iterator_next: ::std::option::Option<
|
|
unsafe extern "C" fn(
|
|
ctx: *mut JSContext,
|
|
this_val: JSValue,
|
|
argc: ::std::os::raw::c_int,
|
|
argv: *mut JSValue,
|
|
pdone: *mut ::std::os::raw::c_int,
|
|
magic: ::std::os::raw::c_int,
|
|
) -> JSValue,
|
|
>,
|
|
_bindgen_union_align: u64,
|
|
}
|
|
#[test]
|
|
fn bindgen_test_layout_JSCFunctionType() {
|
|
assert_eq!(
|
|
::std::mem::size_of::<JSCFunctionType>(),
|
|
8usize,
|
|
concat!("Size of: ", stringify!(JSCFunctionType))
|
|
);
|
|
assert_eq!(
|
|
::std::mem::align_of::<JSCFunctionType>(),
|
|
8usize,
|
|
concat!("Alignment of ", stringify!(JSCFunctionType))
|
|
);
|
|
assert_eq!(
|
|
unsafe { &(*(::std::ptr::null::<JSCFunctionType>())).generic as *const _ as usize },
|
|
0usize,
|
|
concat!(
|
|
"Offset of field: ",
|
|
stringify!(JSCFunctionType),
|
|
"::",
|
|
stringify!(generic)
|
|
)
|
|
);
|
|
assert_eq!(
|
|
unsafe { &(*(::std::ptr::null::<JSCFunctionType>())).generic_magic as *const _ as usize },
|
|
0usize,
|
|
concat!(
|
|
"Offset of field: ",
|
|
stringify!(JSCFunctionType),
|
|
"::",
|
|
stringify!(generic_magic)
|
|
)
|
|
);
|
|
assert_eq!(
|
|
unsafe { &(*(::std::ptr::null::<JSCFunctionType>())).constructor as *const _ as usize },
|
|
0usize,
|
|
concat!(
|
|
"Offset of field: ",
|
|
stringify!(JSCFunctionType),
|
|
"::",
|
|
stringify!(constructor)
|
|
)
|
|
);
|
|
assert_eq!(
|
|
unsafe {
|
|
&(*(::std::ptr::null::<JSCFunctionType>())).constructor_magic as *const _ as usize
|
|
},
|
|
0usize,
|
|
concat!(
|
|
"Offset of field: ",
|
|
stringify!(JSCFunctionType),
|
|
"::",
|
|
stringify!(constructor_magic)
|
|
)
|
|
);
|
|
assert_eq!(
|
|
unsafe {
|
|
&(*(::std::ptr::null::<JSCFunctionType>())).constructor_or_func as *const _ as usize
|
|
},
|
|
0usize,
|
|
concat!(
|
|
"Offset of field: ",
|
|
stringify!(JSCFunctionType),
|
|
"::",
|
|
stringify!(constructor_or_func)
|
|
)
|
|
);
|
|
assert_eq!(
|
|
unsafe { &(*(::std::ptr::null::<JSCFunctionType>())).f_f as *const _ as usize },
|
|
0usize,
|
|
concat!(
|
|
"Offset of field: ",
|
|
stringify!(JSCFunctionType),
|
|
"::",
|
|
stringify!(f_f)
|
|
)
|
|
);
|
|
assert_eq!(
|
|
unsafe { &(*(::std::ptr::null::<JSCFunctionType>())).f_f_f as *const _ as usize },
|
|
0usize,
|
|
concat!(
|
|
"Offset of field: ",
|
|
stringify!(JSCFunctionType),
|
|
"::",
|
|
stringify!(f_f_f)
|
|
)
|
|
);
|
|
assert_eq!(
|
|
unsafe { &(*(::std::ptr::null::<JSCFunctionType>())).getter as *const _ as usize },
|
|
0usize,
|
|
concat!(
|
|
"Offset of field: ",
|
|
stringify!(JSCFunctionType),
|
|
"::",
|
|
stringify!(getter)
|
|
)
|
|
);
|
|
assert_eq!(
|
|
unsafe { &(*(::std::ptr::null::<JSCFunctionType>())).setter as *const _ as usize },
|
|
0usize,
|
|
concat!(
|
|
"Offset of field: ",
|
|
stringify!(JSCFunctionType),
|
|
"::",
|
|
stringify!(setter)
|
|
)
|
|
);
|
|
assert_eq!(
|
|
unsafe { &(*(::std::ptr::null::<JSCFunctionType>())).getter_magic as *const _ as usize },
|
|
0usize,
|
|
concat!(
|
|
"Offset of field: ",
|
|
stringify!(JSCFunctionType),
|
|
"::",
|
|
stringify!(getter_magic)
|
|
)
|
|
);
|
|
assert_eq!(
|
|
unsafe { &(*(::std::ptr::null::<JSCFunctionType>())).setter_magic as *const _ as usize },
|
|
0usize,
|
|
concat!(
|
|
"Offset of field: ",
|
|
stringify!(JSCFunctionType),
|
|
"::",
|
|
stringify!(setter_magic)
|
|
)
|
|
);
|
|
assert_eq!(
|
|
unsafe { &(*(::std::ptr::null::<JSCFunctionType>())).iterator_next as *const _ as usize },
|
|
0usize,
|
|
concat!(
|
|
"Offset of field: ",
|
|
stringify!(JSCFunctionType),
|
|
"::",
|
|
stringify!(iterator_next)
|
|
)
|
|
);
|
|
}
|
|
extern "C" {
|
|
pub fn JS_NewCFunction2(
|
|
ctx: *mut JSContext,
|
|
func: JSCFunction,
|
|
name: *const ::std::os::raw::c_char,
|
|
length: ::std::os::raw::c_int,
|
|
cproto: JSCFunctionEnum,
|
|
magic: ::std::os::raw::c_int,
|
|
) -> JSValue;
|
|
}
|
|
extern "C" {
|
|
pub fn JS_NewCFunctionData(
|
|
ctx: *mut JSContext,
|
|
func: JSCFunctionData,
|
|
length: ::std::os::raw::c_int,
|
|
magic: ::std::os::raw::c_int,
|
|
data_len: ::std::os::raw::c_int,
|
|
data: *mut JSValue,
|
|
) -> JSValue;
|
|
}
|
|
extern "C" {
|
|
pub fn JS_SetConstructor(ctx: *mut JSContext, func_obj: JSValue, proto: JSValue);
|
|
}
|
|
#[repr(C)]
|
|
#[derive(Copy, Clone)]
|
|
pub struct JSCFunctionListEntry {
|
|
pub name: *const ::std::os::raw::c_char,
|
|
pub prop_flags: u8,
|
|
pub def_type: u8,
|
|
pub magic: i16,
|
|
pub u: JSCFunctionListEntry__bindgen_ty_1,
|
|
}
|
|
#[repr(C)]
|
|
#[derive(Copy, Clone)]
|
|
pub union JSCFunctionListEntry__bindgen_ty_1 {
|
|
pub func: JSCFunctionListEntry__bindgen_ty_1__bindgen_ty_1,
|
|
pub getset: JSCFunctionListEntry__bindgen_ty_1__bindgen_ty_2,
|
|
pub alias: JSCFunctionListEntry__bindgen_ty_1__bindgen_ty_3,
|
|
pub prop_list: JSCFunctionListEntry__bindgen_ty_1__bindgen_ty_4,
|
|
pub str_: *const ::std::os::raw::c_char,
|
|
pub i32_: i32,
|
|
pub i64_: i64,
|
|
pub f64_: f64,
|
|
_bindgen_union_align: [u64; 2usize],
|
|
}
|
|
#[repr(C)]
|
|
#[derive(Copy, Clone)]
|
|
pub struct JSCFunctionListEntry__bindgen_ty_1__bindgen_ty_1 {
|
|
pub length: u8,
|
|
pub cproto: u8,
|
|
pub cfunc: JSCFunctionType,
|
|
}
|
|
#[test]
|
|
fn bindgen_test_layout_JSCFunctionListEntry__bindgen_ty_1__bindgen_ty_1() {
|
|
assert_eq!(
|
|
::std::mem::size_of::<JSCFunctionListEntry__bindgen_ty_1__bindgen_ty_1>(),
|
|
16usize,
|
|
concat!(
|
|
"Size of: ",
|
|
stringify!(JSCFunctionListEntry__bindgen_ty_1__bindgen_ty_1)
|
|
)
|
|
);
|
|
assert_eq!(
|
|
::std::mem::align_of::<JSCFunctionListEntry__bindgen_ty_1__bindgen_ty_1>(),
|
|
8usize,
|
|
concat!(
|
|
"Alignment of ",
|
|
stringify!(JSCFunctionListEntry__bindgen_ty_1__bindgen_ty_1)
|
|
)
|
|
);
|
|
assert_eq!(
|
|
unsafe {
|
|
&(*(::std::ptr::null::<JSCFunctionListEntry__bindgen_ty_1__bindgen_ty_1>())).length
|
|
as *const _ as usize
|
|
},
|
|
0usize,
|
|
concat!(
|
|
"Offset of field: ",
|
|
stringify!(JSCFunctionListEntry__bindgen_ty_1__bindgen_ty_1),
|
|
"::",
|
|
stringify!(length)
|
|
)
|
|
);
|
|
assert_eq!(
|
|
unsafe {
|
|
&(*(::std::ptr::null::<JSCFunctionListEntry__bindgen_ty_1__bindgen_ty_1>())).cproto
|
|
as *const _ as usize
|
|
},
|
|
1usize,
|
|
concat!(
|
|
"Offset of field: ",
|
|
stringify!(JSCFunctionListEntry__bindgen_ty_1__bindgen_ty_1),
|
|
"::",
|
|
stringify!(cproto)
|
|
)
|
|
);
|
|
assert_eq!(
|
|
unsafe {
|
|
&(*(::std::ptr::null::<JSCFunctionListEntry__bindgen_ty_1__bindgen_ty_1>())).cfunc
|
|
as *const _ as usize
|
|
},
|
|
8usize,
|
|
concat!(
|
|
"Offset of field: ",
|
|
stringify!(JSCFunctionListEntry__bindgen_ty_1__bindgen_ty_1),
|
|
"::",
|
|
stringify!(cfunc)
|
|
)
|
|
);
|
|
}
|
|
#[repr(C)]
|
|
#[derive(Copy, Clone)]
|
|
pub struct JSCFunctionListEntry__bindgen_ty_1__bindgen_ty_2 {
|
|
pub get: JSCFunctionType,
|
|
pub set: JSCFunctionType,
|
|
}
|
|
#[test]
|
|
fn bindgen_test_layout_JSCFunctionListEntry__bindgen_ty_1__bindgen_ty_2() {
|
|
assert_eq!(
|
|
::std::mem::size_of::<JSCFunctionListEntry__bindgen_ty_1__bindgen_ty_2>(),
|
|
16usize,
|
|
concat!(
|
|
"Size of: ",
|
|
stringify!(JSCFunctionListEntry__bindgen_ty_1__bindgen_ty_2)
|
|
)
|
|
);
|
|
assert_eq!(
|
|
::std::mem::align_of::<JSCFunctionListEntry__bindgen_ty_1__bindgen_ty_2>(),
|
|
8usize,
|
|
concat!(
|
|
"Alignment of ",
|
|
stringify!(JSCFunctionListEntry__bindgen_ty_1__bindgen_ty_2)
|
|
)
|
|
);
|
|
assert_eq!(
|
|
unsafe {
|
|
&(*(::std::ptr::null::<JSCFunctionListEntry__bindgen_ty_1__bindgen_ty_2>())).get
|
|
as *const _ as usize
|
|
},
|
|
0usize,
|
|
concat!(
|
|
"Offset of field: ",
|
|
stringify!(JSCFunctionListEntry__bindgen_ty_1__bindgen_ty_2),
|
|
"::",
|
|
stringify!(get)
|
|
)
|
|
);
|
|
assert_eq!(
|
|
unsafe {
|
|
&(*(::std::ptr::null::<JSCFunctionListEntry__bindgen_ty_1__bindgen_ty_2>())).set
|
|
as *const _ as usize
|
|
},
|
|
8usize,
|
|
concat!(
|
|
"Offset of field: ",
|
|
stringify!(JSCFunctionListEntry__bindgen_ty_1__bindgen_ty_2),
|
|
"::",
|
|
stringify!(set)
|
|
)
|
|
);
|
|
}
|
|
#[repr(C)]
|
|
#[derive(Debug, Copy, Clone)]
|
|
pub struct JSCFunctionListEntry__bindgen_ty_1__bindgen_ty_3 {
|
|
pub name: *const ::std::os::raw::c_char,
|
|
pub base: ::std::os::raw::c_int,
|
|
}
|
|
#[test]
|
|
fn bindgen_test_layout_JSCFunctionListEntry__bindgen_ty_1__bindgen_ty_3() {
|
|
assert_eq!(
|
|
::std::mem::size_of::<JSCFunctionListEntry__bindgen_ty_1__bindgen_ty_3>(),
|
|
16usize,
|
|
concat!(
|
|
"Size of: ",
|
|
stringify!(JSCFunctionListEntry__bindgen_ty_1__bindgen_ty_3)
|
|
)
|
|
);
|
|
assert_eq!(
|
|
::std::mem::align_of::<JSCFunctionListEntry__bindgen_ty_1__bindgen_ty_3>(),
|
|
8usize,
|
|
concat!(
|
|
"Alignment of ",
|
|
stringify!(JSCFunctionListEntry__bindgen_ty_1__bindgen_ty_3)
|
|
)
|
|
);
|
|
assert_eq!(
|
|
unsafe {
|
|
&(*(::std::ptr::null::<JSCFunctionListEntry__bindgen_ty_1__bindgen_ty_3>())).name
|
|
as *const _ as usize
|
|
},
|
|
0usize,
|
|
concat!(
|
|
"Offset of field: ",
|
|
stringify!(JSCFunctionListEntry__bindgen_ty_1__bindgen_ty_3),
|
|
"::",
|
|
stringify!(name)
|
|
)
|
|
);
|
|
assert_eq!(
|
|
unsafe {
|
|
&(*(::std::ptr::null::<JSCFunctionListEntry__bindgen_ty_1__bindgen_ty_3>())).base
|
|
as *const _ as usize
|
|
},
|
|
8usize,
|
|
concat!(
|
|
"Offset of field: ",
|
|
stringify!(JSCFunctionListEntry__bindgen_ty_1__bindgen_ty_3),
|
|
"::",
|
|
stringify!(base)
|
|
)
|
|
);
|
|
}
|
|
#[repr(C)]
|
|
#[derive(Debug, Copy, Clone)]
|
|
pub struct JSCFunctionListEntry__bindgen_ty_1__bindgen_ty_4 {
|
|
pub tab: *const JSCFunctionListEntry,
|
|
pub len: ::std::os::raw::c_int,
|
|
}
|
|
#[test]
|
|
fn bindgen_test_layout_JSCFunctionListEntry__bindgen_ty_1__bindgen_ty_4() {
|
|
assert_eq!(
|
|
::std::mem::size_of::<JSCFunctionListEntry__bindgen_ty_1__bindgen_ty_4>(),
|
|
16usize,
|
|
concat!(
|
|
"Size of: ",
|
|
stringify!(JSCFunctionListEntry__bindgen_ty_1__bindgen_ty_4)
|
|
)
|
|
);
|
|
assert_eq!(
|
|
::std::mem::align_of::<JSCFunctionListEntry__bindgen_ty_1__bindgen_ty_4>(),
|
|
8usize,
|
|
concat!(
|
|
"Alignment of ",
|
|
stringify!(JSCFunctionListEntry__bindgen_ty_1__bindgen_ty_4)
|
|
)
|
|
);
|
|
assert_eq!(
|
|
unsafe {
|
|
&(*(::std::ptr::null::<JSCFunctionListEntry__bindgen_ty_1__bindgen_ty_4>())).tab
|
|
as *const _ as usize
|
|
},
|
|
0usize,
|
|
concat!(
|
|
"Offset of field: ",
|
|
stringify!(JSCFunctionListEntry__bindgen_ty_1__bindgen_ty_4),
|
|
"::",
|
|
stringify!(tab)
|
|
)
|
|
);
|
|
assert_eq!(
|
|
unsafe {
|
|
&(*(::std::ptr::null::<JSCFunctionListEntry__bindgen_ty_1__bindgen_ty_4>())).len
|
|
as *const _ as usize
|
|
},
|
|
8usize,
|
|
concat!(
|
|
"Offset of field: ",
|
|
stringify!(JSCFunctionListEntry__bindgen_ty_1__bindgen_ty_4),
|
|
"::",
|
|
stringify!(len)
|
|
)
|
|
);
|
|
}
|
|
#[test]
|
|
fn bindgen_test_layout_JSCFunctionListEntry__bindgen_ty_1() {
|
|
assert_eq!(
|
|
::std::mem::size_of::<JSCFunctionListEntry__bindgen_ty_1>(),
|
|
16usize,
|
|
concat!("Size of: ", stringify!(JSCFunctionListEntry__bindgen_ty_1))
|
|
);
|
|
assert_eq!(
|
|
::std::mem::align_of::<JSCFunctionListEntry__bindgen_ty_1>(),
|
|
8usize,
|
|
concat!(
|
|
"Alignment of ",
|
|
stringify!(JSCFunctionListEntry__bindgen_ty_1)
|
|
)
|
|
);
|
|
assert_eq!(
|
|
unsafe {
|
|
&(*(::std::ptr::null::<JSCFunctionListEntry__bindgen_ty_1>())).func as *const _ as usize
|
|
},
|
|
0usize,
|
|
concat!(
|
|
"Offset of field: ",
|
|
stringify!(JSCFunctionListEntry__bindgen_ty_1),
|
|
"::",
|
|
stringify!(func)
|
|
)
|
|
);
|
|
assert_eq!(
|
|
unsafe {
|
|
&(*(::std::ptr::null::<JSCFunctionListEntry__bindgen_ty_1>())).getset as *const _
|
|
as usize
|
|
},
|
|
0usize,
|
|
concat!(
|
|
"Offset of field: ",
|
|
stringify!(JSCFunctionListEntry__bindgen_ty_1),
|
|
"::",
|
|
stringify!(getset)
|
|
)
|
|
);
|
|
assert_eq!(
|
|
unsafe {
|
|
&(*(::std::ptr::null::<JSCFunctionListEntry__bindgen_ty_1>())).alias as *const _
|
|
as usize
|
|
},
|
|
0usize,
|
|
concat!(
|
|
"Offset of field: ",
|
|
stringify!(JSCFunctionListEntry__bindgen_ty_1),
|
|
"::",
|
|
stringify!(alias)
|
|
)
|
|
);
|
|
assert_eq!(
|
|
unsafe {
|
|
&(*(::std::ptr::null::<JSCFunctionListEntry__bindgen_ty_1>())).prop_list as *const _
|
|
as usize
|
|
},
|
|
0usize,
|
|
concat!(
|
|
"Offset of field: ",
|
|
stringify!(JSCFunctionListEntry__bindgen_ty_1),
|
|
"::",
|
|
stringify!(prop_list)
|
|
)
|
|
);
|
|
assert_eq!(
|
|
unsafe {
|
|
&(*(::std::ptr::null::<JSCFunctionListEntry__bindgen_ty_1>())).str_ as *const _ as usize
|
|
},
|
|
0usize,
|
|
concat!(
|
|
"Offset of field: ",
|
|
stringify!(JSCFunctionListEntry__bindgen_ty_1),
|
|
"::",
|
|
stringify!(str_)
|
|
)
|
|
);
|
|
assert_eq!(
|
|
unsafe {
|
|
&(*(::std::ptr::null::<JSCFunctionListEntry__bindgen_ty_1>())).i32_ as *const _ as usize
|
|
},
|
|
0usize,
|
|
concat!(
|
|
"Offset of field: ",
|
|
stringify!(JSCFunctionListEntry__bindgen_ty_1),
|
|
"::",
|
|
stringify!(i32_)
|
|
)
|
|
);
|
|
assert_eq!(
|
|
unsafe {
|
|
&(*(::std::ptr::null::<JSCFunctionListEntry__bindgen_ty_1>())).i64_ as *const _ as usize
|
|
},
|
|
0usize,
|
|
concat!(
|
|
"Offset of field: ",
|
|
stringify!(JSCFunctionListEntry__bindgen_ty_1),
|
|
"::",
|
|
stringify!(i64_)
|
|
)
|
|
);
|
|
assert_eq!(
|
|
unsafe {
|
|
&(*(::std::ptr::null::<JSCFunctionListEntry__bindgen_ty_1>())).f64_ as *const _ as usize
|
|
},
|
|
0usize,
|
|
concat!(
|
|
"Offset of field: ",
|
|
stringify!(JSCFunctionListEntry__bindgen_ty_1),
|
|
"::",
|
|
stringify!(f64_)
|
|
)
|
|
);
|
|
}
|
|
#[test]
|
|
fn bindgen_test_layout_JSCFunctionListEntry() {
|
|
assert_eq!(
|
|
::std::mem::size_of::<JSCFunctionListEntry>(),
|
|
32usize,
|
|
concat!("Size of: ", stringify!(JSCFunctionListEntry))
|
|
);
|
|
assert_eq!(
|
|
::std::mem::align_of::<JSCFunctionListEntry>(),
|
|
8usize,
|
|
concat!("Alignment of ", stringify!(JSCFunctionListEntry))
|
|
);
|
|
assert_eq!(
|
|
unsafe { &(*(::std::ptr::null::<JSCFunctionListEntry>())).name as *const _ as usize },
|
|
0usize,
|
|
concat!(
|
|
"Offset of field: ",
|
|
stringify!(JSCFunctionListEntry),
|
|
"::",
|
|
stringify!(name)
|
|
)
|
|
);
|
|
assert_eq!(
|
|
unsafe { &(*(::std::ptr::null::<JSCFunctionListEntry>())).prop_flags as *const _ as usize },
|
|
8usize,
|
|
concat!(
|
|
"Offset of field: ",
|
|
stringify!(JSCFunctionListEntry),
|
|
"::",
|
|
stringify!(prop_flags)
|
|
)
|
|
);
|
|
assert_eq!(
|
|
unsafe { &(*(::std::ptr::null::<JSCFunctionListEntry>())).def_type as *const _ as usize },
|
|
9usize,
|
|
concat!(
|
|
"Offset of field: ",
|
|
stringify!(JSCFunctionListEntry),
|
|
"::",
|
|
stringify!(def_type)
|
|
)
|
|
);
|
|
assert_eq!(
|
|
unsafe { &(*(::std::ptr::null::<JSCFunctionListEntry>())).magic as *const _ as usize },
|
|
10usize,
|
|
concat!(
|
|
"Offset of field: ",
|
|
stringify!(JSCFunctionListEntry),
|
|
"::",
|
|
stringify!(magic)
|
|
)
|
|
);
|
|
assert_eq!(
|
|
unsafe { &(*(::std::ptr::null::<JSCFunctionListEntry>())).u as *const _ as usize },
|
|
16usize,
|
|
concat!(
|
|
"Offset of field: ",
|
|
stringify!(JSCFunctionListEntry),
|
|
"::",
|
|
stringify!(u)
|
|
)
|
|
);
|
|
}
|
|
extern "C" {
|
|
pub fn JS_SetPropertyFunctionList(
|
|
ctx: *mut JSContext,
|
|
obj: JSValue,
|
|
tab: *const JSCFunctionListEntry,
|
|
len: ::std::os::raw::c_int,
|
|
);
|
|
}
|
|
pub type JSModuleInitFunc = ::std::option::Option<
|
|
unsafe extern "C" fn(ctx: *mut JSContext, m: *mut JSModuleDef) -> ::std::os::raw::c_int,
|
|
>;
|
|
extern "C" {
|
|
pub fn JS_NewCModule(
|
|
ctx: *mut JSContext,
|
|
name_str: *const ::std::os::raw::c_char,
|
|
func: JSModuleInitFunc,
|
|
) -> *mut JSModuleDef;
|
|
}
|
|
extern "C" {
|
|
pub fn JS_AddModuleExport(
|
|
ctx: *mut JSContext,
|
|
m: *mut JSModuleDef,
|
|
name_str: *const ::std::os::raw::c_char,
|
|
) -> ::std::os::raw::c_int;
|
|
}
|
|
extern "C" {
|
|
pub fn JS_AddModuleExportList(
|
|
ctx: *mut JSContext,
|
|
m: *mut JSModuleDef,
|
|
tab: *const JSCFunctionListEntry,
|
|
len: ::std::os::raw::c_int,
|
|
) -> ::std::os::raw::c_int;
|
|
}
|
|
extern "C" {
|
|
pub fn JS_SetModuleExport(
|
|
ctx: *mut JSContext,
|
|
m: *mut JSModuleDef,
|
|
export_name: *const ::std::os::raw::c_char,
|
|
val: JSValue,
|
|
) -> ::std::os::raw::c_int;
|
|
}
|
|
extern "C" {
|
|
pub fn JS_SetModuleExportList(
|
|
ctx: *mut JSContext,
|
|
m: *mut JSModuleDef,
|
|
tab: *const JSCFunctionListEntry,
|
|
len: ::std::os::raw::c_int,
|
|
) -> ::std::os::raw::c_int;
|
|
}
|
|
pub type __builtin_va_list = [__va_list_tag; 1usize];
|
|
#[repr(C)]
|
|
#[derive(Debug, Copy, Clone)]
|
|
pub struct __va_list_tag {
|
|
pub gp_offset: ::std::os::raw::c_uint,
|
|
pub fp_offset: ::std::os::raw::c_uint,
|
|
pub overflow_arg_area: *mut ::std::os::raw::c_void,
|
|
pub reg_save_area: *mut ::std::os::raw::c_void,
|
|
}
|
|
#[test]
|
|
fn bindgen_test_layout___va_list_tag() {
|
|
assert_eq!(
|
|
::std::mem::size_of::<__va_list_tag>(),
|
|
24usize,
|
|
concat!("Size of: ", stringify!(__va_list_tag))
|
|
);
|
|
assert_eq!(
|
|
::std::mem::align_of::<__va_list_tag>(),
|
|
8usize,
|
|
concat!("Alignment of ", stringify!(__va_list_tag))
|
|
);
|
|
assert_eq!(
|
|
unsafe { &(*(::std::ptr::null::<__va_list_tag>())).gp_offset as *const _ as usize },
|
|
0usize,
|
|
concat!(
|
|
"Offset of field: ",
|
|
stringify!(__va_list_tag),
|
|
"::",
|
|
stringify!(gp_offset)
|
|
)
|
|
);
|
|
assert_eq!(
|
|
unsafe { &(*(::std::ptr::null::<__va_list_tag>())).fp_offset as *const _ as usize },
|
|
4usize,
|
|
concat!(
|
|
"Offset of field: ",
|
|
stringify!(__va_list_tag),
|
|
"::",
|
|
stringify!(fp_offset)
|
|
)
|
|
);
|
|
assert_eq!(
|
|
unsafe { &(*(::std::ptr::null::<__va_list_tag>())).overflow_arg_area as *const _ as usize },
|
|
8usize,
|
|
concat!(
|
|
"Offset of field: ",
|
|
stringify!(__va_list_tag),
|
|
"::",
|
|
stringify!(overflow_arg_area)
|
|
)
|
|
);
|
|
assert_eq!(
|
|
unsafe { &(*(::std::ptr::null::<__va_list_tag>())).reg_save_area as *const _ as usize },
|
|
16usize,
|
|
concat!(
|
|
"Offset of field: ",
|
|
stringify!(__va_list_tag),
|
|
"::",
|
|
stringify!(reg_save_area)
|
|
)
|
|
);
|
|
}
|