#[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 = 12;
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.12.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_32: 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_DOUBLE_OFFSET: u32 = 65535;
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_uint;
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_longlong;
pub type __uint64_t = ::std::os::raw::c_ulonglong;
pub type __off_t = ::std::os::raw::c_long;
pub type __off64_t = __int64_t;
pub type va_list = __builtin_va_list;
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(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; 40usize],
}
#[test]
fn bindgen_test_layout__IO_FILE() {
assert_eq!(
::std::mem::size_of::<_IO_FILE>(),
148usize,
concat!("Size of: ", stringify!(_IO_FILE))
);
assert_eq!(
::std::mem::align_of::<_IO_FILE>(),
4usize,
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 },
4usize,
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 },
8usize,
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 },
12usize,
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 },
16usize,
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 },
20usize,
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 },
24usize,
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 },
28usize,
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 },
32usize,
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 },
36usize,
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 },
40usize,
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 },
44usize,
concat!(
"Offset of field: ",
stringify!(_IO_FILE),
"::",
stringify!(_IO_save_end)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_IO_FILE>()))._markers as *const _ as usize },
48usize,
concat!(
"Offset of field: ",
stringify!(_IO_FILE),
"::",
stringify!(_markers)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_IO_FILE>()))._chain as *const _ as usize },
52usize,
concat!(
"Offset of field: ",
stringify!(_IO_FILE),
"::",
stringify!(_chain)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_IO_FILE>()))._fileno as *const _ as usize },
56usize,
concat!(
"Offset of field: ",
stringify!(_IO_FILE),
"::",
stringify!(_fileno)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_IO_FILE>()))._flags2 as *const _ as usize },
60usize,
concat!(
"Offset of field: ",
stringify!(_IO_FILE),
"::",
stringify!(_flags2)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_IO_FILE>()))._old_offset as *const _ as usize },
64usize,
concat!(
"Offset of field: ",
stringify!(_IO_FILE),
"::",
stringify!(_old_offset)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_IO_FILE>()))._cur_column as *const _ as usize },
68usize,
concat!(
"Offset of field: ",
stringify!(_IO_FILE),
"::",
stringify!(_cur_column)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_IO_FILE>()))._vtable_offset as *const _ as usize },
70usize,
concat!(
"Offset of field: ",
stringify!(_IO_FILE),
"::",
stringify!(_vtable_offset)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_IO_FILE>()))._shortbuf as *const _ as usize },
71usize,
concat!(
"Offset of field: ",
stringify!(_IO_FILE),
"::",
stringify!(_shortbuf)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_IO_FILE>()))._lock as *const _ as usize },
72usize,
concat!(
"Offset of field: ",
stringify!(_IO_FILE),
"::",
stringify!(_lock)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_IO_FILE>()))._offset as *const _ as usize },
76usize,
concat!(
"Offset of field: ",
stringify!(_IO_FILE),
"::",
stringify!(_offset)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_IO_FILE>()))._codecvt as *const _ as usize },
84usize,
concat!(
"Offset of field: ",
stringify!(_IO_FILE),
"::",
stringify!(_codecvt)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_IO_FILE>()))._wide_data as *const _ as usize },
88usize,
concat!(
"Offset of field: ",
stringify!(_IO_FILE),
"::",
stringify!(_wide_data)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_IO_FILE>()))._freeres_list as *const _ as usize },
92usize,
concat!(
"Offset of field: ",
stringify!(_IO_FILE),
"::",
stringify!(_freeres_list)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_IO_FILE>()))._freeres_buf as *const _ as usize },
96usize,
concat!(
"Offset of field: ",
stringify!(_IO_FILE),
"::",
stringify!(_freeres_buf)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_IO_FILE>())).__pad5 as *const _ as usize },
100usize,
concat!(
"Offset of field: ",
stringify!(_IO_FILE),
"::",
stringify!(__pad5)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_IO_FILE>()))._mode as *const _ as usize },
104usize,
concat!(
"Offset of field: ",
stringify!(_IO_FILE),
"::",
stringify!(_mode)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_IO_FILE>()))._unused2 as *const _ as usize },
108usize,
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 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 tagged: Janet__bindgen_ty_1,
pub number: f64,
pub u64_: u64,
_bindgen_union_align: [u32; 2usize],
}
#[repr(C)]
#[derive(Copy, Clone)]
pub struct Janet__bindgen_ty_1 {
pub payload: Janet__bindgen_ty_1__bindgen_ty_1,
pub type_: u32,
}
#[repr(C)]
#[derive(Copy, Clone)]
pub union Janet__bindgen_ty_1__bindgen_ty_1 {
pub integer: i32,
pub pointer: *mut ::std::os::raw::c_void,
_bindgen_union_align: u32,
}
#[test]
fn bindgen_test_layout_Janet__bindgen_ty_1__bindgen_ty_1() {
assert_eq!(
::std::mem::size_of::<Janet__bindgen_ty_1__bindgen_ty_1>(),
4usize,
concat!("Size of: ", stringify!(Janet__bindgen_ty_1__bindgen_ty_1))
);
assert_eq!(
::std::mem::align_of::<Janet__bindgen_ty_1__bindgen_ty_1>(),
4usize,
concat!(
"Alignment of ",
stringify!(Janet__bindgen_ty_1__bindgen_ty_1)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<Janet__bindgen_ty_1__bindgen_ty_1>())).integer as *const _
as usize
},
0usize,
concat!(
"Offset of field: ",
stringify!(Janet__bindgen_ty_1__bindgen_ty_1),
"::",
stringify!(integer)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<Janet__bindgen_ty_1__bindgen_ty_1>())).pointer as *const _
as usize
},
0usize,
concat!(
"Offset of field: ",
stringify!(Janet__bindgen_ty_1__bindgen_ty_1),
"::",
stringify!(pointer)
)
);
}
#[test]
fn bindgen_test_layout_Janet__bindgen_ty_1() {
assert_eq!(
::std::mem::size_of::<Janet__bindgen_ty_1>(),
8usize,
concat!("Size of: ", stringify!(Janet__bindgen_ty_1))
);
assert_eq!(
::std::mem::align_of::<Janet__bindgen_ty_1>(),
4usize,
concat!("Alignment of ", stringify!(Janet__bindgen_ty_1))
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<Janet__bindgen_ty_1>())).payload as *const _ as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(Janet__bindgen_ty_1),
"::",
stringify!(payload)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<Janet__bindgen_ty_1>())).type_ as *const _ as usize },
4usize,
concat!(
"Offset of field: ",
stringify!(Janet__bindgen_ty_1),
"::",
stringify!(type_)
)
);
}
#[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>(),
4usize,
concat!("Alignment of ", stringify!(Janet))
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<Janet>())).tagged as *const _ as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(Janet),
"::",
stringify!(tagged)
)
);
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>())).u64_ as *const _ as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(Janet),
"::",
stringify!(u64_)
)
);
}
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;
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_nanbox32_from_tagi(tag: u32, integer: i32) -> Janet;
}
extern "C" {
pub fn janet_nanbox32_from_tagp(tag: u32, pointer: *mut ::std::os::raw::c_void) -> 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>(),
8usize,
concat!("Size of: ", stringify!(JanetGCObject))
);
assert_eq!(
::std::mem::align_of::<JanetGCObject>(),
4usize,
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 },
4usize,
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,
}
#[test]
fn bindgen_test_layout_JanetFiber() {
assert_eq!(
::std::mem::size_of::<JanetFiber>(),
44usize,
concat!("Size of: ", stringify!(JanetFiber))
);
assert_eq!(
::std::mem::align_of::<JanetFiber>(),
4usize,
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 },
8usize,
concat!(
"Offset of field: ",
stringify!(JanetFiber),
"::",
stringify!(flags)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<JanetFiber>())).frame as *const _ as usize },
12usize,
concat!(
"Offset of field: ",
stringify!(JanetFiber),
"::",
stringify!(frame)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<JanetFiber>())).stackstart as *const _ as usize },
16usize,
concat!(
"Offset of field: ",
stringify!(JanetFiber),
"::",
stringify!(stackstart)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<JanetFiber>())).stacktop as *const _ as usize },
20usize,
concat!(
"Offset of field: ",
stringify!(JanetFiber),
"::",
stringify!(stacktop)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<JanetFiber>())).capacity as *const _ as usize },
24usize,
concat!(
"Offset of field: ",
stringify!(JanetFiber),
"::",
stringify!(capacity)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<JanetFiber>())).maxstack as *const _ as usize },
28usize,
concat!(
"Offset of field: ",
stringify!(JanetFiber),
"::",
stringify!(maxstack)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<JanetFiber>())).env as *const _ as usize },
32usize,
concat!(
"Offset of field: ",
stringify!(JanetFiber),
"::",
stringify!(env)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<JanetFiber>())).data as *const _ as usize },
36usize,
concat!(
"Offset of field: ",
stringify!(JanetFiber),
"::",
stringify!(data)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<JanetFiber>())).child as *const _ as usize },
40usize,
concat!(
"Offset of field: ",
stringify!(JanetFiber),
"::",
stringify!(child)
)
);
}
#[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>(),
20usize,
concat!("Size of: ", stringify!(JanetStackFrame))
);
assert_eq!(
::std::mem::align_of::<JanetStackFrame>(),
4usize,
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 },
4usize,
concat!(
"Offset of field: ",
stringify!(JanetStackFrame),
"::",
stringify!(pc)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<JanetStackFrame>())).env as *const _ as usize },
8usize,
concat!(
"Offset of field: ",
stringify!(JanetStackFrame),
"::",
stringify!(env)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<JanetStackFrame>())).prevframe as *const _ as usize },
12usize,
concat!(
"Offset of field: ",
stringify!(JanetStackFrame),
"::",
stringify!(prevframe)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<JanetStackFrame>())).flags as *const _ as usize },
16usize,
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>(),
20usize,
concat!("Size of: ", stringify!(JanetArray))
);
assert_eq!(
::std::mem::align_of::<JanetArray>(),
4usize,
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 },
8usize,
concat!(
"Offset of field: ",
stringify!(JanetArray),
"::",
stringify!(count)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<JanetArray>())).capacity as *const _ as usize },
12usize,
concat!(
"Offset of field: ",
stringify!(JanetArray),
"::",
stringify!(capacity)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<JanetArray>())).data as *const _ as usize },
16usize,
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>(),
20usize,
concat!("Size of: ", stringify!(JanetBuffer))
);
assert_eq!(
::std::mem::align_of::<JanetBuffer>(),
4usize,
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 },
8usize,
concat!(
"Offset of field: ",
stringify!(JanetBuffer),
"::",
stringify!(count)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<JanetBuffer>())).capacity as *const _ as usize },
12usize,
concat!(
"Offset of field: ",
stringify!(JanetBuffer),
"::",
stringify!(capacity)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<JanetBuffer>())).data as *const _ as usize },
16usize,
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>(),
28usize,
concat!("Size of: ", stringify!(JanetTable))
);
assert_eq!(
::std::mem::align_of::<JanetTable>(),
4usize,
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 },
8usize,
concat!(
"Offset of field: ",
stringify!(JanetTable),
"::",
stringify!(count)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<JanetTable>())).capacity as *const _ as usize },
12usize,
concat!(
"Offset of field: ",
stringify!(JanetTable),
"::",
stringify!(capacity)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<JanetTable>())).deleted as *const _ as usize },
16usize,
concat!(
"Offset of field: ",
stringify!(JanetTable),
"::",
stringify!(deleted)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<JanetTable>())).data as *const _ as usize },
20usize,
concat!(
"Offset of field: ",
stringify!(JanetTable),
"::",
stringify!(data)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<JanetTable>())).proto as *const _ as usize },
24usize,
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>(),
4usize,
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>(),
24usize,
concat!("Size of: ", stringify!(JanetTupleHead))
);
assert_eq!(
::std::mem::align_of::<JanetTupleHead>(),
4usize,
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 },
8usize,
concat!(
"Offset of field: ",
stringify!(JanetTupleHead),
"::",
stringify!(length)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<JanetTupleHead>())).hash as *const _ as usize },
12usize,
concat!(
"Offset of field: ",
stringify!(JanetTupleHead),
"::",
stringify!(hash)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<JanetTupleHead>())).sm_line as *const _ as usize },
16usize,
concat!(
"Offset of field: ",
stringify!(JanetTupleHead),
"::",
stringify!(sm_line)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<JanetTupleHead>())).sm_column as *const _ as usize },
20usize,
concat!(
"Offset of field: ",
stringify!(JanetTupleHead),
"::",
stringify!(sm_column)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<JanetTupleHead>())).data as *const _ as usize },
24usize,
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>(),
20usize,
concat!("Size of: ", stringify!(JanetStructHead))
);
assert_eq!(
::std::mem::align_of::<JanetStructHead>(),
4usize,
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 },
8usize,
concat!(
"Offset of field: ",
stringify!(JanetStructHead),
"::",
stringify!(length)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<JanetStructHead>())).hash as *const _ as usize },
12usize,
concat!(
"Offset of field: ",
stringify!(JanetStructHead),
"::",
stringify!(hash)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<JanetStructHead>())).capacity as *const _ as usize },
16usize,
concat!(
"Offset of field: ",
stringify!(JanetStructHead),
"::",
stringify!(capacity)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<JanetStructHead>())).data as *const _ as usize },
20usize,
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>(),
16usize,
concat!("Size of: ", stringify!(JanetStringHead))
);
assert_eq!(
::std::mem::align_of::<JanetStringHead>(),
4usize,
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 },
8usize,
concat!(
"Offset of field: ",
stringify!(JanetStringHead),
"::",
stringify!(length)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<JanetStringHead>())).hash as *const _ as usize },
12usize,
concat!(
"Offset of field: ",
stringify!(JanetStringHead),
"::",
stringify!(hash)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<JanetStringHead>())).data as *const _ as usize },
16usize,
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>(),
16usize,
concat!("Size of: ", stringify!(JanetAbstractHead))
);
assert_eq!(
::std::mem::align_of::<JanetAbstractHead>(),
4usize,
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 },
8usize,
concat!(
"Offset of field: ",
stringify!(JanetAbstractHead),
"::",
stringify!(type_)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<JanetAbstractHead>())).size as *const _ as usize },
12usize,
concat!(
"Offset of field: ",
stringify!(JanetAbstractHead),
"::",
stringify!(size)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<JanetAbstractHead>())).data as *const _ as usize },
16usize,
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>(),
76usize,
concat!("Size of: ", stringify!(JanetFuncDef))
);
assert_eq!(
::std::mem::align_of::<JanetFuncDef>(),
4usize,
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 },
8usize,
concat!(
"Offset of field: ",
stringify!(JanetFuncDef),
"::",
stringify!(environments)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<JanetFuncDef>())).constants as *const _ as usize },
12usize,
concat!(
"Offset of field: ",
stringify!(JanetFuncDef),
"::",
stringify!(constants)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<JanetFuncDef>())).defs as *const _ as usize },
16usize,
concat!(
"Offset of field: ",
stringify!(JanetFuncDef),
"::",
stringify!(defs)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<JanetFuncDef>())).bytecode as *const _ as usize },
20usize,
concat!(
"Offset of field: ",
stringify!(JanetFuncDef),
"::",
stringify!(bytecode)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<JanetFuncDef>())).closure_bitset as *const _ as usize },
24usize,
concat!(
"Offset of field: ",
stringify!(JanetFuncDef),
"::",
stringify!(closure_bitset)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<JanetFuncDef>())).sourcemap as *const _ as usize },
28usize,
concat!(
"Offset of field: ",
stringify!(JanetFuncDef),
"::",
stringify!(sourcemap)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<JanetFuncDef>())).source as *const _ as usize },
32usize,
concat!(
"Offset of field: ",
stringify!(JanetFuncDef),
"::",
stringify!(source)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<JanetFuncDef>())).name as *const _ as usize },
36usize,
concat!(
"Offset of field: ",
stringify!(JanetFuncDef),
"::",
stringify!(name)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<JanetFuncDef>())).flags as *const _ as usize },
40usize,
concat!(
"Offset of field: ",
stringify!(JanetFuncDef),
"::",
stringify!(flags)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<JanetFuncDef>())).slotcount as *const _ as usize },
44usize,
concat!(
"Offset of field: ",
stringify!(JanetFuncDef),
"::",
stringify!(slotcount)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<JanetFuncDef>())).arity as *const _ as usize },
48usize,
concat!(
"Offset of field: ",
stringify!(JanetFuncDef),
"::",
stringify!(arity)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<JanetFuncDef>())).min_arity as *const _ as usize },
52usize,
concat!(
"Offset of field: ",
stringify!(JanetFuncDef),
"::",
stringify!(min_arity)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<JanetFuncDef>())).max_arity as *const _ as usize },
56usize,
concat!(
"Offset of field: ",
stringify!(JanetFuncDef),
"::",
stringify!(max_arity)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<JanetFuncDef>())).constants_length as *const _ as usize },
60usize,
concat!(
"Offset of field: ",
stringify!(JanetFuncDef),
"::",
stringify!(constants_length)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<JanetFuncDef>())).bytecode_length as *const _ as usize },
64usize,
concat!(
"Offset of field: ",
stringify!(JanetFuncDef),
"::",
stringify!(bytecode_length)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<JanetFuncDef>())).environments_length as *const _ as usize
},
68usize,
concat!(
"Offset of field: ",
stringify!(JanetFuncDef),
"::",
stringify!(environments_length)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<JanetFuncDef>())).defs_length as *const _ as usize },
72usize,
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: u32,
}
#[test]
fn bindgen_test_layout_JanetFuncEnv__bindgen_ty_1() {
assert_eq!(
::std::mem::size_of::<JanetFuncEnv__bindgen_ty_1>(),
4usize,
concat!("Size of: ", stringify!(JanetFuncEnv__bindgen_ty_1))
);
assert_eq!(
::std::mem::align_of::<JanetFuncEnv__bindgen_ty_1>(),
4usize,
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>(),
20usize,
concat!("Size of: ", stringify!(JanetFuncEnv))
);
assert_eq!(
::std::mem::align_of::<JanetFuncEnv>(),
4usize,
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 },
8usize,
concat!(
"Offset of field: ",
stringify!(JanetFuncEnv),
"::",
stringify!(as_)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<JanetFuncEnv>())).length as *const _ as usize },
12usize,
concat!(
"Offset of field: ",
stringify!(JanetFuncEnv),
"::",
stringify!(length)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<JanetFuncEnv>())).offset as *const _ as usize },
16usize,
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>(),
12usize,
concat!("Size of: ", stringify!(JanetFunction))
);
assert_eq!(
::std::mem::align_of::<JanetFunction>(),
4usize,
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 },
8usize,
concat!(
"Offset of field: ",
stringify!(JanetFunction),
"::",
stringify!(def)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<JanetFunction>())).envs as *const _ as usize },
12usize,
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>(),
60usize,
concat!("Size of: ", stringify!(JanetParser))
);
assert_eq!(
::std::mem::align_of::<JanetParser>(),
4usize,
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 },
4usize,
concat!(
"Offset of field: ",
stringify!(JanetParser),
"::",
stringify!(error)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<JanetParser>())).states as *const _ as usize },
8usize,
concat!(
"Offset of field: ",
stringify!(JanetParser),
"::",
stringify!(states)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<JanetParser>())).buf as *const _ as usize },
12usize,
concat!(
"Offset of field: ",
stringify!(JanetParser),
"::",
stringify!(buf)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<JanetParser>())).argcount as *const _ as usize },
16usize,
concat!(
"Offset of field: ",
stringify!(JanetParser),
"::",
stringify!(argcount)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<JanetParser>())).argcap as *const _ as usize },
20usize,
concat!(
"Offset of field: ",
stringify!(JanetParser),
"::",
stringify!(argcap)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<JanetParser>())).statecount as *const _ as usize },
24usize,
concat!(
"Offset of field: ",
stringify!(JanetParser),
"::",
stringify!(statecount)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<JanetParser>())).statecap as *const _ as usize },
28usize,
concat!(
"Offset of field: ",
stringify!(JanetParser),
"::",
stringify!(statecap)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<JanetParser>())).bufcount as *const _ as usize },
32usize,
concat!(
"Offset of field: ",
stringify!(JanetParser),
"::",
stringify!(bufcount)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<JanetParser>())).bufcap as *const _ as usize },
36usize,
concat!(
"Offset of field: ",
stringify!(JanetParser),
"::",
stringify!(bufcap)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<JanetParser>())).line as *const _ as usize },
40usize,
concat!(
"Offset of field: ",
stringify!(JanetParser),
"::",
stringify!(line)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<JanetParser>())).column as *const _ as usize },
44usize,
concat!(
"Offset of field: ",
stringify!(JanetParser),
"::",
stringify!(column)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<JanetParser>())).pending as *const _ as usize },
48usize,
concat!(
"Offset of field: ",
stringify!(JanetParser),
"::",
stringify!(pending)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<JanetParser>())).lookback as *const _ as usize },
52usize,
concat!(
"Offset of field: ",
stringify!(JanetParser),
"::",
stringify!(lookback)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<JanetParser>())).flag as *const _ as usize },
56usize,
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>(),
20usize,
concat!("Size of: ", stringify!(JanetMarshalContext))
);
assert_eq!(
::std::mem::align_of::<JanetMarshalContext>(),
4usize,
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 },
4usize,
concat!(
"Offset of field: ",
stringify!(JanetMarshalContext),
"::",
stringify!(u_state)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<JanetMarshalContext>())).flags as *const _ as usize },
8usize,
concat!(
"Offset of field: ",
stringify!(JanetMarshalContext),
"::",
stringify!(flags)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<JanetMarshalContext>())).data as *const _ as usize },
12usize,
concat!(
"Offset of field: ",
stringify!(JanetMarshalContext),
"::",
stringify!(data)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<JanetMarshalContext>())).at as *const _ as usize },
16usize,
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>(),
48usize,
concat!("Size of: ", stringify!(JanetAbstractType))
);
assert_eq!(
::std::mem::align_of::<JanetAbstractType>(),
4usize,
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 },
4usize,
concat!(
"Offset of field: ",
stringify!(JanetAbstractType),
"::",
stringify!(gc)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<JanetAbstractType>())).gcmark as *const _ as usize },
8usize,
concat!(
"Offset of field: ",
stringify!(JanetAbstractType),
"::",
stringify!(gcmark)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<JanetAbstractType>())).get as *const _ as usize },
12usize,
concat!(
"Offset of field: ",
stringify!(JanetAbstractType),
"::",
stringify!(get)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<JanetAbstractType>())).put as *const _ as usize },
16usize,
concat!(
"Offset of field: ",
stringify!(JanetAbstractType),
"::",
stringify!(put)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<JanetAbstractType>())).marshal as *const _ as usize },
20usize,
concat!(
"Offset of field: ",
stringify!(JanetAbstractType),
"::",
stringify!(marshal)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<JanetAbstractType>())).unmarshal as *const _ as usize },
24usize,
concat!(
"Offset of field: ",
stringify!(JanetAbstractType),
"::",
stringify!(unmarshal)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<JanetAbstractType>())).tostring as *const _ as usize },
28usize,
concat!(
"Offset of field: ",
stringify!(JanetAbstractType),
"::",
stringify!(tostring)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<JanetAbstractType>())).compare as *const _ as usize },
32usize,
concat!(
"Offset of field: ",
stringify!(JanetAbstractType),
"::",
stringify!(compare)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<JanetAbstractType>())).hash as *const _ as usize },
36usize,
concat!(
"Offset of field: ",
stringify!(JanetAbstractType),
"::",
stringify!(hash)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<JanetAbstractType>())).next as *const _ as usize },
40usize,
concat!(
"Offset of field: ",
stringify!(JanetAbstractType),
"::",
stringify!(next)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<JanetAbstractType>())).call as *const _ as usize },
44usize,
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>(),
12usize,
concat!("Size of: ", stringify!(JanetReg))
);
assert_eq!(
::std::mem::align_of::<JanetReg>(),
4usize,
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 },
4usize,
concat!(
"Offset of field: ",
stringify!(JanetReg),
"::",
stringify!(cfun)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<JanetReg>())).documentation as *const _ as usize },
8usize,
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>(),
8usize,
concat!("Size of: ", stringify!(JanetMethod))
);
assert_eq!(
::std::mem::align_of::<JanetMethod>(),
4usize,
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 },
4usize,
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>(),
8usize,
concat!("Size of: ", stringify!(JanetView))
);
assert_eq!(
::std::mem::align_of::<JanetView>(),
4usize,
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 },
4usize,
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>(),
8usize,
concat!("Size of: ", stringify!(JanetByteView))
);
assert_eq!(
::std::mem::align_of::<JanetByteView>(),
4usize,
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 },
4usize,
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>(),
12usize,
concat!("Size of: ", stringify!(JanetDictView))
);
assert_eq!(
::std::mem::align_of::<JanetDictView>(),
4usize,
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 },
4usize,
concat!(
"Offset of field: ",
stringify!(JanetDictView),
"::",
stringify!(len)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<JanetDictView>())).cap as *const _ as usize },
8usize,
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>(),
8usize,
concat!("Size of: ", stringify!(JanetFile))
);
assert_eq!(
::std::mem::align_of::<JanetFile>(),
4usize,
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 },
4usize,
concat!(
"Offset of field: ",
stringify!(JanetFile),
"::",
stringify!(flags)
)
);
}
#[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>(),
8usize,
concat!("Size of: ", stringify!(JanetThread))
);
assert_eq!(
::std::mem::align_of::<JanetThread>(),
4usize,
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 },
4usize,
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 fn janet_loop();
}
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>(),
12usize,
concat!("Size of: ", stringify!(JanetAssembleResult))
);
assert_eq!(
::std::mem::align_of::<JanetAssembleResult>(),
4usize,
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 },
4usize,
concat!(
"Offset of field: ",
stringify!(JanetAssembleResult),
"::",
stringify!(error)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<JanetAssembleResult>())).status as *const _ as usize },
8usize,
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>(),
24usize,
concat!("Size of: ", stringify!(JanetCompileResult))
);
assert_eq!(
::std::mem::align_of::<JanetCompileResult>(),
4usize,
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 },
4usize,
concat!(
"Offset of field: ",
stringify!(JanetCompileResult),
"::",
stringify!(error)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<JanetCompileResult>())).macrofiber as *const _ as usize },
8usize,
concat!(
"Offset of field: ",
stringify!(JanetCompileResult),
"::",
stringify!(macrofiber)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<JanetCompileResult>())).error_mapping as *const _ as usize
},
12usize,
concat!(
"Offset of field: ",
stringify!(JanetCompileResult),
"::",
stringify!(error_mapping)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<JanetCompileResult>())).status as *const _ as usize },
20usize,
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: va_list,
);
}
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_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_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 JanetPegOpcode_RULE_LITERAL: JanetPegOpcode = 0;
pub const JanetPegOpcode_RULE_NCHAR: JanetPegOpcode = 1;
pub const JanetPegOpcode_RULE_NOTNCHAR: JanetPegOpcode = 2;
pub const JanetPegOpcode_RULE_RANGE: JanetPegOpcode = 3;
pub const JanetPegOpcode_RULE_SET: JanetPegOpcode = 4;
pub const JanetPegOpcode_RULE_LOOK: JanetPegOpcode = 5;
pub const JanetPegOpcode_RULE_CHOICE: JanetPegOpcode = 6;
pub const JanetPegOpcode_RULE_SEQUENCE: JanetPegOpcode = 7;
pub const JanetPegOpcode_RULE_IF: JanetPegOpcode = 8;
pub const JanetPegOpcode_RULE_IFNOT: JanetPegOpcode = 9;
pub const JanetPegOpcode_RULE_NOT: JanetPegOpcode = 10;
pub const JanetPegOpcode_RULE_BETWEEN: JanetPegOpcode = 11;
pub const JanetPegOpcode_RULE_GETTAG: JanetPegOpcode = 12;
pub const JanetPegOpcode_RULE_CAPTURE: JanetPegOpcode = 13;
pub const JanetPegOpcode_RULE_POSITION: JanetPegOpcode = 14;
pub const JanetPegOpcode_RULE_ARGUMENT: JanetPegOpcode = 15;
pub const JanetPegOpcode_RULE_CONSTANT: JanetPegOpcode = 16;
pub const JanetPegOpcode_RULE_ACCUMULATE: JanetPegOpcode = 17;
pub const JanetPegOpcode_RULE_GROUP: JanetPegOpcode = 18;
pub const JanetPegOpcode_RULE_REPLACE: JanetPegOpcode = 19;
pub const JanetPegOpcode_RULE_MATCHTIME: JanetPegOpcode = 20;
pub const JanetPegOpcode_RULE_ERROR: JanetPegOpcode = 21;
pub const JanetPegOpcode_RULE_DROP: JanetPegOpcode = 22;
pub const JanetPegOpcode_RULE_BACKMATCH: JanetPegOpcode = 23;
pub const JanetPegOpcode_RULE_TO: JanetPegOpcode = 24;
pub const JanetPegOpcode_RULE_THRU: JanetPegOpcode = 25;
pub const JanetPegOpcode_RULE_LENPREFIX: JanetPegOpcode = 26;
pub type JanetPegOpcode = ::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>(),
16usize,
concat!("Size of: ", stringify!(JanetPeg))
);
assert_eq!(
::std::mem::align_of::<JanetPeg>(),
4usize,
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 },
4usize,
concat!(
"Offset of field: ",
stringify!(JanetPeg),
"::",
stringify!(constants)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<JanetPeg>())).bytecode_len as *const _ as usize },
8usize,
concat!(
"Offset of field: ",
stringify!(JanetPeg),
"::",
stringify!(bytecode_len)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<JanetPeg>())).num_constants as *const _ as usize },
12usize,
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>(),
12usize,
concat!("Size of: ", stringify!(JanetTArrayBuffer))
);
assert_eq!(
::std::mem::align_of::<JanetTArrayBuffer>(),
4usize,
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 },
4usize,
concat!(
"Offset of field: ",
stringify!(JanetTArrayBuffer),
"::",
stringify!(size)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<JanetTArrayBuffer>())).flags as *const _ as usize },
8usize,
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: u32,
}
#[test]
fn bindgen_test_layout_JanetTArrayView__bindgen_ty_1() {
assert_eq!(
::std::mem::size_of::<JanetTArrayView__bindgen_ty_1>(),
4usize,
concat!("Size of: ", stringify!(JanetTArrayView__bindgen_ty_1))
);
assert_eq!(
::std::mem::align_of::<JanetTArrayView__bindgen_ty_1>(),
4usize,
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>(),
20usize,
concat!("Size of: ", stringify!(JanetTArrayView))
);
assert_eq!(
::std::mem::align_of::<JanetTArrayView>(),
4usize,
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 },
4usize,
concat!(
"Offset of field: ",
stringify!(JanetTArrayView),
"::",
stringify!(buffer)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<JanetTArrayView>())).size as *const _ as usize },
8usize,
concat!(
"Offset of field: ",
stringify!(JanetTArrayView),
"::",
stringify!(size)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<JanetTArrayView>())).stride as *const _ as usize },
12usize,
concat!(
"Offset of field: ",
stringify!(JanetTArrayView),
"::",
stringify!(stride)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<JanetTArrayView>())).type_ as *const _ as usize },
16usize,
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;
}
pub type __builtin_va_list = *mut ::std::os::raw::c_char;