#[repr(C)]
#[derive(Copy, Clone, Debug, Default, Eq, Hash, Ord, PartialEq, PartialOrd)]
pub struct __BindgenBitfieldUnit<Storage> {
storage: Storage,
}
impl<Storage> __BindgenBitfieldUnit<Storage> {
#[inline]
pub const fn new(storage: Storage) -> Self {
Self { storage }
}
}
impl<Storage> __BindgenBitfieldUnit<Storage>
where
Storage: AsRef<[u8]> + AsMut<[u8]>,
{
#[inline]
pub fn get_bit(&self, index: usize) -> bool {
debug_assert!(index / 8 < self.storage.as_ref().len());
let byte_index = index / 8;
let byte = self.storage.as_ref()[byte_index];
let bit_index = if cfg!(target_endian = "big") {
7 - (index % 8)
} else {
index % 8
};
let mask = 1 << bit_index;
byte & mask == mask
}
#[inline]
pub fn set_bit(&mut self, index: usize, val: bool) {
debug_assert!(index / 8 < self.storage.as_ref().len());
let byte_index = index / 8;
let byte = &mut self.storage.as_mut()[byte_index];
let bit_index = if cfg!(target_endian = "big") {
7 - (index % 8)
} else {
index % 8
};
let mask = 1 << bit_index;
if val {
*byte |= mask;
} else {
*byte &= !mask;
}
}
#[inline]
pub fn get(&self, bit_offset: usize, bit_width: u8) -> u64 {
debug_assert!(bit_width <= 64);
debug_assert!(bit_offset / 8 < self.storage.as_ref().len());
debug_assert!((bit_offset + (bit_width as usize)) / 8 <= self.storage.as_ref().len());
let mut val = 0;
for i in 0..(bit_width as usize) {
if self.get_bit(i + bit_offset) {
let index = if cfg!(target_endian = "big") {
bit_width as usize - 1 - i
} else {
i
};
val |= 1 << index;
}
}
val
}
#[inline]
pub fn set(&mut self, bit_offset: usize, bit_width: u8, val: u64) {
debug_assert!(bit_width <= 64);
debug_assert!(bit_offset / 8 < self.storage.as_ref().len());
debug_assert!((bit_offset + (bit_width as usize)) / 8 <= self.storage.as_ref().len());
for i in 0..(bit_width as usize) {
let mask = 1 << i;
let val_bit_is_set = val & mask == mask;
let index = if cfg!(target_endian = "big") {
bit_width as usize - 1 - i
} else {
i
};
self.set_bit(index + bit_offset, val_bit_is_set);
}
}
}
pub type mrb_sym = u32;
pub type mrb_bool = bool;
pub type mrb_int = i64;
pub type mrb_float = f64;
pub const mrb_vtype_MRB_TT_FALSE: mrb_vtype = 0;
pub const mrb_vtype_MRB_TT_TRUE: mrb_vtype = 1;
pub const mrb_vtype_MRB_TT_SYMBOL: mrb_vtype = 2;
pub const mrb_vtype_MRB_TT_UNDEF: mrb_vtype = 3;
pub const mrb_vtype_MRB_TT_FREE: mrb_vtype = 4;
pub const mrb_vtype_MRB_TT_FLOAT: mrb_vtype = 5;
pub const mrb_vtype_MRB_TT_INTEGER: mrb_vtype = 6;
pub const mrb_vtype_MRB_TT_CPTR: mrb_vtype = 7;
pub const mrb_vtype_MRB_TT_OBJECT: mrb_vtype = 8;
pub const mrb_vtype_MRB_TT_CLASS: mrb_vtype = 9;
pub const mrb_vtype_MRB_TT_MODULE: mrb_vtype = 10;
pub const mrb_vtype_MRB_TT_ICLASS: mrb_vtype = 11;
pub const mrb_vtype_MRB_TT_SCLASS: mrb_vtype = 12;
pub const mrb_vtype_MRB_TT_PROC: mrb_vtype = 13;
pub const mrb_vtype_MRB_TT_ARRAY: mrb_vtype = 14;
pub const mrb_vtype_MRB_TT_HASH: mrb_vtype = 15;
pub const mrb_vtype_MRB_TT_STRING: mrb_vtype = 16;
pub const mrb_vtype_MRB_TT_RANGE: mrb_vtype = 17;
pub const mrb_vtype_MRB_TT_EXCEPTION: mrb_vtype = 18;
pub const mrb_vtype_MRB_TT_ENV: mrb_vtype = 19;
pub const mrb_vtype_MRB_TT_CDATA: mrb_vtype = 20;
pub const mrb_vtype_MRB_TT_FIBER: mrb_vtype = 21;
pub const mrb_vtype_MRB_TT_STRUCT: mrb_vtype = 22;
pub const mrb_vtype_MRB_TT_ISTRUCT: mrb_vtype = 23;
pub const mrb_vtype_MRB_TT_BREAK: mrb_vtype = 24;
pub const mrb_vtype_MRB_TT_COMPLEX: mrb_vtype = 25;
pub const mrb_vtype_MRB_TT_RATIONAL: mrb_vtype = 26;
pub const mrb_vtype_MRB_TT_BIGINT: mrb_vtype = 27;
pub const mrb_vtype_MRB_TT_MAXDEFINE: mrb_vtype = 28;
pub type mrb_vtype = ::std::os::raw::c_uint;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct RFloat {
_unused: [u8; 0],
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct RProc {
_unused: [u8; 0],
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct RRange {
_unused: [u8; 0],
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct REnv {
_unused: [u8; 0],
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct RComplex {
_unused: [u8; 0],
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct RRational {
_unused: [u8; 0],
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct RBasic {
pub c: *mut RClass,
pub gcnext: *mut RBasic,
pub _bitfield_align_1: [u32; 0],
pub _bitfield_1: __BindgenBitfieldUnit<[u8; 4usize]>,
pub __bindgen_padding_0: u32,
}
impl RBasic {
#[inline]
pub fn tt(&self) -> mrb_vtype {
unsafe { ::std::mem::transmute(self._bitfield_1.get(0usize, 8u8) as u32) }
}
#[inline]
pub fn set_tt(&mut self, val: mrb_vtype) {
unsafe {
let val: u32 = ::std::mem::transmute(val);
self._bitfield_1.set(0usize, 8u8, val as u64)
}
}
#[inline]
pub fn color(&self) -> u32 {
unsafe { ::std::mem::transmute(self._bitfield_1.get(8usize, 3u8) as u32) }
}
#[inline]
pub fn set_color(&mut self, val: u32) {
unsafe {
let val: u32 = ::std::mem::transmute(val);
self._bitfield_1.set(8usize, 3u8, val as u64)
}
}
#[inline]
pub fn flags(&self) -> u32 {
unsafe { ::std::mem::transmute(self._bitfield_1.get(11usize, 21u8) as u32) }
}
#[inline]
pub fn set_flags(&mut self, val: u32) {
unsafe {
let val: u32 = ::std::mem::transmute(val);
self._bitfield_1.set(11usize, 21u8, val as u64)
}
}
#[inline]
pub fn new_bitfield_1(
tt: mrb_vtype,
color: u32,
flags: u32,
) -> __BindgenBitfieldUnit<[u8; 4usize]> {
let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 4usize]> = Default::default();
__bindgen_bitfield_unit.set(0usize, 8u8, {
let tt: u32 = unsafe { ::std::mem::transmute(tt) };
tt as u64
});
__bindgen_bitfield_unit.set(8usize, 3u8, {
let color: u32 = unsafe { ::std::mem::transmute(color) };
color as u64
});
__bindgen_bitfield_unit.set(11usize, 21u8, {
let flags: u32 = unsafe { ::std::mem::transmute(flags) };
flags as u64
});
__bindgen_bitfield_unit
}
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct RObject {
pub c: *mut RClass,
pub gcnext: *mut RBasic,
pub _bitfield_align_1: [u32; 0],
pub _bitfield_1: __BindgenBitfieldUnit<[u8; 4usize]>,
pub iv: *mut iv_tbl,
}
impl RObject {
#[inline]
pub fn tt(&self) -> mrb_vtype {
unsafe { ::std::mem::transmute(self._bitfield_1.get(0usize, 8u8) as u32) }
}
#[inline]
pub fn set_tt(&mut self, val: mrb_vtype) {
unsafe {
let val: u32 = ::std::mem::transmute(val);
self._bitfield_1.set(0usize, 8u8, val as u64)
}
}
#[inline]
pub fn color(&self) -> u32 {
unsafe { ::std::mem::transmute(self._bitfield_1.get(8usize, 3u8) as u32) }
}
#[inline]
pub fn set_color(&mut self, val: u32) {
unsafe {
let val: u32 = ::std::mem::transmute(val);
self._bitfield_1.set(8usize, 3u8, val as u64)
}
}
#[inline]
pub fn flags(&self) -> u32 {
unsafe { ::std::mem::transmute(self._bitfield_1.get(11usize, 21u8) as u32) }
}
#[inline]
pub fn set_flags(&mut self, val: u32) {
unsafe {
let val: u32 = ::std::mem::transmute(val);
self._bitfield_1.set(11usize, 21u8, val as u64)
}
}
#[inline]
pub fn new_bitfield_1(
tt: mrb_vtype,
color: u32,
flags: u32,
) -> __BindgenBitfieldUnit<[u8; 4usize]> {
let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 4usize]> = Default::default();
__bindgen_bitfield_unit.set(0usize, 8u8, {
let tt: u32 = unsafe { ::std::mem::transmute(tt) };
tt as u64
});
__bindgen_bitfield_unit.set(8usize, 3u8, {
let color: u32 = unsafe { ::std::mem::transmute(color) };
color as u64
});
__bindgen_bitfield_unit.set(11usize, 21u8, {
let flags: u32 = unsafe { ::std::mem::transmute(flags) };
flags as u64
});
__bindgen_bitfield_unit
}
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct RFiber {
pub c: *mut RClass,
pub gcnext: *mut RBasic,
pub _bitfield_align_1: [u32; 0],
pub _bitfield_1: __BindgenBitfieldUnit<[u8; 4usize]>,
pub cxt: *mut mrb_context,
}
impl RFiber {
#[inline]
pub fn tt(&self) -> mrb_vtype {
unsafe { ::std::mem::transmute(self._bitfield_1.get(0usize, 8u8) as u32) }
}
#[inline]
pub fn set_tt(&mut self, val: mrb_vtype) {
unsafe {
let val: u32 = ::std::mem::transmute(val);
self._bitfield_1.set(0usize, 8u8, val as u64)
}
}
#[inline]
pub fn color(&self) -> u32 {
unsafe { ::std::mem::transmute(self._bitfield_1.get(8usize, 3u8) as u32) }
}
#[inline]
pub fn set_color(&mut self, val: u32) {
unsafe {
let val: u32 = ::std::mem::transmute(val);
self._bitfield_1.set(8usize, 3u8, val as u64)
}
}
#[inline]
pub fn flags(&self) -> u32 {
unsafe { ::std::mem::transmute(self._bitfield_1.get(11usize, 21u8) as u32) }
}
#[inline]
pub fn set_flags(&mut self, val: u32) {
unsafe {
let val: u32 = ::std::mem::transmute(val);
self._bitfield_1.set(11usize, 21u8, val as u64)
}
}
#[inline]
pub fn new_bitfield_1(
tt: mrb_vtype,
color: u32,
flags: u32,
) -> __BindgenBitfieldUnit<[u8; 4usize]> {
let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 4usize]> = Default::default();
__bindgen_bitfield_unit.set(0usize, 8u8, {
let tt: u32 = unsafe { ::std::mem::transmute(tt) };
tt as u64
});
__bindgen_bitfield_unit.set(8usize, 3u8, {
let color: u32 = unsafe { ::std::mem::transmute(color) };
color as u64
});
__bindgen_bitfield_unit.set(11usize, 21u8, {
let flags: u32 = unsafe { ::std::mem::transmute(flags) };
flags as u64
});
__bindgen_bitfield_unit
}
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct RInteger {
pub c: *mut RClass,
pub gcnext: *mut RBasic,
pub _bitfield_align_1: [u32; 0],
pub _bitfield_1: __BindgenBitfieldUnit<[u8; 4usize]>,
pub i: mrb_int,
}
impl RInteger {
#[inline]
pub fn tt(&self) -> mrb_vtype {
unsafe { ::std::mem::transmute(self._bitfield_1.get(0usize, 8u8) as u32) }
}
#[inline]
pub fn set_tt(&mut self, val: mrb_vtype) {
unsafe {
let val: u32 = ::std::mem::transmute(val);
self._bitfield_1.set(0usize, 8u8, val as u64)
}
}
#[inline]
pub fn color(&self) -> u32 {
unsafe { ::std::mem::transmute(self._bitfield_1.get(8usize, 3u8) as u32) }
}
#[inline]
pub fn set_color(&mut self, val: u32) {
unsafe {
let val: u32 = ::std::mem::transmute(val);
self._bitfield_1.set(8usize, 3u8, val as u64)
}
}
#[inline]
pub fn flags(&self) -> u32 {
unsafe { ::std::mem::transmute(self._bitfield_1.get(11usize, 21u8) as u32) }
}
#[inline]
pub fn set_flags(&mut self, val: u32) {
unsafe {
let val: u32 = ::std::mem::transmute(val);
self._bitfield_1.set(11usize, 21u8, val as u64)
}
}
#[inline]
pub fn new_bitfield_1(
tt: mrb_vtype,
color: u32,
flags: u32,
) -> __BindgenBitfieldUnit<[u8; 4usize]> {
let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 4usize]> = Default::default();
__bindgen_bitfield_unit.set(0usize, 8u8, {
let tt: u32 = unsafe { ::std::mem::transmute(tt) };
tt as u64
});
__bindgen_bitfield_unit.set(8usize, 3u8, {
let color: u32 = unsafe { ::std::mem::transmute(color) };
color as u64
});
__bindgen_bitfield_unit.set(11usize, 21u8, {
let flags: u32 = unsafe { ::std::mem::transmute(flags) };
flags as u64
});
__bindgen_bitfield_unit
}
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct mrb_value {
pub w: usize,
}
pub type mrb_ssize = mrb_int;
pub const mrb_gc_state_MRB_GC_STATE_ROOT: mrb_gc_state = 0;
pub const mrb_gc_state_MRB_GC_STATE_MARK: mrb_gc_state = 1;
pub const mrb_gc_state_MRB_GC_STATE_SWEEP: mrb_gc_state = 2;
pub type mrb_gc_state = ::std::os::raw::c_uint;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct mrb_heap_page {
pub freelist: *mut RBasic,
pub prev: *mut mrb_heap_page,
pub next: *mut mrb_heap_page,
pub free_next: *mut mrb_heap_page,
pub free_prev: *mut mrb_heap_page,
pub _bitfield_align_1: [u8; 0],
pub _bitfield_1: __BindgenBitfieldUnit<[u8; 1usize]>,
pub __bindgen_padding_0: [u8; 7usize],
}
impl mrb_heap_page {
#[inline]
pub fn old(&self) -> mrb_bool {
unsafe { ::std::mem::transmute(self._bitfield_1.get(0usize, 1u8) as u8) }
}
#[inline]
pub fn set_old(&mut self, val: mrb_bool) {
unsafe {
let val: u8 = ::std::mem::transmute(val);
self._bitfield_1.set(0usize, 1u8, val as u64)
}
}
#[inline]
pub fn new_bitfield_1(old: mrb_bool) -> __BindgenBitfieldUnit<[u8; 1usize]> {
let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 1usize]> = Default::default();
__bindgen_bitfield_unit.set(0usize, 1u8, {
let old: u8 = unsafe { ::std::mem::transmute(old) };
old as u64
});
__bindgen_bitfield_unit
}
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct mrb_gc {
pub heaps: *mut mrb_heap_page,
pub sweeps: *mut mrb_heap_page,
pub free_heaps: *mut mrb_heap_page,
pub live: usize,
pub arena: *mut *mut RBasic,
pub arena_capa: ::std::os::raw::c_int,
pub arena_idx: ::std::os::raw::c_int,
pub state: mrb_gc_state,
pub current_white_part: ::std::os::raw::c_int,
pub gray_list: *mut RBasic,
pub atomic_gray_list: *mut RBasic,
pub live_after_mark: usize,
pub threshold: usize,
pub interval_ratio: ::std::os::raw::c_int,
pub step_ratio: ::std::os::raw::c_int,
pub _bitfield_align_1: [u8; 0],
pub _bitfield_1: __BindgenBitfieldUnit<[u8; 1usize]>,
pub majorgc_old_threshold: usize,
}
impl mrb_gc {
#[inline]
pub fn iterating(&self) -> mrb_bool {
unsafe { ::std::mem::transmute(self._bitfield_1.get(0usize, 1u8) as u8) }
}
#[inline]
pub fn set_iterating(&mut self, val: mrb_bool) {
unsafe {
let val: u8 = ::std::mem::transmute(val);
self._bitfield_1.set(0usize, 1u8, val as u64)
}
}
#[inline]
pub fn disabled(&self) -> mrb_bool {
unsafe { ::std::mem::transmute(self._bitfield_1.get(1usize, 1u8) as u8) }
}
#[inline]
pub fn set_disabled(&mut self, val: mrb_bool) {
unsafe {
let val: u8 = ::std::mem::transmute(val);
self._bitfield_1.set(1usize, 1u8, val as u64)
}
}
#[inline]
pub fn full(&self) -> mrb_bool {
unsafe { ::std::mem::transmute(self._bitfield_1.get(2usize, 1u8) as u8) }
}
#[inline]
pub fn set_full(&mut self, val: mrb_bool) {
unsafe {
let val: u8 = ::std::mem::transmute(val);
self._bitfield_1.set(2usize, 1u8, val as u64)
}
}
#[inline]
pub fn generational(&self) -> mrb_bool {
unsafe { ::std::mem::transmute(self._bitfield_1.get(3usize, 1u8) as u8) }
}
#[inline]
pub fn set_generational(&mut self, val: mrb_bool) {
unsafe {
let val: u8 = ::std::mem::transmute(val);
self._bitfield_1.set(3usize, 1u8, val as u64)
}
}
#[inline]
pub fn out_of_memory(&self) -> mrb_bool {
unsafe { ::std::mem::transmute(self._bitfield_1.get(4usize, 1u8) as u8) }
}
#[inline]
pub fn set_out_of_memory(&mut self, val: mrb_bool) {
unsafe {
let val: u8 = ::std::mem::transmute(val);
self._bitfield_1.set(4usize, 1u8, val as u64)
}
}
#[inline]
pub fn new_bitfield_1(
iterating: mrb_bool,
disabled: mrb_bool,
full: mrb_bool,
generational: mrb_bool,
out_of_memory: mrb_bool,
) -> __BindgenBitfieldUnit<[u8; 1usize]> {
let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 1usize]> = Default::default();
__bindgen_bitfield_unit.set(0usize, 1u8, {
let iterating: u8 = unsafe { ::std::mem::transmute(iterating) };
iterating as u64
});
__bindgen_bitfield_unit.set(1usize, 1u8, {
let disabled: u8 = unsafe { ::std::mem::transmute(disabled) };
disabled as u64
});
__bindgen_bitfield_unit.set(2usize, 1u8, {
let full: u8 = unsafe { ::std::mem::transmute(full) };
full as u64
});
__bindgen_bitfield_unit.set(3usize, 1u8, {
let generational: u8 = unsafe { ::std::mem::transmute(generational) };
generational as u64
});
__bindgen_bitfield_unit.set(4usize, 1u8, {
let out_of_memory: u8 = unsafe { ::std::mem::transmute(out_of_memory) };
out_of_memory as u64
});
__bindgen_bitfield_unit
}
}
pub type mrb_code = u8;
pub type mrb_aspec = u32;
pub type mrb_allocf = ::std::option::Option<
unsafe extern "C" fn(
mrb: *mut mrb_state,
arg1: *mut ::std::os::raw::c_void,
arg2: usize,
ud: *mut ::std::os::raw::c_void,
) -> *mut ::std::os::raw::c_void,
>;
#[repr(C)]
#[derive(Copy, Clone)]
pub struct mrb_callinfo {
pub _bitfield_align_1: [u8; 0],
pub _bitfield_1: __BindgenBitfieldUnit<[u8; 1usize]>,
pub cci: u8,
pub mid: mrb_sym,
pub proc_: *const RProc,
pub blk: *mut RProc,
pub stack: *mut mrb_value,
pub pc: *const mrb_code,
pub u: mrb_callinfo__bindgen_ty_1,
}
#[repr(C)]
#[derive(Copy, Clone)]
pub union mrb_callinfo__bindgen_ty_1 {
pub env: *mut REnv,
pub target_class: *mut RClass,
}
impl mrb_callinfo {
#[inline]
pub fn n(&self) -> u8 {
unsafe { ::std::mem::transmute(self._bitfield_1.get(0usize, 4u8) as u8) }
}
#[inline]
pub fn set_n(&mut self, val: u8) {
unsafe {
let val: u8 = ::std::mem::transmute(val);
self._bitfield_1.set(0usize, 4u8, val as u64)
}
}
#[inline]
pub fn nk(&self) -> u8 {
unsafe { ::std::mem::transmute(self._bitfield_1.get(4usize, 4u8) as u8) }
}
#[inline]
pub fn set_nk(&mut self, val: u8) {
unsafe {
let val: u8 = ::std::mem::transmute(val);
self._bitfield_1.set(4usize, 4u8, val as u64)
}
}
#[inline]
pub fn new_bitfield_1(n: u8, nk: u8) -> __BindgenBitfieldUnit<[u8; 1usize]> {
let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 1usize]> = Default::default();
__bindgen_bitfield_unit.set(0usize, 4u8, {
let n: u8 = unsafe { ::std::mem::transmute(n) };
n as u64
});
__bindgen_bitfield_unit.set(4usize, 4u8, {
let nk: u8 = unsafe { ::std::mem::transmute(nk) };
nk as u64
});
__bindgen_bitfield_unit
}
}
pub const mrb_fiber_state_MRB_FIBER_CREATED: mrb_fiber_state = 0;
pub const mrb_fiber_state_MRB_FIBER_RUNNING: mrb_fiber_state = 1;
pub const mrb_fiber_state_MRB_FIBER_RESUMED: mrb_fiber_state = 2;
pub const mrb_fiber_state_MRB_FIBER_SUSPENDED: mrb_fiber_state = 3;
pub const mrb_fiber_state_MRB_FIBER_TRANSFERRED: mrb_fiber_state = 4;
pub const mrb_fiber_state_MRB_FIBER_TERMINATED: mrb_fiber_state = 5;
pub type mrb_fiber_state = ::std::os::raw::c_uint;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct mrb_context {
pub prev: *mut mrb_context,
pub stbase: *mut mrb_value,
pub stend: *mut mrb_value,
pub ci: *mut mrb_callinfo,
pub cibase: *mut mrb_callinfo,
pub ciend: *mut mrb_callinfo,
pub _bitfield_align_1: [u8; 0],
pub _bitfield_1: __BindgenBitfieldUnit<[u8; 1usize]>,
pub fib: *mut RFiber,
}
impl mrb_context {
#[inline]
pub fn status(&self) -> mrb_fiber_state {
unsafe { ::std::mem::transmute(self._bitfield_1.get(0usize, 4u8) as u32) }
}
#[inline]
pub fn set_status(&mut self, val: mrb_fiber_state) {
unsafe {
let val: u32 = ::std::mem::transmute(val);
self._bitfield_1.set(0usize, 4u8, val as u64)
}
}
#[inline]
pub fn vmexec(&self) -> mrb_bool {
unsafe { ::std::mem::transmute(self._bitfield_1.get(4usize, 1u8) as u8) }
}
#[inline]
pub fn set_vmexec(&mut self, val: mrb_bool) {
unsafe {
let val: u8 = ::std::mem::transmute(val);
self._bitfield_1.set(4usize, 1u8, val as u64)
}
}
#[inline]
pub fn new_bitfield_1(
status: mrb_fiber_state,
vmexec: mrb_bool,
) -> __BindgenBitfieldUnit<[u8; 1usize]> {
let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 1usize]> = Default::default();
__bindgen_bitfield_unit.set(0usize, 4u8, {
let status: u32 = unsafe { ::std::mem::transmute(status) };
status as u64
});
__bindgen_bitfield_unit.set(4usize, 1u8, {
let vmexec: u8 = unsafe { ::std::mem::transmute(vmexec) };
vmexec as u64
});
__bindgen_bitfield_unit
}
}
pub type mrb_func_t =
::std::option::Option<unsafe extern "C" fn(mrb: *mut mrb_state, self_: mrb_value) -> mrb_value>;
pub type mrb_method_t = usize;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct mrb_cache_entry {
pub c: *mut RClass,
pub c0: *mut RClass,
pub mid: mrb_sym,
pub m: mrb_method_t,
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct mrb_jmpbuf {
_unused: [u8; 0],
}
pub type mrb_atexit_func = ::std::option::Option<unsafe extern "C" fn(arg1: *mut mrb_state)>;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct mrb_state {
pub jmp: *mut mrb_jmpbuf,
pub allocf: mrb_allocf,
pub allocf_ud: *mut ::std::os::raw::c_void,
pub c: *mut mrb_context,
pub root_c: *mut mrb_context,
pub globals: *mut iv_tbl,
pub exc: *mut RObject,
pub top_self: *mut RObject,
pub object_class: *mut RClass,
pub class_class: *mut RClass,
pub module_class: *mut RClass,
pub proc_class: *mut RClass,
pub string_class: *mut RClass,
pub array_class: *mut RClass,
pub hash_class: *mut RClass,
pub range_class: *mut RClass,
pub float_class: *mut RClass,
pub integer_class: *mut RClass,
pub true_class: *mut RClass,
pub false_class: *mut RClass,
pub nil_class: *mut RClass,
pub symbol_class: *mut RClass,
pub kernel_module: *mut RClass,
pub gc: mrb_gc,
pub cache: [mrb_cache_entry; 256usize],
pub symidx: mrb_sym,
pub symtbl: *mut *const ::std::os::raw::c_char,
pub symlink: *mut u8,
pub symflags: *mut u8,
pub symhash: [mrb_sym; 256usize],
pub symcapa: usize,
pub symbuf: [::std::os::raw::c_char; 8usize],
pub eException_class: *mut RClass,
pub eStandardError_class: *mut RClass,
pub nomem_err: *mut RObject,
pub stack_err: *mut RObject,
pub ud: *mut ::std::os::raw::c_void,
pub atexit_stack: *mut mrb_atexit_func,
pub atexit_stack_len: u16,
}
pub type mrb_args_format = *const ::std::os::raw::c_char;
extern "C" {
pub fn mrb_get_args(mrb: *mut mrb_state, format: mrb_args_format, ...) -> mrb_int;
}
extern "C" {
pub fn mrb_raise(mrb: *mut mrb_state, c: *mut RClass, msg: *const ::std::os::raw::c_char);
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct mrb_data_type {
pub struct_name: *const ::std::os::raw::c_char,
pub dfree: ::std::option::Option<
unsafe extern "C" fn(mrb: *mut mrb_state, arg1: *mut ::std::os::raw::c_void),
>,
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct RData {
pub c: *mut RClass,
pub gcnext: *mut RBasic,
pub _bitfield_align_1: [u32; 0],
pub _bitfield_1: __BindgenBitfieldUnit<[u8; 4usize]>,
pub iv: *mut iv_tbl,
pub type_: *const mrb_data_type,
pub data: *mut ::std::os::raw::c_void,
}
impl RData {
#[inline]
pub fn tt(&self) -> mrb_vtype {
unsafe { ::std::mem::transmute(self._bitfield_1.get(0usize, 8u8) as u32) }
}
#[inline]
pub fn set_tt(&mut self, val: mrb_vtype) {
unsafe {
let val: u32 = ::std::mem::transmute(val);
self._bitfield_1.set(0usize, 8u8, val as u64)
}
}
#[inline]
pub fn color(&self) -> u32 {
unsafe { ::std::mem::transmute(self._bitfield_1.get(8usize, 3u8) as u32) }
}
#[inline]
pub fn set_color(&mut self, val: u32) {
unsafe {
let val: u32 = ::std::mem::transmute(val);
self._bitfield_1.set(8usize, 3u8, val as u64)
}
}
#[inline]
pub fn flags(&self) -> u32 {
unsafe { ::std::mem::transmute(self._bitfield_1.get(11usize, 21u8) as u32) }
}
#[inline]
pub fn set_flags(&mut self, val: u32) {
unsafe {
let val: u32 = ::std::mem::transmute(val);
self._bitfield_1.set(11usize, 21u8, val as u64)
}
}
#[inline]
pub fn new_bitfield_1(
tt: mrb_vtype,
color: u32,
flags: u32,
) -> __BindgenBitfieldUnit<[u8; 4usize]> {
let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 4usize]> = Default::default();
__bindgen_bitfield_unit.set(0usize, 8u8, {
let tt: u32 = unsafe { ::std::mem::transmute(tt) };
tt as u64
});
__bindgen_bitfield_unit.set(8usize, 3u8, {
let color: u32 = unsafe { ::std::mem::transmute(color) };
color as u64
});
__bindgen_bitfield_unit.set(11usize, 21u8, {
let flags: u32 = unsafe { ::std::mem::transmute(flags) };
flags as u64
});
__bindgen_bitfield_unit
}
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct RClass {
pub c: *mut RClass,
pub gcnext: *mut RBasic,
pub _bitfield_align_1: [u32; 0],
pub _bitfield_1: __BindgenBitfieldUnit<[u8; 4usize]>,
pub iv: *mut iv_tbl,
pub mt: *mut mt_tbl,
pub super_: *mut RClass,
}
impl RClass {
#[inline]
pub fn tt(&self) -> mrb_vtype {
unsafe { ::std::mem::transmute(self._bitfield_1.get(0usize, 8u8) as u32) }
}
#[inline]
pub fn set_tt(&mut self, val: mrb_vtype) {
unsafe {
let val: u32 = ::std::mem::transmute(val);
self._bitfield_1.set(0usize, 8u8, val as u64)
}
}
#[inline]
pub fn color(&self) -> u32 {
unsafe { ::std::mem::transmute(self._bitfield_1.get(8usize, 3u8) as u32) }
}
#[inline]
pub fn set_color(&mut self, val: u32) {
unsafe {
let val: u32 = ::std::mem::transmute(val);
self._bitfield_1.set(8usize, 3u8, val as u64)
}
}
#[inline]
pub fn flags(&self) -> u32 {
unsafe { ::std::mem::transmute(self._bitfield_1.get(11usize, 21u8) as u32) }
}
#[inline]
pub fn set_flags(&mut self, val: u32) {
unsafe {
let val: u32 = ::std::mem::transmute(val);
self._bitfield_1.set(11usize, 21u8, val as u64)
}
}
#[inline]
pub fn new_bitfield_1(
tt: mrb_vtype,
color: u32,
flags: u32,
) -> __BindgenBitfieldUnit<[u8; 4usize]> {
let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 4usize]> = Default::default();
__bindgen_bitfield_unit.set(0usize, 8u8, {
let tt: u32 = unsafe { ::std::mem::transmute(tt) };
tt as u64
});
__bindgen_bitfield_unit.set(8usize, 3u8, {
let color: u32 = unsafe { ::std::mem::transmute(color) };
color as u64
});
__bindgen_bitfield_unit.set(11usize, 21u8, {
let flags: u32 = unsafe { ::std::mem::transmute(flags) };
flags as u64
});
__bindgen_bitfield_unit
}
}
#[repr(C)]
#[derive(Copy, Clone)]
pub struct RString {
pub c: *mut RClass,
pub gcnext: *mut RBasic,
pub _bitfield_align_1: [u32; 0],
pub _bitfield_1: __BindgenBitfieldUnit<[u8; 4usize]>,
pub as_: RString__bindgen_ty_1,
}
#[repr(C)]
#[derive(Copy, Clone)]
pub union RString__bindgen_ty_1 {
pub heap: RString__bindgen_ty_1__bindgen_ty_1,
}
#[repr(C)]
#[derive(Copy, Clone)]
pub struct RString__bindgen_ty_1__bindgen_ty_1 {
pub len: mrb_ssize,
pub aux: RString__bindgen_ty_1__bindgen_ty_1__bindgen_ty_1,
pub ptr: *mut ::std::os::raw::c_char,
}
#[repr(C)]
#[derive(Copy, Clone)]
pub union RString__bindgen_ty_1__bindgen_ty_1__bindgen_ty_1 {
pub capa: mrb_ssize,
pub shared: *mut mrb_shared_string,
pub fshared: *mut RString,
}
impl RString {
#[inline]
pub fn tt(&self) -> mrb_vtype {
unsafe { ::std::mem::transmute(self._bitfield_1.get(0usize, 8u8) as u32) }
}
#[inline]
pub fn set_tt(&mut self, val: mrb_vtype) {
unsafe {
let val: u32 = ::std::mem::transmute(val);
self._bitfield_1.set(0usize, 8u8, val as u64)
}
}
#[inline]
pub fn color(&self) -> u32 {
unsafe { ::std::mem::transmute(self._bitfield_1.get(8usize, 3u8) as u32) }
}
#[inline]
pub fn set_color(&mut self, val: u32) {
unsafe {
let val: u32 = ::std::mem::transmute(val);
self._bitfield_1.set(8usize, 3u8, val as u64)
}
}
#[inline]
pub fn flags(&self) -> u32 {
unsafe { ::std::mem::transmute(self._bitfield_1.get(11usize, 21u8) as u32) }
}
#[inline]
pub fn set_flags(&mut self, val: u32) {
unsafe {
let val: u32 = ::std::mem::transmute(val);
self._bitfield_1.set(11usize, 21u8, val as u64)
}
}
#[inline]
pub fn new_bitfield_1(
tt: mrb_vtype,
color: u32,
flags: u32,
) -> __BindgenBitfieldUnit<[u8; 4usize]> {
let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 4usize]> = Default::default();
__bindgen_bitfield_unit.set(0usize, 8u8, {
let tt: u32 = unsafe { ::std::mem::transmute(tt) };
tt as u64
});
__bindgen_bitfield_unit.set(8usize, 3u8, {
let color: u32 = unsafe { ::std::mem::transmute(color) };
color as u64
});
__bindgen_bitfield_unit.set(11usize, 21u8, {
let flags: u32 = unsafe { ::std::mem::transmute(flags) };
flags as u64
});
__bindgen_bitfield_unit
}
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct mrb_shared_array {
pub refcnt: ::std::os::raw::c_int,
pub len: mrb_ssize,
pub ptr: *mut mrb_value,
}
#[repr(C)]
#[derive(Copy, Clone)]
pub struct RArray {
pub c: *mut RClass,
pub gcnext: *mut RBasic,
pub _bitfield_align_1: [u32; 0],
pub _bitfield_1: __BindgenBitfieldUnit<[u8; 4usize]>,
pub as_: RArray__bindgen_ty_1,
}
#[repr(C)]
#[derive(Copy, Clone)]
pub union RArray__bindgen_ty_1 {
pub heap: RArray__bindgen_ty_1__bindgen_ty_1,
pub ary: [mrb_value; 3usize],
}
#[repr(C)]
#[derive(Copy, Clone)]
pub struct RArray__bindgen_ty_1__bindgen_ty_1 {
pub len: mrb_ssize,
pub aux: RArray__bindgen_ty_1__bindgen_ty_1__bindgen_ty_1,
pub ptr: *mut mrb_value,
}
#[repr(C)]
#[derive(Copy, Clone)]
pub union RArray__bindgen_ty_1__bindgen_ty_1__bindgen_ty_1 {
pub capa: mrb_ssize,
pub shared: *mut mrb_shared_array,
}
impl RArray {
#[inline]
pub fn tt(&self) -> mrb_vtype {
unsafe { ::std::mem::transmute(self._bitfield_1.get(0usize, 8u8) as u32) }
}
#[inline]
pub fn set_tt(&mut self, val: mrb_vtype) {
unsafe {
let val: u32 = ::std::mem::transmute(val);
self._bitfield_1.set(0usize, 8u8, val as u64)
}
}
#[inline]
pub fn color(&self) -> u32 {
unsafe { ::std::mem::transmute(self._bitfield_1.get(8usize, 3u8) as u32) }
}
#[inline]
pub fn set_color(&mut self, val: u32) {
unsafe {
let val: u32 = ::std::mem::transmute(val);
self._bitfield_1.set(8usize, 3u8, val as u64)
}
}
#[inline]
pub fn flags(&self) -> u32 {
unsafe { ::std::mem::transmute(self._bitfield_1.get(11usize, 21u8) as u32) }
}
#[inline]
pub fn set_flags(&mut self, val: u32) {
unsafe {
let val: u32 = ::std::mem::transmute(val);
self._bitfield_1.set(11usize, 21u8, val as u64)
}
}
#[inline]
pub fn new_bitfield_1(
tt: mrb_vtype,
color: u32,
flags: u32,
) -> __BindgenBitfieldUnit<[u8; 4usize]> {
let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 4usize]> = Default::default();
__bindgen_bitfield_unit.set(0usize, 8u8, {
let tt: u32 = unsafe { ::std::mem::transmute(tt) };
tt as u64
});
__bindgen_bitfield_unit.set(8usize, 3u8, {
let color: u32 = unsafe { ::std::mem::transmute(color) };
color as u64
});
__bindgen_bitfield_unit.set(11usize, 21u8, {
let flags: u32 = unsafe { ::std::mem::transmute(flags) };
flags as u64
});
__bindgen_bitfield_unit
}
}
#[repr(C)]
#[derive(Copy, Clone)]
pub struct RHash {
pub c: *mut RClass,
pub gcnext: *mut RBasic,
pub _bitfield_align_1: [u32; 0],
pub _bitfield_1: __BindgenBitfieldUnit<[u8; 4usize]>,
pub size: u32,
pub iv: *mut iv_tbl,
pub ea_capa: u32,
pub ea_n_used: u32,
pub hsh: RHash__bindgen_ty_1,
}
#[repr(C)]
#[derive(Copy, Clone)]
pub union RHash__bindgen_ty_1 {
pub ea: *mut hash_entry,
pub ht: *mut hash_table,
}
impl RHash {
#[inline]
pub fn tt(&self) -> mrb_vtype {
unsafe { ::std::mem::transmute(self._bitfield_1.get(0usize, 8u8) as u32) }
}
#[inline]
pub fn set_tt(&mut self, val: mrb_vtype) {
unsafe {
let val: u32 = ::std::mem::transmute(val);
self._bitfield_1.set(0usize, 8u8, val as u64)
}
}
#[inline]
pub fn color(&self) -> u32 {
unsafe { ::std::mem::transmute(self._bitfield_1.get(8usize, 3u8) as u32) }
}
#[inline]
pub fn set_color(&mut self, val: u32) {
unsafe {
let val: u32 = ::std::mem::transmute(val);
self._bitfield_1.set(8usize, 3u8, val as u64)
}
}
#[inline]
pub fn flags(&self) -> u32 {
unsafe { ::std::mem::transmute(self._bitfield_1.get(11usize, 21u8) as u32) }
}
#[inline]
pub fn set_flags(&mut self, val: u32) {
unsafe {
let val: u32 = ::std::mem::transmute(val);
self._bitfield_1.set(11usize, 21u8, val as u64)
}
}
#[inline]
pub fn new_bitfield_1(
tt: mrb_vtype,
color: u32,
flags: u32,
) -> __BindgenBitfieldUnit<[u8; 4usize]> {
let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 4usize]> = Default::default();
__bindgen_bitfield_unit.set(0usize, 8u8, {
let tt: u32 = unsafe { ::std::mem::transmute(tt) };
tt as u64
});
__bindgen_bitfield_unit.set(8usize, 3u8, {
let color: u32 = unsafe { ::std::mem::transmute(color) };
color as u64
});
__bindgen_bitfield_unit.set(11usize, 21u8, {
let flags: u32 = unsafe { ::std::mem::transmute(flags) };
flags as u64
});
__bindgen_bitfield_unit
}
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct RException {
pub c: *mut RClass,
pub gcnext: *mut RBasic,
pub _bitfield_align_1: [u32; 0],
pub _bitfield_1: __BindgenBitfieldUnit<[u8; 4usize]>,
pub iv: *mut iv_tbl,
pub mesg: *mut RObject,
pub backtrace: *mut RObject,
}
impl RException {
#[inline]
pub fn tt(&self) -> mrb_vtype {
unsafe { ::std::mem::transmute(self._bitfield_1.get(0usize, 8u8) as u32) }
}
#[inline]
pub fn set_tt(&mut self, val: mrb_vtype) {
unsafe {
let val: u32 = ::std::mem::transmute(val);
self._bitfield_1.set(0usize, 8u8, val as u64)
}
}
#[inline]
pub fn color(&self) -> u32 {
unsafe { ::std::mem::transmute(self._bitfield_1.get(8usize, 3u8) as u32) }
}
#[inline]
pub fn set_color(&mut self, val: u32) {
unsafe {
let val: u32 = ::std::mem::transmute(val);
self._bitfield_1.set(8usize, 3u8, val as u64)
}
}
#[inline]
pub fn flags(&self) -> u32 {
unsafe { ::std::mem::transmute(self._bitfield_1.get(11usize, 21u8) as u32) }
}
#[inline]
pub fn set_flags(&mut self, val: u32) {
unsafe {
let val: u32 = ::std::mem::transmute(val);
self._bitfield_1.set(11usize, 21u8, val as u64)
}
}
#[inline]
pub fn new_bitfield_1(
tt: mrb_vtype,
color: u32,
flags: u32,
) -> __BindgenBitfieldUnit<[u8; 4usize]> {
let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 4usize]> = Default::default();
__bindgen_bitfield_unit.set(0usize, 8u8, {
let tt: u32 = unsafe { ::std::mem::transmute(tt) };
tt as u64
});
__bindgen_bitfield_unit.set(8usize, 3u8, {
let color: u32 = unsafe { ::std::mem::transmute(color) };
color as u64
});
__bindgen_bitfield_unit.set(11usize, 21u8, {
let flags: u32 = unsafe { ::std::mem::transmute(flags) };
flags as u64
});
__bindgen_bitfield_unit
}
}
pub type minu_state = mrb_state;
pub type minu_aspec = mrb_aspec;
pub type minu_value = mrb_value;
pub type minu_int = mrb_int;
pub type minu_float = mrb_float;
pub type minu_bool = mrb_bool;
pub type minu_sym = mrb_sym;
pub type minu_func_t = mrb_func_t;
extern "C" {
pub fn minu_array_p(v: minu_value) -> minu_bool;
}
extern "C" {
pub fn minu_class_p(v: minu_value) -> minu_bool;
}
extern "C" {
pub fn minu_data_p(v: minu_value) -> minu_bool;
}
extern "C" {
pub fn minu_exception_p(v: minu_value) -> minu_bool;
}
extern "C" {
pub fn minu_false_p(v: minu_value) -> minu_bool;
}
extern "C" {
pub fn minu_fixnum_p(v: minu_value) -> minu_bool;
}
extern "C" {
pub fn minu_float_p(v: minu_value) -> minu_bool;
}
extern "C" {
pub fn minu_hash_p(v: minu_value) -> minu_bool;
}
extern "C" {
pub fn minu_module_p(v: minu_value) -> minu_bool;
}
extern "C" {
pub fn minu_nil_p(v: minu_value) -> minu_bool;
}
extern "C" {
pub fn minu_object_p(v: minu_value) -> minu_bool;
}
extern "C" {
pub fn minu_range_p(v: minu_value) -> minu_bool;
}
extern "C" {
pub fn minu_string_p(v: minu_value) -> minu_bool;
}
extern "C" {
pub fn minu_true_p(v: minu_value) -> minu_bool;
}
extern "C" {
pub fn minu_false_value() -> minu_value;
}
extern "C" {
pub fn minu_nil_value() -> minu_value;
}
extern "C" {
pub fn minu_true_value() -> minu_value;
}
extern "C" {
pub fn minu_float_func(v: minu_value) -> minu_float;
}
extern "C" {
pub fn minu_fixnum_func(v: minu_value) -> minu_int;
}
extern "C" {
pub fn minu_fixnum_value(v: minu_int) -> minu_value;
}
extern "C" {
pub fn minu_float_value(minu: *mut minu_state, v: minu_float) -> minu_value;
}
extern "C" {
pub fn minu_obj_value(v: *mut ::std::os::raw::c_void) -> minu_value;
}
pub type minu_data_type = mrb_data_type;
extern "C" {
pub fn minu_data_get_ptr(
mrb: *mut minu_state,
v: minu_value,
t: *const minu_data_type,
) -> *mut ::std::os::raw::c_void;
}
extern "C" {
pub fn minu_malloc(mrb: *mut mrb_state, s: usize) -> *mut ::std::os::raw::c_void;
}
extern "C" {
pub fn minu_data_object_alloc(
mrb: *mut mrb_state,
klass: *mut RClass,
datap: *mut ::std::os::raw::c_void,
type_: *const mrb_data_type,
) -> *mut RData;
}
extern "C" {
pub fn minu_free(mrb: *mut minu_state, ptr: *mut ::std::os::raw::c_void);
}
extern "C" {
pub fn minu_set_vtype_as_data(cla: *mut RClass);
}
extern "C" {
pub fn minu_define_class_method(
mrb: *mut minu_state,
cla: *mut RClass,
name: *const ::std::os::raw::c_char,
fun: mrb_func_t,
aspec: minu_aspec,
);
}
extern "C" {
pub fn minu_define_method(
mrb: *mut minu_state,
cla: *mut RClass,
name: *const ::std::os::raw::c_char,
func: mrb_func_t,
aspec: minu_aspec,
);
}
extern "C" {
pub fn minu_MRB_ARGS_ARG(n1: u32, n2: u32) -> minu_aspec;
}
extern "C" {
pub fn minu_str_to_cstr(mrb: *mut mrb_state, str_: mrb_value) -> *mut ::std::os::raw::c_char;
}
extern "C" {
pub fn minu_str_new_cstr(mrb: *mut mrb_state, s: *const ::std::os::raw::c_char) -> mrb_value;
}
extern "C" {
pub fn minu_str_new(
mrb: *mut mrb_state,
s: *const ::std::os::raw::c_char,
len: usize,
) -> mrb_value;
}
extern "C" {
pub fn minu_rarray_len(ary: minu_value) -> minu_int;
}
extern "C" {
pub fn minu_ary_ref(ary: minu_value, n: minu_int) -> minu_value;
}
extern "C" {
pub fn minu_ary_new_capa(mrb: *mut mrb_state, capa: mrb_int) -> minu_value;
}
extern "C" {
pub fn minu_ary_new(mrb: *mut mrb_state) -> minu_value;
}
extern "C" {
pub fn minu_ary_push(mrb: *mut mrb_state, array: mrb_value, value: mrb_value);
}
extern "C" {
pub fn minu_hash_keys(mrb: *mut minu_state, hash: minu_value) -> minu_value;
}
extern "C" {
pub fn minu_hash_values(mrb: *mut minu_state, hash: minu_value) -> minu_value;
}
extern "C" {
pub fn minu_hash_size(mrb: *mut minu_state, hash: minu_value) -> minu_int;
}
extern "C" {
pub fn minu_hash_new_capa(mrb: *mut minu_state, capa: minu_int) -> minu_value;
}
extern "C" {
pub fn minu_hash_set(mrb: *mut minu_state, hash: minu_value, key: minu_value, val: minu_value);
}
extern "C" {
pub fn minu_gc_register(mrb: *mut mrb_state, obj: mrb_value);
}
extern "C" {
pub fn minu_gc_unregister(mrb: *mut mrb_state, obj: mrb_value);
}
extern "C" {
pub fn minu_print_backtrace(mrb: *mut mrb_state);
}
extern "C" {
pub fn minu_print_error(mrb: *mut mrb_state);
}
extern "C" {
pub fn minu_get_backtrace(mrb: *mut mrb_state) -> minu_value;
}
extern "C" {
pub fn minu_exc_backtrace(mrb: *mut mrb_state, exc: mrb_value) -> minu_value;
}
extern "C" {
pub fn minu_protect(
mrb: *mut minu_state,
body: minu_func_t,
data: minu_value,
state: *mut minu_bool,
) -> minu_value;
}
extern "C" {
pub fn minu_intern_cstr(mrb: *mut minu_state, s: *const ::std::os::raw::c_char) -> minu_sym;
}
extern "C" {
pub fn minu_symbol_value(i: mrb_sym) -> minu_value;
}
extern "C" {
pub fn minu_obj_to_sym(mrb: *mut minu_state, name: minu_value) -> minu_sym;
}
extern "C" {
pub fn minu_sym2name(mrb: *mut minu_state, mid: minu_sym) -> *const ::std::os::raw::c_char;
}
extern "C" {
pub fn minu_class_get(mrb: *mut minu_state, name: *const ::std::os::raw::c_char)
-> *mut RClass;
}
extern "C" {
pub fn minu_define_class(
mrb: *mut minu_state,
name: *const ::std::os::raw::c_char,
super_: *mut RClass,
) -> *mut RClass;
}
extern "C" {
pub fn minu_load_string(mrb: *mut minu_state, s: *const ::std::os::raw::c_char) -> minu_value;
}
extern "C" {
pub fn minu_open() -> *mut minu_state;
}
extern "C" {
pub fn minu_close(mrb: *mut minu_state);
}
extern "C" {
pub fn minu_inspect(mrb: *mut minu_state, v: mrb_value) -> minu_value;
}
extern "C" {
pub fn minu_obj_is_kind_of(mrb: *mut minu_state, obj: minu_value, c: *mut RClass) -> minu_bool;
}
extern "C" {
pub fn minu_funcall_argv(
mrb: *mut minu_state,
val: minu_value,
name: minu_sym,
argc: minu_int,
argv: *const minu_value,
) -> minu_value;
}
extern "C" {
pub fn minu_funcall_with_block(
mrb: *mut minu_state,
val: minu_value,
name: minu_sym,
argc: minu_int,
argv: *const minu_value,
block: mrb_value,
) -> minu_value;
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct iv_tbl {
pub _address: u8,
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct mt_tbl {
pub _address: u8,
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct mrb_shared_string {
pub _address: u8,
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct hash_entry {
pub _address: u8,
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct hash_table {
pub _address: u8,
}