# [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 const MRB_INT_BIT : u32 = 64 ; pub const MRB_PRIo : & [u8 ; 3] = b"lo\0" ; pub const MRB_PRId : & [u8 ; 3] = b"ld\0" ; pub const MRB_PRIx : & [u8 ; 3] = b"lx\0" ; pub const MRB_FL_OBJ_IS_FROZEN : u32 = 1048576 ; pub const MRB_FIXNUM_SHIFT : u32 = 0 ; pub const MRB_SYMBOL_SHIFT : u32 = 0 ; pub const MRB_EACH_OBJ_OK : u32 = 0 ; pub const MRB_EACH_OBJ_BREAK : u32 = 1 ; pub const MRB_GC_ARENA_SIZE : u32 = 100 ; pub const MRB_GC_RED : u32 = 7 ; pub const MRUBY_RUBY_VERSION : & [u8 ; 4] = b"3.2\0" ; pub const MRUBY_RUBY_ENGINE : & [u8 ; 6] = b"mruby\0" ; pub const MRUBY_RELEASE_MAJOR : u32 = 3 ; pub const MRUBY_RELEASE_MINOR : u32 = 2 ; pub const MRUBY_RELEASE_TEENY : u32 = 0 ; pub const MRUBY_PATCHLEVEL : i32 = - 1 ; pub const MRUBY_PATCHLEVEL_STR : & [u8 ; 1] = b"\0" ; pub const MRUBY_RELEASE_NO : u32 = 30200 ; pub const MRUBY_RELEASE_YEAR : u32 = 2023 ; pub const MRUBY_RELEASE_MONTH : u32 = 2 ; pub const MRUBY_RELEASE_DAY : u32 = 24 ; pub const MRUBY_BIRTH_YEAR : u32 = 2010 ; pub const MRUBY_AUTHOR : & [u8 ; 17] = b"mruby developers\0" ; pub const MRB_FIXED_STATE_ATEXIT_STACK_SIZE : u32 = 5 ; pub const MRB_METHOD_CACHE_SIZE : u32 = 256 ; pub const MRB_ARY_EMBED_LEN_MAX : u32 = 0 ; pub const MRB_ARY_SHARED : u32 = 256 ; pub const MRB_FL_CLASS_IS_PREPENDED : u32 = 524288 ; pub const MRB_FL_CLASS_IS_ORIGIN : u32 = 262144 ; pub const MRB_FL_CLASS_IS_INHERITED : u32 = 131072 ; pub const MRB_INSTANCE_TT_MASK : u32 = 255 ; pub const MRB_PARSER_TOKBUF_MAX : u32 = 65534 ; pub const MRB_PARSER_TOKBUF_SIZE : u32 = 256 ; pub const MRB_ISEQ_NO_FREE : u32 = 1 ; pub const MRB_IREP_NO_FREE : u32 = 2 ; pub const MRB_IREP_STATIC : u32 = 3 ; pub const MRB_DUMP_DEBUG_INFO : u32 = 1 ; pub const MRB_DUMP_STATIC : u32 = 2 ; pub const MRB_DUMP_OK : u32 = 0 ; pub const MRB_DUMP_GENERAL_FAILURE : i32 = - 1 ; pub const MRB_DUMP_WRITE_FAULT : i32 = - 2 ; pub const MRB_DUMP_READ_FAULT : i32 = - 3 ; pub const MRB_DUMP_INVALID_FILE_HEADER : i32 = - 4 ; pub const MRB_DUMP_INVALID_IREP : i32 = - 5 ; pub const MRB_DUMP_INVALID_ARGUMENT : i32 = - 6 ; pub const MRB_DUMP_NULL_SYM_LEN : u32 = 65535 ; pub const MRB_DUMP_DEFAULT_STR_LEN : u32 = 128 ; pub const MRB_EXC_EXIT : u32 = 65536 ; pub const MRB_HASH_IB_BIT_BIT : u32 = 5 ; pub const MRB_HASH_AR_EA_CAPA_BIT : u32 = 5 ; pub const MRB_HASH_IB_BIT_SHIFT : u32 = 0 ; pub const MRB_HASH_AR_EA_CAPA_SHIFT : u32 = 0 ; pub const MRB_HASH_AR_EA_N_USED_SHIFT : u32 = 5 ; pub const MRB_HASH_SIZE_FLAGS_SHIFT : u32 = 10 ; pub const MRB_HASH_IB_BIT_MASK : u32 = 31 ; pub const MRB_HASH_AR_EA_CAPA_MASK : u32 = 31 ; pub const MRB_HASH_AR_EA_N_USED_MASK : u32 = 992 ; pub const MRB_HASH_DEFAULT : u32 = 1024 ; pub const MRB_HASH_PROC_DEFAULT : u32 = 2048 ; pub const MRB_HASH_HT : u32 = 4096 ; pub const MRB_ENV_CLOSED : u32 = 1048576 ; pub const MRB_PROC_CFUNC_FL : u32 = 128 ; pub const MRB_PROC_STRICT : u32 = 256 ; pub const MRB_PROC_ORPHAN : u32 = 512 ; pub const MRB_PROC_ENVSET : u32 = 1024 ; pub const MRB_PROC_SCOPE : u32 = 2048 ; pub const MRB_PROC_NOARG : u32 = 4096 ; pub const MRB_METHOD_FUNC_FL : u32 = 1 ; pub const MRB_METHOD_NOARG_FL : u32 = 2 ; pub const MRB_STR_SHARED : u32 = 1 ; pub const MRB_STR_FSHARED : u32 = 2 ; pub const MRB_STR_NOFREE : u32 = 4 ; pub const MRB_STR_EMBED : u32 = 8 ; pub const MRB_STR_ASCII : u32 = 16 ; pub const MRB_STR_EMBED_LEN_SHIFT : u32 = 6 ; pub const MRB_STR_EMBED_LEN_BIT : u32 = 5 ; pub const MRB_STR_EMBED_LEN_MASK : u32 = 1984 ; pub const MRB_STR_TYPE_MASK : u32 = 15 ; pub type va_list = __builtin_va_list ; # [repr (C)] # [derive (Debug , Copy , Clone)] pub struct __sigset_t { pub __val : [:: std :: os :: raw :: c_ulong ; 16usize] , } # [test] fn bindgen_test_layout___sigset_t () { const UNINIT : :: std :: mem :: MaybeUninit < __sigset_t > = :: std :: mem :: MaybeUninit :: uninit () ; let ptr = UNINIT . as_ptr () ; assert_eq ! (:: std :: mem :: size_of :: < __sigset_t > () , 128usize , concat ! ("Size of: " , stringify ! (__sigset_t))) ; assert_eq ! (:: std :: mem :: align_of :: < __sigset_t > () , 8usize , concat ! ("Alignment of " , stringify ! (__sigset_t))) ; assert_eq ! (unsafe { :: std :: ptr :: addr_of ! ((* ptr) . __val) as usize - ptr as usize } , 0usize , concat ! ("Offset of field: " , stringify ! (__sigset_t) , "::" , stringify ! (__val))) ; } pub type mrb_sym = u32 ; pub type mrb_bool = bool ; pub type mrb_int = i64 ; pub type mrb_uint = u64 ; extern "C" { pub fn mrb_read_int (p : * const :: std :: os :: raw :: c_char , e : * const :: std :: os :: raw :: c_char , endp : * mut * mut :: std :: os :: raw :: c_char , np : * mut mrb_int) -> mrb_bool ; } extern "C" { pub fn mrb_int_read (arg1 : * const :: std :: os :: raw :: c_char , arg2 : * const :: std :: os :: raw :: c_char , arg3 : * mut * mut :: std :: os :: raw :: c_char) -> mrb_int ; } extern "C" { pub fn mrb_read_float (p : * const :: std :: os :: raw :: c_char , endp : * mut * mut :: std :: os :: raw :: c_char , fp : * mut f64) -> mrb_bool ; } extern "C" { pub fn mrb_float_read (p : * const :: std :: os :: raw :: c_char , endp : * mut * mut :: std :: os :: raw :: c_char) -> f64 ; } pub type mrb_float = f64 ; # [repr (u32)] # [derive (Debug , Copy , Clone , Hash , PartialEq , Eq)] pub enum mrb_vtype { MRB_TT_FALSE = 0 , MRB_TT_TRUE = 1 , MRB_TT_SYMBOL = 2 , MRB_TT_UNDEF = 3 , MRB_TT_FREE = 4 , MRB_TT_FLOAT = 5 , MRB_TT_INTEGER = 6 , MRB_TT_CPTR = 7 , MRB_TT_OBJECT = 8 , MRB_TT_CLASS = 9 , MRB_TT_MODULE = 10 , MRB_TT_ICLASS = 11 , MRB_TT_SCLASS = 12 , MRB_TT_PROC = 13 , MRB_TT_ARRAY = 14 , MRB_TT_HASH = 15 , MRB_TT_STRING = 16 , MRB_TT_RANGE = 17 , MRB_TT_EXCEPTION = 18 , MRB_TT_ENV = 19 , MRB_TT_CDATA = 20 , MRB_TT_FIBER = 21 , MRB_TT_STRUCT = 22 , MRB_TT_ISTRUCT = 23 , MRB_TT_BREAK = 24 , MRB_TT_COMPLEX = 25 , MRB_TT_RATIONAL = 26 , MRB_TT_BIGINT = 27 , MRB_TT_MAXDEFINE = 28 , } # [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 , } # [test] fn bindgen_test_layout_RBasic () { const UNINIT : :: std :: mem :: MaybeUninit < RBasic > = :: std :: mem :: MaybeUninit :: uninit () ; let ptr = UNINIT . as_ptr () ; assert_eq ! (:: std :: mem :: size_of :: < RBasic > () , 24usize , concat ! ("Size of: " , stringify ! (RBasic))) ; assert_eq ! (:: std :: mem :: align_of :: < RBasic > () , 8usize , concat ! ("Alignment of " , stringify ! (RBasic))) ; assert_eq ! (unsafe { :: std :: ptr :: addr_of ! ((* ptr) . c) as usize - ptr as usize } , 0usize , concat ! ("Offset of field: " , stringify ! (RBasic) , "::" , stringify ! (c))) ; assert_eq ! (unsafe { :: std :: ptr :: addr_of ! ((* ptr) . gcnext) as usize - ptr as usize } , 8usize , concat ! ("Offset of field: " , stringify ! (RBasic) , "::" , stringify ! (gcnext))) ; } 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 , } # [test] fn bindgen_test_layout_RObject () { const UNINIT : :: std :: mem :: MaybeUninit < RObject > = :: std :: mem :: MaybeUninit :: uninit () ; let ptr = UNINIT . as_ptr () ; assert_eq ! (:: std :: mem :: size_of :: < RObject > () , 32usize , concat ! ("Size of: " , stringify ! (RObject))) ; assert_eq ! (:: std :: mem :: align_of :: < RObject > () , 8usize , concat ! ("Alignment of " , stringify ! (RObject))) ; assert_eq ! (unsafe { :: std :: ptr :: addr_of ! ((* ptr) . c) as usize - ptr as usize } , 0usize , concat ! ("Offset of field: " , stringify ! (RObject) , "::" , stringify ! (c))) ; assert_eq ! (unsafe { :: std :: ptr :: addr_of ! ((* ptr) . gcnext) as usize - ptr as usize } , 8usize , concat ! ("Offset of field: " , stringify ! (RObject) , "::" , stringify ! (gcnext))) ; assert_eq ! (unsafe { :: std :: ptr :: addr_of ! ((* ptr) . iv) as usize - ptr as usize } , 24usize , concat ! ("Offset of field: " , stringify ! (RObject) , "::" , stringify ! (iv))) ; } 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 , } # [test] fn bindgen_test_layout_RFiber () { const UNINIT : :: std :: mem :: MaybeUninit < RFiber > = :: std :: mem :: MaybeUninit :: uninit () ; let ptr = UNINIT . as_ptr () ; assert_eq ! (:: std :: mem :: size_of :: < RFiber > () , 32usize , concat ! ("Size of: " , stringify ! (RFiber))) ; assert_eq ! (:: std :: mem :: align_of :: < RFiber > () , 8usize , concat ! ("Alignment of " , stringify ! (RFiber))) ; assert_eq ! (unsafe { :: std :: ptr :: addr_of ! ((* ptr) . c) as usize - ptr as usize } , 0usize , concat ! ("Offset of field: " , stringify ! (RFiber) , "::" , stringify ! (c))) ; assert_eq ! (unsafe { :: std :: ptr :: addr_of ! ((* ptr) . gcnext) as usize - ptr as usize } , 8usize , concat ! ("Offset of field: " , stringify ! (RFiber) , "::" , stringify ! (gcnext))) ; assert_eq ! (unsafe { :: std :: ptr :: addr_of ! ((* ptr) . cxt) as usize - ptr as usize } , 24usize , concat ! ("Offset of field: " , stringify ! (RFiber) , "::" , stringify ! (cxt))) ; } 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 (Copy , Clone)] pub union mrb_value_union { pub f : mrb_float , pub p : * mut :: std :: os :: raw :: c_void , pub i : mrb_int , pub sym : mrb_sym , } # [test] fn bindgen_test_layout_mrb_value_union () { const UNINIT : :: std :: mem :: MaybeUninit < mrb_value_union > = :: std :: mem :: MaybeUninit :: uninit () ; let ptr = UNINIT . as_ptr () ; assert_eq ! (:: std :: mem :: size_of :: < mrb_value_union > () , 8usize , concat ! ("Size of: " , stringify ! (mrb_value_union))) ; assert_eq ! (:: std :: mem :: align_of :: < mrb_value_union > () , 8usize , concat ! ("Alignment of " , stringify ! (mrb_value_union))) ; assert_eq ! (unsafe { :: std :: ptr :: addr_of ! ((* ptr) . f) as usize - ptr as usize } , 0usize , concat ! ("Offset of field: " , stringify ! (mrb_value_union) , "::" , stringify ! (f))) ; assert_eq ! (unsafe { :: std :: ptr :: addr_of ! ((* ptr) . p) as usize - ptr as usize } , 0usize , concat ! ("Offset of field: " , stringify ! (mrb_value_union) , "::" , stringify ! (p))) ; assert_eq ! (unsafe { :: std :: ptr :: addr_of ! ((* ptr) . i) as usize - ptr as usize } , 0usize , concat ! ("Offset of field: " , stringify ! (mrb_value_union) , "::" , stringify ! (i))) ; assert_eq ! (unsafe { :: std :: ptr :: addr_of ! ((* ptr) . sym) as usize - ptr as usize } , 0usize , concat ! ("Offset of field: " , stringify ! (mrb_value_union) , "::" , stringify ! (sym))) ; } # [repr (C)] # [derive (Copy , Clone)] pub struct mrb_value { pub value : mrb_value_union , pub tt : mrb_vtype , } # [test] fn bindgen_test_layout_mrb_value () { const UNINIT : :: std :: mem :: MaybeUninit < mrb_value > = :: std :: mem :: MaybeUninit :: uninit () ; let ptr = UNINIT . as_ptr () ; assert_eq ! (:: std :: mem :: size_of :: < mrb_value > () , 16usize , concat ! ("Size of: " , stringify ! (mrb_value))) ; assert_eq ! (:: std :: mem :: align_of :: < mrb_value > () , 8usize , concat ! ("Alignment of " , stringify ! (mrb_value))) ; assert_eq ! (unsafe { :: std :: ptr :: addr_of ! ((* ptr) . value) as usize - ptr as usize } , 0usize , concat ! ("Offset of field: " , stringify ! (mrb_value) , "::" , stringify ! (value))) ; assert_eq ! (unsafe { :: std :: ptr :: addr_of ! ((* ptr) . tt) as usize - ptr as usize } , 8usize , concat ! ("Offset of field: " , stringify ! (mrb_value) , "::" , stringify ! (tt))) ; } pub type mrb_ssize = mrb_int ; pub type mrb_each_object_callback = :: std :: option :: Option < unsafe extern "C" fn (mrb : * mut mrb_state , obj : * mut RBasic , data : * mut :: std :: os :: raw :: c_void) -> :: std :: os :: raw :: c_int > ; extern "C" { pub fn mrb_objspace_each_objects (mrb : * mut mrb_state , callback : mrb_each_object_callback , data : * mut :: std :: os :: raw :: c_void) ; } extern "C" { pub fn mrb_objspace_page_slot_size () -> usize ; } extern "C" { pub fn mrb_free_context (mrb : * mut mrb_state , c : * mut mrb_context) ; } # [repr (u32)] # [derive (Debug , Copy , Clone , Hash , PartialEq , Eq)] pub enum mrb_gc_state { MRB_GC_STATE_ROOT = 0 , MRB_GC_STATE_MARK = 1 , MRB_GC_STATE_SWEEP = 2 , } # [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] , } # [test] fn bindgen_test_layout_mrb_heap_page () { const UNINIT : :: std :: mem :: MaybeUninit < mrb_heap_page > = :: std :: mem :: MaybeUninit :: uninit () ; let ptr = UNINIT . as_ptr () ; assert_eq ! (:: std :: mem :: size_of :: < mrb_heap_page > () , 48usize , concat ! ("Size of: " , stringify ! (mrb_heap_page))) ; assert_eq ! (:: std :: mem :: align_of :: < mrb_heap_page > () , 8usize , concat ! ("Alignment of " , stringify ! (mrb_heap_page))) ; assert_eq ! (unsafe { :: std :: ptr :: addr_of ! ((* ptr) . freelist) as usize - ptr as usize } , 0usize , concat ! ("Offset of field: " , stringify ! (mrb_heap_page) , "::" , stringify ! (freelist))) ; assert_eq ! (unsafe { :: std :: ptr :: addr_of ! ((* ptr) . prev) as usize - ptr as usize } , 8usize , concat ! ("Offset of field: " , stringify ! (mrb_heap_page) , "::" , stringify ! (prev))) ; assert_eq ! (unsafe { :: std :: ptr :: addr_of ! ((* ptr) . next) as usize - ptr as usize } , 16usize , concat ! ("Offset of field: " , stringify ! (mrb_heap_page) , "::" , stringify ! (next))) ; assert_eq ! (unsafe { :: std :: ptr :: addr_of ! ((* ptr) . free_next) as usize - ptr as usize } , 24usize , concat ! ("Offset of field: " , stringify ! (mrb_heap_page) , "::" , stringify ! (free_next))) ; assert_eq ! (unsafe { :: std :: ptr :: addr_of ! ((* ptr) . free_prev) as usize - ptr as usize } , 32usize , concat ! ("Offset of field: " , stringify ! (mrb_heap_page) , "::" , stringify ! (free_prev))) ; } 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 , } # [test] fn bindgen_test_layout_mrb_gc () { const UNINIT : :: std :: mem :: MaybeUninit < mrb_gc > = :: std :: mem :: MaybeUninit :: uninit () ; let ptr = UNINIT . as_ptr () ; assert_eq ! (:: std :: mem :: size_of :: < mrb_gc > () , 112usize , concat ! ("Size of: " , stringify ! (mrb_gc))) ; assert_eq ! (:: std :: mem :: align_of :: < mrb_gc > () , 8usize , concat ! ("Alignment of " , stringify ! (mrb_gc))) ; assert_eq ! (unsafe { :: std :: ptr :: addr_of ! ((* ptr) . heaps) as usize - ptr as usize } , 0usize , concat ! ("Offset of field: " , stringify ! (mrb_gc) , "::" , stringify ! (heaps))) ; assert_eq ! (unsafe { :: std :: ptr :: addr_of ! ((* ptr) . sweeps) as usize - ptr as usize } , 8usize , concat ! ("Offset of field: " , stringify ! (mrb_gc) , "::" , stringify ! (sweeps))) ; assert_eq ! (unsafe { :: std :: ptr :: addr_of ! ((* ptr) . free_heaps) as usize - ptr as usize } , 16usize , concat ! ("Offset of field: " , stringify ! (mrb_gc) , "::" , stringify ! (free_heaps))) ; assert_eq ! (unsafe { :: std :: ptr :: addr_of ! ((* ptr) . live) as usize - ptr as usize } , 24usize , concat ! ("Offset of field: " , stringify ! (mrb_gc) , "::" , stringify ! (live))) ; assert_eq ! (unsafe { :: std :: ptr :: addr_of ! ((* ptr) . arena) as usize - ptr as usize } , 32usize , concat ! ("Offset of field: " , stringify ! (mrb_gc) , "::" , stringify ! (arena))) ; assert_eq ! (unsafe { :: std :: ptr :: addr_of ! ((* ptr) . arena_capa) as usize - ptr as usize } , 40usize , concat ! ("Offset of field: " , stringify ! (mrb_gc) , "::" , stringify ! (arena_capa))) ; assert_eq ! (unsafe { :: std :: ptr :: addr_of ! ((* ptr) . arena_idx) as usize - ptr as usize } , 44usize , concat ! ("Offset of field: " , stringify ! (mrb_gc) , "::" , stringify ! (arena_idx))) ; assert_eq ! (unsafe { :: std :: ptr :: addr_of ! ((* ptr) . state) as usize - ptr as usize } , 48usize , concat ! ("Offset of field: " , stringify ! (mrb_gc) , "::" , stringify ! (state))) ; assert_eq ! (unsafe { :: std :: ptr :: addr_of ! ((* ptr) . current_white_part) as usize - ptr as usize } , 52usize , concat ! ("Offset of field: " , stringify ! (mrb_gc) , "::" , stringify ! (current_white_part))) ; assert_eq ! (unsafe { :: std :: ptr :: addr_of ! ((* ptr) . gray_list) as usize - ptr as usize } , 56usize , concat ! ("Offset of field: " , stringify ! (mrb_gc) , "::" , stringify ! (gray_list))) ; assert_eq ! (unsafe { :: std :: ptr :: addr_of ! ((* ptr) . atomic_gray_list) as usize - ptr as usize } , 64usize , concat ! ("Offset of field: " , stringify ! (mrb_gc) , "::" , stringify ! (atomic_gray_list))) ; assert_eq ! (unsafe { :: std :: ptr :: addr_of ! ((* ptr) . live_after_mark) as usize - ptr as usize } , 72usize , concat ! ("Offset of field: " , stringify ! (mrb_gc) , "::" , stringify ! (live_after_mark))) ; assert_eq ! (unsafe { :: std :: ptr :: addr_of ! ((* ptr) . threshold) as usize - ptr as usize } , 80usize , concat ! ("Offset of field: " , stringify ! (mrb_gc) , "::" , stringify ! (threshold))) ; assert_eq ! (unsafe { :: std :: ptr :: addr_of ! ((* ptr) . interval_ratio) as usize - ptr as usize } , 88usize , concat ! ("Offset of field: " , stringify ! (mrb_gc) , "::" , stringify ! (interval_ratio))) ; assert_eq ! (unsafe { :: std :: ptr :: addr_of ! ((* ptr) . step_ratio) as usize - ptr as usize } , 92usize , concat ! ("Offset of field: " , stringify ! (mrb_gc) , "::" , stringify ! (step_ratio))) ; assert_eq ! (unsafe { :: std :: ptr :: addr_of ! ((* ptr) . majorgc_old_threshold) as usize - ptr as usize } , 104usize , concat ! ("Offset of field: " , stringify ! (mrb_gc) , "::" , stringify ! (majorgc_old_threshold))) ; } 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 } } extern "C" { pub fn mrb_object_dead_p (mrb : * mut mrb_state , object : * mut RBasic) -> mrb_bool ; } 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 , } # [test] fn bindgen_test_layout_mrb_callinfo__bindgen_ty_1 () { const UNINIT : :: std :: mem :: MaybeUninit < mrb_callinfo__bindgen_ty_1 > = :: std :: mem :: MaybeUninit :: uninit () ; let ptr = UNINIT . as_ptr () ; assert_eq ! (:: std :: mem :: size_of :: < mrb_callinfo__bindgen_ty_1 > () , 8usize , concat ! ("Size of: " , stringify ! (mrb_callinfo__bindgen_ty_1))) ; assert_eq ! (:: std :: mem :: align_of :: < mrb_callinfo__bindgen_ty_1 > () , 8usize , concat ! ("Alignment of " , stringify ! (mrb_callinfo__bindgen_ty_1))) ; assert_eq ! (unsafe { :: std :: ptr :: addr_of ! ((* ptr) . env) as usize - ptr as usize } , 0usize , concat ! ("Offset of field: " , stringify ! (mrb_callinfo__bindgen_ty_1) , "::" , stringify ! (env))) ; assert_eq ! (unsafe { :: std :: ptr :: addr_of ! ((* ptr) . target_class) as usize - ptr as usize } , 0usize , concat ! ("Offset of field: " , stringify ! (mrb_callinfo__bindgen_ty_1) , "::" , stringify ! (target_class))) ; } # [test] fn bindgen_test_layout_mrb_callinfo () { const UNINIT : :: std :: mem :: MaybeUninit < mrb_callinfo > = :: std :: mem :: MaybeUninit :: uninit () ; let ptr = UNINIT . as_ptr () ; assert_eq ! (:: std :: mem :: size_of :: < mrb_callinfo > () , 48usize , concat ! ("Size of: " , stringify ! (mrb_callinfo))) ; assert_eq ! (:: std :: mem :: align_of :: < mrb_callinfo > () , 8usize , concat ! ("Alignment of " , stringify ! (mrb_callinfo))) ; assert_eq ! (unsafe { :: std :: ptr :: addr_of ! ((* ptr) . cci) as usize - ptr as usize } , 1usize , concat ! ("Offset of field: " , stringify ! (mrb_callinfo) , "::" , stringify ! (cci))) ; assert_eq ! (unsafe { :: std :: ptr :: addr_of ! ((* ptr) . mid) as usize - ptr as usize } , 4usize , concat ! ("Offset of field: " , stringify ! (mrb_callinfo) , "::" , stringify ! (mid))) ; assert_eq ! (unsafe { :: std :: ptr :: addr_of ! ((* ptr) . proc_) as usize - ptr as usize } , 8usize , concat ! ("Offset of field: " , stringify ! (mrb_callinfo) , "::" , stringify ! (proc_))) ; assert_eq ! (unsafe { :: std :: ptr :: addr_of ! ((* ptr) . blk) as usize - ptr as usize } , 16usize , concat ! ("Offset of field: " , stringify ! (mrb_callinfo) , "::" , stringify ! (blk))) ; assert_eq ! (unsafe { :: std :: ptr :: addr_of ! ((* ptr) . stack) as usize - ptr as usize } , 24usize , concat ! ("Offset of field: " , stringify ! (mrb_callinfo) , "::" , stringify ! (stack))) ; assert_eq ! (unsafe { :: std :: ptr :: addr_of ! ((* ptr) . pc) as usize - ptr as usize } , 32usize , concat ! ("Offset of field: " , stringify ! (mrb_callinfo) , "::" , stringify ! (pc))) ; assert_eq ! (unsafe { :: std :: ptr :: addr_of ! ((* ptr) . u) as usize - ptr as usize } , 40usize , concat ! ("Offset of field: " , stringify ! (mrb_callinfo) , "::" , stringify ! (u))) ; } 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 } } # [repr (u32)] # [derive (Debug , Copy , Clone , Hash , PartialEq , Eq)] pub enum mrb_fiber_state { MRB_FIBER_CREATED = 0 , MRB_FIBER_RUNNING = 1 , MRB_FIBER_RESUMED = 2 , MRB_FIBER_SUSPENDED = 3 , MRB_FIBER_TRANSFERRED = 4 , MRB_FIBER_TERMINATED = 5 , } # [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 , } # [test] fn bindgen_test_layout_mrb_context () { const UNINIT : :: std :: mem :: MaybeUninit < mrb_context > = :: std :: mem :: MaybeUninit :: uninit () ; let ptr = UNINIT . as_ptr () ; assert_eq ! (:: std :: mem :: size_of :: < mrb_context > () , 64usize , concat ! ("Size of: " , stringify ! (mrb_context))) ; assert_eq ! (:: std :: mem :: align_of :: < mrb_context > () , 8usize , concat ! ("Alignment of " , stringify ! (mrb_context))) ; assert_eq ! (unsafe { :: std :: ptr :: addr_of ! ((* ptr) . prev) as usize - ptr as usize } , 0usize , concat ! ("Offset of field: " , stringify ! (mrb_context) , "::" , stringify ! (prev))) ; assert_eq ! (unsafe { :: std :: ptr :: addr_of ! ((* ptr) . stbase) as usize - ptr as usize } , 8usize , concat ! ("Offset of field: " , stringify ! (mrb_context) , "::" , stringify ! (stbase))) ; assert_eq ! (unsafe { :: std :: ptr :: addr_of ! ((* ptr) . stend) as usize - ptr as usize } , 16usize , concat ! ("Offset of field: " , stringify ! (mrb_context) , "::" , stringify ! (stend))) ; assert_eq ! (unsafe { :: std :: ptr :: addr_of ! ((* ptr) . ci) as usize - ptr as usize } , 24usize , concat ! ("Offset of field: " , stringify ! (mrb_context) , "::" , stringify ! (ci))) ; assert_eq ! (unsafe { :: std :: ptr :: addr_of ! ((* ptr) . cibase) as usize - ptr as usize } , 32usize , concat ! ("Offset of field: " , stringify ! (mrb_context) , "::" , stringify ! (cibase))) ; assert_eq ! (unsafe { :: std :: ptr :: addr_of ! ((* ptr) . ciend) as usize - ptr as usize } , 40usize , concat ! ("Offset of field: " , stringify ! (mrb_context) , "::" , stringify ! (ciend))) ; assert_eq ! (unsafe { :: std :: ptr :: addr_of ! ((* ptr) . fib) as usize - ptr as usize } , 56usize , concat ! ("Offset of field: " , stringify ! (mrb_context) , "::" , stringify ! (fib))) ; } 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 , } # [test] fn bindgen_test_layout_mrb_cache_entry () { const UNINIT : :: std :: mem :: MaybeUninit < mrb_cache_entry > = :: std :: mem :: MaybeUninit :: uninit () ; let ptr = UNINIT . as_ptr () ; assert_eq ! (:: std :: mem :: size_of :: < mrb_cache_entry > () , 32usize , concat ! ("Size of: " , stringify ! (mrb_cache_entry))) ; assert_eq ! (:: std :: mem :: align_of :: < mrb_cache_entry > () , 8usize , concat ! ("Alignment of " , stringify ! (mrb_cache_entry))) ; assert_eq ! (unsafe { :: std :: ptr :: addr_of ! ((* ptr) . c) as usize - ptr as usize } , 0usize , concat ! ("Offset of field: " , stringify ! (mrb_cache_entry) , "::" , stringify ! (c))) ; assert_eq ! (unsafe { :: std :: ptr :: addr_of ! ((* ptr) . c0) as usize - ptr as usize } , 8usize , concat ! ("Offset of field: " , stringify ! (mrb_cache_entry) , "::" , stringify ! (c0))) ; assert_eq ! (unsafe { :: std :: ptr :: addr_of ! ((* ptr) . mid) as usize - ptr as usize } , 16usize , concat ! ("Offset of field: " , stringify ! (mrb_cache_entry) , "::" , stringify ! (mid))) ; assert_eq ! (unsafe { :: std :: ptr :: addr_of ! ((* ptr) . m) as usize - ptr as usize } , 24usize , concat ! ("Offset of field: " , stringify ! (mrb_cache_entry) , "::" , stringify ! (m))) ; } 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 , } # [test] fn bindgen_test_layout_mrb_state () { const UNINIT : :: std :: mem :: MaybeUninit < mrb_state > = :: std :: mem :: MaybeUninit :: uninit () ; let ptr = UNINIT . as_ptr () ; assert_eq ! (:: std :: mem :: size_of :: < mrb_state > () , 9616usize , concat ! ("Size of: " , stringify ! (mrb_state))) ; assert_eq ! (:: std :: mem :: align_of :: < mrb_state > () , 8usize , concat ! ("Alignment of " , stringify ! (mrb_state))) ; assert_eq ! (unsafe { :: std :: ptr :: addr_of ! ((* ptr) . jmp) as usize - ptr as usize } , 0usize , concat ! ("Offset of field: " , stringify ! (mrb_state) , "::" , stringify ! (jmp))) ; assert_eq ! (unsafe { :: std :: ptr :: addr_of ! ((* ptr) . allocf) as usize - ptr as usize } , 8usize , concat ! ("Offset of field: " , stringify ! (mrb_state) , "::" , stringify ! (allocf))) ; assert_eq ! (unsafe { :: std :: ptr :: addr_of ! ((* ptr) . allocf_ud) as usize - ptr as usize } , 16usize , concat ! ("Offset of field: " , stringify ! (mrb_state) , "::" , stringify ! (allocf_ud))) ; assert_eq ! (unsafe { :: std :: ptr :: addr_of ! ((* ptr) . c) as usize - ptr as usize } , 24usize , concat ! ("Offset of field: " , stringify ! (mrb_state) , "::" , stringify ! (c))) ; assert_eq ! (unsafe { :: std :: ptr :: addr_of ! ((* ptr) . root_c) as usize - ptr as usize } , 32usize , concat ! ("Offset of field: " , stringify ! (mrb_state) , "::" , stringify ! (root_c))) ; assert_eq ! (unsafe { :: std :: ptr :: addr_of ! ((* ptr) . globals) as usize - ptr as usize } , 40usize , concat ! ("Offset of field: " , stringify ! (mrb_state) , "::" , stringify ! (globals))) ; assert_eq ! (unsafe { :: std :: ptr :: addr_of ! ((* ptr) . exc) as usize - ptr as usize } , 48usize , concat ! ("Offset of field: " , stringify ! (mrb_state) , "::" , stringify ! (exc))) ; assert_eq ! (unsafe { :: std :: ptr :: addr_of ! ((* ptr) . top_self) as usize - ptr as usize } , 56usize , concat ! ("Offset of field: " , stringify ! (mrb_state) , "::" , stringify ! (top_self))) ; assert_eq ! (unsafe { :: std :: ptr :: addr_of ! ((* ptr) . object_class) as usize - ptr as usize } , 64usize , concat ! ("Offset of field: " , stringify ! (mrb_state) , "::" , stringify ! (object_class))) ; assert_eq ! (unsafe { :: std :: ptr :: addr_of ! ((* ptr) . class_class) as usize - ptr as usize } , 72usize , concat ! ("Offset of field: " , stringify ! (mrb_state) , "::" , stringify ! (class_class))) ; assert_eq ! (unsafe { :: std :: ptr :: addr_of ! ((* ptr) . module_class) as usize - ptr as usize } , 80usize , concat ! ("Offset of field: " , stringify ! (mrb_state) , "::" , stringify ! (module_class))) ; assert_eq ! (unsafe { :: std :: ptr :: addr_of ! ((* ptr) . proc_class) as usize - ptr as usize } , 88usize , concat ! ("Offset of field: " , stringify ! (mrb_state) , "::" , stringify ! (proc_class))) ; assert_eq ! (unsafe { :: std :: ptr :: addr_of ! ((* ptr) . string_class) as usize - ptr as usize } , 96usize , concat ! ("Offset of field: " , stringify ! (mrb_state) , "::" , stringify ! (string_class))) ; assert_eq ! (unsafe { :: std :: ptr :: addr_of ! ((* ptr) . array_class) as usize - ptr as usize } , 104usize , concat ! ("Offset of field: " , stringify ! (mrb_state) , "::" , stringify ! (array_class))) ; assert_eq ! (unsafe { :: std :: ptr :: addr_of ! ((* ptr) . hash_class) as usize - ptr as usize } , 112usize , concat ! ("Offset of field: " , stringify ! (mrb_state) , "::" , stringify ! (hash_class))) ; assert_eq ! (unsafe { :: std :: ptr :: addr_of ! ((* ptr) . range_class) as usize - ptr as usize } , 120usize , concat ! ("Offset of field: " , stringify ! (mrb_state) , "::" , stringify ! (range_class))) ; assert_eq ! (unsafe { :: std :: ptr :: addr_of ! ((* ptr) . float_class) as usize - ptr as usize } , 128usize , concat ! ("Offset of field: " , stringify ! (mrb_state) , "::" , stringify ! (float_class))) ; assert_eq ! (unsafe { :: std :: ptr :: addr_of ! ((* ptr) . integer_class) as usize - ptr as usize } , 136usize , concat ! ("Offset of field: " , stringify ! (mrb_state) , "::" , stringify ! (integer_class))) ; assert_eq ! (unsafe { :: std :: ptr :: addr_of ! ((* ptr) . true_class) as usize - ptr as usize } , 144usize , concat ! ("Offset of field: " , stringify ! (mrb_state) , "::" , stringify ! (true_class))) ; assert_eq ! (unsafe { :: std :: ptr :: addr_of ! ((* ptr) . false_class) as usize - ptr as usize } , 152usize , concat ! ("Offset of field: " , stringify ! (mrb_state) , "::" , stringify ! (false_class))) ; assert_eq ! (unsafe { :: std :: ptr :: addr_of ! ((* ptr) . nil_class) as usize - ptr as usize } , 160usize , concat ! ("Offset of field: " , stringify ! (mrb_state) , "::" , stringify ! (nil_class))) ; assert_eq ! (unsafe { :: std :: ptr :: addr_of ! ((* ptr) . symbol_class) as usize - ptr as usize } , 168usize , concat ! ("Offset of field: " , stringify ! (mrb_state) , "::" , stringify ! (symbol_class))) ; assert_eq ! (unsafe { :: std :: ptr :: addr_of ! ((* ptr) . kernel_module) as usize - ptr as usize } , 176usize , concat ! ("Offset of field: " , stringify ! (mrb_state) , "::" , stringify ! (kernel_module))) ; assert_eq ! (unsafe { :: std :: ptr :: addr_of ! ((* ptr) . gc) as usize - ptr as usize } , 184usize , concat ! ("Offset of field: " , stringify ! (mrb_state) , "::" , stringify ! (gc))) ; assert_eq ! (unsafe { :: std :: ptr :: addr_of ! ((* ptr) . cache) as usize - ptr as usize } , 296usize , concat ! ("Offset of field: " , stringify ! (mrb_state) , "::" , stringify ! (cache))) ; assert_eq ! (unsafe { :: std :: ptr :: addr_of ! ((* ptr) . symidx) as usize - ptr as usize } , 8488usize , concat ! ("Offset of field: " , stringify ! (mrb_state) , "::" , stringify ! (symidx))) ; assert_eq ! (unsafe { :: std :: ptr :: addr_of ! ((* ptr) . symtbl) as usize - ptr as usize } , 8496usize , concat ! ("Offset of field: " , stringify ! (mrb_state) , "::" , stringify ! (symtbl))) ; assert_eq ! (unsafe { :: std :: ptr :: addr_of ! ((* ptr) . symlink) as usize - ptr as usize } , 8504usize , concat ! ("Offset of field: " , stringify ! (mrb_state) , "::" , stringify ! (symlink))) ; assert_eq ! (unsafe { :: std :: ptr :: addr_of ! ((* ptr) . symflags) as usize - ptr as usize } , 8512usize , concat ! ("Offset of field: " , stringify ! (mrb_state) , "::" , stringify ! (symflags))) ; assert_eq ! (unsafe { :: std :: ptr :: addr_of ! ((* ptr) . symhash) as usize - ptr as usize } , 8520usize , concat ! ("Offset of field: " , stringify ! (mrb_state) , "::" , stringify ! (symhash))) ; assert_eq ! (unsafe { :: std :: ptr :: addr_of ! ((* ptr) . symcapa) as usize - ptr as usize } , 9544usize , concat ! ("Offset of field: " , stringify ! (mrb_state) , "::" , stringify ! (symcapa))) ; assert_eq ! (unsafe { :: std :: ptr :: addr_of ! ((* ptr) . symbuf) as usize - ptr as usize } , 9552usize , concat ! ("Offset of field: " , stringify ! (mrb_state) , "::" , stringify ! (symbuf))) ; assert_eq ! (unsafe { :: std :: ptr :: addr_of ! ((* ptr) . eException_class) as usize - ptr as usize } , 9560usize , concat ! ("Offset of field: " , stringify ! (mrb_state) , "::" , stringify ! (eException_class))) ; assert_eq ! (unsafe { :: std :: ptr :: addr_of ! ((* ptr) . eStandardError_class) as usize - ptr as usize } , 9568usize , concat ! ("Offset of field: " , stringify ! (mrb_state) , "::" , stringify ! (eStandardError_class))) ; assert_eq ! (unsafe { :: std :: ptr :: addr_of ! ((* ptr) . nomem_err) as usize - ptr as usize } , 9576usize , concat ! ("Offset of field: " , stringify ! (mrb_state) , "::" , stringify ! (nomem_err))) ; assert_eq ! (unsafe { :: std :: ptr :: addr_of ! ((* ptr) . stack_err) as usize - ptr as usize } , 9584usize , concat ! ("Offset of field: " , stringify ! (mrb_state) , "::" , stringify ! (stack_err))) ; assert_eq ! (unsafe { :: std :: ptr :: addr_of ! ((* ptr) . ud) as usize - ptr as usize } , 9592usize , concat ! ("Offset of field: " , stringify ! (mrb_state) , "::" , stringify ! (ud))) ; assert_eq ! (unsafe { :: std :: ptr :: addr_of ! ((* ptr) . atexit_stack) as usize - ptr as usize } , 9600usize , concat ! ("Offset of field: " , stringify ! (mrb_state) , "::" , stringify ! (atexit_stack))) ; assert_eq ! (unsafe { :: std :: ptr :: addr_of ! ((* ptr) . atexit_stack_len) as usize - ptr as usize } , 9608usize , concat ! ("Offset of field: " , stringify ! (mrb_state) , "::" , stringify ! (atexit_stack_len))) ; } extern "C" { pub fn mrb_define_class (mrb : * mut mrb_state , name : * const :: std :: os :: raw :: c_char , super_ : * mut RClass) -> * mut RClass ; } extern "C" { pub fn mrb_define_class_id (mrb : * mut mrb_state , name : mrb_sym , super_ : * mut RClass) -> * mut RClass ; } extern "C" { pub fn mrb_define_module (mrb : * mut mrb_state , name : * const :: std :: os :: raw :: c_char) -> * mut RClass ; } extern "C" { pub fn mrb_define_module_id (mrb : * mut mrb_state , name : mrb_sym) -> * mut RClass ; } extern "C" { pub fn mrb_singleton_class (mrb : * mut mrb_state , val : mrb_value) -> mrb_value ; } extern "C" { pub fn mrb_singleton_class_ptr (mrb : * mut mrb_state , val : mrb_value) -> * mut RClass ; } extern "C" { pub fn mrb_include_module (mrb : * mut mrb_state , cla : * mut RClass , included : * mut RClass) ; } extern "C" { pub fn mrb_prepend_module (mrb : * mut mrb_state , cla : * mut RClass , prepended : * mut RClass) ; } extern "C" { pub fn mrb_define_method (mrb : * mut mrb_state , cla : * mut RClass , name : * const :: std :: os :: raw :: c_char , func : mrb_func_t , aspec : mrb_aspec) ; } extern "C" { pub fn mrb_define_method_id (mrb : * mut mrb_state , c : * mut RClass , mid : mrb_sym , func : mrb_func_t , aspec : mrb_aspec) ; } extern "C" { pub fn mrb_define_class_method (mrb : * mut mrb_state , cla : * mut RClass , name : * const :: std :: os :: raw :: c_char , fun : mrb_func_t , aspec : mrb_aspec) ; } extern "C" { pub fn mrb_define_class_method_id (mrb : * mut mrb_state , cla : * mut RClass , name : mrb_sym , fun : mrb_func_t , aspec : mrb_aspec) ; } extern "C" { pub fn mrb_define_singleton_method (mrb : * mut mrb_state , cla : * mut RObject , name : * const :: std :: os :: raw :: c_char , fun : mrb_func_t , aspec : mrb_aspec) ; } extern "C" { pub fn mrb_define_singleton_method_id (mrb : * mut mrb_state , cla : * mut RObject , name : mrb_sym , fun : mrb_func_t , aspec : mrb_aspec) ; } extern "C" { pub fn mrb_define_module_function (mrb : * mut mrb_state , cla : * mut RClass , name : * const :: std :: os :: raw :: c_char , fun : mrb_func_t , aspec : mrb_aspec) ; } extern "C" { pub fn mrb_define_module_function_id (mrb : * mut mrb_state , cla : * mut RClass , name : mrb_sym , fun : mrb_func_t , aspec : mrb_aspec) ; } extern "C" { pub fn mrb_define_const (mrb : * mut mrb_state , cla : * mut RClass , name : * const :: std :: os :: raw :: c_char , val : mrb_value) ; } extern "C" { pub fn mrb_define_const_id (mrb : * mut mrb_state , cla : * mut RClass , name : mrb_sym , val : mrb_value) ; } extern "C" { pub fn mrb_undef_method (mrb : * mut mrb_state , cla : * mut RClass , name : * const :: std :: os :: raw :: c_char) ; } extern "C" { pub fn mrb_undef_method_id (arg1 : * mut mrb_state , arg2 : * mut RClass , arg3 : mrb_sym) ; } extern "C" { pub fn mrb_undef_class_method (mrb : * mut mrb_state , cls : * mut RClass , name : * const :: std :: os :: raw :: c_char) ; } extern "C" { pub fn mrb_undef_class_method_id (mrb : * mut mrb_state , cls : * mut RClass , name : mrb_sym) ; } extern "C" { pub fn mrb_obj_new (mrb : * mut mrb_state , c : * mut RClass , argc : mrb_int , argv : * const mrb_value) -> mrb_value ; } extern "C" { pub fn mrb_class_new (mrb : * mut mrb_state , super_ : * mut RClass) -> * mut RClass ; } extern "C" { pub fn mrb_module_new (mrb : * mut mrb_state) -> * mut RClass ; } extern "C" { pub fn mrb_class_defined (mrb : * mut mrb_state , name : * const :: std :: os :: raw :: c_char) -> mrb_bool ; } extern "C" { pub fn mrb_class_defined_id (mrb : * mut mrb_state , name : mrb_sym) -> mrb_bool ; } extern "C" { pub fn mrb_class_get (mrb : * mut mrb_state , name : * const :: std :: os :: raw :: c_char) -> * mut RClass ; } extern "C" { pub fn mrb_class_get_id (mrb : * mut mrb_state , name : mrb_sym) -> * mut RClass ; } extern "C" { pub fn mrb_exc_get_id (mrb : * mut mrb_state , name : mrb_sym) -> * mut RClass ; } extern "C" { pub fn mrb_class_defined_under (mrb : * mut mrb_state , outer : * mut RClass , name : * const :: std :: os :: raw :: c_char) -> mrb_bool ; } extern "C" { pub fn mrb_class_defined_under_id (mrb : * mut mrb_state , outer : * mut RClass , name : mrb_sym) -> mrb_bool ; } extern "C" { pub fn mrb_class_get_under (mrb : * mut mrb_state , outer : * mut RClass , name : * const :: std :: os :: raw :: c_char) -> * mut RClass ; } extern "C" { pub fn mrb_class_get_under_id (mrb : * mut mrb_state , outer : * mut RClass , name : mrb_sym) -> * mut RClass ; } extern "C" { pub fn mrb_module_get (mrb : * mut mrb_state , name : * const :: std :: os :: raw :: c_char) -> * mut RClass ; } extern "C" { pub fn mrb_module_get_id (mrb : * mut mrb_state , name : mrb_sym) -> * mut RClass ; } extern "C" { pub fn mrb_module_get_under (mrb : * mut mrb_state , outer : * mut RClass , name : * const :: std :: os :: raw :: c_char) -> * mut RClass ; } extern "C" { pub fn mrb_module_get_under_id (mrb : * mut mrb_state , outer : * mut RClass , name : mrb_sym) -> * mut RClass ; } extern "C" { pub fn mrb_notimplement (arg1 : * mut mrb_state) ; } extern "C" { pub fn mrb_notimplement_m (arg1 : * mut mrb_state , arg2 : mrb_value) -> mrb_value ; } extern "C" { pub fn mrb_obj_dup (mrb : * mut mrb_state , obj : mrb_value) -> mrb_value ; } extern "C" { pub fn mrb_obj_respond_to (mrb : * mut mrb_state , c : * mut RClass , mid : mrb_sym) -> mrb_bool ; } extern "C" { pub fn mrb_define_class_under (mrb : * mut mrb_state , outer : * mut RClass , name : * const :: std :: os :: raw :: c_char , super_ : * mut RClass) -> * mut RClass ; } extern "C" { pub fn mrb_define_class_under_id (mrb : * mut mrb_state , outer : * mut RClass , name : mrb_sym , super_ : * mut RClass) -> * mut RClass ; } extern "C" { pub fn mrb_define_module_under (mrb : * mut mrb_state , outer : * mut RClass , name : * const :: std :: os :: raw :: c_char) -> * mut RClass ; } extern "C" { pub fn mrb_define_module_under_id (mrb : * mut mrb_state , outer : * mut RClass , name : mrb_sym) -> * mut RClass ; } pub type mrb_args_format = * const :: std :: os :: raw :: c_char ; # [repr (C)] # [derive (Debug , Copy , Clone)] pub struct mrb_kwargs { pub num : mrb_int , pub required : mrb_int , pub table : * const mrb_sym , pub values : * mut mrb_value , pub rest : * mut mrb_value , } # [test] fn bindgen_test_layout_mrb_kwargs () { const UNINIT : :: std :: mem :: MaybeUninit < mrb_kwargs > = :: std :: mem :: MaybeUninit :: uninit () ; let ptr = UNINIT . as_ptr () ; assert_eq ! (:: std :: mem :: size_of :: < mrb_kwargs > () , 40usize , concat ! ("Size of: " , stringify ! (mrb_kwargs))) ; assert_eq ! (:: std :: mem :: align_of :: < mrb_kwargs > () , 8usize , concat ! ("Alignment of " , stringify ! (mrb_kwargs))) ; assert_eq ! (unsafe { :: std :: ptr :: addr_of ! ((* ptr) . num) as usize - ptr as usize } , 0usize , concat ! ("Offset of field: " , stringify ! (mrb_kwargs) , "::" , stringify ! (num))) ; assert_eq ! (unsafe { :: std :: ptr :: addr_of ! ((* ptr) . required) as usize - ptr as usize } , 8usize , concat ! ("Offset of field: " , stringify ! (mrb_kwargs) , "::" , stringify ! (required))) ; assert_eq ! (unsafe { :: std :: ptr :: addr_of ! ((* ptr) . table) as usize - ptr as usize } , 16usize , concat ! ("Offset of field: " , stringify ! (mrb_kwargs) , "::" , stringify ! (table))) ; assert_eq ! (unsafe { :: std :: ptr :: addr_of ! ((* ptr) . values) as usize - ptr as usize } , 24usize , concat ! ("Offset of field: " , stringify ! (mrb_kwargs) , "::" , stringify ! (values))) ; assert_eq ! (unsafe { :: std :: ptr :: addr_of ! ((* ptr) . rest) as usize - ptr as usize } , 32usize , concat ! ("Offset of field: " , stringify ! (mrb_kwargs) , "::" , stringify ! (rest))) ; } extern "C" { pub fn mrb_get_args (mrb : * mut mrb_state , format : mrb_args_format , ...) -> mrb_int ; } extern "C" { pub fn mrb_get_args_a (mrb : * mut mrb_state , format : mrb_args_format , ptr : * mut * mut :: std :: os :: raw :: c_void) -> mrb_int ; } extern "C" { pub fn mrb_get_argc (mrb : * mut mrb_state) -> mrb_int ; } extern "C" { pub fn mrb_get_argv (mrb : * mut mrb_state) -> * const mrb_value ; } extern "C" { pub fn mrb_get_arg1 (mrb : * mut mrb_state) -> mrb_value ; } extern "C" { pub fn mrb_block_given_p (mrb : * mut mrb_state) -> mrb_bool ; } extern "C" { pub fn mrb_funcall (mrb : * mut mrb_state , val : mrb_value , name : * const :: std :: os :: raw :: c_char , argc : mrb_int , ...) -> mrb_value ; } extern "C" { pub fn mrb_funcall_id (mrb : * mut mrb_state , val : mrb_value , mid : mrb_sym , argc : mrb_int , ...) -> mrb_value ; } extern "C" { pub fn mrb_funcall_argv (mrb : * mut mrb_state , val : mrb_value , name : mrb_sym , argc : mrb_int , argv : * const mrb_value) -> mrb_value ; } extern "C" { pub fn mrb_funcall_with_block (mrb : * mut mrb_state , val : mrb_value , name : mrb_sym , argc : mrb_int , argv : * const mrb_value , block : mrb_value) -> mrb_value ; } extern "C" { pub fn mrb_intern_cstr (mrb : * mut mrb_state , str_ : * const :: std :: os :: raw :: c_char) -> mrb_sym ; } extern "C" { pub fn mrb_intern (arg1 : * mut mrb_state , arg2 : * const :: std :: os :: raw :: c_char , arg3 : usize) -> mrb_sym ; } extern "C" { pub fn mrb_intern_static (arg1 : * mut mrb_state , arg2 : * const :: std :: os :: raw :: c_char , arg3 : usize) -> mrb_sym ; } extern "C" { pub fn mrb_intern_str (arg1 : * mut mrb_state , arg2 : mrb_value) -> mrb_sym ; } extern "C" { pub fn mrb_intern_check_cstr (arg1 : * mut mrb_state , arg2 : * const :: std :: os :: raw :: c_char) -> mrb_sym ; } extern "C" { pub fn mrb_intern_check (arg1 : * mut mrb_state , arg2 : * const :: std :: os :: raw :: c_char , arg3 : usize) -> mrb_sym ; } extern "C" { pub fn mrb_intern_check_str (arg1 : * mut mrb_state , arg2 : mrb_value) -> mrb_sym ; } extern "C" { pub fn mrb_check_intern_cstr (arg1 : * mut mrb_state , arg2 : * const :: std :: os :: raw :: c_char) -> mrb_value ; } extern "C" { pub fn mrb_check_intern (arg1 : * mut mrb_state , arg2 : * const :: std :: os :: raw :: c_char , arg3 : usize) -> mrb_value ; } extern "C" { pub fn mrb_check_intern_str (arg1 : * mut mrb_state , arg2 : mrb_value) -> mrb_value ; } extern "C" { pub fn mrb_sym_name (arg1 : * mut mrb_state , arg2 : mrb_sym) -> * const :: std :: os :: raw :: c_char ; } extern "C" { pub fn mrb_sym_name_len (arg1 : * mut mrb_state , arg2 : mrb_sym , arg3 : * mut mrb_int) -> * const :: std :: os :: raw :: c_char ; } extern "C" { pub fn mrb_sym_dump (arg1 : * mut mrb_state , arg2 : mrb_sym) -> * const :: std :: os :: raw :: c_char ; } extern "C" { pub fn mrb_sym_str (arg1 : * mut mrb_state , arg2 : mrb_sym) -> mrb_value ; } extern "C" { pub fn mrb_malloc (arg1 : * mut mrb_state , arg2 : usize) -> * mut :: std :: os :: raw :: c_void ; } extern "C" { pub fn mrb_calloc (arg1 : * mut mrb_state , arg2 : usize , arg3 : usize) -> * mut :: std :: os :: raw :: c_void ; } extern "C" { pub fn mrb_realloc (arg1 : * mut mrb_state , arg2 : * mut :: std :: os :: raw :: c_void , arg3 : usize) -> * mut :: std :: os :: raw :: c_void ; } extern "C" { pub fn mrb_realloc_simple (arg1 : * mut mrb_state , arg2 : * mut :: std :: os :: raw :: c_void , arg3 : usize) -> * mut :: std :: os :: raw :: c_void ; } extern "C" { pub fn mrb_malloc_simple (arg1 : * mut mrb_state , arg2 : usize) -> * mut :: std :: os :: raw :: c_void ; } extern "C" { pub fn mrb_obj_alloc (arg1 : * mut mrb_state , arg2 : mrb_vtype , arg3 : * mut RClass) -> * mut RBasic ; } extern "C" { pub fn mrb_free (arg1 : * mut mrb_state , arg2 : * mut :: std :: os :: raw :: c_void) ; } extern "C" { pub fn mrb_str_new (mrb : * mut mrb_state , p : * const :: std :: os :: raw :: c_char , len : mrb_int) -> mrb_value ; } extern "C" { pub fn mrb_str_new_cstr (arg1 : * mut mrb_state , arg2 : * const :: std :: os :: raw :: c_char) -> mrb_value ; } extern "C" { pub fn mrb_str_new_static (mrb : * mut mrb_state , p : * const :: std :: os :: raw :: c_char , len : mrb_int) -> mrb_value ; } extern "C" { pub fn mrb_obj_freeze (arg1 : * mut mrb_state , arg2 : mrb_value) -> mrb_value ; } extern "C" { pub fn mrb_open () -> * mut mrb_state ; } extern "C" { pub fn mrb_open_allocf (f : mrb_allocf , ud : * mut :: std :: os :: raw :: c_void) -> * mut mrb_state ; } extern "C" { pub fn mrb_open_core (f : mrb_allocf , ud : * mut :: std :: os :: raw :: c_void) -> * mut mrb_state ; } extern "C" { pub fn mrb_close (mrb : * mut mrb_state) ; } extern "C" { pub fn mrb_default_allocf (arg1 : * mut mrb_state , arg2 : * mut :: std :: os :: raw :: c_void , arg3 : usize , arg4 : * mut :: std :: os :: raw :: c_void) -> * mut :: std :: os :: raw :: c_void ; } extern "C" { pub fn mrb_top_self (mrb : * mut mrb_state) -> mrb_value ; } extern "C" { pub fn mrb_top_run (mrb : * mut mrb_state , proc_ : * const RProc , self_ : mrb_value , stack_keep : mrb_int) -> mrb_value ; } extern "C" { pub fn mrb_vm_run (mrb : * mut mrb_state , proc_ : * const RProc , self_ : mrb_value , stack_keep : mrb_int) -> mrb_value ; } extern "C" { pub fn mrb_vm_exec (mrb : * mut mrb_state , proc_ : * const RProc , iseq : * const mrb_code) -> mrb_value ; } extern "C" { pub fn mrb_p (arg1 : * mut mrb_state , arg2 : mrb_value) ; } extern "C" { pub fn mrb_obj_id (obj : mrb_value) -> mrb_int ; } extern "C" { pub fn mrb_obj_to_sym (mrb : * mut mrb_state , name : mrb_value) -> mrb_sym ; } extern "C" { pub fn mrb_obj_eq (mrb : * mut mrb_state , a : mrb_value , b : mrb_value) -> mrb_bool ; } extern "C" { pub fn mrb_obj_equal (mrb : * mut mrb_state , a : mrb_value , b : mrb_value) -> mrb_bool ; } extern "C" { pub fn mrb_equal (mrb : * mut mrb_state , obj1 : mrb_value , obj2 : mrb_value) -> mrb_bool ; } extern "C" { pub fn mrb_ensure_float_type (mrb : * mut mrb_state , val : mrb_value) -> mrb_value ; } extern "C" { pub fn mrb_inspect (mrb : * mut mrb_state , obj : mrb_value) -> mrb_value ; } extern "C" { pub fn mrb_eql (mrb : * mut mrb_state , obj1 : mrb_value , obj2 : mrb_value) -> mrb_bool ; } extern "C" { pub fn mrb_cmp (mrb : * mut mrb_state , obj1 : mrb_value , obj2 : mrb_value) -> mrb_int ; } extern "C" { pub fn mrb_garbage_collect (arg1 : * mut mrb_state) ; } extern "C" { pub fn mrb_full_gc (arg1 : * mut mrb_state) ; } extern "C" { pub fn mrb_incremental_gc (arg1 : * mut mrb_state) ; } extern "C" { pub fn mrb_gc_mark (arg1 : * mut mrb_state , arg2 : * mut RBasic) ; } extern "C" { pub fn mrb_field_write_barrier (arg1 : * mut mrb_state , arg2 : * mut RBasic , arg3 : * mut RBasic) ; } extern "C" { pub fn mrb_write_barrier (arg1 : * mut mrb_state , arg2 : * mut RBasic) ; } extern "C" { pub fn mrb_type_convert (mrb : * mut mrb_state , val : mrb_value , type_ : mrb_vtype , method : mrb_sym) -> mrb_value ; } extern "C" { pub fn mrb_type_convert_check (mrb : * mut mrb_state , val : mrb_value , type_ : mrb_vtype , method : mrb_sym) -> mrb_value ; } extern "C" { pub fn mrb_any_to_s (mrb : * mut mrb_state , obj : mrb_value) -> mrb_value ; } extern "C" { pub fn mrb_obj_classname (mrb : * mut mrb_state , obj : mrb_value) -> * const :: std :: os :: raw :: c_char ; } extern "C" { pub fn mrb_obj_class (mrb : * mut mrb_state , obj : mrb_value) -> * mut RClass ; } extern "C" { pub fn mrb_class_path (mrb : * mut mrb_state , c : * mut RClass) -> mrb_value ; } extern "C" { pub fn mrb_obj_is_kind_of (mrb : * mut mrb_state , obj : mrb_value , c : * mut RClass) -> mrb_bool ; } extern "C" { pub fn mrb_obj_inspect (mrb : * mut mrb_state , self_ : mrb_value) -> mrb_value ; } extern "C" { pub fn mrb_obj_clone (mrb : * mut mrb_state , self_ : mrb_value) -> mrb_value ; } extern "C" { pub fn mrb_exc_new (mrb : * mut mrb_state , c : * mut RClass , ptr : * const :: std :: os :: raw :: c_char , len : mrb_int) -> mrb_value ; } extern "C" { pub fn mrb_exc_raise (mrb : * mut mrb_state , exc : mrb_value) ; } extern "C" { pub fn mrb_raise (mrb : * mut mrb_state , c : * mut RClass , msg : * const :: std :: os :: raw :: c_char) ; } extern "C" { pub fn mrb_raisef (mrb : * mut mrb_state , c : * mut RClass , fmt : * const :: std :: os :: raw :: c_char , ...) ; } extern "C" { pub fn mrb_name_error (mrb : * mut mrb_state , id : mrb_sym , fmt : * const :: std :: os :: raw :: c_char , ...) ; } extern "C" { pub fn mrb_frozen_error (mrb : * mut mrb_state , frozen_obj : * mut :: std :: os :: raw :: c_void) ; } extern "C" { pub fn mrb_argnum_error (mrb : * mut mrb_state , argc : mrb_int , min : :: std :: os :: raw :: c_int , max : :: std :: os :: raw :: c_int) ; } extern "C" { pub fn mrb_warn (mrb : * mut mrb_state , fmt : * const :: std :: os :: raw :: c_char , ...) ; } extern "C" { pub fn mrb_bug (mrb : * mut mrb_state , fmt : * const :: std :: os :: raw :: c_char , ...) ; } extern "C" { pub fn mrb_print_backtrace (mrb : * mut mrb_state) ; } extern "C" { pub fn mrb_print_error (mrb : * mut mrb_state) ; } extern "C" { pub fn mrb_vformat (mrb : * mut mrb_state , format : * const :: std :: os :: raw :: c_char , ap : * mut __va_list_tag) -> mrb_value ; } extern "C" { pub fn mrb_yield (mrb : * mut mrb_state , b : mrb_value , arg : mrb_value) -> mrb_value ; } extern "C" { pub fn mrb_yield_argv (mrb : * mut mrb_state , b : mrb_value , argc : mrb_int , argv : * const mrb_value) -> mrb_value ; } extern "C" { pub fn mrb_yield_with_class (mrb : * mut mrb_state , b : mrb_value , argc : mrb_int , argv : * const mrb_value , self_ : mrb_value , c : * mut RClass) -> mrb_value ; } extern "C" { pub fn mrb_yield_cont (mrb : * mut mrb_state , b : mrb_value , self_ : mrb_value , argc : mrb_int , argv : * const mrb_value) -> mrb_value ; } extern "C" { pub fn mrb_gc_protect (mrb : * mut mrb_state , obj : mrb_value) ; } extern "C" { pub fn mrb_gc_register (mrb : * mut mrb_state , obj : mrb_value) ; } extern "C" { pub fn mrb_gc_unregister (mrb : * mut mrb_state , obj : mrb_value) ; } extern "C" { pub fn mrb_ensure_array_type (mrb : * mut mrb_state , self_ : mrb_value) -> mrb_value ; } extern "C" { pub fn mrb_check_array_type (mrb : * mut mrb_state , self_ : mrb_value) -> mrb_value ; } extern "C" { pub fn mrb_ensure_hash_type (mrb : * mut mrb_state , hash : mrb_value) -> mrb_value ; } extern "C" { pub fn mrb_check_hash_type (mrb : * mut mrb_state , hash : mrb_value) -> mrb_value ; } extern "C" { pub fn mrb_ensure_string_type (mrb : * mut mrb_state , str_ : mrb_value) -> mrb_value ; } extern "C" { pub fn mrb_check_string_type (mrb : * mut mrb_state , str_ : mrb_value) -> mrb_value ; } extern "C" { pub fn mrb_ensure_integer_type (mrb : * mut mrb_state , val : mrb_value) -> mrb_value ; } extern "C" { pub fn mrb_ensure_int_type (mrb : * mut mrb_state , val : mrb_value) -> mrb_value ; } extern "C" { pub fn mrb_check_type (mrb : * mut mrb_state , x : mrb_value , t : mrb_vtype) ; } extern "C" { pub fn mrb_define_alias (mrb : * mut mrb_state , c : * mut RClass , a : * const :: std :: os :: raw :: c_char , b : * const :: std :: os :: raw :: c_char) ; } extern "C" { pub fn mrb_define_alias_id (mrb : * mut mrb_state , c : * mut RClass , a : mrb_sym , b : mrb_sym) ; } extern "C" { pub fn mrb_class_name (mrb : * mut mrb_state , klass : * mut RClass) -> * const :: std :: os :: raw :: c_char ; } extern "C" { pub fn mrb_define_global_const (mrb : * mut mrb_state , name : * const :: std :: os :: raw :: c_char , val : mrb_value) ; } extern "C" { pub fn mrb_attr_get (mrb : * mut mrb_state , obj : mrb_value , id : mrb_sym) -> mrb_value ; } extern "C" { pub fn mrb_respond_to (mrb : * mut mrb_state , obj : mrb_value , mid : mrb_sym) -> mrb_bool ; } extern "C" { pub fn mrb_obj_is_instance_of (mrb : * mut mrb_state , obj : mrb_value , c : * mut RClass) -> mrb_bool ; } extern "C" { pub fn mrb_func_basic_p (mrb : * mut mrb_state , obj : mrb_value , mid : mrb_sym , func : mrb_func_t) -> mrb_bool ; } extern "C" { pub fn mrb_fiber_resume (mrb : * mut mrb_state , fib : mrb_value , argc : mrb_int , argv : * const mrb_value) -> mrb_value ; } extern "C" { pub fn mrb_fiber_yield (mrb : * mut mrb_state , argc : mrb_int , argv : * const mrb_value) -> mrb_value ; } extern "C" { pub fn mrb_fiber_alive_p (mrb : * mut mrb_state , fib : mrb_value) -> mrb_value ; } extern "C" { pub fn mrb_stack_extend (arg1 : * mut mrb_state , arg2 : mrb_int) ; } # [repr (C)] # [derive (Debug , Copy , Clone)] pub struct mrb_pool { _unused : [u8 ; 0] , } extern "C" { pub fn mrb_pool_open (arg1 : * mut mrb_state) -> * mut mrb_pool ; } extern "C" { pub fn mrb_pool_close (arg1 : * mut mrb_pool) ; } extern "C" { pub fn mrb_pool_alloc (arg1 : * mut mrb_pool , arg2 : usize) -> * mut :: std :: os :: raw :: c_void ; } extern "C" { pub fn mrb_pool_realloc (arg1 : * mut mrb_pool , arg2 : * mut :: std :: os :: raw :: c_void , oldlen : usize , newlen : usize) -> * mut :: std :: os :: raw :: c_void ; } extern "C" { pub fn mrb_pool_can_realloc (arg1 : * mut mrb_pool , arg2 : * mut :: std :: os :: raw :: c_void , arg3 : usize) -> mrb_bool ; } extern "C" { pub fn mrb_alloca (mrb : * mut mrb_state , arg1 : usize) -> * mut :: std :: os :: raw :: c_void ; } extern "C" { pub fn mrb_state_atexit (mrb : * mut mrb_state , func : mrb_atexit_func) ; } extern "C" { pub fn mrb_show_version (mrb : * mut mrb_state) ; } extern "C" { pub fn mrb_show_copyright (mrb : * mut mrb_state) ; } extern "C" { pub fn mrb_format (mrb : * mut mrb_state , format : * const :: std :: os :: raw :: c_char , ...) -> mrb_value ; } # [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 , } # [test] fn bindgen_test_layout_mrb_shared_array () { const UNINIT : :: std :: mem :: MaybeUninit < mrb_shared_array > = :: std :: mem :: MaybeUninit :: uninit () ; let ptr = UNINIT . as_ptr () ; assert_eq ! (:: std :: mem :: size_of :: < mrb_shared_array > () , 24usize , concat ! ("Size of: " , stringify ! (mrb_shared_array))) ; assert_eq ! (:: std :: mem :: align_of :: < mrb_shared_array > () , 8usize , concat ! ("Alignment of " , stringify ! (mrb_shared_array))) ; assert_eq ! (unsafe { :: std :: ptr :: addr_of ! ((* ptr) . refcnt) as usize - ptr as usize } , 0usize , concat ! ("Offset of field: " , stringify ! (mrb_shared_array) , "::" , stringify ! (refcnt))) ; assert_eq ! (unsafe { :: std :: ptr :: addr_of ! ((* ptr) . len) as usize - ptr as usize } , 8usize , concat ! ("Offset of field: " , stringify ! (mrb_shared_array) , "::" , stringify ! (len))) ; assert_eq ! (unsafe { :: std :: ptr :: addr_of ! ((* ptr) . ptr) as usize - ptr as usize } , 16usize , concat ! ("Offset of field: " , stringify ! (mrb_shared_array) , "::" , stringify ! (ptr))) ; } # [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 , } # [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 , } # [test] fn bindgen_test_layout_RArray__bindgen_ty_1__bindgen_ty_1__bindgen_ty_1 () { const UNINIT : :: std :: mem :: MaybeUninit < RArray__bindgen_ty_1__bindgen_ty_1__bindgen_ty_1 > = :: std :: mem :: MaybeUninit :: uninit () ; let ptr = UNINIT . as_ptr () ; assert_eq ! (:: std :: mem :: size_of :: < RArray__bindgen_ty_1__bindgen_ty_1__bindgen_ty_1 > () , 8usize , concat ! ("Size of: " , stringify ! (RArray__bindgen_ty_1__bindgen_ty_1__bindgen_ty_1))) ; assert_eq ! (:: std :: mem :: align_of :: < RArray__bindgen_ty_1__bindgen_ty_1__bindgen_ty_1 > () , 8usize , concat ! ("Alignment of " , stringify ! (RArray__bindgen_ty_1__bindgen_ty_1__bindgen_ty_1))) ; assert_eq ! (unsafe { :: std :: ptr :: addr_of ! ((* ptr) . capa) as usize - ptr as usize } , 0usize , concat ! ("Offset of field: " , stringify ! (RArray__bindgen_ty_1__bindgen_ty_1__bindgen_ty_1) , "::" , stringify ! (capa))) ; assert_eq ! (unsafe { :: std :: ptr :: addr_of ! ((* ptr) . shared) as usize - ptr as usize } , 0usize , concat ! ("Offset of field: " , stringify ! (RArray__bindgen_ty_1__bindgen_ty_1__bindgen_ty_1) , "::" , stringify ! (shared))) ; } # [test] fn bindgen_test_layout_RArray__bindgen_ty_1__bindgen_ty_1 () { const UNINIT : :: std :: mem :: MaybeUninit < RArray__bindgen_ty_1__bindgen_ty_1 > = :: std :: mem :: MaybeUninit :: uninit () ; let ptr = UNINIT . as_ptr () ; assert_eq ! (:: std :: mem :: size_of :: < RArray__bindgen_ty_1__bindgen_ty_1 > () , 24usize , concat ! ("Size of: " , stringify ! (RArray__bindgen_ty_1__bindgen_ty_1))) ; assert_eq ! (:: std :: mem :: align_of :: < RArray__bindgen_ty_1__bindgen_ty_1 > () , 8usize , concat ! ("Alignment of " , stringify ! (RArray__bindgen_ty_1__bindgen_ty_1))) ; assert_eq ! (unsafe { :: std :: ptr :: addr_of ! ((* ptr) . len) as usize - ptr as usize } , 0usize , concat ! ("Offset of field: " , stringify ! (RArray__bindgen_ty_1__bindgen_ty_1) , "::" , stringify ! (len))) ; assert_eq ! (unsafe { :: std :: ptr :: addr_of ! ((* ptr) . aux) as usize - ptr as usize } , 8usize , concat ! ("Offset of field: " , stringify ! (RArray__bindgen_ty_1__bindgen_ty_1) , "::" , stringify ! (aux))) ; assert_eq ! (unsafe { :: std :: ptr :: addr_of ! ((* ptr) . ptr) as usize - ptr as usize } , 16usize , concat ! ("Offset of field: " , stringify ! (RArray__bindgen_ty_1__bindgen_ty_1) , "::" , stringify ! (ptr))) ; } # [test] fn bindgen_test_layout_RArray__bindgen_ty_1 () { const UNINIT : :: std :: mem :: MaybeUninit < RArray__bindgen_ty_1 > = :: std :: mem :: MaybeUninit :: uninit () ; let ptr = UNINIT . as_ptr () ; assert_eq ! (:: std :: mem :: size_of :: < RArray__bindgen_ty_1 > () , 24usize , concat ! ("Size of: " , stringify ! (RArray__bindgen_ty_1))) ; assert_eq ! (:: std :: mem :: align_of :: < RArray__bindgen_ty_1 > () , 8usize , concat ! ("Alignment of " , stringify ! (RArray__bindgen_ty_1))) ; assert_eq ! (unsafe { :: std :: ptr :: addr_of ! ((* ptr) . heap) as usize - ptr as usize } , 0usize , concat ! ("Offset of field: " , stringify ! (RArray__bindgen_ty_1) , "::" , stringify ! (heap))) ; } # [test] fn bindgen_test_layout_RArray () { const UNINIT : :: std :: mem :: MaybeUninit < RArray > = :: std :: mem :: MaybeUninit :: uninit () ; let ptr = UNINIT . as_ptr () ; assert_eq ! (:: std :: mem :: size_of :: < RArray > () , 48usize , concat ! ("Size of: " , stringify ! (RArray))) ; assert_eq ! (:: std :: mem :: align_of :: < RArray > () , 8usize , concat ! ("Alignment of " , stringify ! (RArray))) ; assert_eq ! (unsafe { :: std :: ptr :: addr_of ! ((* ptr) . c) as usize - ptr as usize } , 0usize , concat ! ("Offset of field: " , stringify ! (RArray) , "::" , stringify ! (c))) ; assert_eq ! (unsafe { :: std :: ptr :: addr_of ! ((* ptr) . gcnext) as usize - ptr as usize } , 8usize , concat ! ("Offset of field: " , stringify ! (RArray) , "::" , stringify ! (gcnext))) ; assert_eq ! (unsafe { :: std :: ptr :: addr_of ! ((* ptr) . as_) as usize - ptr as usize } , 24usize , concat ! ("Offset of field: " , stringify ! (RArray) , "::" , stringify ! (as_))) ; } 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 } } extern "C" { pub fn mrb_ary_modify (arg1 : * mut mrb_state , arg2 : * mut RArray) ; } extern "C" { pub fn mrb_ary_new_capa (arg1 : * mut mrb_state , arg2 : mrb_int) -> mrb_value ; } extern "C" { pub fn mrb_ary_new (mrb : * mut mrb_state) -> mrb_value ; } extern "C" { pub fn mrb_ary_new_from_values (mrb : * mut mrb_state , size : mrb_int , vals : * const mrb_value) -> mrb_value ; } extern "C" { pub fn mrb_assoc_new (mrb : * mut mrb_state , car : mrb_value , cdr : mrb_value) -> mrb_value ; } extern "C" { pub fn mrb_ary_concat (mrb : * mut mrb_state , self_ : mrb_value , other : mrb_value) ; } extern "C" { pub fn mrb_ary_splat (mrb : * mut mrb_state , value : mrb_value) -> mrb_value ; } extern "C" { pub fn mrb_ary_push (mrb : * mut mrb_state , array : mrb_value , value : mrb_value) ; } extern "C" { pub fn mrb_ary_pop (mrb : * mut mrb_state , ary : mrb_value) -> mrb_value ; } extern "C" { pub fn mrb_ary_set (mrb : * mut mrb_state , ary : mrb_value , n : mrb_int , val : mrb_value) ; } extern "C" { pub fn mrb_ary_replace (mrb : * mut mrb_state , self_ : mrb_value , other : mrb_value) ; } extern "C" { pub fn mrb_ary_unshift (mrb : * mut mrb_state , self_ : mrb_value , item : mrb_value) -> mrb_value ; } extern "C" { pub fn mrb_ary_entry (ary : mrb_value , offset : mrb_int) -> mrb_value ; } extern "C" { pub fn mrb_ary_splice (mrb : * mut mrb_state , self_ : mrb_value , head : mrb_int , len : mrb_int , rpl : mrb_value) -> mrb_value ; } extern "C" { pub fn mrb_ary_shift (mrb : * mut mrb_state , self_ : mrb_value) -> mrb_value ; } extern "C" { pub fn mrb_ary_clear (mrb : * mut mrb_state , self_ : mrb_value) -> mrb_value ; } extern "C" { pub fn mrb_ary_join (mrb : * mut mrb_state , ary : mrb_value , sep : mrb_value) -> mrb_value ; } extern "C" { pub fn mrb_ary_resize (mrb : * mut mrb_state , ary : mrb_value , new_len : mrb_int) -> mrb_value ; } extern "C" { pub fn mrb_ary_artichoke_free (mrb : * mut mrb_state , ary : * mut RArray) ; } # [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 , } # [test] fn bindgen_test_layout_RClass () { const UNINIT : :: std :: mem :: MaybeUninit < RClass > = :: std :: mem :: MaybeUninit :: uninit () ; let ptr = UNINIT . as_ptr () ; assert_eq ! (:: std :: mem :: size_of :: < RClass > () , 48usize , concat ! ("Size of: " , stringify ! (RClass))) ; assert_eq ! (:: std :: mem :: align_of :: < RClass > () , 8usize , concat ! ("Alignment of " , stringify ! (RClass))) ; assert_eq ! (unsafe { :: std :: ptr :: addr_of ! ((* ptr) . c) as usize - ptr as usize } , 0usize , concat ! ("Offset of field: " , stringify ! (RClass) , "::" , stringify ! (c))) ; assert_eq ! (unsafe { :: std :: ptr :: addr_of ! ((* ptr) . gcnext) as usize - ptr as usize } , 8usize , concat ! ("Offset of field: " , stringify ! (RClass) , "::" , stringify ! (gcnext))) ; assert_eq ! (unsafe { :: std :: ptr :: addr_of ! ((* ptr) . iv) as usize - ptr as usize } , 24usize , concat ! ("Offset of field: " , stringify ! (RClass) , "::" , stringify ! (iv))) ; assert_eq ! (unsafe { :: std :: ptr :: addr_of ! ((* ptr) . mt) as usize - ptr as usize } , 32usize , concat ! ("Offset of field: " , stringify ! (RClass) , "::" , stringify ! (mt))) ; assert_eq ! (unsafe { :: std :: ptr :: addr_of ! ((* ptr) . super_) as usize - ptr as usize } , 40usize , concat ! ("Offset of field: " , stringify ! (RClass) , "::" , stringify ! (super_))) ; } 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 } } extern "C" { pub fn mrb_define_method_raw (arg1 : * mut mrb_state , arg2 : * mut RClass , arg3 : mrb_sym , arg4 : mrb_method_t) ; } extern "C" { pub fn mrb_alias_method (arg1 : * mut mrb_state , c : * mut RClass , a : mrb_sym , b : mrb_sym) ; } extern "C" { pub fn mrb_remove_method (mrb : * mut mrb_state , c : * mut RClass , sym : mrb_sym) ; } extern "C" { pub fn mrb_method_search_vm (arg1 : * mut mrb_state , arg2 : * mut * mut RClass , arg3 : mrb_sym) -> mrb_method_t ; } extern "C" { pub fn mrb_method_search (arg1 : * mut mrb_state , arg2 : * mut RClass , arg3 : mrb_sym) -> mrb_method_t ; } extern "C" { pub fn mrb_class_real (cl : * mut RClass) -> * mut RClass ; } extern "C" { pub fn mrb_mc_clear_by_class (mrb : * mut mrb_state , c : * mut RClass) ; } pub type mrb_mt_foreach_func = :: std :: option :: Option < unsafe extern "C" fn (arg1 : * mut mrb_state , arg2 : mrb_sym , arg3 : mrb_method_t , arg4 : * mut :: std :: os :: raw :: c_void) -> :: std :: os :: raw :: c_int > ; extern "C" { pub fn mrb_mt_foreach (arg1 : * mut mrb_state , arg2 : * mut RClass , arg3 : mrb_mt_foreach_func , arg4 : * mut :: std :: os :: raw :: c_void) ; } # [repr (C)] # [derive (Debug , Copy , Clone)] pub struct mrbc_context { pub syms : * mut mrb_sym , pub slen : :: std :: os :: raw :: c_int , pub filename : * mut :: std :: os :: raw :: c_char , pub lineno : u16 , pub partial_hook : :: std :: option :: Option < unsafe extern "C" fn (arg1 : * mut mrb_parser_state) -> :: std :: os :: raw :: c_int > , pub partial_data : * mut :: std :: os :: raw :: c_void , pub target_class : * mut RClass , pub _bitfield_align_1 : [u8 ; 0] , pub _bitfield_1 : __BindgenBitfieldUnit < [u8 ; 1usize] > , pub upper : * const RProc , pub parser_nerr : usize , } # [test] fn bindgen_test_layout_mrbc_context () { const UNINIT : :: std :: mem :: MaybeUninit < mrbc_context > = :: std :: mem :: MaybeUninit :: uninit () ; let ptr = UNINIT . as_ptr () ; assert_eq ! (:: std :: mem :: size_of :: < mrbc_context > () , 80usize , concat ! ("Size of: " , stringify ! (mrbc_context))) ; assert_eq ! (:: std :: mem :: align_of :: < mrbc_context > () , 8usize , concat ! ("Alignment of " , stringify ! (mrbc_context))) ; assert_eq ! (unsafe { :: std :: ptr :: addr_of ! ((* ptr) . syms) as usize - ptr as usize } , 0usize , concat ! ("Offset of field: " , stringify ! (mrbc_context) , "::" , stringify ! (syms))) ; assert_eq ! (unsafe { :: std :: ptr :: addr_of ! ((* ptr) . slen) as usize - ptr as usize } , 8usize , concat ! ("Offset of field: " , stringify ! (mrbc_context) , "::" , stringify ! (slen))) ; assert_eq ! (unsafe { :: std :: ptr :: addr_of ! ((* ptr) . filename) as usize - ptr as usize } , 16usize , concat ! ("Offset of field: " , stringify ! (mrbc_context) , "::" , stringify ! (filename))) ; assert_eq ! (unsafe { :: std :: ptr :: addr_of ! ((* ptr) . lineno) as usize - ptr as usize } , 24usize , concat ! ("Offset of field: " , stringify ! (mrbc_context) , "::" , stringify ! (lineno))) ; assert_eq ! (unsafe { :: std :: ptr :: addr_of ! ((* ptr) . partial_hook) as usize - ptr as usize } , 32usize , concat ! ("Offset of field: " , stringify ! (mrbc_context) , "::" , stringify ! (partial_hook))) ; assert_eq ! (unsafe { :: std :: ptr :: addr_of ! ((* ptr) . partial_data) as usize - ptr as usize } , 40usize , concat ! ("Offset of field: " , stringify ! (mrbc_context) , "::" , stringify ! (partial_data))) ; assert_eq ! (unsafe { :: std :: ptr :: addr_of ! ((* ptr) . target_class) as usize - ptr as usize } , 48usize , concat ! ("Offset of field: " , stringify ! (mrbc_context) , "::" , stringify ! (target_class))) ; assert_eq ! (unsafe { :: std :: ptr :: addr_of ! ((* ptr) . upper) as usize - ptr as usize } , 64usize , concat ! ("Offset of field: " , stringify ! (mrbc_context) , "::" , stringify ! (upper))) ; assert_eq ! (unsafe { :: std :: ptr :: addr_of ! ((* ptr) . parser_nerr) as usize - ptr as usize } , 72usize , concat ! ("Offset of field: " , stringify ! (mrbc_context) , "::" , stringify ! (parser_nerr))) ; } impl mrbc_context { # [inline] pub fn capture_errors (& self) -> mrb_bool { unsafe { :: std :: mem :: transmute (self . _bitfield_1 . get (0usize , 1u8) as u8) } } # [inline] pub fn set_capture_errors (& 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 dump_result (& self) -> mrb_bool { unsafe { :: std :: mem :: transmute (self . _bitfield_1 . get (1usize , 1u8) as u8) } } # [inline] pub fn set_dump_result (& 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 no_exec (& self) -> mrb_bool { unsafe { :: std :: mem :: transmute (self . _bitfield_1 . get (2usize , 1u8) as u8) } } # [inline] pub fn set_no_exec (& 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 keep_lv (& self) -> mrb_bool { unsafe { :: std :: mem :: transmute (self . _bitfield_1 . get (3usize , 1u8) as u8) } } # [inline] pub fn set_keep_lv (& 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 no_optimize (& self) -> mrb_bool { unsafe { :: std :: mem :: transmute (self . _bitfield_1 . get (4usize , 1u8) as u8) } } # [inline] pub fn set_no_optimize (& 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 no_ext_ops (& self) -> mrb_bool { unsafe { :: std :: mem :: transmute (self . _bitfield_1 . get (5usize , 1u8) as u8) } } # [inline] pub fn set_no_ext_ops (& mut self , val : mrb_bool) { unsafe { let val : u8 = :: std :: mem :: transmute (val) ; self . _bitfield_1 . set (5usize , 1u8 , val as u64) } } # [inline] pub fn new_bitfield_1 (capture_errors : mrb_bool , dump_result : mrb_bool , no_exec : mrb_bool , keep_lv : mrb_bool , no_optimize : mrb_bool , no_ext_ops : mrb_bool) -> __BindgenBitfieldUnit < [u8 ; 1usize] > { let mut __bindgen_bitfield_unit : __BindgenBitfieldUnit < [u8 ; 1usize] > = Default :: default () ; __bindgen_bitfield_unit . set (0usize , 1u8 , { let capture_errors : u8 = unsafe { :: std :: mem :: transmute (capture_errors) } ; capture_errors as u64 }) ; __bindgen_bitfield_unit . set (1usize , 1u8 , { let dump_result : u8 = unsafe { :: std :: mem :: transmute (dump_result) } ; dump_result as u64 }) ; __bindgen_bitfield_unit . set (2usize , 1u8 , { let no_exec : u8 = unsafe { :: std :: mem :: transmute (no_exec) } ; no_exec as u64 }) ; __bindgen_bitfield_unit . set (3usize , 1u8 , { let keep_lv : u8 = unsafe { :: std :: mem :: transmute (keep_lv) } ; keep_lv as u64 }) ; __bindgen_bitfield_unit . set (4usize , 1u8 , { let no_optimize : u8 = unsafe { :: std :: mem :: transmute (no_optimize) } ; no_optimize as u64 }) ; __bindgen_bitfield_unit . set (5usize , 1u8 , { let no_ext_ops : u8 = unsafe { :: std :: mem :: transmute (no_ext_ops) } ; no_ext_ops as u64 }) ; __bindgen_bitfield_unit } } extern "C" { pub fn mrbc_context_new (mrb : * mut mrb_state) -> * mut mrbc_context ; } extern "C" { pub fn mrbc_context_free (mrb : * mut mrb_state , cxt : * mut mrbc_context) ; } extern "C" { pub fn mrbc_filename (mrb : * mut mrb_state , c : * mut mrbc_context , s : * const :: std :: os :: raw :: c_char) -> * const :: std :: os :: raw :: c_char ; } extern "C" { pub fn mrbc_partial_hook (mrb : * mut mrb_state , c : * mut mrbc_context , partial_hook : :: std :: option :: Option < unsafe extern "C" fn (arg1 : * mut mrb_parser_state) -> :: std :: os :: raw :: c_int > , data : * mut :: std :: os :: raw :: c_void) ; } extern "C" { pub fn mrbc_cleanup_local_variables (mrb : * mut mrb_state , c : * mut mrbc_context) ; } # [repr (C)] # [derive (Debug , Copy , Clone)] pub struct mrb_ast_node { pub car : * mut mrb_ast_node , pub cdr : * mut mrb_ast_node , pub lineno : u16 , pub filename_index : u16 , } # [test] fn bindgen_test_layout_mrb_ast_node () { const UNINIT : :: std :: mem :: MaybeUninit < mrb_ast_node > = :: std :: mem :: MaybeUninit :: uninit () ; let ptr = UNINIT . as_ptr () ; assert_eq ! (:: std :: mem :: size_of :: < mrb_ast_node > () , 24usize , concat ! ("Size of: " , stringify ! (mrb_ast_node))) ; assert_eq ! (:: std :: mem :: align_of :: < mrb_ast_node > () , 8usize , concat ! ("Alignment of " , stringify ! (mrb_ast_node))) ; assert_eq ! (unsafe { :: std :: ptr :: addr_of ! ((* ptr) . car) as usize - ptr as usize } , 0usize , concat ! ("Offset of field: " , stringify ! (mrb_ast_node) , "::" , stringify ! (car))) ; assert_eq ! (unsafe { :: std :: ptr :: addr_of ! ((* ptr) . cdr) as usize - ptr as usize } , 8usize , concat ! ("Offset of field: " , stringify ! (mrb_ast_node) , "::" , stringify ! (cdr))) ; assert_eq ! (unsafe { :: std :: ptr :: addr_of ! ((* ptr) . lineno) as usize - ptr as usize } , 16usize , concat ! ("Offset of field: " , stringify ! (mrb_ast_node) , "::" , stringify ! (lineno))) ; assert_eq ! (unsafe { :: std :: ptr :: addr_of ! ((* ptr) . filename_index) as usize - ptr as usize } , 18usize , concat ! ("Offset of field: " , stringify ! (mrb_ast_node) , "::" , stringify ! (filename_index))) ; } # [repr (u32)] # [derive (Debug , Copy , Clone , Hash , PartialEq , Eq)] pub enum mrb_lex_state_enum { EXPR_BEG = 0 , EXPR_END = 1 , EXPR_ENDARG = 2 , EXPR_ENDFN = 3 , EXPR_ARG = 4 , EXPR_CMDARG = 5 , EXPR_MID = 6 , EXPR_FNAME = 7 , EXPR_DOT = 8 , EXPR_CLASS = 9 , EXPR_VALUE = 10 , EXPR_MAX_STATE = 11 , } # [repr (C)] # [derive (Debug , Copy , Clone)] pub struct mrb_parser_message { pub lineno : u16 , pub column : :: std :: os :: raw :: c_int , pub message : * mut :: std :: os :: raw :: c_char , } # [test] fn bindgen_test_layout_mrb_parser_message () { const UNINIT : :: std :: mem :: MaybeUninit < mrb_parser_message > = :: std :: mem :: MaybeUninit :: uninit () ; let ptr = UNINIT . as_ptr () ; assert_eq ! (:: std :: mem :: size_of :: < mrb_parser_message > () , 16usize , concat ! ("Size of: " , stringify ! (mrb_parser_message))) ; assert_eq ! (:: std :: mem :: align_of :: < mrb_parser_message > () , 8usize , concat ! ("Alignment of " , stringify ! (mrb_parser_message))) ; assert_eq ! (unsafe { :: std :: ptr :: addr_of ! ((* ptr) . lineno) as usize - ptr as usize } , 0usize , concat ! ("Offset of field: " , stringify ! (mrb_parser_message) , "::" , stringify ! (lineno))) ; assert_eq ! (unsafe { :: std :: ptr :: addr_of ! ((* ptr) . column) as usize - ptr as usize } , 4usize , concat ! ("Offset of field: " , stringify ! (mrb_parser_message) , "::" , stringify ! (column))) ; assert_eq ! (unsafe { :: std :: ptr :: addr_of ! ((* ptr) . message) as usize - ptr as usize } , 8usize , concat ! ("Offset of field: " , stringify ! (mrb_parser_message) , "::" , stringify ! (message))) ; } # [repr (u32)] # [derive (Debug , Copy , Clone , Hash , PartialEq , Eq)] pub enum mrb_string_type { str_not_parsing = 0 , str_squote = 1 , str_dquote = 3 , str_regexp = 7 , str_sword = 41 , str_dword = 43 , str_ssym = 17 , str_ssymbols = 49 , str_dsymbols = 51 , str_heredoc = 65 , str_xquote = 131 , } # [repr (C)] # [derive (Debug , Copy , Clone)] pub struct mrb_parser_heredoc_info { pub _bitfield_align_1 : [u8 ; 0] , pub _bitfield_1 : __BindgenBitfieldUnit < [u8 ; 1usize] > , pub indent : usize , pub indented : * mut mrb_ast_node , pub type_ : mrb_string_type , pub term : * const :: std :: os :: raw :: c_char , pub term_len : :: std :: os :: raw :: c_int , pub doc : * mut mrb_ast_node , } # [test] fn bindgen_test_layout_mrb_parser_heredoc_info () { const UNINIT : :: std :: mem :: MaybeUninit < mrb_parser_heredoc_info > = :: std :: mem :: MaybeUninit :: uninit () ; let ptr = UNINIT . as_ptr () ; assert_eq ! (:: std :: mem :: size_of :: < mrb_parser_heredoc_info > () , 56usize , concat ! ("Size of: " , stringify ! (mrb_parser_heredoc_info))) ; assert_eq ! (:: std :: mem :: align_of :: < mrb_parser_heredoc_info > () , 8usize , concat ! ("Alignment of " , stringify ! (mrb_parser_heredoc_info))) ; assert_eq ! (unsafe { :: std :: ptr :: addr_of ! ((* ptr) . indent) as usize - ptr as usize } , 8usize , concat ! ("Offset of field: " , stringify ! (mrb_parser_heredoc_info) , "::" , stringify ! (indent))) ; assert_eq ! (unsafe { :: std :: ptr :: addr_of ! ((* ptr) . indented) as usize - ptr as usize } , 16usize , concat ! ("Offset of field: " , stringify ! (mrb_parser_heredoc_info) , "::" , stringify ! (indented))) ; assert_eq ! (unsafe { :: std :: ptr :: addr_of ! ((* ptr) . type_) as usize - ptr as usize } , 24usize , concat ! ("Offset of field: " , stringify ! (mrb_parser_heredoc_info) , "::" , stringify ! (type_))) ; assert_eq ! (unsafe { :: std :: ptr :: addr_of ! ((* ptr) . term) as usize - ptr as usize } , 32usize , concat ! ("Offset of field: " , stringify ! (mrb_parser_heredoc_info) , "::" , stringify ! (term))) ; assert_eq ! (unsafe { :: std :: ptr :: addr_of ! ((* ptr) . term_len) as usize - ptr as usize } , 40usize , concat ! ("Offset of field: " , stringify ! (mrb_parser_heredoc_info) , "::" , stringify ! (term_len))) ; assert_eq ! (unsafe { :: std :: ptr :: addr_of ! ((* ptr) . doc) as usize - ptr as usize } , 48usize , concat ! ("Offset of field: " , stringify ! (mrb_parser_heredoc_info) , "::" , stringify ! (doc))) ; } impl mrb_parser_heredoc_info { # [inline] pub fn allow_indent (& self) -> mrb_bool { unsafe { :: std :: mem :: transmute (self . _bitfield_1 . get (0usize , 1u8) as u8) } } # [inline] pub fn set_allow_indent (& 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 remove_indent (& self) -> mrb_bool { unsafe { :: std :: mem :: transmute (self . _bitfield_1 . get (1usize , 1u8) as u8) } } # [inline] pub fn set_remove_indent (& 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 line_head (& self) -> mrb_bool { unsafe { :: std :: mem :: transmute (self . _bitfield_1 . get (2usize , 1u8) as u8) } } # [inline] pub fn set_line_head (& 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 new_bitfield_1 (allow_indent : mrb_bool , remove_indent : mrb_bool , line_head : mrb_bool) -> __BindgenBitfieldUnit < [u8 ; 1usize] > { let mut __bindgen_bitfield_unit : __BindgenBitfieldUnit < [u8 ; 1usize] > = Default :: default () ; __bindgen_bitfield_unit . set (0usize , 1u8 , { let allow_indent : u8 = unsafe { :: std :: mem :: transmute (allow_indent) } ; allow_indent as u64 }) ; __bindgen_bitfield_unit . set (1usize , 1u8 , { let remove_indent : u8 = unsafe { :: std :: mem :: transmute (remove_indent) } ; remove_indent as u64 }) ; __bindgen_bitfield_unit . set (2usize , 1u8 , { let line_head : u8 = unsafe { :: std :: mem :: transmute (line_head) } ; line_head as u64 }) ; __bindgen_bitfield_unit } } # [repr (C)] # [derive (Debug , Copy , Clone)] pub struct mrb_parser_state { pub mrb : * mut mrb_state , pub pool : * mut mrb_pool , pub cells : * mut mrb_ast_node , pub s : * const :: std :: os :: raw :: c_char , pub send : * const :: std :: os :: raw :: c_char , pub cxt : * mut mrbc_context , pub filename_sym : mrb_sym , pub lineno : u16 , pub column : :: std :: os :: raw :: c_int , pub lstate : mrb_lex_state_enum , pub lex_strterm : * mut parser_lex_strterm , pub cond_stack : :: std :: os :: raw :: c_uint , pub cmdarg_stack : :: std :: os :: raw :: c_uint , pub paren_nest : :: std :: os :: raw :: c_int , pub lpar_beg : :: std :: os :: raw :: c_int , pub in_def : :: std :: os :: raw :: c_int , pub in_single : :: std :: os :: raw :: c_int , pub _bitfield_align_1 : [u8 ; 0] , pub _bitfield_1 : __BindgenBitfieldUnit < [u8 ; 1usize] > , pub locals : * mut mrb_ast_node , pub pb : * mut mrb_ast_node , pub tokbuf : * mut :: std :: os :: raw :: c_char , pub buf : [:: std :: os :: raw :: c_char ; 256usize] , pub tidx : :: std :: os :: raw :: c_int , pub tsiz : :: std :: os :: raw :: c_int , pub heredocs_from_nextline : * mut mrb_ast_node , pub parsing_heredoc : * mut mrb_ast_node , pub ylval : * mut :: std :: os :: raw :: c_void , pub nerr : usize , pub nwarn : usize , pub tree : * mut mrb_ast_node , pub _bitfield_align_2 : [u8 ; 0] , pub _bitfield_2 : __BindgenBitfieldUnit < [u8 ; 1usize] > , pub upper : * const RProc , pub error_buffer : [mrb_parser_message ; 10usize] , pub warn_buffer : [mrb_parser_message ; 10usize] , pub filename_table : * mut mrb_sym , pub filename_table_length : u16 , pub current_filename_index : u16 , pub nvars : * mut mrb_ast_node , } # [test] fn bindgen_test_layout_mrb_parser_state () { const UNINIT : :: std :: mem :: MaybeUninit < mrb_parser_state > = :: std :: mem :: MaybeUninit :: uninit () ; let ptr = UNINIT . as_ptr () ; assert_eq ! (:: std :: mem :: size_of :: < mrb_parser_state > () , 800usize , concat ! ("Size of: " , stringify ! (mrb_parser_state))) ; assert_eq ! (:: std :: mem :: align_of :: < mrb_parser_state > () , 8usize , concat ! ("Alignment of " , stringify ! (mrb_parser_state))) ; assert_eq ! (unsafe { :: std :: ptr :: addr_of ! ((* ptr) . mrb) as usize - ptr as usize } , 0usize , concat ! ("Offset of field: " , stringify ! (mrb_parser_state) , "::" , stringify ! (mrb))) ; assert_eq ! (unsafe { :: std :: ptr :: addr_of ! ((* ptr) . pool) as usize - ptr as usize } , 8usize , concat ! ("Offset of field: " , stringify ! (mrb_parser_state) , "::" , stringify ! (pool))) ; assert_eq ! (unsafe { :: std :: ptr :: addr_of ! ((* ptr) . cells) as usize - ptr as usize } , 16usize , concat ! ("Offset of field: " , stringify ! (mrb_parser_state) , "::" , stringify ! (cells))) ; assert_eq ! (unsafe { :: std :: ptr :: addr_of ! ((* ptr) . s) as usize - ptr as usize } , 24usize , concat ! ("Offset of field: " , stringify ! (mrb_parser_state) , "::" , stringify ! (s))) ; assert_eq ! (unsafe { :: std :: ptr :: addr_of ! ((* ptr) . send) as usize - ptr as usize } , 32usize , concat ! ("Offset of field: " , stringify ! (mrb_parser_state) , "::" , stringify ! (send))) ; assert_eq ! (unsafe { :: std :: ptr :: addr_of ! ((* ptr) . cxt) as usize - ptr as usize } , 40usize , concat ! ("Offset of field: " , stringify ! (mrb_parser_state) , "::" , stringify ! (cxt))) ; assert_eq ! (unsafe { :: std :: ptr :: addr_of ! ((* ptr) . filename_sym) as usize - ptr as usize } , 48usize , concat ! ("Offset of field: " , stringify ! (mrb_parser_state) , "::" , stringify ! (filename_sym))) ; assert_eq ! (unsafe { :: std :: ptr :: addr_of ! ((* ptr) . lineno) as usize - ptr as usize } , 52usize , concat ! ("Offset of field: " , stringify ! (mrb_parser_state) , "::" , stringify ! (lineno))) ; assert_eq ! (unsafe { :: std :: ptr :: addr_of ! ((* ptr) . column) as usize - ptr as usize } , 56usize , concat ! ("Offset of field: " , stringify ! (mrb_parser_state) , "::" , stringify ! (column))) ; assert_eq ! (unsafe { :: std :: ptr :: addr_of ! ((* ptr) . lstate) as usize - ptr as usize } , 60usize , concat ! ("Offset of field: " , stringify ! (mrb_parser_state) , "::" , stringify ! (lstate))) ; assert_eq ! (unsafe { :: std :: ptr :: addr_of ! ((* ptr) . lex_strterm) as usize - ptr as usize } , 64usize , concat ! ("Offset of field: " , stringify ! (mrb_parser_state) , "::" , stringify ! (lex_strterm))) ; assert_eq ! (unsafe { :: std :: ptr :: addr_of ! ((* ptr) . cond_stack) as usize - ptr as usize } , 72usize , concat ! ("Offset of field: " , stringify ! (mrb_parser_state) , "::" , stringify ! (cond_stack))) ; assert_eq ! (unsafe { :: std :: ptr :: addr_of ! ((* ptr) . cmdarg_stack) as usize - ptr as usize } , 76usize , concat ! ("Offset of field: " , stringify ! (mrb_parser_state) , "::" , stringify ! (cmdarg_stack))) ; assert_eq ! (unsafe { :: std :: ptr :: addr_of ! ((* ptr) . paren_nest) as usize - ptr as usize } , 80usize , concat ! ("Offset of field: " , stringify ! (mrb_parser_state) , "::" , stringify ! (paren_nest))) ; assert_eq ! (unsafe { :: std :: ptr :: addr_of ! ((* ptr) . lpar_beg) as usize - ptr as usize } , 84usize , concat ! ("Offset of field: " , stringify ! (mrb_parser_state) , "::" , stringify ! (lpar_beg))) ; assert_eq ! (unsafe { :: std :: ptr :: addr_of ! ((* ptr) . in_def) as usize - ptr as usize } , 88usize , concat ! ("Offset of field: " , stringify ! (mrb_parser_state) , "::" , stringify ! (in_def))) ; assert_eq ! (unsafe { :: std :: ptr :: addr_of ! ((* ptr) . in_single) as usize - ptr as usize } , 92usize , concat ! ("Offset of field: " , stringify ! (mrb_parser_state) , "::" , stringify ! (in_single))) ; assert_eq ! (unsafe { :: std :: ptr :: addr_of ! ((* ptr) . locals) as usize - ptr as usize } , 104usize , concat ! ("Offset of field: " , stringify ! (mrb_parser_state) , "::" , stringify ! (locals))) ; assert_eq ! (unsafe { :: std :: ptr :: addr_of ! ((* ptr) . pb) as usize - ptr as usize } , 112usize , concat ! ("Offset of field: " , stringify ! (mrb_parser_state) , "::" , stringify ! (pb))) ; assert_eq ! (unsafe { :: std :: ptr :: addr_of ! ((* ptr) . tokbuf) as usize - ptr as usize } , 120usize , concat ! ("Offset of field: " , stringify ! (mrb_parser_state) , "::" , stringify ! (tokbuf))) ; assert_eq ! (unsafe { :: std :: ptr :: addr_of ! ((* ptr) . buf) as usize - ptr as usize } , 128usize , concat ! ("Offset of field: " , stringify ! (mrb_parser_state) , "::" , stringify ! (buf))) ; assert_eq ! (unsafe { :: std :: ptr :: addr_of ! ((* ptr) . tidx) as usize - ptr as usize } , 384usize , concat ! ("Offset of field: " , stringify ! (mrb_parser_state) , "::" , stringify ! (tidx))) ; assert_eq ! (unsafe { :: std :: ptr :: addr_of ! ((* ptr) . tsiz) as usize - ptr as usize } , 388usize , concat ! ("Offset of field: " , stringify ! (mrb_parser_state) , "::" , stringify ! (tsiz))) ; assert_eq ! (unsafe { :: std :: ptr :: addr_of ! ((* ptr) . heredocs_from_nextline) as usize - ptr as usize } , 392usize , concat ! ("Offset of field: " , stringify ! (mrb_parser_state) , "::" , stringify ! (heredocs_from_nextline))) ; assert_eq ! (unsafe { :: std :: ptr :: addr_of ! ((* ptr) . parsing_heredoc) as usize - ptr as usize } , 400usize , concat ! ("Offset of field: " , stringify ! (mrb_parser_state) , "::" , stringify ! (parsing_heredoc))) ; assert_eq ! (unsafe { :: std :: ptr :: addr_of ! ((* ptr) . ylval) as usize - ptr as usize } , 408usize , concat ! ("Offset of field: " , stringify ! (mrb_parser_state) , "::" , stringify ! (ylval))) ; assert_eq ! (unsafe { :: std :: ptr :: addr_of ! ((* ptr) . nerr) as usize - ptr as usize } , 416usize , concat ! ("Offset of field: " , stringify ! (mrb_parser_state) , "::" , stringify ! (nerr))) ; assert_eq ! (unsafe { :: std :: ptr :: addr_of ! ((* ptr) . nwarn) as usize - ptr as usize } , 424usize , concat ! ("Offset of field: " , stringify ! (mrb_parser_state) , "::" , stringify ! (nwarn))) ; assert_eq ! (unsafe { :: std :: ptr :: addr_of ! ((* ptr) . tree) as usize - ptr as usize } , 432usize , concat ! ("Offset of field: " , stringify ! (mrb_parser_state) , "::" , stringify ! (tree))) ; assert_eq ! (unsafe { :: std :: ptr :: addr_of ! ((* ptr) . upper) as usize - ptr as usize } , 448usize , concat ! ("Offset of field: " , stringify ! (mrb_parser_state) , "::" , stringify ! (upper))) ; assert_eq ! (unsafe { :: std :: ptr :: addr_of ! ((* ptr) . error_buffer) as usize - ptr as usize } , 456usize , concat ! ("Offset of field: " , stringify ! (mrb_parser_state) , "::" , stringify ! (error_buffer))) ; assert_eq ! (unsafe { :: std :: ptr :: addr_of ! ((* ptr) . warn_buffer) as usize - ptr as usize } , 616usize , concat ! ("Offset of field: " , stringify ! (mrb_parser_state) , "::" , stringify ! (warn_buffer))) ; assert_eq ! (unsafe { :: std :: ptr :: addr_of ! ((* ptr) . filename_table) as usize - ptr as usize } , 776usize , concat ! ("Offset of field: " , stringify ! (mrb_parser_state) , "::" , stringify ! (filename_table))) ; assert_eq ! (unsafe { :: std :: ptr :: addr_of ! ((* ptr) . filename_table_length) as usize - ptr as usize } , 784usize , concat ! ("Offset of field: " , stringify ! (mrb_parser_state) , "::" , stringify ! (filename_table_length))) ; assert_eq ! (unsafe { :: std :: ptr :: addr_of ! ((* ptr) . current_filename_index) as usize - ptr as usize } , 786usize , concat ! ("Offset of field: " , stringify ! (mrb_parser_state) , "::" , stringify ! (current_filename_index))) ; assert_eq ! (unsafe { :: std :: ptr :: addr_of ! ((* ptr) . nvars) as usize - ptr as usize } , 792usize , concat ! ("Offset of field: " , stringify ! (mrb_parser_state) , "::" , stringify ! (nvars))) ; } impl mrb_parser_state { # [inline] pub fn cmd_start (& self) -> mrb_bool { unsafe { :: std :: mem :: transmute (self . _bitfield_1 . get (0usize , 1u8) as u8) } } # [inline] pub fn set_cmd_start (& 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 (cmd_start : mrb_bool) -> __BindgenBitfieldUnit < [u8 ; 1usize] > { let mut __bindgen_bitfield_unit : __BindgenBitfieldUnit < [u8 ; 1usize] > = Default :: default () ; __bindgen_bitfield_unit . set (0usize , 1u8 , { let cmd_start : u8 = unsafe { :: std :: mem :: transmute (cmd_start) } ; cmd_start as u64 }) ; __bindgen_bitfield_unit } # [inline] pub fn no_optimize (& self) -> mrb_bool { unsafe { :: std :: mem :: transmute (self . _bitfield_2 . get (0usize , 1u8) as u8) } } # [inline] pub fn set_no_optimize (& mut self , val : mrb_bool) { unsafe { let val : u8 = :: std :: mem :: transmute (val) ; self . _bitfield_2 . set (0usize , 1u8 , val as u64) } } # [inline] pub fn capture_errors (& self) -> mrb_bool { unsafe { :: std :: mem :: transmute (self . _bitfield_2 . get (1usize , 1u8) as u8) } } # [inline] pub fn set_capture_errors (& mut self , val : mrb_bool) { unsafe { let val : u8 = :: std :: mem :: transmute (val) ; self . _bitfield_2 . set (1usize , 1u8 , val as u64) } } # [inline] pub fn no_ext_ops (& self) -> mrb_bool { unsafe { :: std :: mem :: transmute (self . _bitfield_2 . get (2usize , 1u8) as u8) } } # [inline] pub fn set_no_ext_ops (& mut self , val : mrb_bool) { unsafe { let val : u8 = :: std :: mem :: transmute (val) ; self . _bitfield_2 . set (2usize , 1u8 , val as u64) } } # [inline] pub fn new_bitfield_2 (no_optimize : mrb_bool , capture_errors : mrb_bool , no_ext_ops : mrb_bool) -> __BindgenBitfieldUnit < [u8 ; 1usize] > { let mut __bindgen_bitfield_unit : __BindgenBitfieldUnit < [u8 ; 1usize] > = Default :: default () ; __bindgen_bitfield_unit . set (0usize , 1u8 , { let no_optimize : u8 = unsafe { :: std :: mem :: transmute (no_optimize) } ; no_optimize as u64 }) ; __bindgen_bitfield_unit . set (1usize , 1u8 , { let capture_errors : u8 = unsafe { :: std :: mem :: transmute (capture_errors) } ; capture_errors as u64 }) ; __bindgen_bitfield_unit . set (2usize , 1u8 , { let no_ext_ops : u8 = unsafe { :: std :: mem :: transmute (no_ext_ops) } ; no_ext_ops as u64 }) ; __bindgen_bitfield_unit } } extern "C" { pub fn mrb_parser_new (arg1 : * mut mrb_state) -> * mut mrb_parser_state ; } extern "C" { pub fn mrb_parser_free (arg1 : * mut mrb_parser_state) ; } extern "C" { pub fn mrb_parser_parse (arg1 : * mut mrb_parser_state , arg2 : * mut mrbc_context) ; } extern "C" { pub fn mrb_parser_set_filename (arg1 : * mut mrb_parser_state , arg2 : * const :: std :: os :: raw :: c_char) ; } extern "C" { pub fn mrb_parser_get_filename (arg1 : * mut mrb_parser_state , idx : u16) -> mrb_sym ; } extern "C" { pub fn mrb_parse_string (arg1 : * mut mrb_state , arg2 : * const :: std :: os :: raw :: c_char , arg3 : * mut mrbc_context) -> * mut mrb_parser_state ; } extern "C" { pub fn mrb_parse_nstring (arg1 : * mut mrb_state , arg2 : * const :: std :: os :: raw :: c_char , arg3 : usize , arg4 : * mut mrbc_context) -> * mut mrb_parser_state ; } extern "C" { pub fn mrb_generate_code (arg1 : * mut mrb_state , arg2 : * mut mrb_parser_state) -> * mut RProc ; } extern "C" { pub fn mrb_load_exec (mrb : * mut mrb_state , p : * mut mrb_parser_state , c : * mut mrbc_context) -> mrb_value ; } extern "C" { pub fn mrb_load_string (mrb : * mut mrb_state , s : * const :: std :: os :: raw :: c_char) -> mrb_value ; } extern "C" { pub fn mrb_load_nstring (mrb : * mut mrb_state , s : * const :: std :: os :: raw :: c_char , len : usize) -> mrb_value ; } extern "C" { pub fn mrb_load_string_cxt (mrb : * mut mrb_state , s : * const :: std :: os :: raw :: c_char , cxt : * mut mrbc_context) -> mrb_value ; } extern "C" { pub fn mrb_load_nstring_cxt (mrb : * mut mrb_state , s : * const :: std :: os :: raw :: c_char , len : usize , cxt : * mut mrbc_context) -> mrb_value ; } # [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) > , } # [test] fn bindgen_test_layout_mrb_data_type () { const UNINIT : :: std :: mem :: MaybeUninit < mrb_data_type > = :: std :: mem :: MaybeUninit :: uninit () ; let ptr = UNINIT . as_ptr () ; assert_eq ! (:: std :: mem :: size_of :: < mrb_data_type > () , 16usize , concat ! ("Size of: " , stringify ! (mrb_data_type))) ; assert_eq ! (:: std :: mem :: align_of :: < mrb_data_type > () , 8usize , concat ! ("Alignment of " , stringify ! (mrb_data_type))) ; assert_eq ! (unsafe { :: std :: ptr :: addr_of ! ((* ptr) . struct_name) as usize - ptr as usize } , 0usize , concat ! ("Offset of field: " , stringify ! (mrb_data_type) , "::" , stringify ! (struct_name))) ; assert_eq ! (unsafe { :: std :: ptr :: addr_of ! ((* ptr) . dfree) as usize - ptr as usize } , 8usize , concat ! ("Offset of field: " , stringify ! (mrb_data_type) , "::" , stringify ! (dfree))) ; } # [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 , } # [test] fn bindgen_test_layout_RData () { const UNINIT : :: std :: mem :: MaybeUninit < RData > = :: std :: mem :: MaybeUninit :: uninit () ; let ptr = UNINIT . as_ptr () ; assert_eq ! (:: std :: mem :: size_of :: < RData > () , 48usize , concat ! ("Size of: " , stringify ! (RData))) ; assert_eq ! (:: std :: mem :: align_of :: < RData > () , 8usize , concat ! ("Alignment of " , stringify ! (RData))) ; assert_eq ! (unsafe { :: std :: ptr :: addr_of ! ((* ptr) . c) as usize - ptr as usize } , 0usize , concat ! ("Offset of field: " , stringify ! (RData) , "::" , stringify ! (c))) ; assert_eq ! (unsafe { :: std :: ptr :: addr_of ! ((* ptr) . gcnext) as usize - ptr as usize } , 8usize , concat ! ("Offset of field: " , stringify ! (RData) , "::" , stringify ! (gcnext))) ; assert_eq ! (unsafe { :: std :: ptr :: addr_of ! ((* ptr) . iv) as usize - ptr as usize } , 24usize , concat ! ("Offset of field: " , stringify ! (RData) , "::" , stringify ! (iv))) ; assert_eq ! (unsafe { :: std :: ptr :: addr_of ! ((* ptr) . type_) as usize - ptr as usize } , 32usize , concat ! ("Offset of field: " , stringify ! (RData) , "::" , stringify ! (type_))) ; assert_eq ! (unsafe { :: std :: ptr :: addr_of ! ((* ptr) . data) as usize - ptr as usize } , 40usize , concat ! ("Offset of field: " , stringify ! (RData) , "::" , stringify ! (data))) ; } 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 } } extern "C" { pub fn mrb_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 mrb_data_check_type (mrb : * mut mrb_state , arg1 : mrb_value , arg2 : * const mrb_data_type) ; } extern "C" { pub fn mrb_data_get_ptr (mrb : * mut mrb_state , arg1 : mrb_value , arg2 : * const mrb_data_type) -> * mut :: std :: os :: raw :: c_void ; } extern "C" { pub fn mrb_data_check_get_ptr (mrb : * mut mrb_state , arg1 : mrb_value , arg2 : * const mrb_data_type) -> * mut :: std :: os :: raw :: c_void ; } # [repr (C)] # [derive (Copy , Clone)] pub struct mrb_pool_value { pub tt : u32 , pub u : mrb_pool_value__bindgen_ty_1 , } # [repr (C)] # [derive (Copy , Clone)] pub union mrb_pool_value__bindgen_ty_1 { pub str_ : * const :: std :: os :: raw :: c_char , pub i32_ : i32 , pub i64_ : i64 , pub f : mrb_float , } # [test] fn bindgen_test_layout_mrb_pool_value__bindgen_ty_1 () { const UNINIT : :: std :: mem :: MaybeUninit < mrb_pool_value__bindgen_ty_1 > = :: std :: mem :: MaybeUninit :: uninit () ; let ptr = UNINIT . as_ptr () ; assert_eq ! (:: std :: mem :: size_of :: < mrb_pool_value__bindgen_ty_1 > () , 8usize , concat ! ("Size of: " , stringify ! (mrb_pool_value__bindgen_ty_1))) ; assert_eq ! (:: std :: mem :: align_of :: < mrb_pool_value__bindgen_ty_1 > () , 8usize , concat ! ("Alignment of " , stringify ! (mrb_pool_value__bindgen_ty_1))) ; assert_eq ! (unsafe { :: std :: ptr :: addr_of ! ((* ptr) . str_) as usize - ptr as usize } , 0usize , concat ! ("Offset of field: " , stringify ! (mrb_pool_value__bindgen_ty_1) , "::" , stringify ! (str_))) ; assert_eq ! (unsafe { :: std :: ptr :: addr_of ! ((* ptr) . i32_) as usize - ptr as usize } , 0usize , concat ! ("Offset of field: " , stringify ! (mrb_pool_value__bindgen_ty_1) , "::" , stringify ! (i32_))) ; assert_eq ! (unsafe { :: std :: ptr :: addr_of ! ((* ptr) . i64_) as usize - ptr as usize } , 0usize , concat ! ("Offset of field: " , stringify ! (mrb_pool_value__bindgen_ty_1) , "::" , stringify ! (i64_))) ; assert_eq ! (unsafe { :: std :: ptr :: addr_of ! ((* ptr) . f) as usize - ptr as usize } , 0usize , concat ! ("Offset of field: " , stringify ! (mrb_pool_value__bindgen_ty_1) , "::" , stringify ! (f))) ; } # [test] fn bindgen_test_layout_mrb_pool_value () { const UNINIT : :: std :: mem :: MaybeUninit < mrb_pool_value > = :: std :: mem :: MaybeUninit :: uninit () ; let ptr = UNINIT . as_ptr () ; assert_eq ! (:: std :: mem :: size_of :: < mrb_pool_value > () , 16usize , concat ! ("Size of: " , stringify ! (mrb_pool_value))) ; assert_eq ! (:: std :: mem :: align_of :: < mrb_pool_value > () , 8usize , concat ! ("Alignment of " , stringify ! (mrb_pool_value))) ; assert_eq ! (unsafe { :: std :: ptr :: addr_of ! ((* ptr) . tt) as usize - ptr as usize } , 0usize , concat ! ("Offset of field: " , stringify ! (mrb_pool_value) , "::" , stringify ! (tt))) ; assert_eq ! (unsafe { :: std :: ptr :: addr_of ! ((* ptr) . u) as usize - ptr as usize } , 8usize , concat ! ("Offset of field: " , stringify ! (mrb_pool_value) , "::" , stringify ! (u))) ; } # [repr (u32)] # [derive (Debug , Copy , Clone , Hash , PartialEq , Eq)] pub enum mrb_catch_type { MRB_CATCH_RESCUE = 0 , MRB_CATCH_ENSURE = 1 , } # [repr (C)] # [derive (Debug , Copy , Clone)] pub struct mrb_irep_catch_handler { pub type_ : u8 , pub begin : [u8 ; 4usize] , pub end : [u8 ; 4usize] , pub target : [u8 ; 4usize] , } # [test] fn bindgen_test_layout_mrb_irep_catch_handler () { const UNINIT : :: std :: mem :: MaybeUninit < mrb_irep_catch_handler > = :: std :: mem :: MaybeUninit :: uninit () ; let ptr = UNINIT . as_ptr () ; assert_eq ! (:: std :: mem :: size_of :: < mrb_irep_catch_handler > () , 13usize , concat ! ("Size of: " , stringify ! (mrb_irep_catch_handler))) ; assert_eq ! (:: std :: mem :: align_of :: < mrb_irep_catch_handler > () , 1usize , concat ! ("Alignment of " , stringify ! (mrb_irep_catch_handler))) ; assert_eq ! (unsafe { :: std :: ptr :: addr_of ! ((* ptr) . type_) as usize - ptr as usize } , 0usize , concat ! ("Offset of field: " , stringify ! (mrb_irep_catch_handler) , "::" , stringify ! (type_))) ; assert_eq ! (unsafe { :: std :: ptr :: addr_of ! ((* ptr) . begin) as usize - ptr as usize } , 1usize , concat ! ("Offset of field: " , stringify ! (mrb_irep_catch_handler) , "::" , stringify ! (begin))) ; assert_eq ! (unsafe { :: std :: ptr :: addr_of ! ((* ptr) . end) as usize - ptr as usize } , 5usize , concat ! ("Offset of field: " , stringify ! (mrb_irep_catch_handler) , "::" , stringify ! (end))) ; assert_eq ! (unsafe { :: std :: ptr :: addr_of ! ((* ptr) . target) as usize - ptr as usize } , 9usize , concat ! ("Offset of field: " , stringify ! (mrb_irep_catch_handler) , "::" , stringify ! (target))) ; } # [repr (C)] # [derive (Debug , Copy , Clone)] pub struct mrb_irep { pub nlocals : u16 , pub nregs : u16 , pub clen : u16 , pub flags : u8 , pub iseq : * const mrb_code , pub pool : * const mrb_pool_value , pub syms : * const mrb_sym , pub reps : * const * const mrb_irep , pub lv : * const mrb_sym , pub debug_info : * mut mrb_irep_debug_info , pub ilen : u32 , pub plen : u16 , pub slen : u16 , pub rlen : u16 , pub refcnt : u16 , } # [test] fn bindgen_test_layout_mrb_irep () { const UNINIT : :: std :: mem :: MaybeUninit < mrb_irep > = :: std :: mem :: MaybeUninit :: uninit () ; let ptr = UNINIT . as_ptr () ; assert_eq ! (:: std :: mem :: size_of :: < mrb_irep > () , 72usize , concat ! ("Size of: " , stringify ! (mrb_irep))) ; assert_eq ! (:: std :: mem :: align_of :: < mrb_irep > () , 8usize , concat ! ("Alignment of " , stringify ! (mrb_irep))) ; assert_eq ! (unsafe { :: std :: ptr :: addr_of ! ((* ptr) . nlocals) as usize - ptr as usize } , 0usize , concat ! ("Offset of field: " , stringify ! (mrb_irep) , "::" , stringify ! (nlocals))) ; assert_eq ! (unsafe { :: std :: ptr :: addr_of ! ((* ptr) . nregs) as usize - ptr as usize } , 2usize , concat ! ("Offset of field: " , stringify ! (mrb_irep) , "::" , stringify ! (nregs))) ; assert_eq ! (unsafe { :: std :: ptr :: addr_of ! ((* ptr) . clen) as usize - ptr as usize } , 4usize , concat ! ("Offset of field: " , stringify ! (mrb_irep) , "::" , stringify ! (clen))) ; assert_eq ! (unsafe { :: std :: ptr :: addr_of ! ((* ptr) . flags) as usize - ptr as usize } , 6usize , concat ! ("Offset of field: " , stringify ! (mrb_irep) , "::" , stringify ! (flags))) ; assert_eq ! (unsafe { :: std :: ptr :: addr_of ! ((* ptr) . iseq) as usize - ptr as usize } , 8usize , concat ! ("Offset of field: " , stringify ! (mrb_irep) , "::" , stringify ! (iseq))) ; assert_eq ! (unsafe { :: std :: ptr :: addr_of ! ((* ptr) . pool) as usize - ptr as usize } , 16usize , concat ! ("Offset of field: " , stringify ! (mrb_irep) , "::" , stringify ! (pool))) ; assert_eq ! (unsafe { :: std :: ptr :: addr_of ! ((* ptr) . syms) as usize - ptr as usize } , 24usize , concat ! ("Offset of field: " , stringify ! (mrb_irep) , "::" , stringify ! (syms))) ; assert_eq ! (unsafe { :: std :: ptr :: addr_of ! ((* ptr) . reps) as usize - ptr as usize } , 32usize , concat ! ("Offset of field: " , stringify ! (mrb_irep) , "::" , stringify ! (reps))) ; assert_eq ! (unsafe { :: std :: ptr :: addr_of ! ((* ptr) . lv) as usize - ptr as usize } , 40usize , concat ! ("Offset of field: " , stringify ! (mrb_irep) , "::" , stringify ! (lv))) ; assert_eq ! (unsafe { :: std :: ptr :: addr_of ! ((* ptr) . debug_info) as usize - ptr as usize } , 48usize , concat ! ("Offset of field: " , stringify ! (mrb_irep) , "::" , stringify ! (debug_info))) ; assert_eq ! (unsafe { :: std :: ptr :: addr_of ! ((* ptr) . ilen) as usize - ptr as usize } , 56usize , concat ! ("Offset of field: " , stringify ! (mrb_irep) , "::" , stringify ! (ilen))) ; assert_eq ! (unsafe { :: std :: ptr :: addr_of ! ((* ptr) . plen) as usize - ptr as usize } , 60usize , concat ! ("Offset of field: " , stringify ! (mrb_irep) , "::" , stringify ! (plen))) ; assert_eq ! (unsafe { :: std :: ptr :: addr_of ! ((* ptr) . slen) as usize - ptr as usize } , 62usize , concat ! ("Offset of field: " , stringify ! (mrb_irep) , "::" , stringify ! (slen))) ; assert_eq ! (unsafe { :: std :: ptr :: addr_of ! ((* ptr) . rlen) as usize - ptr as usize } , 64usize , concat ! ("Offset of field: " , stringify ! (mrb_irep) , "::" , stringify ! (rlen))) ; assert_eq ! (unsafe { :: std :: ptr :: addr_of ! ((* ptr) . refcnt) as usize - ptr as usize } , 66usize , concat ! ("Offset of field: " , stringify ! (mrb_irep) , "::" , stringify ! (refcnt))) ; } extern "C" { pub fn mrb_add_irep (mrb : * mut mrb_state) -> * mut mrb_irep ; } extern "C" { pub fn mrb_load_irep (arg1 : * mut mrb_state , arg2 : * const u8) -> mrb_value ; } extern "C" { pub fn mrb_load_irep_buf (arg1 : * mut mrb_state , arg2 : * const :: std :: os :: raw :: c_void , arg3 : usize) -> mrb_value ; } extern "C" { pub fn mrb_load_irep_cxt (arg1 : * mut mrb_state , arg2 : * const u8 , arg3 : * mut mrbc_context) -> mrb_value ; } extern "C" { pub fn mrb_load_irep_buf_cxt (arg1 : * mut mrb_state , arg2 : * const :: std :: os :: raw :: c_void , arg3 : usize , arg4 : * mut mrbc_context) -> mrb_value ; } # [repr (C)] # [derive (Debug , Copy , Clone)] pub struct mrb_insn_data { pub insn : u8 , pub a : u32 , pub b : u16 , pub c : u16 , pub addr : * const mrb_code , } # [test] fn bindgen_test_layout_mrb_insn_data () { const UNINIT : :: std :: mem :: MaybeUninit < mrb_insn_data > = :: std :: mem :: MaybeUninit :: uninit () ; let ptr = UNINIT . as_ptr () ; assert_eq ! (:: std :: mem :: size_of :: < mrb_insn_data > () , 24usize , concat ! ("Size of: " , stringify ! (mrb_insn_data))) ; assert_eq ! (:: std :: mem :: align_of :: < mrb_insn_data > () , 8usize , concat ! ("Alignment of " , stringify ! (mrb_insn_data))) ; assert_eq ! (unsafe { :: std :: ptr :: addr_of ! ((* ptr) . insn) as usize - ptr as usize } , 0usize , concat ! ("Offset of field: " , stringify ! (mrb_insn_data) , "::" , stringify ! (insn))) ; assert_eq ! (unsafe { :: std :: ptr :: addr_of ! ((* ptr) . a) as usize - ptr as usize } , 4usize , concat ! ("Offset of field: " , stringify ! (mrb_insn_data) , "::" , stringify ! (a))) ; assert_eq ! (unsafe { :: std :: ptr :: addr_of ! ((* ptr) . b) as usize - ptr as usize } , 8usize , concat ! ("Offset of field: " , stringify ! (mrb_insn_data) , "::" , stringify ! (b))) ; assert_eq ! (unsafe { :: std :: ptr :: addr_of ! ((* ptr) . c) as usize - ptr as usize } , 10usize , concat ! ("Offset of field: " , stringify ! (mrb_insn_data) , "::" , stringify ! (c))) ; assert_eq ! (unsafe { :: std :: ptr :: addr_of ! ((* ptr) . addr) as usize - ptr as usize } , 16usize , concat ! ("Offset of field: " , stringify ! (mrb_insn_data) , "::" , stringify ! (addr))) ; } extern "C" { pub fn mrb_irep_incref (arg1 : * mut mrb_state , arg2 : * mut mrb_irep) ; } extern "C" { pub fn mrb_irep_decref (arg1 : * mut mrb_state , arg2 : * mut mrb_irep) ; } extern "C" { pub fn mrb_irep_cutref (arg1 : * mut mrb_state , arg2 : * mut mrb_irep) ; } extern "C" { pub fn mrb_read_irep (arg1 : * mut mrb_state , arg2 : * const u8) -> * mut mrb_irep ; } extern "C" { pub fn mrb_read_irep_buf (arg1 : * mut mrb_state , arg2 : * const :: std :: os :: raw :: c_void , arg3 : usize) -> * mut mrb_irep ; } extern "C" { pub fn mrb_sys_fail (mrb : * mut mrb_state , mesg : * const :: std :: os :: raw :: c_char) ; } extern "C" { pub fn mrb_exc_new_str (mrb : * mut mrb_state , c : * mut RClass , str_ : mrb_value) -> mrb_value ; } extern "C" { pub fn mrb_make_exception (mrb : * mut mrb_state , argc : mrb_int , argv : * const mrb_value) -> mrb_value ; } extern "C" { pub fn mrb_no_method_error (mrb : * mut mrb_state , id : mrb_sym , args : mrb_value , fmt : * const :: std :: os :: raw :: c_char , ...) ; } extern "C" { pub fn mrb_f_raise (arg1 : * mut mrb_state , arg2 : mrb_value) -> mrb_value ; } pub type mrb_protect_error_func = :: std :: option :: Option < unsafe extern "C" fn (mrb : * mut mrb_state , userdata : * mut :: std :: os :: raw :: c_void) -> mrb_value > ; extern "C" { pub fn mrb_protect_error (mrb : * mut mrb_state , body : mrb_protect_error_func , userdata : * mut :: std :: os :: raw :: c_void , error : * mut mrb_bool) -> mrb_value ; } extern "C" { pub fn mrb_protect (mrb : * mut mrb_state , body : mrb_func_t , data : mrb_value , state : * mut mrb_bool) -> mrb_value ; } extern "C" { pub fn mrb_ensure (mrb : * mut mrb_state , body : mrb_func_t , b_data : mrb_value , ensure : mrb_func_t , e_data : mrb_value) -> mrb_value ; } extern "C" { pub fn mrb_rescue (mrb : * mut mrb_state , body : mrb_func_t , b_data : mrb_value , rescue : mrb_func_t , r_data : mrb_value) -> mrb_value ; } extern "C" { pub fn mrb_rescue_exceptions (mrb : * mut mrb_state , body : mrb_func_t , b_data : mrb_value , rescue : mrb_func_t , r_data : mrb_value , len : mrb_int , classes : * mut * mut RClass) -> mrb_value ; } # [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 , } # [test] fn bindgen_test_layout_RHash__bindgen_ty_1 () { const UNINIT : :: std :: mem :: MaybeUninit < RHash__bindgen_ty_1 > = :: std :: mem :: MaybeUninit :: uninit () ; let ptr = UNINIT . as_ptr () ; assert_eq ! (:: std :: mem :: size_of :: < RHash__bindgen_ty_1 > () , 8usize , concat ! ("Size of: " , stringify ! (RHash__bindgen_ty_1))) ; assert_eq ! (:: std :: mem :: align_of :: < RHash__bindgen_ty_1 > () , 8usize , concat ! ("Alignment of " , stringify ! (RHash__bindgen_ty_1))) ; assert_eq ! (unsafe { :: std :: ptr :: addr_of ! ((* ptr) . ea) as usize - ptr as usize } , 0usize , concat ! ("Offset of field: " , stringify ! (RHash__bindgen_ty_1) , "::" , stringify ! (ea))) ; assert_eq ! (unsafe { :: std :: ptr :: addr_of ! ((* ptr) . ht) as usize - ptr as usize } , 0usize , concat ! ("Offset of field: " , stringify ! (RHash__bindgen_ty_1) , "::" , stringify ! (ht))) ; } # [test] fn bindgen_test_layout_RHash () { const UNINIT : :: std :: mem :: MaybeUninit < RHash > = :: std :: mem :: MaybeUninit :: uninit () ; let ptr = UNINIT . as_ptr () ; assert_eq ! (:: std :: mem :: size_of :: < RHash > () , 48usize , concat ! ("Size of: " , stringify ! (RHash))) ; assert_eq ! (:: std :: mem :: align_of :: < RHash > () , 8usize , concat ! ("Alignment of " , stringify ! (RHash))) ; assert_eq ! (unsafe { :: std :: ptr :: addr_of ! ((* ptr) . c) as usize - ptr as usize } , 0usize , concat ! ("Offset of field: " , stringify ! (RHash) , "::" , stringify ! (c))) ; assert_eq ! (unsafe { :: std :: ptr :: addr_of ! ((* ptr) . gcnext) as usize - ptr as usize } , 8usize , concat ! ("Offset of field: " , stringify ! (RHash) , "::" , stringify ! (gcnext))) ; assert_eq ! (unsafe { :: std :: ptr :: addr_of ! ((* ptr) . size) as usize - ptr as usize } , 20usize , concat ! ("Offset of field: " , stringify ! (RHash) , "::" , stringify ! (size))) ; assert_eq ! (unsafe { :: std :: ptr :: addr_of ! ((* ptr) . iv) as usize - ptr as usize } , 24usize , concat ! ("Offset of field: " , stringify ! (RHash) , "::" , stringify ! (iv))) ; assert_eq ! (unsafe { :: std :: ptr :: addr_of ! ((* ptr) . ea_capa) as usize - ptr as usize } , 32usize , concat ! ("Offset of field: " , stringify ! (RHash) , "::" , stringify ! (ea_capa))) ; assert_eq ! (unsafe { :: std :: ptr :: addr_of ! ((* ptr) . ea_n_used) as usize - ptr as usize } , 36usize , concat ! ("Offset of field: " , stringify ! (RHash) , "::" , stringify ! (ea_n_used))) ; assert_eq ! (unsafe { :: std :: ptr :: addr_of ! ((* ptr) . hsh) as usize - ptr as usize } , 40usize , concat ! ("Offset of field: " , stringify ! (RHash) , "::" , stringify ! (hsh))) ; } 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 } } extern "C" { pub fn mrb_hash_new_capa (mrb : * mut mrb_state , capa : mrb_int) -> mrb_value ; } extern "C" { pub fn mrb_hash_new (mrb : * mut mrb_state) -> mrb_value ; } extern "C" { pub fn mrb_hash_set (mrb : * mut mrb_state , hash : mrb_value , key : mrb_value , val : mrb_value) ; } extern "C" { pub fn mrb_hash_get (mrb : * mut mrb_state , hash : mrb_value , key : mrb_value) -> mrb_value ; } extern "C" { pub fn mrb_hash_fetch (mrb : * mut mrb_state , hash : mrb_value , key : mrb_value , def : mrb_value) -> mrb_value ; } extern "C" { pub fn mrb_hash_delete_key (mrb : * mut mrb_state , hash : mrb_value , key : mrb_value) -> mrb_value ; } extern "C" { pub fn mrb_hash_keys (mrb : * mut mrb_state , hash : mrb_value) -> mrb_value ; } extern "C" { pub fn mrb_hash_key_p (mrb : * mut mrb_state , hash : mrb_value , key : mrb_value) -> mrb_bool ; } extern "C" { pub fn mrb_hash_empty_p (mrb : * mut mrb_state , self_ : mrb_value) -> mrb_bool ; } extern "C" { pub fn mrb_hash_values (mrb : * mut mrb_state , hash : mrb_value) -> mrb_value ; } extern "C" { pub fn mrb_hash_clear (mrb : * mut mrb_state , hash : mrb_value) -> mrb_value ; } extern "C" { pub fn mrb_hash_size (mrb : * mut mrb_state , hash : mrb_value) -> mrb_int ; } extern "C" { pub fn mrb_hash_dup (mrb : * mut mrb_state , hash : mrb_value) -> mrb_value ; } extern "C" { pub fn mrb_hash_merge (mrb : * mut mrb_state , hash1 : mrb_value , hash2 : mrb_value) ; } pub type mrb_hash_foreach_func = :: std :: option :: Option < unsafe extern "C" fn (mrb : * mut mrb_state , key : mrb_value , val : mrb_value , data : * mut :: std :: os :: raw :: c_void) -> :: std :: os :: raw :: c_int > ; extern "C" { pub fn mrb_hash_foreach (mrb : * mut mrb_state , hash : * mut RHash , func : mrb_hash_foreach_func , p : * mut :: std :: os :: raw :: c_void) ; } extern "C" { pub fn mrb_num_add (mrb : * mut mrb_state , x : mrb_value , y : mrb_value) -> mrb_value ; } extern "C" { pub fn mrb_num_sub (mrb : * mut mrb_state , x : mrb_value , y : mrb_value) -> mrb_value ; } extern "C" { pub fn mrb_num_mul (mrb : * mut mrb_state , x : mrb_value , y : mrb_value) -> mrb_value ; } extern "C" { pub fn mrb_integer_to_str (mrb : * mut mrb_state , x : mrb_value , base : mrb_int) -> mrb_value ; } extern "C" { pub fn mrb_int_to_cstr (buf : * mut :: std :: os :: raw :: c_char , len : usize , n : mrb_int , base : mrb_int) -> * mut :: std :: os :: raw :: c_char ; } extern "C" { pub fn mrb_float_to_integer (mrb : * mut mrb_state , val : mrb_value) -> mrb_value ; } extern "C" { pub fn mrb_div_float (x : mrb_float , y : mrb_float) -> mrb_float ; } extern "C" { pub fn mrb_float_to_str (mrb : * mut mrb_state , x : mrb_value , fmt : * const :: std :: os :: raw :: c_char) -> mrb_value ; } extern "C" { pub fn mrb_format_float (f : mrb_float , buf : * mut :: std :: os :: raw :: c_char , buf_size : usize , fmt : :: std :: os :: raw :: c_char , prec : :: std :: os :: raw :: c_int , sign : :: std :: os :: raw :: c_char) -> :: std :: os :: raw :: c_int ; } # [repr (u32)] # [derive (Debug , Copy , Clone , Hash , PartialEq , Eq)] pub enum mrb_insn { OP_NOP = 0 , OP_MOVE = 1 , OP_LOADL = 2 , OP_LOADI = 3 , OP_LOADINEG = 4 , OP_LOADI__1 = 5 , OP_LOADI_0 = 6 , OP_LOADI_1 = 7 , OP_LOADI_2 = 8 , OP_LOADI_3 = 9 , OP_LOADI_4 = 10 , OP_LOADI_5 = 11 , OP_LOADI_6 = 12 , OP_LOADI_7 = 13 , OP_LOADI16 = 14 , OP_LOADI32 = 15 , OP_LOADSYM = 16 , OP_LOADNIL = 17 , OP_LOADSELF = 18 , OP_LOADT = 19 , OP_LOADF = 20 , OP_GETGV = 21 , OP_SETGV = 22 , OP_GETSV = 23 , OP_SETSV = 24 , OP_GETIV = 25 , OP_SETIV = 26 , OP_GETCV = 27 , OP_SETCV = 28 , OP_GETCONST = 29 , OP_SETCONST = 30 , OP_GETMCNST = 31 , OP_SETMCNST = 32 , OP_GETUPVAR = 33 , OP_SETUPVAR = 34 , OP_GETIDX = 35 , OP_SETIDX = 36 , OP_JMP = 37 , OP_JMPIF = 38 , OP_JMPNOT = 39 , OP_JMPNIL = 40 , OP_JMPUW = 41 , OP_EXCEPT = 42 , OP_RESCUE = 43 , OP_RAISEIF = 44 , OP_SSEND = 45 , OP_SSENDB = 46 , OP_SEND = 47 , OP_SENDB = 48 , OP_CALL = 49 , OP_SUPER = 50 , OP_ARGARY = 51 , OP_ENTER = 52 , OP_KEY_P = 53 , OP_KEYEND = 54 , OP_KARG = 55 , OP_RETURN = 56 , OP_RETURN_BLK = 57 , OP_BREAK = 58 , OP_BLKPUSH = 59 , OP_ADD = 60 , OP_ADDI = 61 , OP_SUB = 62 , OP_SUBI = 63 , OP_MUL = 64 , OP_DIV = 65 , OP_EQ = 66 , OP_LT = 67 , OP_LE = 68 , OP_GT = 69 , OP_GE = 70 , OP_ARRAY = 71 , OP_ARRAY2 = 72 , OP_ARYCAT = 73 , OP_ARYPUSH = 74 , OP_ARYSPLAT = 75 , OP_AREF = 76 , OP_ASET = 77 , OP_APOST = 78 , OP_INTERN = 79 , OP_SYMBOL = 80 , OP_STRING = 81 , OP_STRCAT = 82 , OP_HASH = 83 , OP_HASHADD = 84 , OP_HASHCAT = 85 , OP_LAMBDA = 86 , OP_BLOCK = 87 , OP_METHOD = 88 , OP_RANGE_INC = 89 , OP_RANGE_EXC = 90 , OP_OCLASS = 91 , OP_CLASS = 92 , OP_MODULE = 93 , OP_EXEC = 94 , OP_DEF = 95 , OP_ALIAS = 96 , OP_UNDEF = 97 , OP_SCLASS = 98 , OP_TCLASS = 99 , OP_DEBUG = 100 , OP_ERR = 101 , OP_EXT1 = 102 , OP_EXT2 = 103 , OP_EXT3 = 104 , OP_STOP = 105 , } # [repr (C)] # [derive (Debug , Copy , Clone)] pub struct REnv { pub c : * mut RClass , pub gcnext : * mut RBasic , pub _bitfield_align_1 : [u32 ; 0] , pub _bitfield_1 : __BindgenBitfieldUnit < [u8 ; 4usize] > , pub stack : * mut mrb_value , pub cxt : * mut mrb_context , pub mid : mrb_sym , } # [test] fn bindgen_test_layout_REnv () { const UNINIT : :: std :: mem :: MaybeUninit < REnv > = :: std :: mem :: MaybeUninit :: uninit () ; let ptr = UNINIT . as_ptr () ; assert_eq ! (:: std :: mem :: size_of :: < REnv > () , 48usize , concat ! ("Size of: " , stringify ! (REnv))) ; assert_eq ! (:: std :: mem :: align_of :: < REnv > () , 8usize , concat ! ("Alignment of " , stringify ! (REnv))) ; assert_eq ! (unsafe { :: std :: ptr :: addr_of ! ((* ptr) . c) as usize - ptr as usize } , 0usize , concat ! ("Offset of field: " , stringify ! (REnv) , "::" , stringify ! (c))) ; assert_eq ! (unsafe { :: std :: ptr :: addr_of ! ((* ptr) . gcnext) as usize - ptr as usize } , 8usize , concat ! ("Offset of field: " , stringify ! (REnv) , "::" , stringify ! (gcnext))) ; assert_eq ! (unsafe { :: std :: ptr :: addr_of ! ((* ptr) . stack) as usize - ptr as usize } , 24usize , concat ! ("Offset of field: " , stringify ! (REnv) , "::" , stringify ! (stack))) ; assert_eq ! (unsafe { :: std :: ptr :: addr_of ! ((* ptr) . cxt) as usize - ptr as usize } , 32usize , concat ! ("Offset of field: " , stringify ! (REnv) , "::" , stringify ! (cxt))) ; assert_eq ! (unsafe { :: std :: ptr :: addr_of ! ((* ptr) . mid) as usize - ptr as usize } , 40usize , concat ! ("Offset of field: " , stringify ! (REnv) , "::" , stringify ! (mid))) ; } impl REnv { # [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 } } extern "C" { pub fn mrb_env_unshare (arg1 : * mut mrb_state , arg2 : * mut REnv , noraise : mrb_bool) -> mrb_bool ; } # [repr (C)] # [derive (Copy , Clone)] pub struct RProc { pub c : * mut RClass , pub gcnext : * mut RBasic , pub _bitfield_align_1 : [u32 ; 0] , pub _bitfield_1 : __BindgenBitfieldUnit < [u8 ; 4usize] > , pub body : RProc__bindgen_ty_1 , pub upper : * const RProc , pub e : RProc__bindgen_ty_2 , } # [repr (C)] # [derive (Copy , Clone)] pub union RProc__bindgen_ty_1 { pub irep : * const mrb_irep , pub func : mrb_func_t , } # [test] fn bindgen_test_layout_RProc__bindgen_ty_1 () { const UNINIT : :: std :: mem :: MaybeUninit < RProc__bindgen_ty_1 > = :: std :: mem :: MaybeUninit :: uninit () ; let ptr = UNINIT . as_ptr () ; assert_eq ! (:: std :: mem :: size_of :: < RProc__bindgen_ty_1 > () , 8usize , concat ! ("Size of: " , stringify ! (RProc__bindgen_ty_1))) ; assert_eq ! (:: std :: mem :: align_of :: < RProc__bindgen_ty_1 > () , 8usize , concat ! ("Alignment of " , stringify ! (RProc__bindgen_ty_1))) ; assert_eq ! (unsafe { :: std :: ptr :: addr_of ! ((* ptr) . irep) as usize - ptr as usize } , 0usize , concat ! ("Offset of field: " , stringify ! (RProc__bindgen_ty_1) , "::" , stringify ! (irep))) ; assert_eq ! (unsafe { :: std :: ptr :: addr_of ! ((* ptr) . func) as usize - ptr as usize } , 0usize , concat ! ("Offset of field: " , stringify ! (RProc__bindgen_ty_1) , "::" , stringify ! (func))) ; } # [repr (C)] # [derive (Copy , Clone)] pub union RProc__bindgen_ty_2 { pub target_class : * mut RClass , pub env : * mut REnv , } # [test] fn bindgen_test_layout_RProc__bindgen_ty_2 () { const UNINIT : :: std :: mem :: MaybeUninit < RProc__bindgen_ty_2 > = :: std :: mem :: MaybeUninit :: uninit () ; let ptr = UNINIT . as_ptr () ; assert_eq ! (:: std :: mem :: size_of :: < RProc__bindgen_ty_2 > () , 8usize , concat ! ("Size of: " , stringify ! (RProc__bindgen_ty_2))) ; assert_eq ! (:: std :: mem :: align_of :: < RProc__bindgen_ty_2 > () , 8usize , concat ! ("Alignment of " , stringify ! (RProc__bindgen_ty_2))) ; assert_eq ! (unsafe { :: std :: ptr :: addr_of ! ((* ptr) . target_class) as usize - ptr as usize } , 0usize , concat ! ("Offset of field: " , stringify ! (RProc__bindgen_ty_2) , "::" , stringify ! (target_class))) ; assert_eq ! (unsafe { :: std :: ptr :: addr_of ! ((* ptr) . env) as usize - ptr as usize } , 0usize , concat ! ("Offset of field: " , stringify ! (RProc__bindgen_ty_2) , "::" , stringify ! (env))) ; } # [test] fn bindgen_test_layout_RProc () { const UNINIT : :: std :: mem :: MaybeUninit < RProc > = :: std :: mem :: MaybeUninit :: uninit () ; let ptr = UNINIT . as_ptr () ; assert_eq ! (:: std :: mem :: size_of :: < RProc > () , 48usize , concat ! ("Size of: " , stringify ! (RProc))) ; assert_eq ! (:: std :: mem :: align_of :: < RProc > () , 8usize , concat ! ("Alignment of " , stringify ! (RProc))) ; assert_eq ! (unsafe { :: std :: ptr :: addr_of ! ((* ptr) . c) as usize - ptr as usize } , 0usize , concat ! ("Offset of field: " , stringify ! (RProc) , "::" , stringify ! (c))) ; assert_eq ! (unsafe { :: std :: ptr :: addr_of ! ((* ptr) . gcnext) as usize - ptr as usize } , 8usize , concat ! ("Offset of field: " , stringify ! (RProc) , "::" , stringify ! (gcnext))) ; assert_eq ! (unsafe { :: std :: ptr :: addr_of ! ((* ptr) . body) as usize - ptr as usize } , 24usize , concat ! ("Offset of field: " , stringify ! (RProc) , "::" , stringify ! (body))) ; assert_eq ! (unsafe { :: std :: ptr :: addr_of ! ((* ptr) . upper) as usize - ptr as usize } , 32usize , concat ! ("Offset of field: " , stringify ! (RProc) , "::" , stringify ! (upper))) ; assert_eq ! (unsafe { :: std :: ptr :: addr_of ! ((* ptr) . e) as usize - ptr as usize } , 40usize , concat ! ("Offset of field: " , stringify ! (RProc) , "::" , stringify ! (e))) ; } impl RProc { # [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 } } extern "C" { pub fn mrb_proc_new (arg1 : * mut mrb_state , arg2 : * const mrb_irep) -> * mut RProc ; } extern "C" { pub fn mrb_proc_new_cfunc (arg1 : * mut mrb_state , arg2 : mrb_func_t) -> * mut RProc ; } extern "C" { pub fn mrb_closure_new_cfunc (mrb : * mut mrb_state , func : mrb_func_t , nlocals : :: std :: os :: raw :: c_int) -> * mut RProc ; } extern "C" { pub fn mrb_proc_new_cfunc_with_env (mrb : * mut mrb_state , func : mrb_func_t , argc : mrb_int , argv : * const mrb_value) -> * mut RProc ; } extern "C" { pub fn mrb_proc_cfunc_env_get (mrb : * mut mrb_state , idx : mrb_int) -> mrb_value ; } extern "C" { pub fn mrb_load_proc (mrb : * mut mrb_state , proc_ : * const RProc) -> mrb_value ; } extern "C" { pub fn mrb_vm_ci_proc_set (ci : * mut mrb_callinfo , p : * const RProc) ; } extern "C" { pub fn mrb_vm_ci_target_class (ci : * const mrb_callinfo) -> * mut RClass ; } extern "C" { pub fn mrb_vm_ci_target_class_set (ci : * mut mrb_callinfo , tc : * mut RClass) ; } extern "C" { pub fn mrb_vm_ci_env (ci : * const mrb_callinfo) -> * mut REnv ; } extern "C" { pub fn mrb_vm_ci_env_set (ci : * mut mrb_callinfo , e : * mut REnv) ; } # [repr (C)] # [derive (Copy , Clone)] pub struct mrb_range_edges { pub beg : mrb_value , pub end : mrb_value , } # [test] fn bindgen_test_layout_mrb_range_edges () { const UNINIT : :: std :: mem :: MaybeUninit < mrb_range_edges > = :: std :: mem :: MaybeUninit :: uninit () ; let ptr = UNINIT . as_ptr () ; assert_eq ! (:: std :: mem :: size_of :: < mrb_range_edges > () , 32usize , concat ! ("Size of: " , stringify ! (mrb_range_edges))) ; assert_eq ! (:: std :: mem :: align_of :: < mrb_range_edges > () , 8usize , concat ! ("Alignment of " , stringify ! (mrb_range_edges))) ; assert_eq ! (unsafe { :: std :: ptr :: addr_of ! ((* ptr) . beg) as usize - ptr as usize } , 0usize , concat ! ("Offset of field: " , stringify ! (mrb_range_edges) , "::" , stringify ! (beg))) ; assert_eq ! (unsafe { :: std :: ptr :: addr_of ! ((* ptr) . end) as usize - ptr as usize } , 16usize , concat ! ("Offset of field: " , stringify ! (mrb_range_edges) , "::" , stringify ! (end))) ; } # [repr (C)] # [derive (Debug , Copy , Clone)] pub struct RRange { pub c : * mut RClass , pub gcnext : * mut RBasic , pub _bitfield_align_1 : [u32 ; 0] , pub _bitfield_1 : __BindgenBitfieldUnit < [u8 ; 4usize] > , pub edges : * mut mrb_range_edges , pub excl : mrb_bool , } # [test] fn bindgen_test_layout_RRange () { const UNINIT : :: std :: mem :: MaybeUninit < RRange > = :: std :: mem :: MaybeUninit :: uninit () ; let ptr = UNINIT . as_ptr () ; assert_eq ! (:: std :: mem :: size_of :: < RRange > () , 40usize , concat ! ("Size of: " , stringify ! (RRange))) ; assert_eq ! (:: std :: mem :: align_of :: < RRange > () , 8usize , concat ! ("Alignment of " , stringify ! (RRange))) ; assert_eq ! (unsafe { :: std :: ptr :: addr_of ! ((* ptr) . c) as usize - ptr as usize } , 0usize , concat ! ("Offset of field: " , stringify ! (RRange) , "::" , stringify ! (c))) ; assert_eq ! (unsafe { :: std :: ptr :: addr_of ! ((* ptr) . gcnext) as usize - ptr as usize } , 8usize , concat ! ("Offset of field: " , stringify ! (RRange) , "::" , stringify ! (gcnext))) ; assert_eq ! (unsafe { :: std :: ptr :: addr_of ! ((* ptr) . edges) as usize - ptr as usize } , 24usize , concat ! ("Offset of field: " , stringify ! (RRange) , "::" , stringify ! (edges))) ; assert_eq ! (unsafe { :: std :: ptr :: addr_of ! ((* ptr) . excl) as usize - ptr as usize } , 32usize , concat ! ("Offset of field: " , stringify ! (RRange) , "::" , stringify ! (excl))) ; } impl RRange { # [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 } } extern "C" { pub fn mrb_range_ptr (mrb : * mut mrb_state , range : mrb_value) -> * mut RRange ; } extern "C" { pub fn mrb_range_new (mrb : * mut mrb_state , start : mrb_value , end : mrb_value , exclude : mrb_bool) -> mrb_value ; } # [repr (u32)] # [derive (Debug , Copy , Clone , Hash , PartialEq , Eq)] pub enum mrb_range_beg_len { MRB_RANGE_TYPE_MISMATCH = 0 , MRB_RANGE_OK = 1 , MRB_RANGE_OUT = 2 , } extern "C" { pub fn mrb_range_beg_len (mrb : * mut mrb_state , range : mrb_value , begp : * mut mrb_int , lenp : * mut mrb_int , len : mrb_int , trunc : mrb_bool) -> mrb_range_beg_len ; } extern "C" { pub static mrb_digitmap : [:: std :: os :: raw :: c_char ; 0usize] ; } # [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 , } # [test] fn bindgen_test_layout_RString__bindgen_ty_1__bindgen_ty_1__bindgen_ty_1 () { const UNINIT : :: std :: mem :: MaybeUninit < RString__bindgen_ty_1__bindgen_ty_1__bindgen_ty_1 > = :: std :: mem :: MaybeUninit :: uninit () ; let ptr = UNINIT . as_ptr () ; assert_eq ! (:: std :: mem :: size_of :: < RString__bindgen_ty_1__bindgen_ty_1__bindgen_ty_1 > () , 8usize , concat ! ("Size of: " , stringify ! (RString__bindgen_ty_1__bindgen_ty_1__bindgen_ty_1))) ; assert_eq ! (:: std :: mem :: align_of :: < RString__bindgen_ty_1__bindgen_ty_1__bindgen_ty_1 > () , 8usize , concat ! ("Alignment of " , stringify ! (RString__bindgen_ty_1__bindgen_ty_1__bindgen_ty_1))) ; assert_eq ! (unsafe { :: std :: ptr :: addr_of ! ((* ptr) . capa) as usize - ptr as usize } , 0usize , concat ! ("Offset of field: " , stringify ! (RString__bindgen_ty_1__bindgen_ty_1__bindgen_ty_1) , "::" , stringify ! (capa))) ; assert_eq ! (unsafe { :: std :: ptr :: addr_of ! ((* ptr) . shared) as usize - ptr as usize } , 0usize , concat ! ("Offset of field: " , stringify ! (RString__bindgen_ty_1__bindgen_ty_1__bindgen_ty_1) , "::" , stringify ! (shared))) ; assert_eq ! (unsafe { :: std :: ptr :: addr_of ! ((* ptr) . fshared) as usize - ptr as usize } , 0usize , concat ! ("Offset of field: " , stringify ! (RString__bindgen_ty_1__bindgen_ty_1__bindgen_ty_1) , "::" , stringify ! (fshared))) ; } # [test] fn bindgen_test_layout_RString__bindgen_ty_1__bindgen_ty_1 () { const UNINIT : :: std :: mem :: MaybeUninit < RString__bindgen_ty_1__bindgen_ty_1 > = :: std :: mem :: MaybeUninit :: uninit () ; let ptr = UNINIT . as_ptr () ; assert_eq ! (:: std :: mem :: size_of :: < RString__bindgen_ty_1__bindgen_ty_1 > () , 24usize , concat ! ("Size of: " , stringify ! (RString__bindgen_ty_1__bindgen_ty_1))) ; assert_eq ! (:: std :: mem :: align_of :: < RString__bindgen_ty_1__bindgen_ty_1 > () , 8usize , concat ! ("Alignment of " , stringify ! (RString__bindgen_ty_1__bindgen_ty_1))) ; assert_eq ! (unsafe { :: std :: ptr :: addr_of ! ((* ptr) . len) as usize - ptr as usize } , 0usize , concat ! ("Offset of field: " , stringify ! (RString__bindgen_ty_1__bindgen_ty_1) , "::" , stringify ! (len))) ; assert_eq ! (unsafe { :: std :: ptr :: addr_of ! ((* ptr) . aux) as usize - ptr as usize } , 8usize , concat ! ("Offset of field: " , stringify ! (RString__bindgen_ty_1__bindgen_ty_1) , "::" , stringify ! (aux))) ; assert_eq ! (unsafe { :: std :: ptr :: addr_of ! ((* ptr) . ptr) as usize - ptr as usize } , 16usize , concat ! ("Offset of field: " , stringify ! (RString__bindgen_ty_1__bindgen_ty_1) , "::" , stringify ! (ptr))) ; } # [test] fn bindgen_test_layout_RString__bindgen_ty_1 () { const UNINIT : :: std :: mem :: MaybeUninit < RString__bindgen_ty_1 > = :: std :: mem :: MaybeUninit :: uninit () ; let ptr = UNINIT . as_ptr () ; assert_eq ! (:: std :: mem :: size_of :: < RString__bindgen_ty_1 > () , 24usize , concat ! ("Size of: " , stringify ! (RString__bindgen_ty_1))) ; assert_eq ! (:: std :: mem :: align_of :: < RString__bindgen_ty_1 > () , 8usize , concat ! ("Alignment of " , stringify ! (RString__bindgen_ty_1))) ; assert_eq ! (unsafe { :: std :: ptr :: addr_of ! ((* ptr) . heap) as usize - ptr as usize } , 0usize , concat ! ("Offset of field: " , stringify ! (RString__bindgen_ty_1) , "::" , stringify ! (heap))) ; } # [test] fn bindgen_test_layout_RString () { const UNINIT : :: std :: mem :: MaybeUninit < RString > = :: std :: mem :: MaybeUninit :: uninit () ; let ptr = UNINIT . as_ptr () ; assert_eq ! (:: std :: mem :: size_of :: < RString > () , 48usize , concat ! ("Size of: " , stringify ! (RString))) ; assert_eq ! (:: std :: mem :: align_of :: < RString > () , 8usize , concat ! ("Alignment of " , stringify ! (RString))) ; assert_eq ! (unsafe { :: std :: ptr :: addr_of ! ((* ptr) . c) as usize - ptr as usize } , 0usize , concat ! ("Offset of field: " , stringify ! (RString) , "::" , stringify ! (c))) ; assert_eq ! (unsafe { :: std :: ptr :: addr_of ! ((* ptr) . gcnext) as usize - ptr as usize } , 8usize , concat ! ("Offset of field: " , stringify ! (RString) , "::" , stringify ! (gcnext))) ; assert_eq ! (unsafe { :: std :: ptr :: addr_of ! ((* ptr) . as_) as usize - ptr as usize } , 24usize , concat ! ("Offset of field: " , stringify ! (RString) , "::" , stringify ! (as_))) ; } 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 } } extern "C" { pub fn mrb_str_modify (mrb : * mut mrb_state , s : * mut RString) ; } extern "C" { pub fn mrb_str_modify_keep_ascii (mrb : * mut mrb_state , s : * mut RString) ; } extern "C" { pub fn mrb_str_index (mrb : * mut mrb_state , str_ : mrb_value , p : * const :: std :: os :: raw :: c_char , len : mrb_int , offset : mrb_int) -> mrb_int ; } extern "C" { pub fn mrb_str_concat (mrb : * mut mrb_state , self_ : mrb_value , other : mrb_value) ; } extern "C" { pub fn mrb_str_plus (mrb : * mut mrb_state , a : mrb_value , b : mrb_value) -> mrb_value ; } extern "C" { pub fn mrb_ptr_to_str (mrb : * mut mrb_state , p : * mut :: std :: os :: raw :: c_void) -> mrb_value ; } extern "C" { pub fn mrb_obj_as_string (mrb : * mut mrb_state , obj : mrb_value) -> mrb_value ; } extern "C" { pub fn mrb_str_resize (mrb : * mut mrb_state , str_ : mrb_value , len : mrb_int) -> mrb_value ; } extern "C" { pub fn mrb_str_substr (mrb : * mut mrb_state , str_ : mrb_value , beg : mrb_int , len : mrb_int) -> mrb_value ; } extern "C" { pub fn mrb_str_new_capa (mrb : * mut mrb_state , capa : mrb_int) -> mrb_value ; } extern "C" { pub fn mrb_string_cstr (mrb : * mut mrb_state , str_ : mrb_value) -> * const :: std :: os :: raw :: c_char ; } extern "C" { pub fn mrb_string_value_cstr (mrb : * mut mrb_state , str_ : * mut mrb_value) -> * const :: std :: os :: raw :: c_char ; } extern "C" { pub fn mrb_str_dup (mrb : * mut mrb_state , str_ : mrb_value) -> mrb_value ; } extern "C" { pub fn mrb_str_intern (mrb : * mut mrb_state , self_ : mrb_value) -> mrb_value ; } extern "C" { pub fn mrb_str_to_integer (mrb : * mut mrb_state , str_ : mrb_value , base : mrb_int , badcheck : mrb_bool) -> mrb_value ; } extern "C" { pub fn mrb_str_to_dbl (mrb : * mut mrb_state , str_ : mrb_value , badcheck : mrb_bool) -> f64 ; } extern "C" { pub fn mrb_str_equal (mrb : * mut mrb_state , str1 : mrb_value , str2 : mrb_value) -> mrb_bool ; } extern "C" { pub fn mrb_str_cat (mrb : * mut mrb_state , str_ : mrb_value , ptr : * const :: std :: os :: raw :: c_char , len : usize) -> mrb_value ; } extern "C" { pub fn mrb_str_cat_cstr (mrb : * mut mrb_state , str_ : mrb_value , ptr : * const :: std :: os :: raw :: c_char) -> mrb_value ; } extern "C" { pub fn mrb_str_cat_str (mrb : * mut mrb_state , str_ : mrb_value , str2 : mrb_value) -> mrb_value ; } extern "C" { pub fn mrb_str_append (mrb : * mut mrb_state , str_ : mrb_value , str2 : mrb_value) -> mrb_value ; } extern "C" { pub fn mrb_str_cmp (mrb : * mut mrb_state , str1 : mrb_value , str2 : mrb_value) -> :: std :: os :: raw :: c_int ; } extern "C" { pub fn mrb_str_to_cstr (mrb : * mut mrb_state , str_ : mrb_value) -> * mut :: std :: os :: raw :: c_char ; } pub type __jmp_buf = [:: std :: os :: raw :: c_long ; 8usize] ; # [repr (C)] # [derive (Debug , Copy , Clone)] pub struct __jmp_buf_tag { pub __jmpbuf : __jmp_buf , pub __mask_was_saved : :: std :: os :: raw :: c_int , pub __saved_mask : __sigset_t , } # [test] fn bindgen_test_layout___jmp_buf_tag () { const UNINIT : :: std :: mem :: MaybeUninit < __jmp_buf_tag > = :: std :: mem :: MaybeUninit :: uninit () ; let ptr = UNINIT . as_ptr () ; assert_eq ! (:: std :: mem :: size_of :: < __jmp_buf_tag > () , 200usize , concat ! ("Size of: " , stringify ! (__jmp_buf_tag))) ; assert_eq ! (:: std :: mem :: align_of :: < __jmp_buf_tag > () , 8usize , concat ! ("Alignment of " , stringify ! (__jmp_buf_tag))) ; assert_eq ! (unsafe { :: std :: ptr :: addr_of ! ((* ptr) . __jmpbuf) as usize - ptr as usize } , 0usize , concat ! ("Offset of field: " , stringify ! (__jmp_buf_tag) , "::" , stringify ! (__jmpbuf))) ; assert_eq ! (unsafe { :: std :: ptr :: addr_of ! ((* ptr) . __mask_was_saved) as usize - ptr as usize } , 64usize , concat ! ("Offset of field: " , stringify ! (__jmp_buf_tag) , "::" , stringify ! (__mask_was_saved))) ; assert_eq ! (unsafe { :: std :: ptr :: addr_of ! ((* ptr) . __saved_mask) as usize - ptr as usize } , 72usize , concat ! ("Offset of field: " , stringify ! (__jmp_buf_tag) , "::" , stringify ! (__saved_mask))) ; } pub type jmp_buf = [__jmp_buf_tag ; 1usize] ; # [repr (C)] # [derive (Debug , Copy , Clone)] pub struct mrb_jmpbuf { pub impl_ : jmp_buf , } # [test] fn bindgen_test_layout_mrb_jmpbuf () { const UNINIT : :: std :: mem :: MaybeUninit < mrb_jmpbuf > = :: std :: mem :: MaybeUninit :: uninit () ; let ptr = UNINIT . as_ptr () ; assert_eq ! (:: std :: mem :: size_of :: < mrb_jmpbuf > () , 200usize , concat ! ("Size of: " , stringify ! (mrb_jmpbuf))) ; assert_eq ! (:: std :: mem :: align_of :: < mrb_jmpbuf > () , 8usize , concat ! ("Alignment of " , stringify ! (mrb_jmpbuf))) ; assert_eq ! (unsafe { :: std :: ptr :: addr_of ! ((* ptr) . impl_) as usize - ptr as usize } , 0usize , concat ! ("Offset of field: " , stringify ! (mrb_jmpbuf) , "::" , stringify ! (impl_))) ; } extern "C" { pub fn mrb_const_get (arg1 : * mut mrb_state , arg2 : mrb_value , arg3 : mrb_sym) -> mrb_value ; } extern "C" { pub fn mrb_const_set (arg1 : * mut mrb_state , arg2 : mrb_value , arg3 : mrb_sym , arg4 : mrb_value) ; } extern "C" { pub fn mrb_const_defined (arg1 : * mut mrb_state , arg2 : mrb_value , arg3 : mrb_sym) -> mrb_bool ; } extern "C" { pub fn mrb_const_remove (arg1 : * mut mrb_state , arg2 : mrb_value , arg3 : mrb_sym) ; } extern "C" { pub fn mrb_iv_name_sym_p (mrb : * mut mrb_state , sym : mrb_sym) -> mrb_bool ; } extern "C" { pub fn mrb_iv_name_sym_check (mrb : * mut mrb_state , sym : mrb_sym) ; } extern "C" { pub fn mrb_obj_iv_get (mrb : * mut mrb_state , obj : * mut RObject , sym : mrb_sym) -> mrb_value ; } extern "C" { pub fn mrb_obj_iv_set (mrb : * mut mrb_state , obj : * mut RObject , sym : mrb_sym , v : mrb_value) ; } extern "C" { pub fn mrb_obj_iv_defined (mrb : * mut mrb_state , obj : * mut RObject , sym : mrb_sym) -> mrb_bool ; } extern "C" { pub fn mrb_iv_get (mrb : * mut mrb_state , obj : mrb_value , sym : mrb_sym) -> mrb_value ; } extern "C" { pub fn mrb_iv_set (mrb : * mut mrb_state , obj : mrb_value , sym : mrb_sym , v : mrb_value) ; } extern "C" { pub fn mrb_iv_defined (arg1 : * mut mrb_state , arg2 : mrb_value , arg3 : mrb_sym) -> mrb_bool ; } extern "C" { pub fn mrb_iv_remove (mrb : * mut mrb_state , obj : mrb_value , sym : mrb_sym) -> mrb_value ; } extern "C" { pub fn mrb_iv_copy (mrb : * mut mrb_state , dst : mrb_value , src : mrb_value) ; } extern "C" { pub fn mrb_const_defined_at (mrb : * mut mrb_state , mod_ : mrb_value , id : mrb_sym) -> mrb_bool ; } extern "C" { pub fn mrb_gv_get (mrb : * mut mrb_state , sym : mrb_sym) -> mrb_value ; } extern "C" { pub fn mrb_gv_set (mrb : * mut mrb_state , sym : mrb_sym , val : mrb_value) ; } extern "C" { pub fn mrb_gv_remove (mrb : * mut mrb_state , sym : mrb_sym) ; } extern "C" { pub fn mrb_cv_get (mrb : * mut mrb_state , mod_ : mrb_value , sym : mrb_sym) -> mrb_value ; } extern "C" { pub fn mrb_mod_cv_set (mrb : * mut mrb_state , c : * mut RClass , sym : mrb_sym , v : mrb_value) ; } extern "C" { pub fn mrb_cv_set (mrb : * mut mrb_state , mod_ : mrb_value , sym : mrb_sym , v : mrb_value) ; } extern "C" { pub fn mrb_cv_defined (mrb : * mut mrb_state , mod_ : mrb_value , sym : mrb_sym) -> mrb_bool ; } pub type mrb_iv_foreach_func = :: std :: option :: Option < unsafe extern "C" fn (arg1 : * mut mrb_state , arg2 : mrb_sym , arg3 : mrb_value , arg4 : * mut :: std :: os :: raw :: c_void) -> :: std :: os :: raw :: c_int > ; extern "C" { pub fn mrb_iv_foreach (mrb : * mut mrb_state , obj : mrb_value , func : mrb_iv_foreach_func , p : * mut :: std :: os :: raw :: c_void) ; } extern "C" { pub fn mrb_sys_value_has_method (mrb : * mut mrb_state , value : mrb_value , method : mrb_sym) -> bool ; } extern "C" { pub fn mrb_sys_value_is_nil (value : mrb_value) -> bool ; } extern "C" { pub fn mrb_sys_value_is_false (value : mrb_value) -> bool ; } extern "C" { pub fn mrb_sys_value_is_true (value : mrb_value) -> bool ; } extern "C" { pub fn mrb_sys_range_excl (mrb : * mut mrb_state , value : mrb_value) -> bool ; } extern "C" { pub fn mrb_sys_obj_frozen (mrb : * mut mrb_state , value : mrb_value) -> bool ; } extern "C" { pub fn mrb_sys_fixnum_to_cint (value : mrb_value) -> mrb_int ; } extern "C" { pub fn mrb_sys_float_to_cdouble (value : mrb_value) -> mrb_float ; } extern "C" { pub fn mrb_sys_cptr_ptr (value : mrb_value) -> * mut :: std :: os :: raw :: c_void ; } extern "C" { pub fn mrb_sys_basic_ptr (value : mrb_value) -> * mut RBasic ; } extern "C" { pub fn mrb_sys_obj_ptr (value : mrb_value) -> * mut RObject ; } extern "C" { pub fn mrb_sys_proc_ptr (value : mrb_value) -> * mut RProc ; } extern "C" { pub fn mrb_sys_class_ptr (value : mrb_value) -> * mut RClass ; } extern "C" { pub fn mrb_sys_class_to_rclass (value : mrb_value) -> * mut RClass ; } extern "C" { pub fn mrb_sys_class_of_value (mrb : * mut mrb_state , value : mrb_value) -> * mut RClass ; } extern "C" { pub fn mrb_sys_nil_value () -> mrb_value ; } extern "C" { pub fn mrb_sys_false_value () -> mrb_value ; } extern "C" { pub fn mrb_sys_true_value () -> mrb_value ; } extern "C" { pub fn mrb_sys_fixnum_value (value : mrb_int) -> mrb_value ; } extern "C" { pub fn mrb_sys_float_value (mrb : * mut mrb_state , value : mrb_float) -> mrb_value ; } extern "C" { pub fn mrb_sys_cptr_value (mrb : * mut mrb_state , ptr : * mut :: std :: os :: raw :: c_void) -> mrb_value ; } extern "C" { pub fn mrb_sys_obj_value (p : * mut :: std :: os :: raw :: c_void) -> mrb_value ; } extern "C" { pub fn mrb_sys_class_value (klass : * mut RClass) -> mrb_value ; } extern "C" { pub fn mrb_sys_module_value (module : * mut RClass) -> mrb_value ; } extern "C" { pub fn mrb_sys_data_value (data : * mut RData) -> mrb_value ; } extern "C" { pub fn mrb_sys_proc_value (mrb : * mut mrb_state , proc_ : * mut RProc) -> mrb_value ; } extern "C" { pub fn mrb_sys_new_symbol (id : mrb_sym) -> mrb_value ; } extern "C" { pub fn mrb_sys_set_instance_tt (klass : * mut RClass , type_ : mrb_vtype) ; } extern "C" { pub fn mrb_sys_data_init (value : * mut mrb_value , ptr : * mut :: std :: os :: raw :: c_void , type_ : * const mrb_data_type) ; } extern "C" { pub fn mrb_sys_raise (mrb : * mut mrb_state , eklass : * const :: std :: os :: raw :: c_char , msg : * const :: std :: os :: raw :: c_char) ; } extern "C" { pub fn mrb_sys_raise_current_exception (mrb : * mut mrb_state) ; } extern "C" { pub fn mrb_sys_alloc_rarray (mrb : * mut mrb_state , ptr : * mut mrb_value , len : mrb_int , capa : mrb_int) -> mrb_value ; } extern "C" { pub fn mrb_sys_repack_into_rarray (ptr : * mut mrb_value , len : mrb_int , capa : mrb_int , into : mrb_value) ; } extern "C" { pub fn mrb_sys_alloc_rstring (mrb : * mut mrb_state , ptr : * mut :: std :: os :: raw :: c_char , len : mrb_int , capa : mrb_int) -> mrb_value ; } extern "C" { pub fn mrb_sys_repack_into_rstring (ptr : * mut :: std :: os :: raw :: c_char , len : mrb_int , capa : mrb_int , into : mrb_value) -> * mut RString ; } extern "C" { pub fn mrb_sys_gc_arena_save (mrb : * mut mrb_state) -> :: std :: os :: raw :: c_int ; } extern "C" { pub fn mrb_sys_gc_arena_restore (mrb : * mut mrb_state , arena_index : :: std :: os :: raw :: c_int) ; } extern "C" { pub fn mrb_sys_gc_disable (mrb : * mut mrb_state) -> bool ; } extern "C" { pub fn mrb_sys_gc_enable (mrb : * mut mrb_state) -> bool ; } extern "C" { pub fn mrb_sys_value_is_dead (_mrb : * mut mrb_state , value : mrb_value) -> bool ; } extern "C" { pub fn mrb_sys_gc_live_objects (mrb : * mut mrb_state) -> usize ; } extern "C" { pub fn mrb_sys_safe_gc_mark (mrb : * mut mrb_state , value : mrb_value) ; } extern "C" { pub fn mrb_init_mrbgems (mrb : * mut mrb_state) ; } pub type __builtin_va_list = [__va_list_tag ; 1usize] ; # [repr (C)] # [derive (Debug , Copy , Clone)] pub struct __va_list_tag { pub gp_offset : :: std :: os :: raw :: c_uint , pub fp_offset : :: std :: os :: raw :: c_uint , pub overflow_arg_area : * mut :: std :: os :: raw :: c_void , pub reg_save_area : * mut :: std :: os :: raw :: c_void , } # [test] fn bindgen_test_layout___va_list_tag () { const UNINIT : :: std :: mem :: MaybeUninit < __va_list_tag > = :: std :: mem :: MaybeUninit :: uninit () ; let ptr = UNINIT . as_ptr () ; assert_eq ! (:: std :: mem :: size_of :: < __va_list_tag > () , 24usize , concat ! ("Size of: " , stringify ! (__va_list_tag))) ; assert_eq ! (:: std :: mem :: align_of :: < __va_list_tag > () , 8usize , concat ! ("Alignment of " , stringify ! (__va_list_tag))) ; assert_eq ! (unsafe { :: std :: ptr :: addr_of ! ((* ptr) . gp_offset) as usize - ptr as usize } , 0usize , concat ! ("Offset of field: " , stringify ! (__va_list_tag) , "::" , stringify ! (gp_offset))) ; assert_eq ! (unsafe { :: std :: ptr :: addr_of ! ((* ptr) . fp_offset) as usize - ptr as usize } , 4usize , concat ! ("Offset of field: " , stringify ! (__va_list_tag) , "::" , stringify ! (fp_offset))) ; assert_eq ! (unsafe { :: std :: ptr :: addr_of ! ((* ptr) . overflow_arg_area) as usize - ptr as usize } , 8usize , concat ! ("Offset of field: " , stringify ! (__va_list_tag) , "::" , stringify ! (overflow_arg_area))) ; assert_eq ! (unsafe { :: std :: ptr :: addr_of ! ((* ptr) . reg_save_area) as usize - ptr as usize } , 16usize , concat ! ("Offset of field: " , stringify ! (__va_list_tag) , "::" , stringify ! (reg_save_area))) ; } # [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 parser_lex_strterm { pub _address : u8 , } # [repr (C)] # [derive (Debug , Copy , Clone)] pub struct mrb_irep_debug_info { 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 , } # [repr (C)] # [derive (Debug , Copy , Clone)] pub struct mrb_shared_string { pub _address : u8 , }