#[repr(C)]
#[derive(Default)]
pub struct __IncompleteArrayField<T>(::std::marker::PhantomData<T>, [T; 0]);
impl<T> __IncompleteArrayField<T> {
#[inline]
pub const fn new() -> Self {
__IncompleteArrayField(::std::marker::PhantomData, [])
}
#[inline]
pub fn as_ptr(&self) -> *const T {
self as *const _ as *const T
}
#[inline]
pub fn as_mut_ptr(&mut self) -> *mut T {
self as *mut _ as *mut T
}
#[inline]
pub unsafe fn as_slice(&self, len: usize) -> &[T] {
::std::slice::from_raw_parts(self.as_ptr(), len)
}
#[inline]
pub unsafe fn as_mut_slice(&mut self, len: usize) -> &mut [T] {
::std::slice::from_raw_parts_mut(self.as_mut_ptr(), len)
}
}
impl<T> ::std::fmt::Debug for __IncompleteArrayField<T> {
fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
fmt.write_str("__IncompleteArrayField")
}
}
pub const JANET_VERSION_MAJOR: u32 = 1;
pub const JANET_VERSION_MINOR: u32 = 13;
pub const JANET_VERSION_PATCH: u32 = 1;
pub const JANET_VERSION_EXTRA: &'static [u8; 1usize] = b"\0";
pub const JANET_VERSION: &'static [u8; 7usize] = b"1.13.1\0";
pub const JANET_BUILD: &'static [u8; 6usize] = b"local\0";
pub const JANET_LINUX: u32 = 1;
pub const JANET_POSIX: u32 = 1;
pub const JANET_64: u32 = 1;
pub const JANET_LITTLE_ENDIAN: u32 = 1;
pub const JANET_INTMAX_DOUBLE: f64 = 9007199254740992.0;
pub const JANET_INTMIN_DOUBLE: f64 = -9007199254740992.0;
pub const JANET_INTMAX_INT64: u64 = 9007199254740992;
pub const JANET_INTMIN_INT64: i64 = -9007199254740992;
pub const JANET_RECURSION_GUARD: u32 = 1024;
pub const JANET_MAX_PROTO_DEPTH: u32 = 200;
pub const JANET_MAX_MACRO_EXPAND: u32 = 200;
pub const JANET_STACK_MAX: u32 = 2147483647;
pub const JANET_NANBOX_BIT: u32 = 1;
pub const JANET_SINGLE_THREADED_BIT: u32 = 0;
pub const JANET_CURRENT_CONFIG_BITS: u32 = 1;
pub const JANET_HANDLE_NONE: i32 = -1;
pub const JANET_STREAM_CLOSED: u32 = 1;
pub const JANET_STREAM_SOCKET: u32 = 2;
pub const JANET_STREAM_IOCP: u32 = 4;
pub const JANET_STREAM_READABLE: u32 = 512;
pub const JANET_STREAM_WRITABLE: u32 = 1024;
pub const JANET_STREAM_ACCEPTABLE: u32 = 2048;
pub const JANET_STREAM_UDPSERVER: u32 = 4096;
pub const JANET_NANBOX_TAGBITS: i64 = -140737488355328;
pub const JANET_NANBOX_PAYLOADBITS: u64 = 140737488355327;
pub const JANET_STACKFRAME_TAILCALL: u32 = 1;
pub const JANET_STACKFRAME_ENTRANCE: u32 = 2;
pub const JANET_FRAME_SIZE: u32 = 4;
pub const JANET_FUNCDEF_FLAG_VARARG: u32 = 65536;
pub const JANET_FUNCDEF_FLAG_NEEDSENV: u32 = 131072;
pub const JANET_FUNCDEF_FLAG_HASNAME: u32 = 524288;
pub const JANET_FUNCDEF_FLAG_HASSOURCE: u32 = 1048576;
pub const JANET_FUNCDEF_FLAG_HASDEFS: u32 = 2097152;
pub const JANET_FUNCDEF_FLAG_HASENVS: u32 = 4194304;
pub const JANET_FUNCDEF_FLAG_HASSOURCEMAP: u32 = 8388608;
pub const JANET_FUNCDEF_FLAG_STRUCTARG: u32 = 16777216;
pub const JANET_FUNCDEF_FLAG_HASCLOBITSET: u32 = 33554432;
pub const JANET_FUNCDEF_FLAG_TAG: u32 = 65535;
pub const JANET_FUNCFLAG_TRACE: u32 = 65536;
pub const JANET_TUPLE_FLAG_BRACKETCTOR: u32 = 65536;
pub const JANET_MARSHAL_UNSAFE: u32 = 131072;
pub const JANET_PRETTY_COLOR: u32 = 1;
pub const JANET_PRETTY_ONELINE: u32 = 2;
pub const JANET_PRETTY_NOTRUNC: u32 = 4;
pub const JANET_FILE_WRITE: u32 = 1;
pub const JANET_FILE_READ: u32 = 2;
pub const JANET_FILE_APPEND: u32 = 4;
pub const JANET_FILE_UPDATE: u32 = 8;
pub const JANET_FILE_NOT_CLOSEABLE: u32 = 16;
pub const JANET_FILE_CLOSED: u32 = 32;
pub const JANET_FILE_BINARY: u32 = 64;
pub const JANET_FILE_SERIALIZABLE: u32 = 128;
pub const JANET_FILE_PIPED: u32 = 256;
pub const JANET_FILE_NONIL: u32 = 512;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct JanetBuildConfig {
pub major: ::std::os::raw::c_uint,
pub minor: ::std::os::raw::c_uint,
pub patch: ::std::os::raw::c_uint,
pub bits: ::std::os::raw::c_uint,
}
#[test]
fn bindgen_test_layout_JanetBuildConfig() {
assert_eq!(
::std::mem::size_of::<JanetBuildConfig>(),
16usize,
concat!("Size of: ", stringify!(JanetBuildConfig))
);
assert_eq!(
::std::mem::align_of::<JanetBuildConfig>(),
4usize,
concat!("Alignment of ", stringify!(JanetBuildConfig))
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<JanetBuildConfig>())).major as *const _ as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(JanetBuildConfig),
"::",
stringify!(major)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<JanetBuildConfig>())).minor as *const _ as usize },
4usize,
concat!(
"Offset of field: ",
stringify!(JanetBuildConfig),
"::",
stringify!(minor)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<JanetBuildConfig>())).patch as *const _ as usize },
8usize,
concat!(
"Offset of field: ",
stringify!(JanetBuildConfig),
"::",
stringify!(patch)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<JanetBuildConfig>())).bits as *const _ as usize },
12usize,
concat!(
"Offset of field: ",
stringify!(JanetBuildConfig),
"::",
stringify!(bits)
)
);
}
pub type size_t = ::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 __off_t = ::std::os::raw::c_long;
pub type __off64_t = ::std::os::raw::c_long;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct __sigset_t {
pub __val: [::std::os::raw::c_ulong; 16usize],
}
#[test]
fn bindgen_test_layout___sigset_t() {
assert_eq!(
::std::mem::size_of::<__sigset_t>(),
128usize,
concat!("Size of: ", stringify!(__sigset_t))
);
assert_eq!(
::std::mem::align_of::<__sigset_t>(),
8usize,
concat!("Alignment of ", stringify!(__sigset_t))
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<__sigset_t>())).__val as *const _ as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(__sigset_t),
"::",
stringify!(__val)
)
);
}
pub type va_list = __builtin_va_list;
pub type __jmp_buf = [::std::os::raw::c_long; 8usize];
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct __jmp_buf_tag {
pub __jmpbuf: __jmp_buf,
pub __mask_was_saved: ::std::os::raw::c_int,
pub __saved_mask: __sigset_t,
}
#[test]
fn bindgen_test_layout___jmp_buf_tag() {
assert_eq!(
::std::mem::size_of::<__jmp_buf_tag>(),
200usize,
concat!("Size of: ", stringify!(__jmp_buf_tag))
);
assert_eq!(
::std::mem::align_of::<__jmp_buf_tag>(),
8usize,
concat!("Alignment of ", stringify!(__jmp_buf_tag))
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<__jmp_buf_tag>())).__jmpbuf as *const _ as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(__jmp_buf_tag),
"::",
stringify!(__jmpbuf)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<__jmp_buf_tag>())).__mask_was_saved as *const _ as usize },
64usize,
concat!(
"Offset of field: ",
stringify!(__jmp_buf_tag),
"::",
stringify!(__mask_was_saved)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<__jmp_buf_tag>())).__saved_mask as *const _ as usize },
72usize,
concat!(
"Offset of field: ",
stringify!(__jmp_buf_tag),
"::",
stringify!(__saved_mask)
)
);
}
pub type jmp_buf = [__jmp_buf_tag; 1usize];
extern "C" {
pub fn setjmp(__env: *mut __jmp_buf_tag) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn __sigsetjmp(
__env: *mut __jmp_buf_tag,
__savemask: ::std::os::raw::c_int,
) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn _setjmp(__env: *mut __jmp_buf_tag) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn longjmp(__env: *mut __jmp_buf_tag, __val: ::std::os::raw::c_int);
}
extern "C" {
pub fn _longjmp(__env: *mut __jmp_buf_tag, __val: ::std::os::raw::c_int);
}
extern "C" {
pub fn siglongjmp(__env: *mut __jmp_buf_tag, __val: ::std::os::raw::c_int);
}
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)
)
);
}
extern "C" {
pub static janet_type_names: [*const ::std::os::raw::c_char; 16usize];
}
extern "C" {
pub static janet_signal_names: [*const ::std::os::raw::c_char; 14usize];
}
extern "C" {
pub static janet_status_names: [*const ::std::os::raw::c_char; 16usize];
}
pub type JanetHandle = ::std::os::raw::c_int;
pub const JanetSignal_JANET_SIGNAL_OK: JanetSignal = 0;
pub const JanetSignal_JANET_SIGNAL_ERROR: JanetSignal = 1;
pub const JanetSignal_JANET_SIGNAL_DEBUG: JanetSignal = 2;
pub const JanetSignal_JANET_SIGNAL_YIELD: JanetSignal = 3;
pub const JanetSignal_JANET_SIGNAL_USER0: JanetSignal = 4;
pub const JanetSignal_JANET_SIGNAL_USER1: JanetSignal = 5;
pub const JanetSignal_JANET_SIGNAL_USER2: JanetSignal = 6;
pub const JanetSignal_JANET_SIGNAL_USER3: JanetSignal = 7;
pub const JanetSignal_JANET_SIGNAL_USER4: JanetSignal = 8;
pub const JanetSignal_JANET_SIGNAL_USER5: JanetSignal = 9;
pub const JanetSignal_JANET_SIGNAL_USER6: JanetSignal = 10;
pub const JanetSignal_JANET_SIGNAL_USER7: JanetSignal = 11;
pub const JanetSignal_JANET_SIGNAL_USER8: JanetSignal = 12;
pub const JanetSignal_JANET_SIGNAL_USER9: JanetSignal = 13;
pub type JanetSignal = ::std::os::raw::c_uint;
pub const JanetFiberStatus_JANET_STATUS_DEAD: JanetFiberStatus = 0;
pub const JanetFiberStatus_JANET_STATUS_ERROR: JanetFiberStatus = 1;
pub const JanetFiberStatus_JANET_STATUS_DEBUG: JanetFiberStatus = 2;
pub const JanetFiberStatus_JANET_STATUS_PENDING: JanetFiberStatus = 3;
pub const JanetFiberStatus_JANET_STATUS_USER0: JanetFiberStatus = 4;
pub const JanetFiberStatus_JANET_STATUS_USER1: JanetFiberStatus = 5;
pub const JanetFiberStatus_JANET_STATUS_USER2: JanetFiberStatus = 6;
pub const JanetFiberStatus_JANET_STATUS_USER3: JanetFiberStatus = 7;
pub const JanetFiberStatus_JANET_STATUS_USER4: JanetFiberStatus = 8;
pub const JanetFiberStatus_JANET_STATUS_USER5: JanetFiberStatus = 9;
pub const JanetFiberStatus_JANET_STATUS_USER6: JanetFiberStatus = 10;
pub const JanetFiberStatus_JANET_STATUS_USER7: JanetFiberStatus = 11;
pub const JanetFiberStatus_JANET_STATUS_USER8: JanetFiberStatus = 12;
pub const JanetFiberStatus_JANET_STATUS_USER9: JanetFiberStatus = 13;
pub const JanetFiberStatus_JANET_STATUS_NEW: JanetFiberStatus = 14;
pub const JanetFiberStatus_JANET_STATUS_ALIVE: JanetFiberStatus = 15;
pub type JanetFiberStatus = ::std::os::raw::c_uint;
pub const JanetType_JANET_NUMBER: JanetType = 0;
pub const JanetType_JANET_NIL: JanetType = 1;
pub const JanetType_JANET_BOOLEAN: JanetType = 2;
pub const JanetType_JANET_FIBER: JanetType = 3;
pub const JanetType_JANET_STRING: JanetType = 4;
pub const JanetType_JANET_SYMBOL: JanetType = 5;
pub const JanetType_JANET_KEYWORD: JanetType = 6;
pub const JanetType_JANET_ARRAY: JanetType = 7;
pub const JanetType_JANET_TUPLE: JanetType = 8;
pub const JanetType_JANET_TABLE: JanetType = 9;
pub const JanetType_JANET_STRUCT: JanetType = 10;
pub const JanetType_JANET_BUFFER: JanetType = 11;
pub const JanetType_JANET_FUNCTION: JanetType = 12;
pub const JanetType_JANET_CFUNCTION: JanetType = 13;
pub const JanetType_JANET_ABSTRACT: JanetType = 14;
pub const JanetType_JANET_POINTER: JanetType = 15;
pub type JanetType = ::std::os::raw::c_uint;
#[repr(C)]
#[derive(Copy, Clone)]
pub union Janet {
pub u64_: u64,
pub i64_: i64,
pub number: f64,
pub pointer: *mut ::std::os::raw::c_void,
_bindgen_union_align: u64,
}
#[test]
fn bindgen_test_layout_Janet() {
assert_eq!(
::std::mem::size_of::<Janet>(),
8usize,
concat!("Size of: ", stringify!(Janet))
);
assert_eq!(
::std::mem::align_of::<Janet>(),
8usize,
concat!("Alignment of ", stringify!(Janet))
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<Janet>())).u64_ as *const _ as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(Janet),
"::",
stringify!(u64_)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<Janet>())).i64_ as *const _ as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(Janet),
"::",
stringify!(i64_)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<Janet>())).number as *const _ as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(Janet),
"::",
stringify!(number)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<Janet>())).pointer as *const _ as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(Janet),
"::",
stringify!(pointer)
)
);
}
pub type JanetCFunction =
::std::option::Option<unsafe extern "C" fn(argc: i32, argv: *mut Janet) -> Janet>;
pub type JanetString = *const u8;
pub type JanetSymbol = *const u8;
pub type JanetKeyword = *const u8;
pub type JanetTuple = *const Janet;
pub type JanetStruct = *const JanetKV;
pub type JanetAbstract = *mut ::std::os::raw::c_void;
pub const JanetAsyncEvent_JANET_ASYNC_EVENT_INIT: JanetAsyncEvent = 0;
pub const JanetAsyncEvent_JANET_ASYNC_EVENT_MARK: JanetAsyncEvent = 1;
pub const JanetAsyncEvent_JANET_ASYNC_EVENT_DEINIT: JanetAsyncEvent = 2;
pub const JanetAsyncEvent_JANET_ASYNC_EVENT_CLOSE: JanetAsyncEvent = 3;
pub const JanetAsyncEvent_JANET_ASYNC_EVENT_ERR: JanetAsyncEvent = 4;
pub const JanetAsyncEvent_JANET_ASYNC_EVENT_HUP: JanetAsyncEvent = 5;
pub const JanetAsyncEvent_JANET_ASYNC_EVENT_READ: JanetAsyncEvent = 6;
pub const JanetAsyncEvent_JANET_ASYNC_EVENT_WRITE: JanetAsyncEvent = 7;
pub const JanetAsyncEvent_JANET_ASYNC_EVENT_CANCEL: JanetAsyncEvent = 8;
pub const JanetAsyncEvent_JANET_ASYNC_EVENT_COMPLETE: JanetAsyncEvent = 9;
pub const JanetAsyncEvent_JANET_ASYNC_EVENT_USER: JanetAsyncEvent = 10;
pub type JanetAsyncEvent = ::std::os::raw::c_uint;
pub const JanetAsyncStatus_JANET_ASYNC_STATUS_NOT_DONE: JanetAsyncStatus = 0;
pub const JanetAsyncStatus_JANET_ASYNC_STATUS_DONE: JanetAsyncStatus = 1;
pub type JanetAsyncStatus = ::std::os::raw::c_uint;
pub type JanetListener = ::std::option::Option<
unsafe extern "C" fn(
state: *mut JanetListenerState,
event: JanetAsyncEvent,
) -> JanetAsyncStatus,
>;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct JanetStream {
pub handle: JanetHandle,
pub flags: u32,
pub state: *mut JanetListenerState,
pub methods: *const ::std::os::raw::c_void,
pub _mask: ::std::os::raw::c_int,
}
#[test]
fn bindgen_test_layout_JanetStream() {
assert_eq!(
::std::mem::size_of::<JanetStream>(),
32usize,
concat!("Size of: ", stringify!(JanetStream))
);
assert_eq!(
::std::mem::align_of::<JanetStream>(),
8usize,
concat!("Alignment of ", stringify!(JanetStream))
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<JanetStream>())).handle as *const _ as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(JanetStream),
"::",
stringify!(handle)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<JanetStream>())).flags as *const _ as usize },
4usize,
concat!(
"Offset of field: ",
stringify!(JanetStream),
"::",
stringify!(flags)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<JanetStream>())).state as *const _ as usize },
8usize,
concat!(
"Offset of field: ",
stringify!(JanetStream),
"::",
stringify!(state)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<JanetStream>())).methods as *const _ as usize },
16usize,
concat!(
"Offset of field: ",
stringify!(JanetStream),
"::",
stringify!(methods)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<JanetStream>()))._mask as *const _ as usize },
24usize,
concat!(
"Offset of field: ",
stringify!(JanetStream),
"::",
stringify!(_mask)
)
);
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct JanetListenerState {
pub machine: JanetListener,
pub fiber: *mut JanetFiber,
pub stream: *mut JanetStream,
pub event: *mut ::std::os::raw::c_void,
pub _index: size_t,
pub _mask: ::std::os::raw::c_int,
pub _next: *mut JanetListenerState,
}
#[test]
fn bindgen_test_layout_JanetListenerState() {
assert_eq!(
::std::mem::size_of::<JanetListenerState>(),
56usize,
concat!("Size of: ", stringify!(JanetListenerState))
);
assert_eq!(
::std::mem::align_of::<JanetListenerState>(),
8usize,
concat!("Alignment of ", stringify!(JanetListenerState))
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<JanetListenerState>())).machine as *const _ as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(JanetListenerState),
"::",
stringify!(machine)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<JanetListenerState>())).fiber as *const _ as usize },
8usize,
concat!(
"Offset of field: ",
stringify!(JanetListenerState),
"::",
stringify!(fiber)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<JanetListenerState>())).stream as *const _ as usize },
16usize,
concat!(
"Offset of field: ",
stringify!(JanetListenerState),
"::",
stringify!(stream)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<JanetListenerState>())).event as *const _ as usize },
24usize,
concat!(
"Offset of field: ",
stringify!(JanetListenerState),
"::",
stringify!(event)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<JanetListenerState>()))._index as *const _ as usize },
32usize,
concat!(
"Offset of field: ",
stringify!(JanetListenerState),
"::",
stringify!(_index)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<JanetListenerState>()))._mask as *const _ as usize },
40usize,
concat!(
"Offset of field: ",
stringify!(JanetListenerState),
"::",
stringify!(_mask)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<JanetListenerState>()))._next as *const _ as usize },
48usize,
concat!(
"Offset of field: ",
stringify!(JanetListenerState),
"::",
stringify!(_next)
)
);
}
extern "C" {
#[doc = " START SECTION NON-C API"]
pub fn janet_struct_head(st: *const JanetKV) -> *mut JanetStructHead;
}
extern "C" {
pub fn janet_abstract_head(abstract_: *const ::std::os::raw::c_void) -> *mut JanetAbstractHead;
}
extern "C" {
pub fn janet_string_head(s: *const u8) -> *mut JanetStringHead;
}
extern "C" {
pub fn janet_tuple_head(tuple: *const Janet) -> *mut JanetTupleHead;
}
extern "C" {
pub fn janet_type(x: Janet) -> JanetType;
}
extern "C" {
pub fn janet_checktype(x: Janet, type_: JanetType) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn janet_checktypes(x: Janet, typeflags: ::std::os::raw::c_int) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn janet_truthy(x: Janet) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn janet_unwrap_struct(x: Janet) -> *const JanetKV;
}
extern "C" {
pub fn janet_unwrap_tuple(x: Janet) -> *const Janet;
}
extern "C" {
pub fn janet_unwrap_fiber(x: Janet) -> *mut JanetFiber;
}
extern "C" {
pub fn janet_unwrap_array(x: Janet) -> *mut JanetArray;
}
extern "C" {
pub fn janet_unwrap_table(x: Janet) -> *mut JanetTable;
}
extern "C" {
pub fn janet_unwrap_buffer(x: Janet) -> *mut JanetBuffer;
}
extern "C" {
pub fn janet_unwrap_string(x: Janet) -> *const u8;
}
extern "C" {
pub fn janet_unwrap_symbol(x: Janet) -> *const u8;
}
extern "C" {
pub fn janet_unwrap_keyword(x: Janet) -> *const u8;
}
extern "C" {
pub fn janet_unwrap_abstract(x: Janet) -> *mut ::std::os::raw::c_void;
}
extern "C" {
pub fn janet_unwrap_pointer(x: Janet) -> *mut ::std::os::raw::c_void;
}
extern "C" {
pub fn janet_unwrap_function(x: Janet) -> *mut JanetFunction;
}
extern "C" {
pub fn janet_unwrap_cfunction(x: Janet) -> JanetCFunction;
}
extern "C" {
pub fn janet_unwrap_boolean(x: Janet) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn janet_unwrap_number(x: Janet) -> f64;
}
extern "C" {
pub fn janet_unwrap_integer(x: Janet) -> i32;
}
extern "C" {
pub fn janet_wrap_nil() -> Janet;
}
extern "C" {
pub fn janet_wrap_number(x: f64) -> Janet;
}
extern "C" {
pub fn janet_wrap_true() -> Janet;
}
extern "C" {
pub fn janet_wrap_false() -> Janet;
}
extern "C" {
pub fn janet_wrap_boolean(x: ::std::os::raw::c_int) -> Janet;
}
extern "C" {
pub fn janet_wrap_string(x: *const u8) -> Janet;
}
extern "C" {
pub fn janet_wrap_symbol(x: *const u8) -> Janet;
}
extern "C" {
pub fn janet_wrap_keyword(x: *const u8) -> Janet;
}
extern "C" {
pub fn janet_wrap_array(x: *mut JanetArray) -> Janet;
}
extern "C" {
pub fn janet_wrap_tuple(x: *const Janet) -> Janet;
}
extern "C" {
pub fn janet_wrap_struct(x: *const JanetKV) -> Janet;
}
extern "C" {
pub fn janet_wrap_fiber(x: *mut JanetFiber) -> Janet;
}
extern "C" {
pub fn janet_wrap_buffer(x: *mut JanetBuffer) -> Janet;
}
extern "C" {
pub fn janet_wrap_function(x: *mut JanetFunction) -> Janet;
}
extern "C" {
pub fn janet_wrap_cfunction(x: JanetCFunction) -> Janet;
}
extern "C" {
pub fn janet_wrap_table(x: *mut JanetTable) -> Janet;
}
extern "C" {
pub fn janet_wrap_abstract(x: *mut ::std::os::raw::c_void) -> Janet;
}
extern "C" {
pub fn janet_wrap_pointer(x: *mut ::std::os::raw::c_void) -> Janet;
}
extern "C" {
pub fn janet_wrap_integer(x: i32) -> Janet;
}
extern "C" {
pub fn janet_nanbox_to_pointer(x: Janet) -> *mut ::std::os::raw::c_void;
}
extern "C" {
pub fn janet_nanbox_from_pointer(p: *mut ::std::os::raw::c_void, tagmask: u64) -> Janet;
}
extern "C" {
pub fn janet_nanbox_from_cpointer(p: *const ::std::os::raw::c_void, tagmask: u64) -> Janet;
}
extern "C" {
pub fn janet_nanbox_from_double(d: f64) -> Janet;
}
extern "C" {
pub fn janet_nanbox_from_bits(bits: u64) -> Janet;
}
extern "C" {
pub fn janet_checkint(x: Janet) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn janet_checkint64(x: Janet) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn janet_checksize(x: Janet) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn janet_checkabstract(x: Janet, at: *const JanetAbstractType) -> JanetAbstract;
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct JanetGCObject {
pub flags: i32,
pub next: *mut JanetGCObject,
}
#[test]
fn bindgen_test_layout_JanetGCObject() {
assert_eq!(
::std::mem::size_of::<JanetGCObject>(),
16usize,
concat!("Size of: ", stringify!(JanetGCObject))
);
assert_eq!(
::std::mem::align_of::<JanetGCObject>(),
8usize,
concat!("Alignment of ", stringify!(JanetGCObject))
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<JanetGCObject>())).flags as *const _ as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(JanetGCObject),
"::",
stringify!(flags)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<JanetGCObject>())).next as *const _ as usize },
8usize,
concat!(
"Offset of field: ",
stringify!(JanetGCObject),
"::",
stringify!(next)
)
);
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct JanetFiber {
pub gc: JanetGCObject,
pub flags: i32,
pub frame: i32,
pub stackstart: i32,
pub stacktop: i32,
pub capacity: i32,
pub maxstack: i32,
pub env: *mut JanetTable,
pub data: *mut Janet,
pub child: *mut JanetFiber,
pub waiting: *mut JanetListenerState,
pub sched_id: u32,
}
#[test]
fn bindgen_test_layout_JanetFiber() {
assert_eq!(
::std::mem::size_of::<JanetFiber>(),
80usize,
concat!("Size of: ", stringify!(JanetFiber))
);
assert_eq!(
::std::mem::align_of::<JanetFiber>(),
8usize,
concat!("Alignment of ", stringify!(JanetFiber))
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<JanetFiber>())).gc as *const _ as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(JanetFiber),
"::",
stringify!(gc)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<JanetFiber>())).flags as *const _ as usize },
16usize,
concat!(
"Offset of field: ",
stringify!(JanetFiber),
"::",
stringify!(flags)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<JanetFiber>())).frame as *const _ as usize },
20usize,
concat!(
"Offset of field: ",
stringify!(JanetFiber),
"::",
stringify!(frame)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<JanetFiber>())).stackstart as *const _ as usize },
24usize,
concat!(
"Offset of field: ",
stringify!(JanetFiber),
"::",
stringify!(stackstart)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<JanetFiber>())).stacktop as *const _ as usize },
28usize,
concat!(
"Offset of field: ",
stringify!(JanetFiber),
"::",
stringify!(stacktop)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<JanetFiber>())).capacity as *const _ as usize },
32usize,
concat!(
"Offset of field: ",
stringify!(JanetFiber),
"::",
stringify!(capacity)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<JanetFiber>())).maxstack as *const _ as usize },
36usize,
concat!(
"Offset of field: ",
stringify!(JanetFiber),
"::",
stringify!(maxstack)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<JanetFiber>())).env as *const _ as usize },
40usize,
concat!(
"Offset of field: ",
stringify!(JanetFiber),
"::",
stringify!(env)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<JanetFiber>())).data as *const _ as usize },
48usize,
concat!(
"Offset of field: ",
stringify!(JanetFiber),
"::",
stringify!(data)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<JanetFiber>())).child as *const _ as usize },
56usize,
concat!(
"Offset of field: ",
stringify!(JanetFiber),
"::",
stringify!(child)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<JanetFiber>())).waiting as *const _ as usize },
64usize,
concat!(
"Offset of field: ",
stringify!(JanetFiber),
"::",
stringify!(waiting)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<JanetFiber>())).sched_id as *const _ as usize },
72usize,
concat!(
"Offset of field: ",
stringify!(JanetFiber),
"::",
stringify!(sched_id)
)
);
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct JanetStackFrame {
pub func: *mut JanetFunction,
pub pc: *mut u32,
pub env: *mut JanetFuncEnv,
pub prevframe: i32,
pub flags: i32,
}
#[test]
fn bindgen_test_layout_JanetStackFrame() {
assert_eq!(
::std::mem::size_of::<JanetStackFrame>(),
32usize,
concat!("Size of: ", stringify!(JanetStackFrame))
);
assert_eq!(
::std::mem::align_of::<JanetStackFrame>(),
8usize,
concat!("Alignment of ", stringify!(JanetStackFrame))
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<JanetStackFrame>())).func as *const _ as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(JanetStackFrame),
"::",
stringify!(func)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<JanetStackFrame>())).pc as *const _ as usize },
8usize,
concat!(
"Offset of field: ",
stringify!(JanetStackFrame),
"::",
stringify!(pc)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<JanetStackFrame>())).env as *const _ as usize },
16usize,
concat!(
"Offset of field: ",
stringify!(JanetStackFrame),
"::",
stringify!(env)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<JanetStackFrame>())).prevframe as *const _ as usize },
24usize,
concat!(
"Offset of field: ",
stringify!(JanetStackFrame),
"::",
stringify!(prevframe)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<JanetStackFrame>())).flags as *const _ as usize },
28usize,
concat!(
"Offset of field: ",
stringify!(JanetStackFrame),
"::",
stringify!(flags)
)
);
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct JanetArray {
pub gc: JanetGCObject,
pub count: i32,
pub capacity: i32,
pub data: *mut Janet,
}
#[test]
fn bindgen_test_layout_JanetArray() {
assert_eq!(
::std::mem::size_of::<JanetArray>(),
32usize,
concat!("Size of: ", stringify!(JanetArray))
);
assert_eq!(
::std::mem::align_of::<JanetArray>(),
8usize,
concat!("Alignment of ", stringify!(JanetArray))
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<JanetArray>())).gc as *const _ as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(JanetArray),
"::",
stringify!(gc)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<JanetArray>())).count as *const _ as usize },
16usize,
concat!(
"Offset of field: ",
stringify!(JanetArray),
"::",
stringify!(count)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<JanetArray>())).capacity as *const _ as usize },
20usize,
concat!(
"Offset of field: ",
stringify!(JanetArray),
"::",
stringify!(capacity)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<JanetArray>())).data as *const _ as usize },
24usize,
concat!(
"Offset of field: ",
stringify!(JanetArray),
"::",
stringify!(data)
)
);
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct JanetBuffer {
pub gc: JanetGCObject,
pub count: i32,
pub capacity: i32,
pub data: *mut u8,
}
#[test]
fn bindgen_test_layout_JanetBuffer() {
assert_eq!(
::std::mem::size_of::<JanetBuffer>(),
32usize,
concat!("Size of: ", stringify!(JanetBuffer))
);
assert_eq!(
::std::mem::align_of::<JanetBuffer>(),
8usize,
concat!("Alignment of ", stringify!(JanetBuffer))
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<JanetBuffer>())).gc as *const _ as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(JanetBuffer),
"::",
stringify!(gc)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<JanetBuffer>())).count as *const _ as usize },
16usize,
concat!(
"Offset of field: ",
stringify!(JanetBuffer),
"::",
stringify!(count)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<JanetBuffer>())).capacity as *const _ as usize },
20usize,
concat!(
"Offset of field: ",
stringify!(JanetBuffer),
"::",
stringify!(capacity)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<JanetBuffer>())).data as *const _ as usize },
24usize,
concat!(
"Offset of field: ",
stringify!(JanetBuffer),
"::",
stringify!(data)
)
);
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct JanetTable {
pub gc: JanetGCObject,
pub count: i32,
pub capacity: i32,
pub deleted: i32,
pub data: *mut JanetKV,
pub proto: *mut JanetTable,
}
#[test]
fn bindgen_test_layout_JanetTable() {
assert_eq!(
::std::mem::size_of::<JanetTable>(),
48usize,
concat!("Size of: ", stringify!(JanetTable))
);
assert_eq!(
::std::mem::align_of::<JanetTable>(),
8usize,
concat!("Alignment of ", stringify!(JanetTable))
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<JanetTable>())).gc as *const _ as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(JanetTable),
"::",
stringify!(gc)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<JanetTable>())).count as *const _ as usize },
16usize,
concat!(
"Offset of field: ",
stringify!(JanetTable),
"::",
stringify!(count)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<JanetTable>())).capacity as *const _ as usize },
20usize,
concat!(
"Offset of field: ",
stringify!(JanetTable),
"::",
stringify!(capacity)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<JanetTable>())).deleted as *const _ as usize },
24usize,
concat!(
"Offset of field: ",
stringify!(JanetTable),
"::",
stringify!(deleted)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<JanetTable>())).data as *const _ as usize },
32usize,
concat!(
"Offset of field: ",
stringify!(JanetTable),
"::",
stringify!(data)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<JanetTable>())).proto as *const _ as usize },
40usize,
concat!(
"Offset of field: ",
stringify!(JanetTable),
"::",
stringify!(proto)
)
);
}
#[repr(C)]
#[derive(Copy, Clone)]
pub struct JanetKV {
pub key: Janet,
pub value: Janet,
}
#[test]
fn bindgen_test_layout_JanetKV() {
assert_eq!(
::std::mem::size_of::<JanetKV>(),
16usize,
concat!("Size of: ", stringify!(JanetKV))
);
assert_eq!(
::std::mem::align_of::<JanetKV>(),
8usize,
concat!("Alignment of ", stringify!(JanetKV))
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<JanetKV>())).key as *const _ as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(JanetKV),
"::",
stringify!(key)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<JanetKV>())).value as *const _ as usize },
8usize,
concat!(
"Offset of field: ",
stringify!(JanetKV),
"::",
stringify!(value)
)
);
}
#[repr(C)]
pub struct JanetTupleHead {
pub gc: JanetGCObject,
pub length: i32,
pub hash: i32,
pub sm_line: i32,
pub sm_column: i32,
pub data: __IncompleteArrayField<Janet>,
}
#[test]
fn bindgen_test_layout_JanetTupleHead() {
assert_eq!(
::std::mem::size_of::<JanetTupleHead>(),
32usize,
concat!("Size of: ", stringify!(JanetTupleHead))
);
assert_eq!(
::std::mem::align_of::<JanetTupleHead>(),
8usize,
concat!("Alignment of ", stringify!(JanetTupleHead))
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<JanetTupleHead>())).gc as *const _ as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(JanetTupleHead),
"::",
stringify!(gc)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<JanetTupleHead>())).length as *const _ as usize },
16usize,
concat!(
"Offset of field: ",
stringify!(JanetTupleHead),
"::",
stringify!(length)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<JanetTupleHead>())).hash as *const _ as usize },
20usize,
concat!(
"Offset of field: ",
stringify!(JanetTupleHead),
"::",
stringify!(hash)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<JanetTupleHead>())).sm_line as *const _ as usize },
24usize,
concat!(
"Offset of field: ",
stringify!(JanetTupleHead),
"::",
stringify!(sm_line)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<JanetTupleHead>())).sm_column as *const _ as usize },
28usize,
concat!(
"Offset of field: ",
stringify!(JanetTupleHead),
"::",
stringify!(sm_column)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<JanetTupleHead>())).data as *const _ as usize },
32usize,
concat!(
"Offset of field: ",
stringify!(JanetTupleHead),
"::",
stringify!(data)
)
);
}
#[repr(C)]
pub struct JanetStructHead {
pub gc: JanetGCObject,
pub length: i32,
pub hash: i32,
pub capacity: i32,
pub data: __IncompleteArrayField<JanetKV>,
}
#[test]
fn bindgen_test_layout_JanetStructHead() {
assert_eq!(
::std::mem::size_of::<JanetStructHead>(),
32usize,
concat!("Size of: ", stringify!(JanetStructHead))
);
assert_eq!(
::std::mem::align_of::<JanetStructHead>(),
8usize,
concat!("Alignment of ", stringify!(JanetStructHead))
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<JanetStructHead>())).gc as *const _ as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(JanetStructHead),
"::",
stringify!(gc)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<JanetStructHead>())).length as *const _ as usize },
16usize,
concat!(
"Offset of field: ",
stringify!(JanetStructHead),
"::",
stringify!(length)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<JanetStructHead>())).hash as *const _ as usize },
20usize,
concat!(
"Offset of field: ",
stringify!(JanetStructHead),
"::",
stringify!(hash)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<JanetStructHead>())).capacity as *const _ as usize },
24usize,
concat!(
"Offset of field: ",
stringify!(JanetStructHead),
"::",
stringify!(capacity)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<JanetStructHead>())).data as *const _ as usize },
32usize,
concat!(
"Offset of field: ",
stringify!(JanetStructHead),
"::",
stringify!(data)
)
);
}
#[repr(C)]
#[derive(Debug)]
pub struct JanetStringHead {
pub gc: JanetGCObject,
pub length: i32,
pub hash: i32,
pub data: __IncompleteArrayField<u8>,
}
#[test]
fn bindgen_test_layout_JanetStringHead() {
assert_eq!(
::std::mem::size_of::<JanetStringHead>(),
24usize,
concat!("Size of: ", stringify!(JanetStringHead))
);
assert_eq!(
::std::mem::align_of::<JanetStringHead>(),
8usize,
concat!("Alignment of ", stringify!(JanetStringHead))
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<JanetStringHead>())).gc as *const _ as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(JanetStringHead),
"::",
stringify!(gc)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<JanetStringHead>())).length as *const _ as usize },
16usize,
concat!(
"Offset of field: ",
stringify!(JanetStringHead),
"::",
stringify!(length)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<JanetStringHead>())).hash as *const _ as usize },
20usize,
concat!(
"Offset of field: ",
stringify!(JanetStringHead),
"::",
stringify!(hash)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<JanetStringHead>())).data as *const _ as usize },
24usize,
concat!(
"Offset of field: ",
stringify!(JanetStringHead),
"::",
stringify!(data)
)
);
}
#[repr(C)]
#[derive(Debug)]
pub struct JanetAbstractHead {
pub gc: JanetGCObject,
pub type_: *const JanetAbstractType,
pub size: size_t,
pub data: __IncompleteArrayField<::std::os::raw::c_longlong>,
}
#[test]
fn bindgen_test_layout_JanetAbstractHead() {
assert_eq!(
::std::mem::size_of::<JanetAbstractHead>(),
32usize,
concat!("Size of: ", stringify!(JanetAbstractHead))
);
assert_eq!(
::std::mem::align_of::<JanetAbstractHead>(),
8usize,
concat!("Alignment of ", stringify!(JanetAbstractHead))
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<JanetAbstractHead>())).gc as *const _ as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(JanetAbstractHead),
"::",
stringify!(gc)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<JanetAbstractHead>())).type_ as *const _ as usize },
16usize,
concat!(
"Offset of field: ",
stringify!(JanetAbstractHead),
"::",
stringify!(type_)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<JanetAbstractHead>())).size as *const _ as usize },
24usize,
concat!(
"Offset of field: ",
stringify!(JanetAbstractHead),
"::",
stringify!(size)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<JanetAbstractHead>())).data as *const _ as usize },
32usize,
concat!(
"Offset of field: ",
stringify!(JanetAbstractHead),
"::",
stringify!(data)
)
);
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct JanetSourceMapping {
pub line: i32,
pub column: i32,
}
#[test]
fn bindgen_test_layout_JanetSourceMapping() {
assert_eq!(
::std::mem::size_of::<JanetSourceMapping>(),
8usize,
concat!("Size of: ", stringify!(JanetSourceMapping))
);
assert_eq!(
::std::mem::align_of::<JanetSourceMapping>(),
4usize,
concat!("Alignment of ", stringify!(JanetSourceMapping))
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<JanetSourceMapping>())).line as *const _ as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(JanetSourceMapping),
"::",
stringify!(line)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<JanetSourceMapping>())).column as *const _ as usize },
4usize,
concat!(
"Offset of field: ",
stringify!(JanetSourceMapping),
"::",
stringify!(column)
)
);
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct JanetFuncDef {
pub gc: JanetGCObject,
pub environments: *mut i32,
pub constants: *mut Janet,
pub defs: *mut *mut JanetFuncDef,
pub bytecode: *mut u32,
pub closure_bitset: *mut u32,
pub sourcemap: *mut JanetSourceMapping,
pub source: JanetString,
pub name: JanetString,
pub flags: i32,
pub slotcount: i32,
pub arity: i32,
pub min_arity: i32,
pub max_arity: i32,
pub constants_length: i32,
pub bytecode_length: i32,
pub environments_length: i32,
pub defs_length: i32,
}
#[test]
fn bindgen_test_layout_JanetFuncDef() {
assert_eq!(
::std::mem::size_of::<JanetFuncDef>(),
120usize,
concat!("Size of: ", stringify!(JanetFuncDef))
);
assert_eq!(
::std::mem::align_of::<JanetFuncDef>(),
8usize,
concat!("Alignment of ", stringify!(JanetFuncDef))
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<JanetFuncDef>())).gc as *const _ as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(JanetFuncDef),
"::",
stringify!(gc)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<JanetFuncDef>())).environments as *const _ as usize },
16usize,
concat!(
"Offset of field: ",
stringify!(JanetFuncDef),
"::",
stringify!(environments)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<JanetFuncDef>())).constants as *const _ as usize },
24usize,
concat!(
"Offset of field: ",
stringify!(JanetFuncDef),
"::",
stringify!(constants)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<JanetFuncDef>())).defs as *const _ as usize },
32usize,
concat!(
"Offset of field: ",
stringify!(JanetFuncDef),
"::",
stringify!(defs)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<JanetFuncDef>())).bytecode as *const _ as usize },
40usize,
concat!(
"Offset of field: ",
stringify!(JanetFuncDef),
"::",
stringify!(bytecode)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<JanetFuncDef>())).closure_bitset as *const _ as usize },
48usize,
concat!(
"Offset of field: ",
stringify!(JanetFuncDef),
"::",
stringify!(closure_bitset)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<JanetFuncDef>())).sourcemap as *const _ as usize },
56usize,
concat!(
"Offset of field: ",
stringify!(JanetFuncDef),
"::",
stringify!(sourcemap)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<JanetFuncDef>())).source as *const _ as usize },
64usize,
concat!(
"Offset of field: ",
stringify!(JanetFuncDef),
"::",
stringify!(source)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<JanetFuncDef>())).name as *const _ as usize },
72usize,
concat!(
"Offset of field: ",
stringify!(JanetFuncDef),
"::",
stringify!(name)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<JanetFuncDef>())).flags as *const _ as usize },
80usize,
concat!(
"Offset of field: ",
stringify!(JanetFuncDef),
"::",
stringify!(flags)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<JanetFuncDef>())).slotcount as *const _ as usize },
84usize,
concat!(
"Offset of field: ",
stringify!(JanetFuncDef),
"::",
stringify!(slotcount)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<JanetFuncDef>())).arity as *const _ as usize },
88usize,
concat!(
"Offset of field: ",
stringify!(JanetFuncDef),
"::",
stringify!(arity)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<JanetFuncDef>())).min_arity as *const _ as usize },
92usize,
concat!(
"Offset of field: ",
stringify!(JanetFuncDef),
"::",
stringify!(min_arity)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<JanetFuncDef>())).max_arity as *const _ as usize },
96usize,
concat!(
"Offset of field: ",
stringify!(JanetFuncDef),
"::",
stringify!(max_arity)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<JanetFuncDef>())).constants_length as *const _ as usize },
100usize,
concat!(
"Offset of field: ",
stringify!(JanetFuncDef),
"::",
stringify!(constants_length)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<JanetFuncDef>())).bytecode_length as *const _ as usize },
104usize,
concat!(
"Offset of field: ",
stringify!(JanetFuncDef),
"::",
stringify!(bytecode_length)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<JanetFuncDef>())).environments_length as *const _ as usize
},
108usize,
concat!(
"Offset of field: ",
stringify!(JanetFuncDef),
"::",
stringify!(environments_length)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<JanetFuncDef>())).defs_length as *const _ as usize },
112usize,
concat!(
"Offset of field: ",
stringify!(JanetFuncDef),
"::",
stringify!(defs_length)
)
);
}
#[repr(C)]
#[derive(Copy, Clone)]
pub struct JanetFuncEnv {
pub gc: JanetGCObject,
pub as_: JanetFuncEnv__bindgen_ty_1,
pub length: i32,
pub offset: i32,
}
#[repr(C)]
#[derive(Copy, Clone)]
pub union JanetFuncEnv__bindgen_ty_1 {
pub fiber: *mut JanetFiber,
pub values: *mut Janet,
_bindgen_union_align: u64,
}
#[test]
fn bindgen_test_layout_JanetFuncEnv__bindgen_ty_1() {
assert_eq!(
::std::mem::size_of::<JanetFuncEnv__bindgen_ty_1>(),
8usize,
concat!("Size of: ", stringify!(JanetFuncEnv__bindgen_ty_1))
);
assert_eq!(
::std::mem::align_of::<JanetFuncEnv__bindgen_ty_1>(),
8usize,
concat!("Alignment of ", stringify!(JanetFuncEnv__bindgen_ty_1))
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<JanetFuncEnv__bindgen_ty_1>())).fiber as *const _ as usize
},
0usize,
concat!(
"Offset of field: ",
stringify!(JanetFuncEnv__bindgen_ty_1),
"::",
stringify!(fiber)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<JanetFuncEnv__bindgen_ty_1>())).values as *const _ as usize
},
0usize,
concat!(
"Offset of field: ",
stringify!(JanetFuncEnv__bindgen_ty_1),
"::",
stringify!(values)
)
);
}
#[test]
fn bindgen_test_layout_JanetFuncEnv() {
assert_eq!(
::std::mem::size_of::<JanetFuncEnv>(),
32usize,
concat!("Size of: ", stringify!(JanetFuncEnv))
);
assert_eq!(
::std::mem::align_of::<JanetFuncEnv>(),
8usize,
concat!("Alignment of ", stringify!(JanetFuncEnv))
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<JanetFuncEnv>())).gc as *const _ as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(JanetFuncEnv),
"::",
stringify!(gc)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<JanetFuncEnv>())).as_ as *const _ as usize },
16usize,
concat!(
"Offset of field: ",
stringify!(JanetFuncEnv),
"::",
stringify!(as_)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<JanetFuncEnv>())).length as *const _ as usize },
24usize,
concat!(
"Offset of field: ",
stringify!(JanetFuncEnv),
"::",
stringify!(length)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<JanetFuncEnv>())).offset as *const _ as usize },
28usize,
concat!(
"Offset of field: ",
stringify!(JanetFuncEnv),
"::",
stringify!(offset)
)
);
}
#[repr(C)]
#[derive(Debug)]
pub struct JanetFunction {
pub gc: JanetGCObject,
pub def: *mut JanetFuncDef,
pub envs: __IncompleteArrayField<*mut JanetFuncEnv>,
}
#[test]
fn bindgen_test_layout_JanetFunction() {
assert_eq!(
::std::mem::size_of::<JanetFunction>(),
24usize,
concat!("Size of: ", stringify!(JanetFunction))
);
assert_eq!(
::std::mem::align_of::<JanetFunction>(),
8usize,
concat!("Alignment of ", stringify!(JanetFunction))
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<JanetFunction>())).gc as *const _ as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(JanetFunction),
"::",
stringify!(gc)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<JanetFunction>())).def as *const _ as usize },
16usize,
concat!(
"Offset of field: ",
stringify!(JanetFunction),
"::",
stringify!(def)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<JanetFunction>())).envs as *const _ as usize },
24usize,
concat!(
"Offset of field: ",
stringify!(JanetFunction),
"::",
stringify!(envs)
)
);
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct JanetParseState {
_unused: [u8; 0],
}
pub const JanetParserStatus_JANET_PARSE_ROOT: JanetParserStatus = 0;
pub const JanetParserStatus_JANET_PARSE_ERROR: JanetParserStatus = 1;
pub const JanetParserStatus_JANET_PARSE_PENDING: JanetParserStatus = 2;
pub const JanetParserStatus_JANET_PARSE_DEAD: JanetParserStatus = 3;
pub type JanetParserStatus = ::std::os::raw::c_uint;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct JanetParser {
pub args: *mut Janet,
pub error: *const ::std::os::raw::c_char,
pub states: *mut JanetParseState,
pub buf: *mut u8,
pub argcount: size_t,
pub argcap: size_t,
pub statecount: size_t,
pub statecap: size_t,
pub bufcount: size_t,
pub bufcap: size_t,
pub line: size_t,
pub column: size_t,
pub pending: size_t,
pub lookback: ::std::os::raw::c_int,
pub flag: ::std::os::raw::c_int,
}
#[test]
fn bindgen_test_layout_JanetParser() {
assert_eq!(
::std::mem::size_of::<JanetParser>(),
112usize,
concat!("Size of: ", stringify!(JanetParser))
);
assert_eq!(
::std::mem::align_of::<JanetParser>(),
8usize,
concat!("Alignment of ", stringify!(JanetParser))
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<JanetParser>())).args as *const _ as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(JanetParser),
"::",
stringify!(args)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<JanetParser>())).error as *const _ as usize },
8usize,
concat!(
"Offset of field: ",
stringify!(JanetParser),
"::",
stringify!(error)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<JanetParser>())).states as *const _ as usize },
16usize,
concat!(
"Offset of field: ",
stringify!(JanetParser),
"::",
stringify!(states)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<JanetParser>())).buf as *const _ as usize },
24usize,
concat!(
"Offset of field: ",
stringify!(JanetParser),
"::",
stringify!(buf)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<JanetParser>())).argcount as *const _ as usize },
32usize,
concat!(
"Offset of field: ",
stringify!(JanetParser),
"::",
stringify!(argcount)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<JanetParser>())).argcap as *const _ as usize },
40usize,
concat!(
"Offset of field: ",
stringify!(JanetParser),
"::",
stringify!(argcap)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<JanetParser>())).statecount as *const _ as usize },
48usize,
concat!(
"Offset of field: ",
stringify!(JanetParser),
"::",
stringify!(statecount)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<JanetParser>())).statecap as *const _ as usize },
56usize,
concat!(
"Offset of field: ",
stringify!(JanetParser),
"::",
stringify!(statecap)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<JanetParser>())).bufcount as *const _ as usize },
64usize,
concat!(
"Offset of field: ",
stringify!(JanetParser),
"::",
stringify!(bufcount)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<JanetParser>())).bufcap as *const _ as usize },
72usize,
concat!(
"Offset of field: ",
stringify!(JanetParser),
"::",
stringify!(bufcap)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<JanetParser>())).line as *const _ as usize },
80usize,
concat!(
"Offset of field: ",
stringify!(JanetParser),
"::",
stringify!(line)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<JanetParser>())).column as *const _ as usize },
88usize,
concat!(
"Offset of field: ",
stringify!(JanetParser),
"::",
stringify!(column)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<JanetParser>())).pending as *const _ as usize },
96usize,
concat!(
"Offset of field: ",
stringify!(JanetParser),
"::",
stringify!(pending)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<JanetParser>())).lookback as *const _ as usize },
104usize,
concat!(
"Offset of field: ",
stringify!(JanetParser),
"::",
stringify!(lookback)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<JanetParser>())).flag as *const _ as usize },
108usize,
concat!(
"Offset of field: ",
stringify!(JanetParser),
"::",
stringify!(flag)
)
);
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct JanetMarshalContext {
pub m_state: *mut ::std::os::raw::c_void,
pub u_state: *mut ::std::os::raw::c_void,
pub flags: ::std::os::raw::c_int,
pub data: *const u8,
pub at: *const JanetAbstractType,
}
#[test]
fn bindgen_test_layout_JanetMarshalContext() {
assert_eq!(
::std::mem::size_of::<JanetMarshalContext>(),
40usize,
concat!("Size of: ", stringify!(JanetMarshalContext))
);
assert_eq!(
::std::mem::align_of::<JanetMarshalContext>(),
8usize,
concat!("Alignment of ", stringify!(JanetMarshalContext))
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<JanetMarshalContext>())).m_state as *const _ as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(JanetMarshalContext),
"::",
stringify!(m_state)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<JanetMarshalContext>())).u_state as *const _ as usize },
8usize,
concat!(
"Offset of field: ",
stringify!(JanetMarshalContext),
"::",
stringify!(u_state)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<JanetMarshalContext>())).flags as *const _ as usize },
16usize,
concat!(
"Offset of field: ",
stringify!(JanetMarshalContext),
"::",
stringify!(flags)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<JanetMarshalContext>())).data as *const _ as usize },
24usize,
concat!(
"Offset of field: ",
stringify!(JanetMarshalContext),
"::",
stringify!(data)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<JanetMarshalContext>())).at as *const _ as usize },
32usize,
concat!(
"Offset of field: ",
stringify!(JanetMarshalContext),
"::",
stringify!(at)
)
);
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct JanetAbstractType {
pub name: *const ::std::os::raw::c_char,
pub gc: ::std::option::Option<
unsafe extern "C" fn(
data: *mut ::std::os::raw::c_void,
len: size_t,
) -> ::std::os::raw::c_int,
>,
pub gcmark: ::std::option::Option<
unsafe extern "C" fn(
data: *mut ::std::os::raw::c_void,
len: size_t,
) -> ::std::os::raw::c_int,
>,
pub get: ::std::option::Option<
unsafe extern "C" fn(
data: *mut ::std::os::raw::c_void,
key: Janet,
out: *mut Janet,
) -> ::std::os::raw::c_int,
>,
pub put: ::std::option::Option<
unsafe extern "C" fn(data: *mut ::std::os::raw::c_void, key: Janet, value: Janet),
>,
pub marshal: ::std::option::Option<
unsafe extern "C" fn(p: *mut ::std::os::raw::c_void, ctx: *mut JanetMarshalContext),
>,
pub unmarshal: ::std::option::Option<
unsafe extern "C" fn(ctx: *mut JanetMarshalContext) -> *mut ::std::os::raw::c_void,
>,
pub tostring: ::std::option::Option<
unsafe extern "C" fn(p: *mut ::std::os::raw::c_void, buffer: *mut JanetBuffer),
>,
pub compare: ::std::option::Option<
unsafe extern "C" fn(
lhs: *mut ::std::os::raw::c_void,
rhs: *mut ::std::os::raw::c_void,
) -> ::std::os::raw::c_int,
>,
pub hash: ::std::option::Option<
unsafe extern "C" fn(p: *mut ::std::os::raw::c_void, len: size_t) -> i32,
>,
pub next: ::std::option::Option<
unsafe extern "C" fn(p: *mut ::std::os::raw::c_void, key: Janet) -> Janet,
>,
pub call: ::std::option::Option<
unsafe extern "C" fn(p: *mut ::std::os::raw::c_void, argc: i32, argv: *mut Janet) -> Janet,
>,
}
#[test]
fn bindgen_test_layout_JanetAbstractType() {
assert_eq!(
::std::mem::size_of::<JanetAbstractType>(),
96usize,
concat!("Size of: ", stringify!(JanetAbstractType))
);
assert_eq!(
::std::mem::align_of::<JanetAbstractType>(),
8usize,
concat!("Alignment of ", stringify!(JanetAbstractType))
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<JanetAbstractType>())).name as *const _ as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(JanetAbstractType),
"::",
stringify!(name)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<JanetAbstractType>())).gc as *const _ as usize },
8usize,
concat!(
"Offset of field: ",
stringify!(JanetAbstractType),
"::",
stringify!(gc)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<JanetAbstractType>())).gcmark as *const _ as usize },
16usize,
concat!(
"Offset of field: ",
stringify!(JanetAbstractType),
"::",
stringify!(gcmark)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<JanetAbstractType>())).get as *const _ as usize },
24usize,
concat!(
"Offset of field: ",
stringify!(JanetAbstractType),
"::",
stringify!(get)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<JanetAbstractType>())).put as *const _ as usize },
32usize,
concat!(
"Offset of field: ",
stringify!(JanetAbstractType),
"::",
stringify!(put)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<JanetAbstractType>())).marshal as *const _ as usize },
40usize,
concat!(
"Offset of field: ",
stringify!(JanetAbstractType),
"::",
stringify!(marshal)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<JanetAbstractType>())).unmarshal as *const _ as usize },
48usize,
concat!(
"Offset of field: ",
stringify!(JanetAbstractType),
"::",
stringify!(unmarshal)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<JanetAbstractType>())).tostring as *const _ as usize },
56usize,
concat!(
"Offset of field: ",
stringify!(JanetAbstractType),
"::",
stringify!(tostring)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<JanetAbstractType>())).compare as *const _ as usize },
64usize,
concat!(
"Offset of field: ",
stringify!(JanetAbstractType),
"::",
stringify!(compare)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<JanetAbstractType>())).hash as *const _ as usize },
72usize,
concat!(
"Offset of field: ",
stringify!(JanetAbstractType),
"::",
stringify!(hash)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<JanetAbstractType>())).next as *const _ as usize },
80usize,
concat!(
"Offset of field: ",
stringify!(JanetAbstractType),
"::",
stringify!(next)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<JanetAbstractType>())).call as *const _ as usize },
88usize,
concat!(
"Offset of field: ",
stringify!(JanetAbstractType),
"::",
stringify!(call)
)
);
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct JanetReg {
pub name: *const ::std::os::raw::c_char,
pub cfun: JanetCFunction,
pub documentation: *const ::std::os::raw::c_char,
}
#[test]
fn bindgen_test_layout_JanetReg() {
assert_eq!(
::std::mem::size_of::<JanetReg>(),
24usize,
concat!("Size of: ", stringify!(JanetReg))
);
assert_eq!(
::std::mem::align_of::<JanetReg>(),
8usize,
concat!("Alignment of ", stringify!(JanetReg))
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<JanetReg>())).name as *const _ as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(JanetReg),
"::",
stringify!(name)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<JanetReg>())).cfun as *const _ as usize },
8usize,
concat!(
"Offset of field: ",
stringify!(JanetReg),
"::",
stringify!(cfun)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<JanetReg>())).documentation as *const _ as usize },
16usize,
concat!(
"Offset of field: ",
stringify!(JanetReg),
"::",
stringify!(documentation)
)
);
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct JanetMethod {
pub name: *const ::std::os::raw::c_char,
pub cfun: JanetCFunction,
}
#[test]
fn bindgen_test_layout_JanetMethod() {
assert_eq!(
::std::mem::size_of::<JanetMethod>(),
16usize,
concat!("Size of: ", stringify!(JanetMethod))
);
assert_eq!(
::std::mem::align_of::<JanetMethod>(),
8usize,
concat!("Alignment of ", stringify!(JanetMethod))
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<JanetMethod>())).name as *const _ as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(JanetMethod),
"::",
stringify!(name)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<JanetMethod>())).cfun as *const _ as usize },
8usize,
concat!(
"Offset of field: ",
stringify!(JanetMethod),
"::",
stringify!(cfun)
)
);
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct JanetView {
pub items: *const Janet,
pub len: i32,
}
#[test]
fn bindgen_test_layout_JanetView() {
assert_eq!(
::std::mem::size_of::<JanetView>(),
16usize,
concat!("Size of: ", stringify!(JanetView))
);
assert_eq!(
::std::mem::align_of::<JanetView>(),
8usize,
concat!("Alignment of ", stringify!(JanetView))
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<JanetView>())).items as *const _ as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(JanetView),
"::",
stringify!(items)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<JanetView>())).len as *const _ as usize },
8usize,
concat!(
"Offset of field: ",
stringify!(JanetView),
"::",
stringify!(len)
)
);
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct JanetByteView {
pub bytes: *const u8,
pub len: i32,
}
#[test]
fn bindgen_test_layout_JanetByteView() {
assert_eq!(
::std::mem::size_of::<JanetByteView>(),
16usize,
concat!("Size of: ", stringify!(JanetByteView))
);
assert_eq!(
::std::mem::align_of::<JanetByteView>(),
8usize,
concat!("Alignment of ", stringify!(JanetByteView))
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<JanetByteView>())).bytes as *const _ as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(JanetByteView),
"::",
stringify!(bytes)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<JanetByteView>())).len as *const _ as usize },
8usize,
concat!(
"Offset of field: ",
stringify!(JanetByteView),
"::",
stringify!(len)
)
);
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct JanetDictView {
pub kvs: *const JanetKV,
pub len: i32,
pub cap: i32,
}
#[test]
fn bindgen_test_layout_JanetDictView() {
assert_eq!(
::std::mem::size_of::<JanetDictView>(),
16usize,
concat!("Size of: ", stringify!(JanetDictView))
);
assert_eq!(
::std::mem::align_of::<JanetDictView>(),
8usize,
concat!("Alignment of ", stringify!(JanetDictView))
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<JanetDictView>())).kvs as *const _ as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(JanetDictView),
"::",
stringify!(kvs)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<JanetDictView>())).len as *const _ as usize },
8usize,
concat!(
"Offset of field: ",
stringify!(JanetDictView),
"::",
stringify!(len)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<JanetDictView>())).cap as *const _ as usize },
12usize,
concat!(
"Offset of field: ",
stringify!(JanetDictView),
"::",
stringify!(cap)
)
);
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct JanetRange {
pub start: i32,
pub end: i32,
}
#[test]
fn bindgen_test_layout_JanetRange() {
assert_eq!(
::std::mem::size_of::<JanetRange>(),
8usize,
concat!("Size of: ", stringify!(JanetRange))
);
assert_eq!(
::std::mem::align_of::<JanetRange>(),
4usize,
concat!("Alignment of ", stringify!(JanetRange))
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<JanetRange>())).start as *const _ as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(JanetRange),
"::",
stringify!(start)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<JanetRange>())).end as *const _ as usize },
4usize,
concat!(
"Offset of field: ",
stringify!(JanetRange),
"::",
stringify!(end)
)
);
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct JanetRNG {
pub a: u32,
pub b: u32,
pub c: u32,
pub d: u32,
pub counter: u32,
}
#[test]
fn bindgen_test_layout_JanetRNG() {
assert_eq!(
::std::mem::size_of::<JanetRNG>(),
20usize,
concat!("Size of: ", stringify!(JanetRNG))
);
assert_eq!(
::std::mem::align_of::<JanetRNG>(),
4usize,
concat!("Alignment of ", stringify!(JanetRNG))
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<JanetRNG>())).a as *const _ as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(JanetRNG),
"::",
stringify!(a)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<JanetRNG>())).b as *const _ as usize },
4usize,
concat!(
"Offset of field: ",
stringify!(JanetRNG),
"::",
stringify!(b)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<JanetRNG>())).c as *const _ as usize },
8usize,
concat!(
"Offset of field: ",
stringify!(JanetRNG),
"::",
stringify!(c)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<JanetRNG>())).d as *const _ as usize },
12usize,
concat!(
"Offset of field: ",
stringify!(JanetRNG),
"::",
stringify!(d)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<JanetRNG>())).counter as *const _ as usize },
16usize,
concat!(
"Offset of field: ",
stringify!(JanetRNG),
"::",
stringify!(counter)
)
);
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct JanetFile {
pub file: *mut FILE,
pub flags: i32,
}
#[test]
fn bindgen_test_layout_JanetFile() {
assert_eq!(
::std::mem::size_of::<JanetFile>(),
16usize,
concat!("Size of: ", stringify!(JanetFile))
);
assert_eq!(
::std::mem::align_of::<JanetFile>(),
8usize,
concat!("Alignment of ", stringify!(JanetFile))
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<JanetFile>())).file as *const _ as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(JanetFile),
"::",
stringify!(file)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<JanetFile>())).flags as *const _ as usize },
8usize,
concat!(
"Offset of field: ",
stringify!(JanetFile),
"::",
stringify!(flags)
)
);
}
#[repr(C)]
#[derive(Copy, Clone)]
pub struct JanetTryState {
pub stackn: i32,
pub gc_handle: ::std::os::raw::c_int,
pub vm_fiber: *mut JanetFiber,
pub vm_jmp_buf: *mut jmp_buf,
pub vm_return_reg: *mut Janet,
pub buf: jmp_buf,
pub payload: Janet,
}
#[test]
fn bindgen_test_layout_JanetTryState() {
assert_eq!(
::std::mem::size_of::<JanetTryState>(),
240usize,
concat!("Size of: ", stringify!(JanetTryState))
);
assert_eq!(
::std::mem::align_of::<JanetTryState>(),
8usize,
concat!("Alignment of ", stringify!(JanetTryState))
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<JanetTryState>())).stackn as *const _ as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(JanetTryState),
"::",
stringify!(stackn)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<JanetTryState>())).gc_handle as *const _ as usize },
4usize,
concat!(
"Offset of field: ",
stringify!(JanetTryState),
"::",
stringify!(gc_handle)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<JanetTryState>())).vm_fiber as *const _ as usize },
8usize,
concat!(
"Offset of field: ",
stringify!(JanetTryState),
"::",
stringify!(vm_fiber)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<JanetTryState>())).vm_jmp_buf as *const _ as usize },
16usize,
concat!(
"Offset of field: ",
stringify!(JanetTryState),
"::",
stringify!(vm_jmp_buf)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<JanetTryState>())).vm_return_reg as *const _ as usize },
24usize,
concat!(
"Offset of field: ",
stringify!(JanetTryState),
"::",
stringify!(vm_return_reg)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<JanetTryState>())).buf as *const _ as usize },
32usize,
concat!(
"Offset of field: ",
stringify!(JanetTryState),
"::",
stringify!(buf)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<JanetTryState>())).payload as *const _ as usize },
232usize,
concat!(
"Offset of field: ",
stringify!(JanetTryState),
"::",
stringify!(payload)
)
);
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct JanetMailbox {
_unused: [u8; 0],
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct JanetThread {
pub mailbox: *mut JanetMailbox,
pub encode: *mut JanetTable,
}
#[test]
fn bindgen_test_layout_JanetThread() {
assert_eq!(
::std::mem::size_of::<JanetThread>(),
16usize,
concat!("Size of: ", stringify!(JanetThread))
);
assert_eq!(
::std::mem::align_of::<JanetThread>(),
8usize,
concat!("Alignment of ", stringify!(JanetThread))
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<JanetThread>())).mailbox as *const _ as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(JanetThread),
"::",
stringify!(mailbox)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<JanetThread>())).encode as *const _ as usize },
8usize,
concat!(
"Offset of field: ",
stringify!(JanetThread),
"::",
stringify!(encode)
)
);
}
pub const JanetOpArgType_JANET_OAT_SLOT: JanetOpArgType = 0;
pub const JanetOpArgType_JANET_OAT_ENVIRONMENT: JanetOpArgType = 1;
pub const JanetOpArgType_JANET_OAT_CONSTANT: JanetOpArgType = 2;
pub const JanetOpArgType_JANET_OAT_INTEGER: JanetOpArgType = 3;
pub const JanetOpArgType_JANET_OAT_TYPE: JanetOpArgType = 4;
pub const JanetOpArgType_JANET_OAT_SIMPLETYPE: JanetOpArgType = 5;
pub const JanetOpArgType_JANET_OAT_LABEL: JanetOpArgType = 6;
pub const JanetOpArgType_JANET_OAT_FUNCDEF: JanetOpArgType = 7;
#[doc = " START SECTION OPCODES"]
pub type JanetOpArgType = ::std::os::raw::c_uint;
pub const JanetInstructionType_JINT_0: JanetInstructionType = 0;
pub const JanetInstructionType_JINT_S: JanetInstructionType = 1;
pub const JanetInstructionType_JINT_L: JanetInstructionType = 2;
pub const JanetInstructionType_JINT_SS: JanetInstructionType = 3;
pub const JanetInstructionType_JINT_SL: JanetInstructionType = 4;
pub const JanetInstructionType_JINT_ST: JanetInstructionType = 5;
pub const JanetInstructionType_JINT_SI: JanetInstructionType = 6;
pub const JanetInstructionType_JINT_SD: JanetInstructionType = 7;
pub const JanetInstructionType_JINT_SU: JanetInstructionType = 8;
pub const JanetInstructionType_JINT_SSS: JanetInstructionType = 9;
pub const JanetInstructionType_JINT_SSI: JanetInstructionType = 10;
pub const JanetInstructionType_JINT_SSU: JanetInstructionType = 11;
pub const JanetInstructionType_JINT_SES: JanetInstructionType = 12;
pub const JanetInstructionType_JINT_SC: JanetInstructionType = 13;
pub type JanetInstructionType = ::std::os::raw::c_uint;
pub const JanetOpCode_JOP_NOOP: JanetOpCode = 0;
pub const JanetOpCode_JOP_ERROR: JanetOpCode = 1;
pub const JanetOpCode_JOP_TYPECHECK: JanetOpCode = 2;
pub const JanetOpCode_JOP_RETURN: JanetOpCode = 3;
pub const JanetOpCode_JOP_RETURN_NIL: JanetOpCode = 4;
pub const JanetOpCode_JOP_ADD_IMMEDIATE: JanetOpCode = 5;
pub const JanetOpCode_JOP_ADD: JanetOpCode = 6;
pub const JanetOpCode_JOP_SUBTRACT: JanetOpCode = 7;
pub const JanetOpCode_JOP_MULTIPLY_IMMEDIATE: JanetOpCode = 8;
pub const JanetOpCode_JOP_MULTIPLY: JanetOpCode = 9;
pub const JanetOpCode_JOP_DIVIDE_IMMEDIATE: JanetOpCode = 10;
pub const JanetOpCode_JOP_DIVIDE: JanetOpCode = 11;
pub const JanetOpCode_JOP_MODULO: JanetOpCode = 12;
pub const JanetOpCode_JOP_REMAINDER: JanetOpCode = 13;
pub const JanetOpCode_JOP_BAND: JanetOpCode = 14;
pub const JanetOpCode_JOP_BOR: JanetOpCode = 15;
pub const JanetOpCode_JOP_BXOR: JanetOpCode = 16;
pub const JanetOpCode_JOP_BNOT: JanetOpCode = 17;
pub const JanetOpCode_JOP_SHIFT_LEFT: JanetOpCode = 18;
pub const JanetOpCode_JOP_SHIFT_LEFT_IMMEDIATE: JanetOpCode = 19;
pub const JanetOpCode_JOP_SHIFT_RIGHT: JanetOpCode = 20;
pub const JanetOpCode_JOP_SHIFT_RIGHT_IMMEDIATE: JanetOpCode = 21;
pub const JanetOpCode_JOP_SHIFT_RIGHT_UNSIGNED: JanetOpCode = 22;
pub const JanetOpCode_JOP_SHIFT_RIGHT_UNSIGNED_IMMEDIATE: JanetOpCode = 23;
pub const JanetOpCode_JOP_MOVE_FAR: JanetOpCode = 24;
pub const JanetOpCode_JOP_MOVE_NEAR: JanetOpCode = 25;
pub const JanetOpCode_JOP_JUMP: JanetOpCode = 26;
pub const JanetOpCode_JOP_JUMP_IF: JanetOpCode = 27;
pub const JanetOpCode_JOP_JUMP_IF_NOT: JanetOpCode = 28;
pub const JanetOpCode_JOP_JUMP_IF_NIL: JanetOpCode = 29;
pub const JanetOpCode_JOP_JUMP_IF_NOT_NIL: JanetOpCode = 30;
pub const JanetOpCode_JOP_GREATER_THAN: JanetOpCode = 31;
pub const JanetOpCode_JOP_GREATER_THAN_IMMEDIATE: JanetOpCode = 32;
pub const JanetOpCode_JOP_LESS_THAN: JanetOpCode = 33;
pub const JanetOpCode_JOP_LESS_THAN_IMMEDIATE: JanetOpCode = 34;
pub const JanetOpCode_JOP_EQUALS: JanetOpCode = 35;
pub const JanetOpCode_JOP_EQUALS_IMMEDIATE: JanetOpCode = 36;
pub const JanetOpCode_JOP_COMPARE: JanetOpCode = 37;
pub const JanetOpCode_JOP_LOAD_NIL: JanetOpCode = 38;
pub const JanetOpCode_JOP_LOAD_TRUE: JanetOpCode = 39;
pub const JanetOpCode_JOP_LOAD_FALSE: JanetOpCode = 40;
pub const JanetOpCode_JOP_LOAD_INTEGER: JanetOpCode = 41;
pub const JanetOpCode_JOP_LOAD_CONSTANT: JanetOpCode = 42;
pub const JanetOpCode_JOP_LOAD_UPVALUE: JanetOpCode = 43;
pub const JanetOpCode_JOP_LOAD_SELF: JanetOpCode = 44;
pub const JanetOpCode_JOP_SET_UPVALUE: JanetOpCode = 45;
pub const JanetOpCode_JOP_CLOSURE: JanetOpCode = 46;
pub const JanetOpCode_JOP_PUSH: JanetOpCode = 47;
pub const JanetOpCode_JOP_PUSH_2: JanetOpCode = 48;
pub const JanetOpCode_JOP_PUSH_3: JanetOpCode = 49;
pub const JanetOpCode_JOP_PUSH_ARRAY: JanetOpCode = 50;
pub const JanetOpCode_JOP_CALL: JanetOpCode = 51;
pub const JanetOpCode_JOP_TAILCALL: JanetOpCode = 52;
pub const JanetOpCode_JOP_RESUME: JanetOpCode = 53;
pub const JanetOpCode_JOP_SIGNAL: JanetOpCode = 54;
pub const JanetOpCode_JOP_PROPAGATE: JanetOpCode = 55;
pub const JanetOpCode_JOP_IN: JanetOpCode = 56;
pub const JanetOpCode_JOP_GET: JanetOpCode = 57;
pub const JanetOpCode_JOP_PUT: JanetOpCode = 58;
pub const JanetOpCode_JOP_GET_INDEX: JanetOpCode = 59;
pub const JanetOpCode_JOP_PUT_INDEX: JanetOpCode = 60;
pub const JanetOpCode_JOP_LENGTH: JanetOpCode = 61;
pub const JanetOpCode_JOP_MAKE_ARRAY: JanetOpCode = 62;
pub const JanetOpCode_JOP_MAKE_BUFFER: JanetOpCode = 63;
pub const JanetOpCode_JOP_MAKE_STRING: JanetOpCode = 64;
pub const JanetOpCode_JOP_MAKE_STRUCT: JanetOpCode = 65;
pub const JanetOpCode_JOP_MAKE_TABLE: JanetOpCode = 66;
pub const JanetOpCode_JOP_MAKE_TUPLE: JanetOpCode = 67;
pub const JanetOpCode_JOP_MAKE_BRACKET_TUPLE: JanetOpCode = 68;
pub const JanetOpCode_JOP_GREATER_THAN_EQUAL: JanetOpCode = 69;
pub const JanetOpCode_JOP_LESS_THAN_EQUAL: JanetOpCode = 70;
pub const JanetOpCode_JOP_NEXT: JanetOpCode = 71;
pub const JanetOpCode_JOP_NOT_EQUALS: JanetOpCode = 72;
pub const JanetOpCode_JOP_NOT_EQUALS_IMMEDIATE: JanetOpCode = 73;
pub const JanetOpCode_JOP_CANCEL: JanetOpCode = 74;
pub const JanetOpCode_JOP_INSTRUCTION_COUNT: JanetOpCode = 75;
pub type JanetOpCode = ::std::os::raw::c_uint;
extern "C" {
pub static mut janet_instructions: [JanetInstructionType; 75usize];
}
extern "C" {
pub static janet_stream_type: JanetAbstractType;
}
extern "C" {
pub fn janet_loop();
}
extern "C" {
pub fn janet_stream(
handle: JanetHandle,
flags: u32,
methods: *const JanetMethod,
) -> *mut JanetStream;
}
extern "C" {
pub fn janet_stream_close(stream: *mut JanetStream);
}
extern "C" {
pub fn janet_cfun_stream_close(argc: i32, argv: *mut Janet) -> Janet;
}
extern "C" {
pub fn janet_cfun_stream_read(argc: i32, argv: *mut Janet) -> Janet;
}
extern "C" {
pub fn janet_cfun_stream_chunk(argc: i32, argv: *mut Janet) -> Janet;
}
extern "C" {
pub fn janet_cfun_stream_write(argc: i32, argv: *mut Janet) -> Janet;
}
extern "C" {
pub fn janet_stream_flags(stream: *mut JanetStream, flags: u32);
}
extern "C" {
pub fn janet_schedule(fiber: *mut JanetFiber, value: Janet);
}
extern "C" {
pub fn janet_cancel(fiber: *mut JanetFiber, value: Janet);
}
extern "C" {
pub fn janet_schedule_signal(fiber: *mut JanetFiber, value: Janet, sig: JanetSignal);
}
extern "C" {
pub fn janet_listen(
stream: *mut JanetStream,
behavior: JanetListener,
mask: ::std::os::raw::c_int,
size: size_t,
user: *mut ::std::os::raw::c_void,
) -> *mut JanetListenerState;
}
extern "C" {
pub fn janet_await();
}
extern "C" {
pub fn janet_addtimeout(sec: f64);
}
extern "C" {
pub fn janet_ev_lasterr() -> Janet;
}
extern "C" {
pub fn janet_ev_read(stream: *mut JanetStream, buf: *mut JanetBuffer, nbytes: i32);
}
extern "C" {
pub fn janet_ev_readchunk(stream: *mut JanetStream, buf: *mut JanetBuffer, nbytes: i32);
}
extern "C" {
pub fn janet_ev_recv(
stream: *mut JanetStream,
buf: *mut JanetBuffer,
nbytes: i32,
flags: ::std::os::raw::c_int,
);
}
extern "C" {
pub fn janet_ev_recvchunk(
stream: *mut JanetStream,
buf: *mut JanetBuffer,
nbytes: i32,
flags: ::std::os::raw::c_int,
);
}
extern "C" {
pub fn janet_ev_recvfrom(
stream: *mut JanetStream,
buf: *mut JanetBuffer,
nbytes: i32,
flags: ::std::os::raw::c_int,
);
}
extern "C" {
pub fn janet_ev_write_buffer(stream: *mut JanetStream, buf: *mut JanetBuffer);
}
extern "C" {
pub fn janet_ev_write_string(stream: *mut JanetStream, str_: JanetString);
}
extern "C" {
pub fn janet_ev_send_buffer(
stream: *mut JanetStream,
buf: *mut JanetBuffer,
flags: ::std::os::raw::c_int,
);
}
extern "C" {
pub fn janet_ev_send_string(
stream: *mut JanetStream,
str_: JanetString,
flags: ::std::os::raw::c_int,
);
}
extern "C" {
pub fn janet_ev_sendto_buffer(
stream: *mut JanetStream,
buf: *mut JanetBuffer,
dest: *mut ::std::os::raw::c_void,
flags: ::std::os::raw::c_int,
);
}
extern "C" {
pub fn janet_ev_sendto_string(
stream: *mut JanetStream,
str_: JanetString,
dest: *mut ::std::os::raw::c_void,
flags: ::std::os::raw::c_int,
);
}
extern "C" {
pub static janet_parser_type: JanetAbstractType;
}
extern "C" {
pub fn janet_parser_init(parser: *mut JanetParser);
}
extern "C" {
pub fn janet_parser_deinit(parser: *mut JanetParser);
}
extern "C" {
pub fn janet_parser_consume(parser: *mut JanetParser, c: u8);
}
extern "C" {
pub fn janet_parser_status(parser: *mut JanetParser) -> JanetParserStatus;
}
extern "C" {
pub fn janet_parser_produce(parser: *mut JanetParser) -> Janet;
}
extern "C" {
pub fn janet_parser_error(parser: *mut JanetParser) -> *const ::std::os::raw::c_char;
}
extern "C" {
pub fn janet_parser_flush(parser: *mut JanetParser);
}
extern "C" {
pub fn janet_parser_eof(parser: *mut JanetParser);
}
extern "C" {
pub fn janet_parser_has_more(parser: *mut JanetParser) -> ::std::os::raw::c_int;
}
pub const JanetAssembleStatus_JANET_ASSEMBLE_OK: JanetAssembleStatus = 0;
pub const JanetAssembleStatus_JANET_ASSEMBLE_ERROR: JanetAssembleStatus = 1;
pub type JanetAssembleStatus = ::std::os::raw::c_uint;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct JanetAssembleResult {
pub funcdef: *mut JanetFuncDef,
pub error: JanetString,
pub status: JanetAssembleStatus,
}
#[test]
fn bindgen_test_layout_JanetAssembleResult() {
assert_eq!(
::std::mem::size_of::<JanetAssembleResult>(),
24usize,
concat!("Size of: ", stringify!(JanetAssembleResult))
);
assert_eq!(
::std::mem::align_of::<JanetAssembleResult>(),
8usize,
concat!("Alignment of ", stringify!(JanetAssembleResult))
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<JanetAssembleResult>())).funcdef as *const _ as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(JanetAssembleResult),
"::",
stringify!(funcdef)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<JanetAssembleResult>())).error as *const _ as usize },
8usize,
concat!(
"Offset of field: ",
stringify!(JanetAssembleResult),
"::",
stringify!(error)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<JanetAssembleResult>())).status as *const _ as usize },
16usize,
concat!(
"Offset of field: ",
stringify!(JanetAssembleResult),
"::",
stringify!(status)
)
);
}
extern "C" {
pub fn janet_asm(source: Janet, flags: ::std::os::raw::c_int) -> JanetAssembleResult;
}
extern "C" {
pub fn janet_disasm(def: *mut JanetFuncDef) -> Janet;
}
extern "C" {
pub fn janet_asm_decode_instruction(instr: u32) -> Janet;
}
pub const JanetCompileStatus_JANET_COMPILE_OK: JanetCompileStatus = 0;
pub const JanetCompileStatus_JANET_COMPILE_ERROR: JanetCompileStatus = 1;
pub type JanetCompileStatus = ::std::os::raw::c_uint;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct JanetCompileResult {
pub funcdef: *mut JanetFuncDef,
pub error: JanetString,
pub macrofiber: *mut JanetFiber,
pub error_mapping: JanetSourceMapping,
pub status: JanetCompileStatus,
}
#[test]
fn bindgen_test_layout_JanetCompileResult() {
assert_eq!(
::std::mem::size_of::<JanetCompileResult>(),
40usize,
concat!("Size of: ", stringify!(JanetCompileResult))
);
assert_eq!(
::std::mem::align_of::<JanetCompileResult>(),
8usize,
concat!("Alignment of ", stringify!(JanetCompileResult))
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<JanetCompileResult>())).funcdef as *const _ as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(JanetCompileResult),
"::",
stringify!(funcdef)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<JanetCompileResult>())).error as *const _ as usize },
8usize,
concat!(
"Offset of field: ",
stringify!(JanetCompileResult),
"::",
stringify!(error)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<JanetCompileResult>())).macrofiber as *const _ as usize },
16usize,
concat!(
"Offset of field: ",
stringify!(JanetCompileResult),
"::",
stringify!(macrofiber)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<JanetCompileResult>())).error_mapping as *const _ as usize
},
24usize,
concat!(
"Offset of field: ",
stringify!(JanetCompileResult),
"::",
stringify!(error_mapping)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<JanetCompileResult>())).status as *const _ as usize },
32usize,
concat!(
"Offset of field: ",
stringify!(JanetCompileResult),
"::",
stringify!(status)
)
);
}
extern "C" {
pub fn janet_compile(
source: Janet,
env: *mut JanetTable,
where_: JanetString,
) -> JanetCompileResult;
}
extern "C" {
pub fn janet_core_env(replacements: *mut JanetTable) -> *mut JanetTable;
}
extern "C" {
pub fn janet_dobytes(
env: *mut JanetTable,
bytes: *const u8,
len: i32,
sourcePath: *const ::std::os::raw::c_char,
out: *mut Janet,
) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn janet_dostring(
env: *mut JanetTable,
str_: *const ::std::os::raw::c_char,
sourcePath: *const ::std::os::raw::c_char,
out: *mut Janet,
) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn janet_scan_number(str_: *const u8, len: i32, out: *mut f64) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn janet_scan_int64(str_: *const u8, len: i32, out: *mut i64) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn janet_scan_uint64(str_: *const u8, len: i32, out: *mut u64) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn janet_debug_break(def: *mut JanetFuncDef, pc: i32);
}
extern "C" {
pub fn janet_debug_unbreak(def: *mut JanetFuncDef, pc: i32);
}
extern "C" {
pub fn janet_debug_find(
def_out: *mut *mut JanetFuncDef,
pc_out: *mut i32,
source: JanetString,
line: i32,
column: i32,
);
}
extern "C" {
pub static janet_rng_type: JanetAbstractType;
}
extern "C" {
pub fn janet_default_rng() -> *mut JanetRNG;
}
extern "C" {
pub fn janet_rng_seed(rng: *mut JanetRNG, seed: u32);
}
extern "C" {
pub fn janet_rng_longseed(rng: *mut JanetRNG, bytes: *const u8, len: i32);
}
extern "C" {
pub fn janet_rng_u32(rng: *mut JanetRNG) -> u32;
}
extern "C" {
pub fn janet_array(capacity: i32) -> *mut JanetArray;
}
extern "C" {
pub fn janet_array_n(elements: *const Janet, n: i32) -> *mut JanetArray;
}
extern "C" {
pub fn janet_array_ensure(array: *mut JanetArray, capacity: i32, growth: i32);
}
extern "C" {
pub fn janet_array_setcount(array: *mut JanetArray, count: i32);
}
extern "C" {
pub fn janet_array_push(array: *mut JanetArray, x: Janet);
}
extern "C" {
pub fn janet_array_pop(array: *mut JanetArray) -> Janet;
}
extern "C" {
pub fn janet_array_peek(array: *mut JanetArray) -> Janet;
}
extern "C" {
pub fn janet_buffer(capacity: i32) -> *mut JanetBuffer;
}
extern "C" {
pub fn janet_buffer_init(buffer: *mut JanetBuffer, capacity: i32) -> *mut JanetBuffer;
}
extern "C" {
pub fn janet_buffer_deinit(buffer: *mut JanetBuffer);
}
extern "C" {
pub fn janet_buffer_ensure(buffer: *mut JanetBuffer, capacity: i32, growth: i32);
}
extern "C" {
pub fn janet_buffer_setcount(buffer: *mut JanetBuffer, count: i32);
}
extern "C" {
pub fn janet_buffer_extra(buffer: *mut JanetBuffer, n: i32);
}
extern "C" {
pub fn janet_buffer_push_bytes(buffer: *mut JanetBuffer, string: *const u8, len: i32);
}
extern "C" {
pub fn janet_buffer_push_string(buffer: *mut JanetBuffer, string: JanetString);
}
extern "C" {
pub fn janet_buffer_push_cstring(
buffer: *mut JanetBuffer,
cstring: *const ::std::os::raw::c_char,
);
}
extern "C" {
pub fn janet_buffer_push_u8(buffer: *mut JanetBuffer, x: u8);
}
extern "C" {
pub fn janet_buffer_push_u16(buffer: *mut JanetBuffer, x: u16);
}
extern "C" {
pub fn janet_buffer_push_u32(buffer: *mut JanetBuffer, x: u32);
}
extern "C" {
pub fn janet_buffer_push_u64(buffer: *mut JanetBuffer, x: u64);
}
extern "C" {
pub fn janet_tuple_begin(length: i32) -> *mut Janet;
}
extern "C" {
pub fn janet_tuple_end(tuple: *mut Janet) -> JanetTuple;
}
extern "C" {
pub fn janet_tuple_n(values: *const Janet, n: i32) -> JanetTuple;
}
extern "C" {
pub fn janet_string_begin(length: i32) -> *mut u8;
}
extern "C" {
pub fn janet_string_end(str_: *mut u8) -> JanetString;
}
extern "C" {
pub fn janet_string(buf: *const u8, len: i32) -> JanetString;
}
extern "C" {
pub fn janet_cstring(cstring: *const ::std::os::raw::c_char) -> JanetString;
}
extern "C" {
pub fn janet_string_compare(lhs: JanetString, rhs: JanetString) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn janet_string_equal(lhs: JanetString, rhs: JanetString) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn janet_string_equalconst(
lhs: JanetString,
rhs: *const u8,
rlen: i32,
rhash: i32,
) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn janet_description(x: Janet) -> JanetString;
}
extern "C" {
pub fn janet_to_string(x: Janet) -> JanetString;
}
extern "C" {
pub fn janet_to_string_b(buffer: *mut JanetBuffer, x: Janet);
}
extern "C" {
pub fn janet_description_b(buffer: *mut JanetBuffer, x: Janet);
}
extern "C" {
pub fn janet_formatc(format: *const ::std::os::raw::c_char, ...) -> JanetString;
}
extern "C" {
pub fn janet_formatb(
bufp: *mut JanetBuffer,
format: *const ::std::os::raw::c_char,
...
) -> *mut JanetBuffer;
}
extern "C" {
pub fn janet_formatbv(
bufp: *mut JanetBuffer,
format: *const ::std::os::raw::c_char,
args: *mut __va_list_tag,
);
}
extern "C" {
pub fn janet_symbol(str_: *const u8, len: i32) -> JanetSymbol;
}
extern "C" {
pub fn janet_csymbol(str_: *const ::std::os::raw::c_char) -> JanetSymbol;
}
extern "C" {
pub fn janet_symbol_gen() -> JanetSymbol;
}
extern "C" {
pub fn janet_struct_begin(count: i32) -> *mut JanetKV;
}
extern "C" {
pub fn janet_struct_put(st: *mut JanetKV, key: Janet, value: Janet);
}
extern "C" {
pub fn janet_struct_end(st: *mut JanetKV) -> JanetStruct;
}
extern "C" {
pub fn janet_struct_get(st: JanetStruct, key: Janet) -> Janet;
}
extern "C" {
pub fn janet_struct_to_table(st: JanetStruct) -> *mut JanetTable;
}
extern "C" {
pub fn janet_struct_find(st: JanetStruct, key: Janet) -> *const JanetKV;
}
extern "C" {
pub fn janet_table(capacity: i32) -> *mut JanetTable;
}
extern "C" {
pub fn janet_table_init(table: *mut JanetTable, capacity: i32) -> *mut JanetTable;
}
extern "C" {
pub fn janet_table_deinit(table: *mut JanetTable);
}
extern "C" {
pub fn janet_table_get(t: *mut JanetTable, key: Janet) -> Janet;
}
extern "C" {
pub fn janet_table_get_ex(t: *mut JanetTable, key: Janet, which: *mut *mut JanetTable)
-> Janet;
}
extern "C" {
pub fn janet_table_rawget(t: *mut JanetTable, key: Janet) -> Janet;
}
extern "C" {
pub fn janet_table_remove(t: *mut JanetTable, key: Janet) -> Janet;
}
extern "C" {
pub fn janet_table_put(t: *mut JanetTable, key: Janet, value: Janet);
}
extern "C" {
pub fn janet_table_to_struct(t: *mut JanetTable) -> JanetStruct;
}
extern "C" {
pub fn janet_table_merge_table(table: *mut JanetTable, other: *mut JanetTable);
}
extern "C" {
pub fn janet_table_merge_struct(table: *mut JanetTable, other: JanetStruct);
}
extern "C" {
pub fn janet_table_find(t: *mut JanetTable, key: Janet) -> *mut JanetKV;
}
extern "C" {
pub fn janet_table_clone(table: *mut JanetTable) -> *mut JanetTable;
}
extern "C" {
pub fn janet_table_clear(table: *mut JanetTable);
}
extern "C" {
pub fn janet_fiber(
callee: *mut JanetFunction,
capacity: i32,
argc: i32,
argv: *const Janet,
) -> *mut JanetFiber;
}
extern "C" {
pub fn janet_fiber_reset(
fiber: *mut JanetFiber,
callee: *mut JanetFunction,
argc: i32,
argv: *const Janet,
) -> *mut JanetFiber;
}
extern "C" {
pub fn janet_fiber_status(fiber: *mut JanetFiber) -> JanetFiberStatus;
}
extern "C" {
pub fn janet_current_fiber() -> *mut JanetFiber;
}
extern "C" {
pub fn janet_root_fiber() -> *mut JanetFiber;
}
extern "C" {
pub fn janet_indexed_view(
seq: Janet,
data: *mut *const Janet,
len: *mut i32,
) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn janet_bytes_view(
str_: Janet,
data: *mut *const u8,
len: *mut i32,
) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn janet_dictionary_view(
tab: Janet,
data: *mut *const JanetKV,
len: *mut i32,
cap: *mut i32,
) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn janet_dictionary_get(data: *const JanetKV, cap: i32, key: Janet) -> Janet;
}
extern "C" {
pub fn janet_dictionary_next(
kvs: *const JanetKV,
cap: i32,
kv: *const JanetKV,
) -> *const JanetKV;
}
extern "C" {
pub fn janet_abstract_begin(
type_: *const JanetAbstractType,
size: size_t,
) -> *mut ::std::os::raw::c_void;
}
extern "C" {
pub fn janet_abstract_end(abstractTemplate: *mut ::std::os::raw::c_void) -> JanetAbstract;
}
extern "C" {
pub fn janet_abstract(type_: *const JanetAbstractType, size: size_t) -> JanetAbstract;
}
pub type JanetModule = ::std::option::Option<unsafe extern "C" fn(arg1: *mut JanetTable)>;
pub type JanetModconf = ::std::option::Option<unsafe extern "C" fn() -> JanetBuildConfig>;
extern "C" {
pub fn janet_native(
name: *const ::std::os::raw::c_char,
error: *mut JanetString,
) -> JanetModule;
}
extern "C" {
pub fn janet_marshal(
buf: *mut JanetBuffer,
x: Janet,
rreg: *mut JanetTable,
flags: ::std::os::raw::c_int,
);
}
extern "C" {
pub fn janet_unmarshal(
bytes: *const u8,
len: size_t,
flags: ::std::os::raw::c_int,
reg: *mut JanetTable,
next: *mut *const u8,
) -> Janet;
}
extern "C" {
pub fn janet_env_lookup(env: *mut JanetTable) -> *mut JanetTable;
}
extern "C" {
pub fn janet_env_lookup_into(
renv: *mut JanetTable,
env: *mut JanetTable,
prefix: *const ::std::os::raw::c_char,
recurse: ::std::os::raw::c_int,
);
}
extern "C" {
pub fn janet_mark(x: Janet);
}
extern "C" {
pub fn janet_sweep();
}
extern "C" {
pub fn janet_collect();
}
extern "C" {
pub fn janet_clear_memory();
}
extern "C" {
pub fn janet_gcroot(root: Janet);
}
extern "C" {
pub fn janet_gcunroot(root: Janet) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn janet_gcunrootall(root: Janet) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn janet_gclock() -> ::std::os::raw::c_int;
}
extern "C" {
pub fn janet_gcunlock(handle: ::std::os::raw::c_int);
}
extern "C" {
pub fn janet_gcpressure(s: size_t);
}
extern "C" {
pub fn janet_funcdef_alloc() -> *mut JanetFuncDef;
}
extern "C" {
pub fn janet_thunk(def: *mut JanetFuncDef) -> *mut JanetFunction;
}
extern "C" {
pub fn janet_verify(def: *mut JanetFuncDef) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn janet_pretty(
buffer: *mut JanetBuffer,
depth: ::std::os::raw::c_int,
flags: ::std::os::raw::c_int,
x: Janet,
) -> *mut JanetBuffer;
}
extern "C" {
pub fn janet_try_init(state: *mut JanetTryState);
}
extern "C" {
pub fn janet_restore(state: *mut JanetTryState);
}
extern "C" {
pub fn janet_equals(x: Janet, y: Janet) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn janet_hash(x: Janet) -> i32;
}
extern "C" {
pub fn janet_compare(x: Janet, y: Janet) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn janet_cstrcmp(
str_: JanetString,
other: *const ::std::os::raw::c_char,
) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn janet_in(ds: Janet, key: Janet) -> Janet;
}
extern "C" {
pub fn janet_get(ds: Janet, key: Janet) -> Janet;
}
extern "C" {
pub fn janet_next(ds: Janet, key: Janet) -> Janet;
}
extern "C" {
pub fn janet_getindex(ds: Janet, index: i32) -> Janet;
}
extern "C" {
pub fn janet_length(x: Janet) -> i32;
}
extern "C" {
pub fn janet_lengthv(x: Janet) -> Janet;
}
extern "C" {
pub fn janet_put(ds: Janet, key: Janet, value: Janet);
}
extern "C" {
pub fn janet_putindex(ds: Janet, index: i32, value: Janet);
}
extern "C" {
pub fn janet_wrap_number_safe(x: f64) -> Janet;
}
extern "C" {
pub fn janet_keyeq(x: Janet, cstring: *const ::std::os::raw::c_char) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn janet_streq(x: Janet, cstring: *const ::std::os::raw::c_char) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn janet_symeq(x: Janet, cstring: *const ::std::os::raw::c_char) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn janet_init() -> ::std::os::raw::c_int;
}
extern "C" {
pub fn janet_deinit();
}
extern "C" {
pub fn janet_continue(fiber: *mut JanetFiber, in_: Janet, out: *mut Janet) -> JanetSignal;
}
extern "C" {
pub fn janet_continue_signal(
fiber: *mut JanetFiber,
in_: Janet,
out: *mut Janet,
sig: JanetSignal,
) -> JanetSignal;
}
extern "C" {
pub fn janet_pcall(
fun: *mut JanetFunction,
argn: i32,
argv: *const Janet,
out: *mut Janet,
f: *mut *mut JanetFiber,
) -> JanetSignal;
}
extern "C" {
pub fn janet_step(fiber: *mut JanetFiber, in_: Janet, out: *mut Janet) -> JanetSignal;
}
extern "C" {
pub fn janet_call(fun: *mut JanetFunction, argc: i32, argv: *const Janet) -> Janet;
}
extern "C" {
pub fn janet_mcall(name: *const ::std::os::raw::c_char, argc: i32, argv: *mut Janet) -> Janet;
}
extern "C" {
pub fn janet_stacktrace(fiber: *mut JanetFiber, err: Janet);
}
pub type JanetScratchFinalizer =
::std::option::Option<unsafe extern "C" fn(arg1: *mut ::std::os::raw::c_void)>;
extern "C" {
pub fn janet_smalloc(size: size_t) -> *mut ::std::os::raw::c_void;
}
extern "C" {
pub fn janet_srealloc(
mem: *mut ::std::os::raw::c_void,
size: size_t,
) -> *mut ::std::os::raw::c_void;
}
extern "C" {
pub fn janet_scalloc(nmemb: size_t, size: size_t) -> *mut ::std::os::raw::c_void;
}
extern "C" {
pub fn janet_sfinalizer(mem: *mut ::std::os::raw::c_void, finalizer: JanetScratchFinalizer);
}
extern "C" {
pub fn janet_sfree(mem: *mut ::std::os::raw::c_void);
}
pub const JanetBindingType_JANET_BINDING_NONE: JanetBindingType = 0;
pub const JanetBindingType_JANET_BINDING_DEF: JanetBindingType = 1;
pub const JanetBindingType_JANET_BINDING_VAR: JanetBindingType = 2;
pub const JanetBindingType_JANET_BINDING_MACRO: JanetBindingType = 3;
pub type JanetBindingType = ::std::os::raw::c_uint;
extern "C" {
pub fn janet_def(
env: *mut JanetTable,
name: *const ::std::os::raw::c_char,
val: Janet,
documentation: *const ::std::os::raw::c_char,
);
}
extern "C" {
pub fn janet_var(
env: *mut JanetTable,
name: *const ::std::os::raw::c_char,
val: Janet,
documentation: *const ::std::os::raw::c_char,
);
}
extern "C" {
pub fn janet_cfuns(
env: *mut JanetTable,
regprefix: *const ::std::os::raw::c_char,
cfuns: *const JanetReg,
);
}
extern "C" {
pub fn janet_cfuns_prefix(
env: *mut JanetTable,
regprefix: *const ::std::os::raw::c_char,
cfuns: *const JanetReg,
);
}
extern "C" {
pub fn janet_resolve(
env: *mut JanetTable,
sym: JanetSymbol,
out: *mut Janet,
) -> JanetBindingType;
}
extern "C" {
pub fn janet_register(name: *const ::std::os::raw::c_char, cfun: JanetCFunction);
}
extern "C" {
pub fn janet_resolve_core(name: *const ::std::os::raw::c_char) -> Janet;
}
extern "C" {
pub fn janet_signalv(signal: JanetSignal, message: Janet);
}
extern "C" {
pub fn janet_panicv(message: Janet);
}
extern "C" {
pub fn janet_panic(message: *const ::std::os::raw::c_char);
}
extern "C" {
pub fn janet_panics(message: JanetString);
}
extern "C" {
pub fn janet_panicf(format: *const ::std::os::raw::c_char, ...);
}
extern "C" {
pub fn janet_dynprintf(
name: *const ::std::os::raw::c_char,
dflt_file: *mut FILE,
format: *const ::std::os::raw::c_char,
...
);
}
extern "C" {
pub fn janet_panic_type(x: Janet, n: i32, expected: ::std::os::raw::c_int);
}
extern "C" {
pub fn janet_panic_abstract(x: Janet, n: i32, at: *const JanetAbstractType);
}
extern "C" {
pub fn janet_arity(arity: i32, min: i32, max: i32);
}
extern "C" {
pub fn janet_fixarity(arity: i32, fix: i32);
}
extern "C" {
pub fn janet_getmethod(
method: JanetKeyword,
methods: *const JanetMethod,
out: *mut Janet,
) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn janet_getnumber(argv: *const Janet, n: i32) -> f64;
}
extern "C" {
pub fn janet_getarray(argv: *const Janet, n: i32) -> *mut JanetArray;
}
extern "C" {
pub fn janet_gettuple(argv: *const Janet, n: i32) -> JanetTuple;
}
extern "C" {
pub fn janet_gettable(argv: *const Janet, n: i32) -> *mut JanetTable;
}
extern "C" {
pub fn janet_getstruct(argv: *const Janet, n: i32) -> JanetStruct;
}
extern "C" {
pub fn janet_getstring(argv: *const Janet, n: i32) -> JanetString;
}
extern "C" {
pub fn janet_getcstring(argv: *const Janet, n: i32) -> *const ::std::os::raw::c_char;
}
extern "C" {
pub fn janet_getsymbol(argv: *const Janet, n: i32) -> JanetSymbol;
}
extern "C" {
pub fn janet_getkeyword(argv: *const Janet, n: i32) -> JanetKeyword;
}
extern "C" {
pub fn janet_getbuffer(argv: *const Janet, n: i32) -> *mut JanetBuffer;
}
extern "C" {
pub fn janet_getfiber(argv: *const Janet, n: i32) -> *mut JanetFiber;
}
extern "C" {
pub fn janet_getfunction(argv: *const Janet, n: i32) -> *mut JanetFunction;
}
extern "C" {
pub fn janet_getcfunction(argv: *const Janet, n: i32) -> JanetCFunction;
}
extern "C" {
pub fn janet_getboolean(argv: *const Janet, n: i32) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn janet_getpointer(argv: *const Janet, n: i32) -> *mut ::std::os::raw::c_void;
}
extern "C" {
pub fn janet_getnat(argv: *const Janet, n: i32) -> i32;
}
extern "C" {
pub fn janet_getinteger(argv: *const Janet, n: i32) -> i32;
}
extern "C" {
pub fn janet_getinteger64(argv: *const Janet, n: i32) -> i64;
}
extern "C" {
pub fn janet_getsize(argv: *const Janet, n: i32) -> size_t;
}
extern "C" {
pub fn janet_getindexed(argv: *const Janet, n: i32) -> JanetView;
}
extern "C" {
pub fn janet_getbytes(argv: *const Janet, n: i32) -> JanetByteView;
}
extern "C" {
pub fn janet_getdictionary(argv: *const Janet, n: i32) -> JanetDictView;
}
extern "C" {
pub fn janet_getabstract(
argv: *const Janet,
n: i32,
at: *const JanetAbstractType,
) -> *mut ::std::os::raw::c_void;
}
extern "C" {
pub fn janet_getslice(argc: i32, argv: *const Janet) -> JanetRange;
}
extern "C" {
pub fn janet_gethalfrange(
argv: *const Janet,
n: i32,
length: i32,
which: *const ::std::os::raw::c_char,
) -> i32;
}
extern "C" {
pub fn janet_getargindex(
argv: *const Janet,
n: i32,
length: i32,
which: *const ::std::os::raw::c_char,
) -> i32;
}
extern "C" {
pub fn janet_getflags(argv: *const Janet, n: i32, flags: *const ::std::os::raw::c_char) -> u64;
}
extern "C" {
pub fn janet_optnumber(argv: *const Janet, argc: i32, n: i32, dflt: f64) -> f64;
}
extern "C" {
pub fn janet_opttuple(argv: *const Janet, argc: i32, n: i32, dflt: JanetTuple) -> JanetTuple;
}
extern "C" {
pub fn janet_optstruct(argv: *const Janet, argc: i32, n: i32, dflt: JanetStruct)
-> JanetStruct;
}
extern "C" {
pub fn janet_optstring(argv: *const Janet, argc: i32, n: i32, dflt: JanetString)
-> JanetString;
}
extern "C" {
pub fn janet_optcstring(
argv: *const Janet,
argc: i32,
n: i32,
dflt: *const ::std::os::raw::c_char,
) -> *const ::std::os::raw::c_char;
}
extern "C" {
pub fn janet_optsymbol(argv: *const Janet, argc: i32, n: i32, dflt: JanetString)
-> JanetSymbol;
}
extern "C" {
pub fn janet_optkeyword(
argv: *const Janet,
argc: i32,
n: i32,
dflt: JanetString,
) -> JanetKeyword;
}
extern "C" {
pub fn janet_optfiber(
argv: *const Janet,
argc: i32,
n: i32,
dflt: *mut JanetFiber,
) -> *mut JanetFiber;
}
extern "C" {
pub fn janet_optfunction(
argv: *const Janet,
argc: i32,
n: i32,
dflt: *mut JanetFunction,
) -> *mut JanetFunction;
}
extern "C" {
pub fn janet_optcfunction(
argv: *const Janet,
argc: i32,
n: i32,
dflt: JanetCFunction,
) -> JanetCFunction;
}
extern "C" {
pub fn janet_optboolean(
argv: *const Janet,
argc: i32,
n: i32,
dflt: ::std::os::raw::c_int,
) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn janet_optpointer(
argv: *const Janet,
argc: i32,
n: i32,
dflt: *mut ::std::os::raw::c_void,
) -> *mut ::std::os::raw::c_void;
}
extern "C" {
pub fn janet_optnat(argv: *const Janet, argc: i32, n: i32, dflt: i32) -> i32;
}
extern "C" {
pub fn janet_optinteger(argv: *const Janet, argc: i32, n: i32, dflt: i32) -> i32;
}
extern "C" {
pub fn janet_optinteger64(argv: *const Janet, argc: i32, n: i32, dflt: i64) -> i64;
}
extern "C" {
pub fn janet_optsize(argv: *const Janet, argc: i32, n: i32, dflt: size_t) -> size_t;
}
extern "C" {
pub fn janet_optabstract(
argv: *const Janet,
argc: i32,
n: i32,
at: *const JanetAbstractType,
dflt: JanetAbstract,
) -> JanetAbstract;
}
extern "C" {
pub fn janet_optbuffer(
argv: *const Janet,
argc: i32,
n: i32,
dflt_len: i32,
) -> *mut JanetBuffer;
}
extern "C" {
pub fn janet_opttable(argv: *const Janet, argc: i32, n: i32, dflt_len: i32) -> *mut JanetTable;
}
extern "C" {
pub fn janet_optarray(argv: *const Janet, argc: i32, n: i32, dflt_len: i32) -> *mut JanetArray;
}
extern "C" {
pub fn janet_dyn(name: *const ::std::os::raw::c_char) -> Janet;
}
extern "C" {
pub fn janet_setdyn(name: *const ::std::os::raw::c_char, value: Janet);
}
extern "C" {
pub static janet_file_type: JanetAbstractType;
}
extern "C" {
pub fn janet_makefile(f: *mut FILE, flags: i32) -> Janet;
}
extern "C" {
pub fn janet_makejfile(f: *mut FILE, flags: i32) -> *mut JanetFile;
}
extern "C" {
pub fn janet_getfile(argv: *const Janet, n: i32, flags: *mut i32) -> *mut FILE;
}
extern "C" {
pub fn janet_dynfile(name: *const ::std::os::raw::c_char, def: *mut FILE) -> *mut FILE;
}
extern "C" {
pub fn janet_getjfile(argv: *const Janet, n: i32) -> *mut JanetFile;
}
extern "C" {
pub fn janet_checkfile(j: Janet) -> JanetAbstract;
}
extern "C" {
pub fn janet_unwrapfile(j: Janet, flags: *mut i32) -> *mut FILE;
}
extern "C" {
pub fn janet_cryptorand(out: *mut u8, n: size_t) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn janet_marshal_size(ctx: *mut JanetMarshalContext, value: size_t);
}
extern "C" {
pub fn janet_marshal_int(ctx: *mut JanetMarshalContext, value: i32);
}
extern "C" {
pub fn janet_marshal_int64(ctx: *mut JanetMarshalContext, value: i64);
}
extern "C" {
pub fn janet_marshal_byte(ctx: *mut JanetMarshalContext, value: u8);
}
extern "C" {
pub fn janet_marshal_bytes(ctx: *mut JanetMarshalContext, bytes: *const u8, len: size_t);
}
extern "C" {
pub fn janet_marshal_janet(ctx: *mut JanetMarshalContext, x: Janet);
}
extern "C" {
pub fn janet_marshal_abstract(ctx: *mut JanetMarshalContext, abstract_: JanetAbstract);
}
extern "C" {
pub fn janet_unmarshal_ensure(ctx: *mut JanetMarshalContext, size: size_t);
}
extern "C" {
pub fn janet_unmarshal_size(ctx: *mut JanetMarshalContext) -> size_t;
}
extern "C" {
pub fn janet_unmarshal_int(ctx: *mut JanetMarshalContext) -> i32;
}
extern "C" {
pub fn janet_unmarshal_int64(ctx: *mut JanetMarshalContext) -> i64;
}
extern "C" {
pub fn janet_unmarshal_byte(ctx: *mut JanetMarshalContext) -> u8;
}
extern "C" {
pub fn janet_unmarshal_bytes(ctx: *mut JanetMarshalContext, dest: *mut u8, len: size_t);
}
extern "C" {
pub fn janet_unmarshal_janet(ctx: *mut JanetMarshalContext) -> Janet;
}
extern "C" {
pub fn janet_unmarshal_abstract(ctx: *mut JanetMarshalContext, size: size_t) -> JanetAbstract;
}
extern "C" {
pub fn janet_register_abstract_type(at: *const JanetAbstractType);
}
extern "C" {
pub fn janet_get_abstract_type(key: Janet) -> *const JanetAbstractType;
}
extern "C" {
pub static janet_peg_type: JanetAbstractType;
}
pub const JanetPegOpcod_RULE_LITERAL: JanetPegOpcod = 0;
pub const JanetPegOpcod_RULE_NCHAR: JanetPegOpcod = 1;
pub const JanetPegOpcod_RULE_NOTNCHAR: JanetPegOpcod = 2;
pub const JanetPegOpcod_RULE_RANGE: JanetPegOpcod = 3;
pub const JanetPegOpcod_RULE_SET: JanetPegOpcod = 4;
pub const JanetPegOpcod_RULE_LOOK: JanetPegOpcod = 5;
pub const JanetPegOpcod_RULE_CHOICE: JanetPegOpcod = 6;
pub const JanetPegOpcod_RULE_SEQUENCE: JanetPegOpcod = 7;
pub const JanetPegOpcod_RULE_IF: JanetPegOpcod = 8;
pub const JanetPegOpcod_RULE_IFNOT: JanetPegOpcod = 9;
pub const JanetPegOpcod_RULE_NOT: JanetPegOpcod = 10;
pub const JanetPegOpcod_RULE_BETWEEN: JanetPegOpcod = 11;
pub const JanetPegOpcod_RULE_GETTAG: JanetPegOpcod = 12;
pub const JanetPegOpcod_RULE_CAPTURE: JanetPegOpcod = 13;
pub const JanetPegOpcod_RULE_POSITION: JanetPegOpcod = 14;
pub const JanetPegOpcod_RULE_ARGUMENT: JanetPegOpcod = 15;
pub const JanetPegOpcod_RULE_CONSTANT: JanetPegOpcod = 16;
pub const JanetPegOpcod_RULE_ACCUMULATE: JanetPegOpcod = 17;
pub const JanetPegOpcod_RULE_GROUP: JanetPegOpcod = 18;
pub const JanetPegOpcod_RULE_REPLACE: JanetPegOpcod = 19;
pub const JanetPegOpcod_RULE_MATCHTIME: JanetPegOpcod = 20;
pub const JanetPegOpcod_RULE_ERROR: JanetPegOpcod = 21;
pub const JanetPegOpcod_RULE_DROP: JanetPegOpcod = 22;
pub const JanetPegOpcod_RULE_BACKMATCH: JanetPegOpcod = 23;
pub const JanetPegOpcod_RULE_TO: JanetPegOpcod = 24;
pub const JanetPegOpcod_RULE_THRU: JanetPegOpcod = 25;
pub const JanetPegOpcod_RULE_LENPREFIX: JanetPegOpcod = 26;
pub const JanetPegOpcod_RULE_READINT: JanetPegOpcod = 27;
pub const JanetPegOpcod_RULE_LINE: JanetPegOpcod = 28;
pub const JanetPegOpcod_RULE_COLUMN: JanetPegOpcod = 29;
pub type JanetPegOpcod = ::std::os::raw::c_uint;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct JanetPeg {
pub bytecode: *mut u32,
pub constants: *mut Janet,
pub bytecode_len: size_t,
pub num_constants: u32,
}
#[test]
fn bindgen_test_layout_JanetPeg() {
assert_eq!(
::std::mem::size_of::<JanetPeg>(),
32usize,
concat!("Size of: ", stringify!(JanetPeg))
);
assert_eq!(
::std::mem::align_of::<JanetPeg>(),
8usize,
concat!("Alignment of ", stringify!(JanetPeg))
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<JanetPeg>())).bytecode as *const _ as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(JanetPeg),
"::",
stringify!(bytecode)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<JanetPeg>())).constants as *const _ as usize },
8usize,
concat!(
"Offset of field: ",
stringify!(JanetPeg),
"::",
stringify!(constants)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<JanetPeg>())).bytecode_len as *const _ as usize },
16usize,
concat!(
"Offset of field: ",
stringify!(JanetPeg),
"::",
stringify!(bytecode_len)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<JanetPeg>())).num_constants as *const _ as usize },
24usize,
concat!(
"Offset of field: ",
stringify!(JanetPeg),
"::",
stringify!(num_constants)
)
);
}
extern "C" {
pub static janet_ta_view_type: JanetAbstractType;
}
extern "C" {
pub static janet_ta_buffer_type: JanetAbstractType;
}
pub const JanetTArrayType_JANET_TARRAY_TYPE_U8: JanetTArrayType = 0;
pub const JanetTArrayType_JANET_TARRAY_TYPE_S8: JanetTArrayType = 1;
pub const JanetTArrayType_JANET_TARRAY_TYPE_U16: JanetTArrayType = 2;
pub const JanetTArrayType_JANET_TARRAY_TYPE_S16: JanetTArrayType = 3;
pub const JanetTArrayType_JANET_TARRAY_TYPE_U32: JanetTArrayType = 4;
pub const JanetTArrayType_JANET_TARRAY_TYPE_S32: JanetTArrayType = 5;
pub const JanetTArrayType_JANET_TARRAY_TYPE_U64: JanetTArrayType = 6;
pub const JanetTArrayType_JANET_TARRAY_TYPE_S64: JanetTArrayType = 7;
pub const JanetTArrayType_JANET_TARRAY_TYPE_F32: JanetTArrayType = 8;
pub const JanetTArrayType_JANET_TARRAY_TYPE_F64: JanetTArrayType = 9;
pub type JanetTArrayType = ::std::os::raw::c_uint;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct JanetTArrayBuffer {
pub data: *mut u8,
pub size: size_t,
pub flags: i32,
}
#[test]
fn bindgen_test_layout_JanetTArrayBuffer() {
assert_eq!(
::std::mem::size_of::<JanetTArrayBuffer>(),
24usize,
concat!("Size of: ", stringify!(JanetTArrayBuffer))
);
assert_eq!(
::std::mem::align_of::<JanetTArrayBuffer>(),
8usize,
concat!("Alignment of ", stringify!(JanetTArrayBuffer))
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<JanetTArrayBuffer>())).data as *const _ as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(JanetTArrayBuffer),
"::",
stringify!(data)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<JanetTArrayBuffer>())).size as *const _ as usize },
8usize,
concat!(
"Offset of field: ",
stringify!(JanetTArrayBuffer),
"::",
stringify!(size)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<JanetTArrayBuffer>())).flags as *const _ as usize },
16usize,
concat!(
"Offset of field: ",
stringify!(JanetTArrayBuffer),
"::",
stringify!(flags)
)
);
}
#[repr(C)]
#[derive(Copy, Clone)]
pub struct JanetTArrayView {
pub as_: JanetTArrayView__bindgen_ty_1,
pub buffer: *mut JanetTArrayBuffer,
pub size: size_t,
pub stride: size_t,
pub type_: JanetTArrayType,
}
#[repr(C)]
#[derive(Copy, Clone)]
pub union JanetTArrayView__bindgen_ty_1 {
pub pointer: *mut ::std::os::raw::c_void,
pub u8_: *mut u8,
pub s8: *mut i8,
pub u16_: *mut u16,
pub s16: *mut i16,
pub u32_: *mut u32,
pub s32: *mut i32,
pub u64_: *mut u64,
pub s64: *mut i64,
pub f32_: *mut f32,
pub f64_: *mut f64,
_bindgen_union_align: u64,
}
#[test]
fn bindgen_test_layout_JanetTArrayView__bindgen_ty_1() {
assert_eq!(
::std::mem::size_of::<JanetTArrayView__bindgen_ty_1>(),
8usize,
concat!("Size of: ", stringify!(JanetTArrayView__bindgen_ty_1))
);
assert_eq!(
::std::mem::align_of::<JanetTArrayView__bindgen_ty_1>(),
8usize,
concat!("Alignment of ", stringify!(JanetTArrayView__bindgen_ty_1))
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<JanetTArrayView__bindgen_ty_1>())).pointer as *const _ as usize
},
0usize,
concat!(
"Offset of field: ",
stringify!(JanetTArrayView__bindgen_ty_1),
"::",
stringify!(pointer)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<JanetTArrayView__bindgen_ty_1>())).u8_ as *const _ as usize
},
0usize,
concat!(
"Offset of field: ",
stringify!(JanetTArrayView__bindgen_ty_1),
"::",
stringify!(u8_)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<JanetTArrayView__bindgen_ty_1>())).s8 as *const _ as usize
},
0usize,
concat!(
"Offset of field: ",
stringify!(JanetTArrayView__bindgen_ty_1),
"::",
stringify!(s8)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<JanetTArrayView__bindgen_ty_1>())).u16_ as *const _ as usize
},
0usize,
concat!(
"Offset of field: ",
stringify!(JanetTArrayView__bindgen_ty_1),
"::",
stringify!(u16_)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<JanetTArrayView__bindgen_ty_1>())).s16 as *const _ as usize
},
0usize,
concat!(
"Offset of field: ",
stringify!(JanetTArrayView__bindgen_ty_1),
"::",
stringify!(s16)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<JanetTArrayView__bindgen_ty_1>())).u32_ as *const _ as usize
},
0usize,
concat!(
"Offset of field: ",
stringify!(JanetTArrayView__bindgen_ty_1),
"::",
stringify!(u32_)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<JanetTArrayView__bindgen_ty_1>())).s32 as *const _ as usize
},
0usize,
concat!(
"Offset of field: ",
stringify!(JanetTArrayView__bindgen_ty_1),
"::",
stringify!(s32)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<JanetTArrayView__bindgen_ty_1>())).u64_ as *const _ as usize
},
0usize,
concat!(
"Offset of field: ",
stringify!(JanetTArrayView__bindgen_ty_1),
"::",
stringify!(u64_)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<JanetTArrayView__bindgen_ty_1>())).s64 as *const _ as usize
},
0usize,
concat!(
"Offset of field: ",
stringify!(JanetTArrayView__bindgen_ty_1),
"::",
stringify!(s64)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<JanetTArrayView__bindgen_ty_1>())).f32_ as *const _ as usize
},
0usize,
concat!(
"Offset of field: ",
stringify!(JanetTArrayView__bindgen_ty_1),
"::",
stringify!(f32_)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<JanetTArrayView__bindgen_ty_1>())).f64_ as *const _ as usize
},
0usize,
concat!(
"Offset of field: ",
stringify!(JanetTArrayView__bindgen_ty_1),
"::",
stringify!(f64_)
)
);
}
#[test]
fn bindgen_test_layout_JanetTArrayView() {
assert_eq!(
::std::mem::size_of::<JanetTArrayView>(),
40usize,
concat!("Size of: ", stringify!(JanetTArrayView))
);
assert_eq!(
::std::mem::align_of::<JanetTArrayView>(),
8usize,
concat!("Alignment of ", stringify!(JanetTArrayView))
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<JanetTArrayView>())).as_ as *const _ as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(JanetTArrayView),
"::",
stringify!(as_)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<JanetTArrayView>())).buffer as *const _ as usize },
8usize,
concat!(
"Offset of field: ",
stringify!(JanetTArrayView),
"::",
stringify!(buffer)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<JanetTArrayView>())).size as *const _ as usize },
16usize,
concat!(
"Offset of field: ",
stringify!(JanetTArrayView),
"::",
stringify!(size)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<JanetTArrayView>())).stride as *const _ as usize },
24usize,
concat!(
"Offset of field: ",
stringify!(JanetTArrayView),
"::",
stringify!(stride)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<JanetTArrayView>())).type_ as *const _ as usize },
32usize,
concat!(
"Offset of field: ",
stringify!(JanetTArrayView),
"::",
stringify!(type_)
)
);
}
extern "C" {
pub fn janet_tarray_buffer(size: size_t) -> *mut JanetTArrayBuffer;
}
extern "C" {
pub fn janet_tarray_view(
type_: JanetTArrayType,
size: size_t,
stride: size_t,
offset: size_t,
buffer: *mut JanetTArrayBuffer,
) -> *mut JanetTArrayView;
}
extern "C" {
pub fn janet_is_tarray_view(x: Janet, type_: JanetTArrayType) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn janet_gettarray_buffer(argv: *const Janet, n: i32) -> *mut JanetTArrayBuffer;
}
extern "C" {
pub fn janet_gettarray_view(
argv: *const Janet,
n: i32,
type_: JanetTArrayType,
) -> *mut JanetTArrayView;
}
extern "C" {
pub fn janet_gettarray_any(argv: *const Janet, n: i32) -> *mut JanetTArrayView;
}
extern "C" {
pub static janet_s64_type: JanetAbstractType;
}
extern "C" {
pub static janet_u64_type: JanetAbstractType;
}
pub const JanetIntType_JANET_INT_NONE: JanetIntType = 0;
pub const JanetIntType_JANET_INT_S64: JanetIntType = 1;
pub const JanetIntType_JANET_INT_U64: JanetIntType = 2;
pub type JanetIntType = ::std::os::raw::c_uint;
extern "C" {
pub fn janet_is_int(x: Janet) -> JanetIntType;
}
extern "C" {
pub fn janet_wrap_s64(x: i64) -> Janet;
}
extern "C" {
pub fn janet_wrap_u64(x: u64) -> Janet;
}
extern "C" {
pub fn janet_unwrap_s64(x: Janet) -> i64;
}
extern "C" {
pub fn janet_unwrap_u64(x: Janet) -> u64;
}
extern "C" {
pub static janet_thread_type: JanetAbstractType;
}
extern "C" {
pub fn janet_thread_receive(msg_out: *mut Janet, timeout: f64) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn janet_thread_send(
thread: *mut JanetThread,
msg: Janet,
timeout: f64,
) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn janet_thread_current() -> *mut JanetThread;
}
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)
)
);
}