1# [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] fn extract_bit (byte : u8 , index : usize) -> bool { 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 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] ; Self :: extract_bit (byte , index) } # [inline] pub unsafe fn raw_get_bit (this : * const Self , index : usize) -> bool { debug_assert ! (index / 8 < core :: mem :: size_of ::< Storage > ()) ; let byte_index = index / 8 ; let byte = * (core :: ptr :: addr_of ! ((* this) . storage) as * const u8) . offset (byte_index as isize) ; Self :: extract_bit (byte , index) } # [inline] fn change_bit (byte : u8 , index : usize , val : bool) -> u8 { 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 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] ; * byte = Self :: change_bit (* byte , index , val) ; } # [inline] pub unsafe fn raw_set_bit (this : * mut Self , index : usize , val : bool) { debug_assert ! (index / 8 < core :: mem :: size_of ::< Storage > ()) ; let byte_index = index / 8 ; let byte = (core :: ptr :: addr_of_mut ! ((* this) . storage) as * mut u8) . offset (byte_index as isize) ; * byte = Self :: change_bit (* byte , index , val) ; } # [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 unsafe fn raw_get (this : * const Self , bit_offset : usize , bit_width : u8 ,) -> u64 { debug_assert ! (bit_width <= 64) ; debug_assert ! (bit_offset / 8 < core :: mem :: size_of ::< Storage > ()) ; debug_assert ! ((bit_offset + (bit_width as usize)) / 8 <= core :: mem :: size_of ::< Storage > ()) ; let mut val = 0 ; for i in 0 .. (bit_width as usize) { if Self :: raw_get_bit (this , 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) ; } } # [inline] pub unsafe fn raw_set (this : * mut Self , bit_offset : usize , bit_width : u8 , val : u64 ,) { debug_assert ! (bit_width <= 64) ; debug_assert ! (bit_offset / 8 < core :: mem :: size_of ::< Storage > ()) ; debug_assert ! ((bit_offset + (bit_width as usize)) / 8 <= core :: mem :: size_of ::< Storage > ()) ; 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 :: raw_set_bit (this , 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] , } # [allow (clippy :: unnecessary_operation , clippy :: identity_op)] const _ : () = { ["Size of __sigset_t"] [:: std :: mem :: size_of :: < __sigset_t > () - 128usize] ; ["Alignment of __sigset_t"] [:: std :: mem :: align_of :: < __sigset_t > () - 8usize] ; ["Offset of field: __sigset_t::__val"] [:: std :: mem :: offset_of ! (__sigset_t , __val) - 0usize] ; } ; pub type mrb_sym = u32 ; pub type mrb_bool = bool ; pub type mrb_int = i64 ; pub type mrb_uint = u64 ; unsafe extern "C-unwind" { 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 ; } unsafe extern "C-unwind" { 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 ; } unsafe extern "C-unwind" { 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 ; } unsafe extern "C-unwind" { 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 , } # [allow (clippy :: unnecessary_operation , clippy :: identity_op)] const _ : () = { ["Size of RBasic"] [:: std :: mem :: size_of :: < RBasic > () - 24usize] ; ["Alignment of RBasic"] [:: std :: mem :: align_of :: < RBasic > () - 8usize] ; ["Offset of field: RBasic::c"] [:: std :: mem :: offset_of ! (RBasic , c) - 0usize] ; ["Offset of field: RBasic::gcnext"] [:: std :: mem :: offset_of ! (RBasic , gcnext) - 8usize] ; } ; 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 unsafe fn tt_raw (this : * const Self) -> mrb_vtype { unsafe { :: std :: mem :: transmute (< __BindgenBitfieldUnit < [u8 ; 4usize] > > :: raw_get (:: std :: ptr :: addr_of ! ((* this) . _bitfield_1) , 0usize , 8u8 ,) as u32) } } # [inline] pub unsafe fn set_tt_raw (this : * mut Self , val : mrb_vtype) { unsafe { let val : u32 = :: std :: mem :: transmute (val) ; < __BindgenBitfieldUnit < [u8 ; 4usize] > > :: raw_set (:: std :: ptr :: addr_of_mut ! ((* this) . _bitfield_1) , 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 unsafe fn color_raw (this : * const Self) -> u32 { unsafe { :: std :: mem :: transmute (< __BindgenBitfieldUnit < [u8 ; 4usize] > > :: raw_get (:: std :: ptr :: addr_of ! ((* this) . _bitfield_1) , 8usize , 3u8 ,) as u32) } } # [inline] pub unsafe fn set_color_raw (this : * mut Self , val : u32) { unsafe { let val : u32 = :: std :: mem :: transmute (val) ; < __BindgenBitfieldUnit < [u8 ; 4usize] > > :: raw_set (:: std :: ptr :: addr_of_mut ! ((* this) . _bitfield_1) , 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 unsafe fn flags_raw (this : * const Self) -> u32 { unsafe { :: std :: mem :: transmute (< __BindgenBitfieldUnit < [u8 ; 4usize] > > :: raw_get (:: std :: ptr :: addr_of ! ((* this) . _bitfield_1) , 11usize , 21u8 ,) as u32) } } # [inline] pub unsafe fn set_flags_raw (this : * mut Self , val : u32) { unsafe { let val : u32 = :: std :: mem :: transmute (val) ; < __BindgenBitfieldUnit < [u8 ; 4usize] > > :: raw_set (:: std :: ptr :: addr_of_mut ! ((* this) . _bitfield_1) , 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 , } # [allow (clippy :: unnecessary_operation , clippy :: identity_op)] const _ : () = { ["Size of RObject"] [:: std :: mem :: size_of :: < RObject > () - 32usize] ; ["Alignment of RObject"] [:: std :: mem :: align_of :: < RObject > () - 8usize] ; ["Offset of field: RObject::c"] [:: std :: mem :: offset_of ! (RObject , c) - 0usize] ; ["Offset of field: RObject::gcnext"] [:: std :: mem :: offset_of ! (RObject , gcnext) - 8usize] ; ["Offset of field: RObject::iv"] [:: std :: mem :: offset_of ! (RObject , iv) - 24usize] ; } ; 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 unsafe fn tt_raw (this : * const Self) -> mrb_vtype { unsafe { :: std :: mem :: transmute (< __BindgenBitfieldUnit < [u8 ; 4usize] > > :: raw_get (:: std :: ptr :: addr_of ! ((* this) . _bitfield_1) , 0usize , 8u8 ,) as u32) } } # [inline] pub unsafe fn set_tt_raw (this : * mut Self , val : mrb_vtype) { unsafe { let val : u32 = :: std :: mem :: transmute (val) ; < __BindgenBitfieldUnit < [u8 ; 4usize] > > :: raw_set (:: std :: ptr :: addr_of_mut ! ((* this) . _bitfield_1) , 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 unsafe fn color_raw (this : * const Self) -> u32 { unsafe { :: std :: mem :: transmute (< __BindgenBitfieldUnit < [u8 ; 4usize] > > :: raw_get (:: std :: ptr :: addr_of ! ((* this) . _bitfield_1) , 8usize , 3u8 ,) as u32) } } # [inline] pub unsafe fn set_color_raw (this : * mut Self , val : u32) { unsafe { let val : u32 = :: std :: mem :: transmute (val) ; < __BindgenBitfieldUnit < [u8 ; 4usize] > > :: raw_set (:: std :: ptr :: addr_of_mut ! ((* this) . _bitfield_1) , 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 unsafe fn flags_raw (this : * const Self) -> u32 { unsafe { :: std :: mem :: transmute (< __BindgenBitfieldUnit < [u8 ; 4usize] > > :: raw_get (:: std :: ptr :: addr_of ! ((* this) . _bitfield_1) , 11usize , 21u8 ,) as u32) } } # [inline] pub unsafe fn set_flags_raw (this : * mut Self , val : u32) { unsafe { let val : u32 = :: std :: mem :: transmute (val) ; < __BindgenBitfieldUnit < [u8 ; 4usize] > > :: raw_set (:: std :: ptr :: addr_of_mut ! ((* this) . _bitfield_1) , 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 , } # [allow (clippy :: unnecessary_operation , clippy :: identity_op)] const _ : () = { ["Size of RFiber"] [:: std :: mem :: size_of :: < RFiber > () - 32usize] ; ["Alignment of RFiber"] [:: std :: mem :: align_of :: < RFiber > () - 8usize] ; ["Offset of field: RFiber::c"] [:: std :: mem :: offset_of ! (RFiber , c) - 0usize] ; ["Offset of field: RFiber::gcnext"] [:: std :: mem :: offset_of ! (RFiber , gcnext) - 8usize] ; ["Offset of field: RFiber::cxt"] [:: std :: mem :: offset_of ! (RFiber , cxt) - 24usize] ; } ; 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 unsafe fn tt_raw (this : * const Self) -> mrb_vtype { unsafe { :: std :: mem :: transmute (< __BindgenBitfieldUnit < [u8 ; 4usize] > > :: raw_get (:: std :: ptr :: addr_of ! ((* this) . _bitfield_1) , 0usize , 8u8 ,) as u32) } } # [inline] pub unsafe fn set_tt_raw (this : * mut Self , val : mrb_vtype) { unsafe { let val : u32 = :: std :: mem :: transmute (val) ; < __BindgenBitfieldUnit < [u8 ; 4usize] > > :: raw_set (:: std :: ptr :: addr_of_mut ! ((* this) . _bitfield_1) , 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 unsafe fn color_raw (this : * const Self) -> u32 { unsafe { :: std :: mem :: transmute (< __BindgenBitfieldUnit < [u8 ; 4usize] > > :: raw_get (:: std :: ptr :: addr_of ! ((* this) . _bitfield_1) , 8usize , 3u8 ,) as u32) } } # [inline] pub unsafe fn set_color_raw (this : * mut Self , val : u32) { unsafe { let val : u32 = :: std :: mem :: transmute (val) ; < __BindgenBitfieldUnit < [u8 ; 4usize] > > :: raw_set (:: std :: ptr :: addr_of_mut ! ((* this) . _bitfield_1) , 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 unsafe fn flags_raw (this : * const Self) -> u32 { unsafe { :: std :: mem :: transmute (< __BindgenBitfieldUnit < [u8 ; 4usize] > > :: raw_get (:: std :: ptr :: addr_of ! ((* this) . _bitfield_1) , 11usize , 21u8 ,) as u32) } } # [inline] pub unsafe fn set_flags_raw (this : * mut Self , val : u32) { unsafe { let val : u32 = :: std :: mem :: transmute (val) ; < __BindgenBitfieldUnit < [u8 ; 4usize] > > :: raw_set (:: std :: ptr :: addr_of_mut ! ((* this) . _bitfield_1) , 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 , } # [allow (clippy :: unnecessary_operation , clippy :: identity_op)] const _ : () = { ["Size of mrb_value_union"] [:: std :: mem :: size_of :: < mrb_value_union > () - 8usize] ; ["Alignment of mrb_value_union"] [:: std :: mem :: align_of :: < mrb_value_union > () - 8usize] ; ["Offset of field: mrb_value_union::f"] [:: std :: mem :: offset_of ! (mrb_value_union , f) - 0usize] ; ["Offset of field: mrb_value_union::p"] [:: std :: mem :: offset_of ! (mrb_value_union , p) - 0usize] ; ["Offset of field: mrb_value_union::i"] [:: std :: mem :: offset_of ! (mrb_value_union , i) - 0usize] ; ["Offset of field: mrb_value_union::sym"] [:: std :: mem :: offset_of ! (mrb_value_union , sym) - 0usize] ; } ; # [repr (C)] # [derive (Copy , Clone)] pub struct mrb_value { pub value : mrb_value_union , pub tt : mrb_vtype , } # [allow (clippy :: unnecessary_operation , clippy :: identity_op)] const _ : () = { ["Size of mrb_value"] [:: std :: mem :: size_of :: < mrb_value > () - 16usize] ; ["Alignment of mrb_value"] [:: std :: mem :: align_of :: < mrb_value > () - 8usize] ; ["Offset of field: mrb_value::value"] [:: std :: mem :: offset_of ! (mrb_value , value) - 0usize] ; ["Offset of field: mrb_value::tt"] [:: std :: mem :: offset_of ! (mrb_value , tt) - 8usize] ; } ; pub type mrb_ssize = mrb_int ; pub type mrb_each_object_callback = :: std :: option :: Option < unsafe extern "C-unwind" fn (mrb : * mut mrb_state , obj : * mut RBasic , data : * mut :: std :: os :: raw :: c_void) -> :: std :: os :: raw :: c_int > ; unsafe extern "C-unwind" { pub fn mrb_objspace_each_objects (mrb : * mut mrb_state , callback : mrb_each_object_callback , data : * mut :: std :: os :: raw :: c_void) ; } unsafe extern "C-unwind" { pub fn mrb_objspace_page_slot_size () -> usize ; } unsafe extern "C-unwind" { 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] , } # [allow (clippy :: unnecessary_operation , clippy :: identity_op)] const _ : () = { ["Size of mrb_heap_page"] [:: std :: mem :: size_of :: < mrb_heap_page > () - 48usize] ; ["Alignment of mrb_heap_page"] [:: std :: mem :: align_of :: < mrb_heap_page > () - 8usize] ; ["Offset of field: mrb_heap_page::freelist"] [:: std :: mem :: offset_of ! (mrb_heap_page , freelist) - 0usize] ; ["Offset of field: mrb_heap_page::prev"] [:: std :: mem :: offset_of ! (mrb_heap_page , prev) - 8usize] ; ["Offset of field: mrb_heap_page::next"] [:: std :: mem :: offset_of ! (mrb_heap_page , next) - 16usize] ; ["Offset of field: mrb_heap_page::free_next"] [:: std :: mem :: offset_of ! (mrb_heap_page , free_next) - 24usize] ; ["Offset of field: mrb_heap_page::free_prev"] [:: std :: mem :: offset_of ! (mrb_heap_page , free_prev) - 32usize] ; } ; 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 unsafe fn old_raw (this : * const Self) -> mrb_bool { unsafe { :: std :: mem :: transmute (< __BindgenBitfieldUnit < [u8 ; 1usize] > > :: raw_get (:: std :: ptr :: addr_of ! ((* this) . _bitfield_1) , 0usize , 1u8 ,) as u8) } } # [inline] pub unsafe fn set_old_raw (this : * mut Self , val : mrb_bool) { unsafe { let val : u8 = :: std :: mem :: transmute (val) ; < __BindgenBitfieldUnit < [u8 ; 1usize] > > :: raw_set (:: std :: ptr :: addr_of_mut ! ((* this) . _bitfield_1) , 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 , } # [allow (clippy :: unnecessary_operation , clippy :: identity_op)] const _ : () = { ["Size of mrb_gc"] [:: std :: mem :: size_of :: < mrb_gc > () - 112usize] ; ["Alignment of mrb_gc"] [:: std :: mem :: align_of :: < mrb_gc > () - 8usize] ; ["Offset of field: mrb_gc::heaps"] [:: std :: mem :: offset_of ! (mrb_gc , heaps) - 0usize] ; ["Offset of field: mrb_gc::sweeps"] [:: std :: mem :: offset_of ! (mrb_gc , sweeps) - 8usize] ; ["Offset of field: mrb_gc::free_heaps"] [:: std :: mem :: offset_of ! (mrb_gc , free_heaps) - 16usize] ; ["Offset of field: mrb_gc::live"] [:: std :: mem :: offset_of ! (mrb_gc , live) - 24usize] ; ["Offset of field: mrb_gc::arena"] [:: std :: mem :: offset_of ! (mrb_gc , arena) - 32usize] ; ["Offset of field: mrb_gc::arena_capa"] [:: std :: mem :: offset_of ! (mrb_gc , arena_capa) - 40usize] ; ["Offset of field: mrb_gc::arena_idx"] [:: std :: mem :: offset_of ! (mrb_gc , arena_idx) - 44usize] ; ["Offset of field: mrb_gc::state"] [:: std :: mem :: offset_of ! (mrb_gc , state) - 48usize] ; ["Offset of field: mrb_gc::current_white_part"] [:: std :: mem :: offset_of ! (mrb_gc , current_white_part) - 52usize] ; ["Offset of field: mrb_gc::gray_list"] [:: std :: mem :: offset_of ! (mrb_gc , gray_list) - 56usize] ; ["Offset of field: mrb_gc::atomic_gray_list"] [:: std :: mem :: offset_of ! (mrb_gc , atomic_gray_list) - 64usize] ; ["Offset of field: mrb_gc::live_after_mark"] [:: std :: mem :: offset_of ! (mrb_gc , live_after_mark) - 72usize] ; ["Offset of field: mrb_gc::threshold"] [:: std :: mem :: offset_of ! (mrb_gc , threshold) - 80usize] ; ["Offset of field: mrb_gc::interval_ratio"] [:: std :: mem :: offset_of ! (mrb_gc , interval_ratio) - 88usize] ; ["Offset of field: mrb_gc::step_ratio"] [:: std :: mem :: offset_of ! (mrb_gc , step_ratio) - 92usize] ; ["Offset of field: mrb_gc::majorgc_old_threshold"] [:: std :: mem :: offset_of ! (mrb_gc , majorgc_old_threshold) - 104usize] ; } ; 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 unsafe fn iterating_raw (this : * const Self) -> mrb_bool { unsafe { :: std :: mem :: transmute (< __BindgenBitfieldUnit < [u8 ; 1usize] > > :: raw_get (:: std :: ptr :: addr_of ! ((* this) . _bitfield_1) , 0usize , 1u8 ,) as u8) } } # [inline] pub unsafe fn set_iterating_raw (this : * mut Self , val : mrb_bool) { unsafe { let val : u8 = :: std :: mem :: transmute (val) ; < __BindgenBitfieldUnit < [u8 ; 1usize] > > :: raw_set (:: std :: ptr :: addr_of_mut ! ((* this) . _bitfield_1) , 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 unsafe fn disabled_raw (this : * const Self) -> mrb_bool { unsafe { :: std :: mem :: transmute (< __BindgenBitfieldUnit < [u8 ; 1usize] > > :: raw_get (:: std :: ptr :: addr_of ! ((* this) . _bitfield_1) , 1usize , 1u8 ,) as u8) } } # [inline] pub unsafe fn set_disabled_raw (this : * mut Self , val : mrb_bool) { unsafe { let val : u8 = :: std :: mem :: transmute (val) ; < __BindgenBitfieldUnit < [u8 ; 1usize] > > :: raw_set (:: std :: ptr :: addr_of_mut ! ((* this) . _bitfield_1) , 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 unsafe fn full_raw (this : * const Self) -> mrb_bool { unsafe { :: std :: mem :: transmute (< __BindgenBitfieldUnit < [u8 ; 1usize] > > :: raw_get (:: std :: ptr :: addr_of ! ((* this) . _bitfield_1) , 2usize , 1u8 ,) as u8) } } # [inline] pub unsafe fn set_full_raw (this : * mut Self , val : mrb_bool) { unsafe { let val : u8 = :: std :: mem :: transmute (val) ; < __BindgenBitfieldUnit < [u8 ; 1usize] > > :: raw_set (:: std :: ptr :: addr_of_mut ! ((* this) . _bitfield_1) , 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 unsafe fn generational_raw (this : * const Self) -> mrb_bool { unsafe { :: std :: mem :: transmute (< __BindgenBitfieldUnit < [u8 ; 1usize] > > :: raw_get (:: std :: ptr :: addr_of ! ((* this) . _bitfield_1) , 3usize , 1u8 ,) as u8) } } # [inline] pub unsafe fn set_generational_raw (this : * mut Self , val : mrb_bool) { unsafe { let val : u8 = :: std :: mem :: transmute (val) ; < __BindgenBitfieldUnit < [u8 ; 1usize] > > :: raw_set (:: std :: ptr :: addr_of_mut ! ((* this) . _bitfield_1) , 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 unsafe fn out_of_memory_raw (this : * const Self) -> mrb_bool { unsafe { :: std :: mem :: transmute (< __BindgenBitfieldUnit < [u8 ; 1usize] > > :: raw_get (:: std :: ptr :: addr_of ! ((* this) . _bitfield_1) , 4usize , 1u8 ,) as u8) } } # [inline] pub unsafe fn set_out_of_memory_raw (this : * mut Self , val : mrb_bool) { unsafe { let val : u8 = :: std :: mem :: transmute (val) ; < __BindgenBitfieldUnit < [u8 ; 1usize] > > :: raw_set (:: std :: ptr :: addr_of_mut ! ((* this) . _bitfield_1) , 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 } } unsafe extern "C-unwind" { 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-unwind" 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 , } # [allow (clippy :: unnecessary_operation , clippy :: identity_op)] const _ : () = { ["Size of mrb_callinfo__bindgen_ty_1"] [:: std :: mem :: size_of :: < mrb_callinfo__bindgen_ty_1 > () - 8usize] ; ["Alignment of mrb_callinfo__bindgen_ty_1"] [:: std :: mem :: align_of :: < mrb_callinfo__bindgen_ty_1 > () - 8usize] ; ["Offset of field: mrb_callinfo__bindgen_ty_1::env"] [:: std :: mem :: offset_of ! (mrb_callinfo__bindgen_ty_1 , env) - 0usize] ; ["Offset of field: mrb_callinfo__bindgen_ty_1::target_class"] [:: std :: mem :: offset_of ! (mrb_callinfo__bindgen_ty_1 , target_class) - 0usize] ; } ; # [allow (clippy :: unnecessary_operation , clippy :: identity_op)] const _ : () = { ["Size of mrb_callinfo"] [:: std :: mem :: size_of :: < mrb_callinfo > () - 48usize] ; ["Alignment of mrb_callinfo"] [:: std :: mem :: align_of :: < mrb_callinfo > () - 8usize] ; ["Offset of field: mrb_callinfo::cci"] [:: std :: mem :: offset_of ! (mrb_callinfo , cci) - 1usize] ; ["Offset of field: mrb_callinfo::mid"] [:: std :: mem :: offset_of ! (mrb_callinfo , mid) - 4usize] ; ["Offset of field: mrb_callinfo::proc_"] [:: std :: mem :: offset_of ! (mrb_callinfo , proc_) - 8usize] ; ["Offset of field: mrb_callinfo::blk"] [:: std :: mem :: offset_of ! (mrb_callinfo , blk) - 16usize] ; ["Offset of field: mrb_callinfo::stack"] [:: std :: mem :: offset_of ! (mrb_callinfo , stack) - 24usize] ; ["Offset of field: mrb_callinfo::pc"] [:: std :: mem :: offset_of ! (mrb_callinfo , pc) - 32usize] ; ["Offset of field: mrb_callinfo::u"] [:: std :: mem :: offset_of ! (mrb_callinfo , u) - 40usize] ; } ; 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 unsafe fn n_raw (this : * const Self) -> u8 { unsafe { :: std :: mem :: transmute (< __BindgenBitfieldUnit < [u8 ; 1usize] > > :: raw_get (:: std :: ptr :: addr_of ! ((* this) . _bitfield_1) , 0usize , 4u8 ,) as u8) } } # [inline] pub unsafe fn set_n_raw (this : * mut Self , val : u8) { unsafe { let val : u8 = :: std :: mem :: transmute (val) ; < __BindgenBitfieldUnit < [u8 ; 1usize] > > :: raw_set (:: std :: ptr :: addr_of_mut ! ((* this) . _bitfield_1) , 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 unsafe fn nk_raw (this : * const Self) -> u8 { unsafe { :: std :: mem :: transmute (< __BindgenBitfieldUnit < [u8 ; 1usize] > > :: raw_get (:: std :: ptr :: addr_of ! ((* this) . _bitfield_1) , 4usize , 4u8 ,) as u8) } } # [inline] pub unsafe fn set_nk_raw (this : * mut Self , val : u8) { unsafe { let val : u8 = :: std :: mem :: transmute (val) ; < __BindgenBitfieldUnit < [u8 ; 1usize] > > :: raw_set (:: std :: ptr :: addr_of_mut ! ((* this) . _bitfield_1) , 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 , } # [allow (clippy :: unnecessary_operation , clippy :: identity_op)] const _ : () = { ["Size of mrb_context"] [:: std :: mem :: size_of :: < mrb_context > () - 64usize] ; ["Alignment of mrb_context"] [:: std :: mem :: align_of :: < mrb_context > () - 8usize] ; ["Offset of field: mrb_context::prev"] [:: std :: mem :: offset_of ! (mrb_context , prev) - 0usize] ; ["Offset of field: mrb_context::stbase"] [:: std :: mem :: offset_of ! (mrb_context , stbase) - 8usize] ; ["Offset of field: mrb_context::stend"] [:: std :: mem :: offset_of ! (mrb_context , stend) - 16usize] ; ["Offset of field: mrb_context::ci"] [:: std :: mem :: offset_of ! (mrb_context , ci) - 24usize] ; ["Offset of field: mrb_context::cibase"] [:: std :: mem :: offset_of ! (mrb_context , cibase) - 32usize] ; ["Offset of field: mrb_context::ciend"] [:: std :: mem :: offset_of ! (mrb_context , ciend) - 40usize] ; ["Offset of field: mrb_context::fib"] [:: std :: mem :: offset_of ! (mrb_context , fib) - 56usize] ; } ; 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 unsafe fn status_raw (this : * const Self) -> mrb_fiber_state { unsafe { :: std :: mem :: transmute (< __BindgenBitfieldUnit < [u8 ; 1usize] > > :: raw_get (:: std :: ptr :: addr_of ! ((* this) . _bitfield_1) , 0usize , 4u8 ,) as u32) } } # [inline] pub unsafe fn set_status_raw (this : * mut Self , val : mrb_fiber_state) { unsafe { let val : u32 = :: std :: mem :: transmute (val) ; < __BindgenBitfieldUnit < [u8 ; 1usize] > > :: raw_set (:: std :: ptr :: addr_of_mut ! ((* this) . _bitfield_1) , 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 unsafe fn vmexec_raw (this : * const Self) -> mrb_bool { unsafe { :: std :: mem :: transmute (< __BindgenBitfieldUnit < [u8 ; 1usize] > > :: raw_get (:: std :: ptr :: addr_of ! ((* this) . _bitfield_1) , 4usize , 1u8 ,) as u8) } } # [inline] pub unsafe fn set_vmexec_raw (this : * mut Self , val : mrb_bool) { unsafe { let val : u8 = :: std :: mem :: transmute (val) ; < __BindgenBitfieldUnit < [u8 ; 1usize] > > :: raw_set (:: std :: ptr :: addr_of_mut ! ((* this) . _bitfield_1) , 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-unwind" 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 , } # [allow (clippy :: unnecessary_operation , clippy :: identity_op)] const _ : () = { ["Size of mrb_cache_entry"] [:: std :: mem :: size_of :: < mrb_cache_entry > () - 32usize] ; ["Alignment of mrb_cache_entry"] [:: std :: mem :: align_of :: < mrb_cache_entry > () - 8usize] ; ["Offset of field: mrb_cache_entry::c"] [:: std :: mem :: offset_of ! (mrb_cache_entry , c) - 0usize] ; ["Offset of field: mrb_cache_entry::c0"] [:: std :: mem :: offset_of ! (mrb_cache_entry , c0) - 8usize] ; ["Offset of field: mrb_cache_entry::mid"] [:: std :: mem :: offset_of ! (mrb_cache_entry , mid) - 16usize] ; ["Offset of field: mrb_cache_entry::m"] [:: std :: mem :: offset_of ! (mrb_cache_entry , m) - 24usize] ; } ; pub type mrb_atexit_func = :: std :: option :: Option < unsafe extern "C-unwind" 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 , } # [allow (clippy :: unnecessary_operation , clippy :: identity_op)] const _ : () = { ["Size of mrb_state"] [:: std :: mem :: size_of :: < mrb_state > () - 9616usize] ; ["Alignment of mrb_state"] [:: std :: mem :: align_of :: < mrb_state > () - 8usize] ; ["Offset of field: mrb_state::jmp"] [:: std :: mem :: offset_of ! (mrb_state , jmp) - 0usize] ; ["Offset of field: mrb_state::allocf"] [:: std :: mem :: offset_of ! (mrb_state , allocf) - 8usize] ; ["Offset of field: mrb_state::allocf_ud"] [:: std :: mem :: offset_of ! (mrb_state , allocf_ud) - 16usize] ; ["Offset of field: mrb_state::c"] [:: std :: mem :: offset_of ! (mrb_state , c) - 24usize] ; ["Offset of field: mrb_state::root_c"] [:: std :: mem :: offset_of ! (mrb_state , root_c) - 32usize] ; ["Offset of field: mrb_state::globals"] [:: std :: mem :: offset_of ! (mrb_state , globals) - 40usize] ; ["Offset of field: mrb_state::exc"] [:: std :: mem :: offset_of ! (mrb_state , exc) - 48usize] ; ["Offset of field: mrb_state::top_self"] [:: std :: mem :: offset_of ! (mrb_state , top_self) - 56usize] ; ["Offset of field: mrb_state::object_class"] [:: std :: mem :: offset_of ! (mrb_state , object_class) - 64usize] ; ["Offset of field: mrb_state::class_class"] [:: std :: mem :: offset_of ! (mrb_state , class_class) - 72usize] ; ["Offset of field: mrb_state::module_class"] [:: std :: mem :: offset_of ! (mrb_state , module_class) - 80usize] ; ["Offset of field: mrb_state::proc_class"] [:: std :: mem :: offset_of ! (mrb_state , proc_class) - 88usize] ; ["Offset of field: mrb_state::string_class"] [:: std :: mem :: offset_of ! (mrb_state , string_class) - 96usize] ; ["Offset of field: mrb_state::array_class"] [:: std :: mem :: offset_of ! (mrb_state , array_class) - 104usize] ; ["Offset of field: mrb_state::hash_class"] [:: std :: mem :: offset_of ! (mrb_state , hash_class) - 112usize] ; ["Offset of field: mrb_state::range_class"] [:: std :: mem :: offset_of ! (mrb_state , range_class) - 120usize] ; ["Offset of field: mrb_state::float_class"] [:: std :: mem :: offset_of ! (mrb_state , float_class) - 128usize] ; ["Offset of field: mrb_state::integer_class"] [:: std :: mem :: offset_of ! (mrb_state , integer_class) - 136usize] ; ["Offset of field: mrb_state::true_class"] [:: std :: mem :: offset_of ! (mrb_state , true_class) - 144usize] ; ["Offset of field: mrb_state::false_class"] [:: std :: mem :: offset_of ! (mrb_state , false_class) - 152usize] ; ["Offset of field: mrb_state::nil_class"] [:: std :: mem :: offset_of ! (mrb_state , nil_class) - 160usize] ; ["Offset of field: mrb_state::symbol_class"] [:: std :: mem :: offset_of ! (mrb_state , symbol_class) - 168usize] ; ["Offset of field: mrb_state::kernel_module"] [:: std :: mem :: offset_of ! (mrb_state , kernel_module) - 176usize] ; ["Offset of field: mrb_state::gc"] [:: std :: mem :: offset_of ! (mrb_state , gc) - 184usize] ; ["Offset of field: mrb_state::cache"] [:: std :: mem :: offset_of ! (mrb_state , cache) - 296usize] ; ["Offset of field: mrb_state::symidx"] [:: std :: mem :: offset_of ! (mrb_state , symidx) - 8488usize] ; ["Offset of field: mrb_state::symtbl"] [:: std :: mem :: offset_of ! (mrb_state , symtbl) - 8496usize] ; ["Offset of field: mrb_state::symlink"] [:: std :: mem :: offset_of ! (mrb_state , symlink) - 8504usize] ; ["Offset of field: mrb_state::symflags"] [:: std :: mem :: offset_of ! (mrb_state , symflags) - 8512usize] ; ["Offset of field: mrb_state::symhash"] [:: std :: mem :: offset_of ! (mrb_state , symhash) - 8520usize] ; ["Offset of field: mrb_state::symcapa"] [:: std :: mem :: offset_of ! (mrb_state , symcapa) - 9544usize] ; ["Offset of field: mrb_state::symbuf"] [:: std :: mem :: offset_of ! (mrb_state , symbuf) - 9552usize] ; ["Offset of field: mrb_state::eException_class"] [:: std :: mem :: offset_of ! (mrb_state , eException_class) - 9560usize] ; ["Offset of field: mrb_state::eStandardError_class"] [:: std :: mem :: offset_of ! (mrb_state , eStandardError_class) - 9568usize] ; ["Offset of field: mrb_state::nomem_err"] [:: std :: mem :: offset_of ! (mrb_state , nomem_err) - 9576usize] ; ["Offset of field: mrb_state::stack_err"] [:: std :: mem :: offset_of ! (mrb_state , stack_err) - 9584usize] ; ["Offset of field: mrb_state::ud"] [:: std :: mem :: offset_of ! (mrb_state , ud) - 9592usize] ; ["Offset of field: mrb_state::atexit_stack"] [:: std :: mem :: offset_of ! (mrb_state , atexit_stack) - 9600usize] ; ["Offset of field: mrb_state::atexit_stack_len"] [:: std :: mem :: offset_of ! (mrb_state , atexit_stack_len) - 9608usize] ; } ; unsafe extern "C-unwind" { pub fn mrb_define_class (mrb : * mut mrb_state , name : * const :: std :: os :: raw :: c_char , super_ : * mut RClass) -> * mut RClass ; } unsafe extern "C-unwind" { pub fn mrb_define_class_id (mrb : * mut mrb_state , name : mrb_sym , super_ : * mut RClass) -> * mut RClass ; } unsafe extern "C-unwind" { pub fn mrb_define_module (mrb : * mut mrb_state , name : * const :: std :: os :: raw :: c_char) -> * mut RClass ; } unsafe extern "C-unwind" { pub fn mrb_define_module_id (mrb : * mut mrb_state , name : mrb_sym) -> * mut RClass ; } unsafe extern "C-unwind" { pub fn mrb_singleton_class (mrb : * mut mrb_state , val : mrb_value) -> mrb_value ; } unsafe extern "C-unwind" { pub fn mrb_singleton_class_ptr (mrb : * mut mrb_state , val : mrb_value) -> * mut RClass ; } unsafe extern "C-unwind" { pub fn mrb_include_module (mrb : * mut mrb_state , cla : * mut RClass , included : * mut RClass) ; } unsafe extern "C-unwind" { pub fn mrb_prepend_module (mrb : * mut mrb_state , cla : * mut RClass , prepended : * mut RClass) ; } unsafe extern "C-unwind" { 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) ; } unsafe extern "C-unwind" { pub fn mrb_define_method_id (mrb : * mut mrb_state , c : * mut RClass , mid : mrb_sym , func : mrb_func_t , aspec : mrb_aspec) ; } unsafe extern "C-unwind" { 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) ; } unsafe extern "C-unwind" { pub fn mrb_define_class_method_id (mrb : * mut mrb_state , cla : * mut RClass , name : mrb_sym , fun : mrb_func_t , aspec : mrb_aspec) ; } unsafe extern "C-unwind" { 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) ; } unsafe extern "C-unwind" { pub fn mrb_define_singleton_method_id (mrb : * mut mrb_state , cla : * mut RObject , name : mrb_sym , fun : mrb_func_t , aspec : mrb_aspec) ; } unsafe extern "C-unwind" { 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) ; } unsafe extern "C-unwind" { pub fn mrb_define_module_function_id (mrb : * mut mrb_state , cla : * mut RClass , name : mrb_sym , fun : mrb_func_t , aspec : mrb_aspec) ; } unsafe extern "C-unwind" { pub fn mrb_define_const (mrb : * mut mrb_state , cla : * mut RClass , name : * const :: std :: os :: raw :: c_char , val : mrb_value) ; } unsafe extern "C-unwind" { pub fn mrb_define_const_id (mrb : * mut mrb_state , cla : * mut RClass , name : mrb_sym , val : mrb_value) ; } unsafe extern "C-unwind" { pub fn mrb_undef_method (mrb : * mut mrb_state , cla : * mut RClass , name : * const :: std :: os :: raw :: c_char) ; } unsafe extern "C-unwind" { pub fn mrb_undef_method_id (arg1 : * mut mrb_state , arg2 : * mut RClass , arg3 : mrb_sym) ; } unsafe extern "C-unwind" { pub fn mrb_undef_class_method (mrb : * mut mrb_state , cls : * mut RClass , name : * const :: std :: os :: raw :: c_char) ; } unsafe extern "C-unwind" { pub fn mrb_undef_class_method_id (mrb : * mut mrb_state , cls : * mut RClass , name : mrb_sym) ; } unsafe extern "C-unwind" { pub fn mrb_obj_new (mrb : * mut mrb_state , c : * mut RClass , argc : mrb_int , argv : * const mrb_value) -> mrb_value ; } unsafe extern "C-unwind" { pub fn mrb_class_new (mrb : * mut mrb_state , super_ : * mut RClass) -> * mut RClass ; } unsafe extern "C-unwind" { pub fn mrb_module_new (mrb : * mut mrb_state) -> * mut RClass ; } unsafe extern "C-unwind" { pub fn mrb_class_defined (mrb : * mut mrb_state , name : * const :: std :: os :: raw :: c_char) -> mrb_bool ; } unsafe extern "C-unwind" { pub fn mrb_class_defined_id (mrb : * mut mrb_state , name : mrb_sym) -> mrb_bool ; } unsafe extern "C-unwind" { pub fn mrb_class_get (mrb : * mut mrb_state , name : * const :: std :: os :: raw :: c_char) -> * mut RClass ; } unsafe extern "C-unwind" { pub fn mrb_class_get_id (mrb : * mut mrb_state , name : mrb_sym) -> * mut RClass ; } unsafe extern "C-unwind" { pub fn mrb_exc_get_id (mrb : * mut mrb_state , name : mrb_sym) -> * mut RClass ; } unsafe extern "C-unwind" { pub fn mrb_class_defined_under (mrb : * mut mrb_state , outer : * mut RClass , name : * const :: std :: os :: raw :: c_char) -> mrb_bool ; } unsafe extern "C-unwind" { pub fn mrb_class_defined_under_id (mrb : * mut mrb_state , outer : * mut RClass , name : mrb_sym) -> mrb_bool ; } unsafe extern "C-unwind" { pub fn mrb_class_get_under (mrb : * mut mrb_state , outer : * mut RClass , name : * const :: std :: os :: raw :: c_char) -> * mut RClass ; } unsafe extern "C-unwind" { pub fn mrb_class_get_under_id (mrb : * mut mrb_state , outer : * mut RClass , name : mrb_sym) -> * mut RClass ; } unsafe extern "C-unwind" { pub fn mrb_module_get (mrb : * mut mrb_state , name : * const :: std :: os :: raw :: c_char) -> * mut RClass ; } unsafe extern "C-unwind" { pub fn mrb_module_get_id (mrb : * mut mrb_state , name : mrb_sym) -> * mut RClass ; } unsafe extern "C-unwind" { pub fn mrb_module_get_under (mrb : * mut mrb_state , outer : * mut RClass , name : * const :: std :: os :: raw :: c_char) -> * mut RClass ; } unsafe extern "C-unwind" { pub fn mrb_module_get_under_id (mrb : * mut mrb_state , outer : * mut RClass , name : mrb_sym) -> * mut RClass ; } unsafe extern "C-unwind" { pub fn mrb_notimplement (arg1 : * mut mrb_state) ; } unsafe extern "C-unwind" { pub fn mrb_notimplement_m (arg1 : * mut mrb_state , arg2 : mrb_value) -> mrb_value ; } unsafe extern "C-unwind" { pub fn mrb_obj_dup (mrb : * mut mrb_state , obj : mrb_value) -> mrb_value ; } unsafe extern "C-unwind" { pub fn mrb_obj_respond_to (mrb : * mut mrb_state , c : * mut RClass , mid : mrb_sym) -> mrb_bool ; } unsafe extern "C-unwind" { 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 ; } unsafe extern "C-unwind" { pub fn mrb_define_class_under_id (mrb : * mut mrb_state , outer : * mut RClass , name : mrb_sym , super_ : * mut RClass) -> * mut RClass ; } unsafe extern "C-unwind" { pub fn mrb_define_module_under (mrb : * mut mrb_state , outer : * mut RClass , name : * const :: std :: os :: raw :: c_char) -> * mut RClass ; } unsafe extern "C-unwind" { 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 , } # [allow (clippy :: unnecessary_operation , clippy :: identity_op)] const _ : () = { ["Size of mrb_kwargs"] [:: std :: mem :: size_of :: < mrb_kwargs > () - 40usize] ; ["Alignment of mrb_kwargs"] [:: std :: mem :: align_of :: < mrb_kwargs > () - 8usize] ; ["Offset of field: mrb_kwargs::num"] [:: std :: mem :: offset_of ! (mrb_kwargs , num) - 0usize] ; ["Offset of field: mrb_kwargs::required"] [:: std :: mem :: offset_of ! (mrb_kwargs , required) - 8usize] ; ["Offset of field: mrb_kwargs::table"] [:: std :: mem :: offset_of ! (mrb_kwargs , table) - 16usize] ; ["Offset of field: mrb_kwargs::values"] [:: std :: mem :: offset_of ! (mrb_kwargs , values) - 24usize] ; ["Offset of field: mrb_kwargs::rest"] [:: std :: mem :: offset_of ! (mrb_kwargs , rest) - 32usize] ; } ; unsafe extern "C-unwind" { pub fn mrb_get_args (mrb : * mut mrb_state , format : mrb_args_format , ...) -> mrb_int ; } unsafe extern "C-unwind" { pub fn mrb_get_args_a (mrb : * mut mrb_state , format : mrb_args_format , ptr : * mut * mut :: std :: os :: raw :: c_void) -> mrb_int ; } unsafe extern "C-unwind" { pub fn mrb_get_argc (mrb : * mut mrb_state) -> mrb_int ; } unsafe extern "C-unwind" { pub fn mrb_get_argv (mrb : * mut mrb_state) -> * const mrb_value ; } unsafe extern "C-unwind" { pub fn mrb_get_arg1 (mrb : * mut mrb_state) -> mrb_value ; } unsafe extern "C-unwind" { pub fn mrb_block_given_p (mrb : * mut mrb_state) -> mrb_bool ; } unsafe extern "C-unwind" { pub fn mrb_funcall (mrb : * mut mrb_state , val : mrb_value , name : * const :: std :: os :: raw :: c_char , argc : mrb_int , ...) -> mrb_value ; } unsafe extern "C-unwind" { pub fn mrb_funcall_id (mrb : * mut mrb_state , val : mrb_value , mid : mrb_sym , argc : mrb_int , ...) -> mrb_value ; } unsafe extern "C-unwind" { pub fn mrb_funcall_argv (mrb : * mut mrb_state , val : mrb_value , name : mrb_sym , argc : mrb_int , argv : * const mrb_value) -> mrb_value ; } unsafe extern "C-unwind" { 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 ; } unsafe extern "C-unwind" { pub fn mrb_intern_cstr (mrb : * mut mrb_state , str_ : * const :: std :: os :: raw :: c_char) -> mrb_sym ; } unsafe extern "C-unwind" { pub fn mrb_intern (arg1 : * mut mrb_state , arg2 : * const :: std :: os :: raw :: c_char , arg3 : usize) -> mrb_sym ; } unsafe extern "C-unwind" { pub fn mrb_intern_static (arg1 : * mut mrb_state , arg2 : * const :: std :: os :: raw :: c_char , arg3 : usize) -> mrb_sym ; } unsafe extern "C-unwind" { pub fn mrb_intern_str (arg1 : * mut mrb_state , arg2 : mrb_value) -> mrb_sym ; } unsafe extern "C-unwind" { pub fn mrb_intern_check_cstr (arg1 : * mut mrb_state , arg2 : * const :: std :: os :: raw :: c_char) -> mrb_sym ; } unsafe extern "C-unwind" { pub fn mrb_intern_check (arg1 : * mut mrb_state , arg2 : * const :: std :: os :: raw :: c_char , arg3 : usize) -> mrb_sym ; } unsafe extern "C-unwind" { pub fn mrb_intern_check_str (arg1 : * mut mrb_state , arg2 : mrb_value) -> mrb_sym ; } unsafe extern "C-unwind" { pub fn mrb_check_intern_cstr (arg1 : * mut mrb_state , arg2 : * const :: std :: os :: raw :: c_char) -> mrb_value ; } unsafe extern "C-unwind" { pub fn mrb_check_intern (arg1 : * mut mrb_state , arg2 : * const :: std :: os :: raw :: c_char , arg3 : usize) -> mrb_value ; } unsafe extern "C-unwind" { pub fn mrb_check_intern_str (arg1 : * mut mrb_state , arg2 : mrb_value) -> mrb_value ; } unsafe extern "C-unwind" { pub fn mrb_sym_name (arg1 : * mut mrb_state , arg2 : mrb_sym) -> * const :: std :: os :: raw :: c_char ; } unsafe extern "C-unwind" { pub fn mrb_sym_name_len (arg1 : * mut mrb_state , arg2 : mrb_sym , arg3 : * mut mrb_int) -> * const :: std :: os :: raw :: c_char ; } unsafe extern "C-unwind" { pub fn mrb_sym_dump (arg1 : * mut mrb_state , arg2 : mrb_sym) -> * const :: std :: os :: raw :: c_char ; } unsafe extern "C-unwind" { pub fn mrb_sym_str (arg1 : * mut mrb_state , arg2 : mrb_sym) -> mrb_value ; } unsafe extern "C-unwind" { pub fn mrb_malloc (arg1 : * mut mrb_state , arg2 : usize) -> * mut :: std :: os :: raw :: c_void ; } unsafe extern "C-unwind" { pub fn mrb_calloc (arg1 : * mut mrb_state , arg2 : usize , arg3 : usize) -> * mut :: std :: os :: raw :: c_void ; } unsafe extern "C-unwind" { pub fn mrb_realloc (arg1 : * mut mrb_state , arg2 : * mut :: std :: os :: raw :: c_void , arg3 : usize) -> * mut :: std :: os :: raw :: c_void ; } unsafe extern "C-unwind" { pub fn mrb_realloc_simple (arg1 : * mut mrb_state , arg2 : * mut :: std :: os :: raw :: c_void , arg3 : usize) -> * mut :: std :: os :: raw :: c_void ; } unsafe extern "C-unwind" { pub fn mrb_malloc_simple (arg1 : * mut mrb_state , arg2 : usize) -> * mut :: std :: os :: raw :: c_void ; } unsafe extern "C-unwind" { pub fn mrb_obj_alloc (arg1 : * mut mrb_state , arg2 : mrb_vtype , arg3 : * mut RClass) -> * mut RBasic ; } unsafe extern "C-unwind" { pub fn mrb_free (arg1 : * mut mrb_state , arg2 : * mut :: std :: os :: raw :: c_void) ; } unsafe extern "C-unwind" { pub fn mrb_str_new (mrb : * mut mrb_state , p : * const :: std :: os :: raw :: c_char , len : mrb_int) -> mrb_value ; } unsafe extern "C-unwind" { pub fn mrb_str_new_cstr (arg1 : * mut mrb_state , arg2 : * const :: std :: os :: raw :: c_char) -> mrb_value ; } unsafe extern "C-unwind" { pub fn mrb_str_new_static (mrb : * mut mrb_state , p : * const :: std :: os :: raw :: c_char , len : mrb_int) -> mrb_value ; } unsafe extern "C-unwind" { pub fn mrb_obj_freeze (arg1 : * mut mrb_state , arg2 : mrb_value) -> mrb_value ; } unsafe extern "C-unwind" { pub fn mrb_open () -> * mut mrb_state ; } unsafe extern "C-unwind" { pub fn mrb_open_allocf (f : mrb_allocf , ud : * mut :: std :: os :: raw :: c_void) -> * mut mrb_state ; } unsafe extern "C-unwind" { pub fn mrb_open_core (f : mrb_allocf , ud : * mut :: std :: os :: raw :: c_void) -> * mut mrb_state ; } unsafe extern "C-unwind" { pub fn mrb_close (mrb : * mut mrb_state) ; } unsafe extern "C-unwind" { 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 ; } unsafe extern "C-unwind" { pub fn mrb_top_self (mrb : * mut mrb_state) -> mrb_value ; } unsafe extern "C-unwind" { pub fn mrb_top_run (mrb : * mut mrb_state , proc_ : * const RProc , self_ : mrb_value , stack_keep : mrb_int) -> mrb_value ; } unsafe extern "C-unwind" { pub fn mrb_vm_run (mrb : * mut mrb_state , proc_ : * const RProc , self_ : mrb_value , stack_keep : mrb_int) -> mrb_value ; } unsafe extern "C-unwind" { pub fn mrb_vm_exec (mrb : * mut mrb_state , proc_ : * const RProc , iseq : * const mrb_code) -> mrb_value ; } unsafe extern "C-unwind" { pub fn mrb_p (arg1 : * mut mrb_state , arg2 : mrb_value) ; } unsafe extern "C-unwind" { pub fn mrb_obj_id (obj : mrb_value) -> mrb_int ; } unsafe extern "C-unwind" { pub fn mrb_obj_to_sym (mrb : * mut mrb_state , name : mrb_value) -> mrb_sym ; } unsafe extern "C-unwind" { pub fn mrb_obj_eq (mrb : * mut mrb_state , a : mrb_value , b : mrb_value) -> mrb_bool ; } unsafe extern "C-unwind" { pub fn mrb_obj_equal (mrb : * mut mrb_state , a : mrb_value , b : mrb_value) -> mrb_bool ; } unsafe extern "C-unwind" { pub fn mrb_equal (mrb : * mut mrb_state , obj1 : mrb_value , obj2 : mrb_value) -> mrb_bool ; } unsafe extern "C-unwind" { pub fn mrb_ensure_float_type (mrb : * mut mrb_state , val : mrb_value) -> mrb_value ; } unsafe extern "C-unwind" { pub fn mrb_inspect (mrb : * mut mrb_state , obj : mrb_value) -> mrb_value ; } unsafe extern "C-unwind" { pub fn mrb_eql (mrb : * mut mrb_state , obj1 : mrb_value , obj2 : mrb_value) -> mrb_bool ; } unsafe extern "C-unwind" { pub fn mrb_cmp (mrb : * mut mrb_state , obj1 : mrb_value , obj2 : mrb_value) -> mrb_int ; } unsafe extern "C-unwind" { pub fn mrb_garbage_collect (arg1 : * mut mrb_state) ; } unsafe extern "C-unwind" { pub fn mrb_full_gc (arg1 : * mut mrb_state) ; } unsafe extern "C-unwind" { pub fn mrb_incremental_gc (arg1 : * mut mrb_state) ; } unsafe extern "C-unwind" { pub fn mrb_gc_mark (arg1 : * mut mrb_state , arg2 : * mut RBasic) ; } unsafe extern "C-unwind" { pub fn mrb_field_write_barrier (arg1 : * mut mrb_state , arg2 : * mut RBasic , arg3 : * mut RBasic) ; } unsafe extern "C-unwind" { pub fn mrb_write_barrier (arg1 : * mut mrb_state , arg2 : * mut RBasic) ; } unsafe extern "C-unwind" { pub fn mrb_type_convert (mrb : * mut mrb_state , val : mrb_value , type_ : mrb_vtype , method : mrb_sym) -> mrb_value ; } unsafe extern "C-unwind" { pub fn mrb_type_convert_check (mrb : * mut mrb_state , val : mrb_value , type_ : mrb_vtype , method : mrb_sym) -> mrb_value ; } unsafe extern "C-unwind" { pub fn mrb_any_to_s (mrb : * mut mrb_state , obj : mrb_value) -> mrb_value ; } unsafe extern "C-unwind" { pub fn mrb_obj_classname (mrb : * mut mrb_state , obj : mrb_value) -> * const :: std :: os :: raw :: c_char ; } unsafe extern "C-unwind" { pub fn mrb_obj_class (mrb : * mut mrb_state , obj : mrb_value) -> * mut RClass ; } unsafe extern "C-unwind" { pub fn mrb_class_path (mrb : * mut mrb_state , c : * mut RClass) -> mrb_value ; } unsafe extern "C-unwind" { pub fn mrb_obj_is_kind_of (mrb : * mut mrb_state , obj : mrb_value , c : * mut RClass) -> mrb_bool ; } unsafe extern "C-unwind" { pub fn mrb_obj_inspect (mrb : * mut mrb_state , self_ : mrb_value) -> mrb_value ; } unsafe extern "C-unwind" { pub fn mrb_obj_clone (mrb : * mut mrb_state , self_ : mrb_value) -> mrb_value ; } unsafe extern "C-unwind" { pub fn mrb_exc_new (mrb : * mut mrb_state , c : * mut RClass , ptr : * const :: std :: os :: raw :: c_char , len : mrb_int) -> mrb_value ; } unsafe extern "C-unwind" { pub fn mrb_exc_raise (mrb : * mut mrb_state , exc : mrb_value) ; } unsafe extern "C-unwind" { pub fn mrb_raise (mrb : * mut mrb_state , c : * mut RClass , msg : * const :: std :: os :: raw :: c_char) ; } unsafe extern "C-unwind" { pub fn mrb_raisef (mrb : * mut mrb_state , c : * mut RClass , fmt : * const :: std :: os :: raw :: c_char , ...) ; } unsafe extern "C-unwind" { pub fn mrb_name_error (mrb : * mut mrb_state , id : mrb_sym , fmt : * const :: std :: os :: raw :: c_char , ...) ; } unsafe extern "C-unwind" { pub fn mrb_frozen_error (mrb : * mut mrb_state , frozen_obj : * mut :: std :: os :: raw :: c_void) ; } unsafe extern "C-unwind" { pub fn mrb_argnum_error (mrb : * mut mrb_state , argc : mrb_int , min : :: std :: os :: raw :: c_int , max : :: std :: os :: raw :: c_int) ; } unsafe extern "C-unwind" { pub fn mrb_warn (mrb : * mut mrb_state , fmt : * const :: std :: os :: raw :: c_char , ...) ; } unsafe extern "C-unwind" { pub fn mrb_bug (mrb : * mut mrb_state , fmt : * const :: std :: os :: raw :: c_char , ...) ; } unsafe extern "C-unwind" { pub fn mrb_print_backtrace (mrb : * mut mrb_state) ; } unsafe extern "C-unwind" { pub fn mrb_print_error (mrb : * mut mrb_state) ; } unsafe extern "C-unwind" { pub fn mrb_vformat (mrb : * mut mrb_state , format : * const :: std :: os :: raw :: c_char , ap : * mut __va_list_tag) -> mrb_value ; } unsafe extern "C-unwind" { pub fn mrb_yield (mrb : * mut mrb_state , b : mrb_value , arg : mrb_value) -> mrb_value ; } unsafe extern "C-unwind" { pub fn mrb_yield_argv (mrb : * mut mrb_state , b : mrb_value , argc : mrb_int , argv : * const mrb_value) -> mrb_value ; } unsafe extern "C-unwind" { 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 ; } unsafe extern "C-unwind" { pub fn mrb_yield_cont (mrb : * mut mrb_state , b : mrb_value , self_ : mrb_value , argc : mrb_int , argv : * const mrb_value) -> mrb_value ; } unsafe extern "C-unwind" { pub fn mrb_gc_protect (mrb : * mut mrb_state , obj : mrb_value) ; } unsafe extern "C-unwind" { pub fn mrb_gc_register (mrb : * mut mrb_state , obj : mrb_value) ; } unsafe extern "C-unwind" { pub fn mrb_gc_unregister (mrb : * mut mrb_state , obj : mrb_value) ; } unsafe extern "C-unwind" { pub fn mrb_ensure_array_type (mrb : * mut mrb_state , self_ : mrb_value) -> mrb_value ; } unsafe extern "C-unwind" { pub fn mrb_check_array_type (mrb : * mut mrb_state , self_ : mrb_value) -> mrb_value ; } unsafe extern "C-unwind" { pub fn mrb_ensure_hash_type (mrb : * mut mrb_state , hash : mrb_value) -> mrb_value ; } unsafe extern "C-unwind" { pub fn mrb_check_hash_type (mrb : * mut mrb_state , hash : mrb_value) -> mrb_value ; } unsafe extern "C-unwind" { pub fn mrb_ensure_string_type (mrb : * mut mrb_state , str_ : mrb_value) -> mrb_value ; } unsafe extern "C-unwind" { pub fn mrb_check_string_type (mrb : * mut mrb_state , str_ : mrb_value) -> mrb_value ; } unsafe extern "C-unwind" { pub fn mrb_ensure_integer_type (mrb : * mut mrb_state , val : mrb_value) -> mrb_value ; } unsafe extern "C-unwind" { pub fn mrb_ensure_int_type (mrb : * mut mrb_state , val : mrb_value) -> mrb_value ; } unsafe extern "C-unwind" { pub fn mrb_check_type (mrb : * mut mrb_state , x : mrb_value , t : mrb_vtype) ; } unsafe extern "C-unwind" { 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) ; } unsafe extern "C-unwind" { pub fn mrb_define_alias_id (mrb : * mut mrb_state , c : * mut RClass , a : mrb_sym , b : mrb_sym) ; } unsafe extern "C-unwind" { pub fn mrb_class_name (mrb : * mut mrb_state , klass : * mut RClass) -> * const :: std :: os :: raw :: c_char ; } unsafe extern "C-unwind" { pub fn mrb_define_global_const (mrb : * mut mrb_state , name : * const :: std :: os :: raw :: c_char , val : mrb_value) ; } unsafe extern "C-unwind" { pub fn mrb_attr_get (mrb : * mut mrb_state , obj : mrb_value , id : mrb_sym) -> mrb_value ; } unsafe extern "C-unwind" { pub fn mrb_respond_to (mrb : * mut mrb_state , obj : mrb_value , mid : mrb_sym) -> mrb_bool ; } unsafe extern "C-unwind" { pub fn mrb_obj_is_instance_of (mrb : * mut mrb_state , obj : mrb_value , c : * mut RClass) -> mrb_bool ; } unsafe extern "C-unwind" { pub fn mrb_func_basic_p (mrb : * mut mrb_state , obj : mrb_value , mid : mrb_sym , func : mrb_func_t) -> mrb_bool ; } unsafe extern "C-unwind" { pub fn mrb_fiber_resume (mrb : * mut mrb_state , fib : mrb_value , argc : mrb_int , argv : * const mrb_value) -> mrb_value ; } unsafe extern "C-unwind" { pub fn mrb_fiber_yield (mrb : * mut mrb_state , argc : mrb_int , argv : * const mrb_value) -> mrb_value ; } unsafe extern "C-unwind" { pub fn mrb_fiber_alive_p (mrb : * mut mrb_state , fib : mrb_value) -> mrb_value ; } unsafe extern "C-unwind" { 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] , } unsafe extern "C-unwind" { pub fn mrb_pool_open (arg1 : * mut mrb_state) -> * mut mrb_pool ; } unsafe extern "C-unwind" { pub fn mrb_pool_close (arg1 : * mut mrb_pool) ; } unsafe extern "C-unwind" { pub fn mrb_pool_alloc (arg1 : * mut mrb_pool , arg2 : usize) -> * mut :: std :: os :: raw :: c_void ; } unsafe extern "C-unwind" { 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 ; } unsafe extern "C-unwind" { pub fn mrb_pool_can_realloc (arg1 : * mut mrb_pool , arg2 : * mut :: std :: os :: raw :: c_void , arg3 : usize) -> mrb_bool ; } unsafe extern "C-unwind" { pub fn mrb_alloca (mrb : * mut mrb_state , arg1 : usize) -> * mut :: std :: os :: raw :: c_void ; } unsafe extern "C-unwind" { pub fn mrb_state_atexit (mrb : * mut mrb_state , func : mrb_atexit_func) ; } unsafe extern "C-unwind" { pub fn mrb_show_version (mrb : * mut mrb_state) ; } unsafe extern "C-unwind" { pub fn mrb_show_copyright (mrb : * mut mrb_state) ; } unsafe extern "C-unwind" { 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 , } # [allow (clippy :: unnecessary_operation , clippy :: identity_op)] const _ : () = { ["Size of mrb_shared_array"] [:: std :: mem :: size_of :: < mrb_shared_array > () - 24usize] ; ["Alignment of mrb_shared_array"] [:: std :: mem :: align_of :: < mrb_shared_array > () - 8usize] ; ["Offset of field: mrb_shared_array::refcnt"] [:: std :: mem :: offset_of ! (mrb_shared_array , refcnt) - 0usize] ; ["Offset of field: mrb_shared_array::len"] [:: std :: mem :: offset_of ! (mrb_shared_array , len) - 8usize] ; ["Offset of field: mrb_shared_array::ptr"] [:: std :: mem :: offset_of ! (mrb_shared_array , ptr) - 16usize] ; } ; # [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 , } # [allow (clippy :: unnecessary_operation , clippy :: identity_op)] const _ : () = { ["Size of RArray__bindgen_ty_1__bindgen_ty_1__bindgen_ty_1"] [:: std :: mem :: size_of :: < RArray__bindgen_ty_1__bindgen_ty_1__bindgen_ty_1 > () - 8usize] ; ["Alignment of RArray__bindgen_ty_1__bindgen_ty_1__bindgen_ty_1"] [:: std :: mem :: align_of :: < RArray__bindgen_ty_1__bindgen_ty_1__bindgen_ty_1 > () - 8usize] ; ["Offset of field: RArray__bindgen_ty_1__bindgen_ty_1__bindgen_ty_1::capa"] [:: std :: mem :: offset_of ! (RArray__bindgen_ty_1__bindgen_ty_1__bindgen_ty_1 , capa) - 0usize] ; ["Offset of field: RArray__bindgen_ty_1__bindgen_ty_1__bindgen_ty_1::shared"] [:: std :: mem :: offset_of ! (RArray__bindgen_ty_1__bindgen_ty_1__bindgen_ty_1 , shared) - 0usize] ; } ; # [allow (clippy :: unnecessary_operation , clippy :: identity_op)] const _ : () = { ["Size of RArray__bindgen_ty_1__bindgen_ty_1"] [:: std :: mem :: size_of :: < RArray__bindgen_ty_1__bindgen_ty_1 > () - 24usize] ; ["Alignment of RArray__bindgen_ty_1__bindgen_ty_1"] [:: std :: mem :: align_of :: < RArray__bindgen_ty_1__bindgen_ty_1 > () - 8usize] ; ["Offset of field: RArray__bindgen_ty_1__bindgen_ty_1::len"] [:: std :: mem :: offset_of ! (RArray__bindgen_ty_1__bindgen_ty_1 , len) - 0usize] ; ["Offset of field: RArray__bindgen_ty_1__bindgen_ty_1::aux"] [:: std :: mem :: offset_of ! (RArray__bindgen_ty_1__bindgen_ty_1 , aux) - 8usize] ; ["Offset of field: RArray__bindgen_ty_1__bindgen_ty_1::ptr"] [:: std :: mem :: offset_of ! (RArray__bindgen_ty_1__bindgen_ty_1 , ptr) - 16usize] ; } ; # [allow (clippy :: unnecessary_operation , clippy :: identity_op)] const _ : () = { ["Size of RArray__bindgen_ty_1"] [:: std :: mem :: size_of :: < RArray__bindgen_ty_1 > () - 24usize] ; ["Alignment of RArray__bindgen_ty_1"] [:: std :: mem :: align_of :: < RArray__bindgen_ty_1 > () - 8usize] ; ["Offset of field: RArray__bindgen_ty_1::heap"] [:: std :: mem :: offset_of ! (RArray__bindgen_ty_1 , heap) - 0usize] ; } ; # [allow (clippy :: unnecessary_operation , clippy :: identity_op)] const _ : () = { ["Size of RArray"] [:: std :: mem :: size_of :: < RArray > () - 48usize] ; ["Alignment of RArray"] [:: std :: mem :: align_of :: < RArray > () - 8usize] ; ["Offset of field: RArray::c"] [:: std :: mem :: offset_of ! (RArray , c) - 0usize] ; ["Offset of field: RArray::gcnext"] [:: std :: mem :: offset_of ! (RArray , gcnext) - 8usize] ; ["Offset of field: RArray::as_"] [:: std :: mem :: offset_of ! (RArray , as_) - 24usize] ; } ; 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 unsafe fn tt_raw (this : * const Self) -> mrb_vtype { unsafe { :: std :: mem :: transmute (< __BindgenBitfieldUnit < [u8 ; 4usize] > > :: raw_get (:: std :: ptr :: addr_of ! ((* this) . _bitfield_1) , 0usize , 8u8 ,) as u32) } } # [inline] pub unsafe fn set_tt_raw (this : * mut Self , val : mrb_vtype) { unsafe { let val : u32 = :: std :: mem :: transmute (val) ; < __BindgenBitfieldUnit < [u8 ; 4usize] > > :: raw_set (:: std :: ptr :: addr_of_mut ! ((* this) . _bitfield_1) , 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 unsafe fn color_raw (this : * const Self) -> u32 { unsafe { :: std :: mem :: transmute (< __BindgenBitfieldUnit < [u8 ; 4usize] > > :: raw_get (:: std :: ptr :: addr_of ! ((* this) . _bitfield_1) , 8usize , 3u8 ,) as u32) } } # [inline] pub unsafe fn set_color_raw (this : * mut Self , val : u32) { unsafe { let val : u32 = :: std :: mem :: transmute (val) ; < __BindgenBitfieldUnit < [u8 ; 4usize] > > :: raw_set (:: std :: ptr :: addr_of_mut ! ((* this) . _bitfield_1) , 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 unsafe fn flags_raw (this : * const Self) -> u32 { unsafe { :: std :: mem :: transmute (< __BindgenBitfieldUnit < [u8 ; 4usize] > > :: raw_get (:: std :: ptr :: addr_of ! ((* this) . _bitfield_1) , 11usize , 21u8 ,) as u32) } } # [inline] pub unsafe fn set_flags_raw (this : * mut Self , val : u32) { unsafe { let val : u32 = :: std :: mem :: transmute (val) ; < __BindgenBitfieldUnit < [u8 ; 4usize] > > :: raw_set (:: std :: ptr :: addr_of_mut ! ((* this) . _bitfield_1) , 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 } } unsafe extern "C-unwind" { pub fn mrb_ary_modify (arg1 : * mut mrb_state , arg2 : * mut RArray) ; } unsafe extern "C-unwind" { pub fn mrb_ary_new_capa (arg1 : * mut mrb_state , arg2 : mrb_int) -> mrb_value ; } unsafe extern "C-unwind" { pub fn mrb_ary_new (mrb : * mut mrb_state) -> mrb_value ; } unsafe extern "C-unwind" { pub fn mrb_ary_new_from_values (mrb : * mut mrb_state , size : mrb_int , vals : * const mrb_value) -> mrb_value ; } unsafe extern "C-unwind" { pub fn mrb_assoc_new (mrb : * mut mrb_state , car : mrb_value , cdr : mrb_value) -> mrb_value ; } unsafe extern "C-unwind" { pub fn mrb_ary_concat (mrb : * mut mrb_state , self_ : mrb_value , other : mrb_value) ; } unsafe extern "C-unwind" { pub fn mrb_ary_splat (mrb : * mut mrb_state , value : mrb_value) -> mrb_value ; } unsafe extern "C-unwind" { pub fn mrb_ary_push (mrb : * mut mrb_state , array : mrb_value , value : mrb_value) ; } unsafe extern "C-unwind" { pub fn mrb_ary_pop (mrb : * mut mrb_state , ary : mrb_value) -> mrb_value ; } unsafe extern "C-unwind" { pub fn mrb_ary_set (mrb : * mut mrb_state , ary : mrb_value , n : mrb_int , val : mrb_value) ; } unsafe extern "C-unwind" { pub fn mrb_ary_replace (mrb : * mut mrb_state , self_ : mrb_value , other : mrb_value) ; } unsafe extern "C-unwind" { pub fn mrb_ary_unshift (mrb : * mut mrb_state , self_ : mrb_value , item : mrb_value) -> mrb_value ; } unsafe extern "C-unwind" { pub fn mrb_ary_entry (ary : mrb_value , offset : mrb_int) -> mrb_value ; } unsafe extern "C-unwind" { pub fn mrb_ary_splice (mrb : * mut mrb_state , self_ : mrb_value , head : mrb_int , len : mrb_int , rpl : mrb_value) -> mrb_value ; } unsafe extern "C-unwind" { pub fn mrb_ary_shift (mrb : * mut mrb_state , self_ : mrb_value) -> mrb_value ; } unsafe extern "C-unwind" { pub fn mrb_ary_clear (mrb : * mut mrb_state , self_ : mrb_value) -> mrb_value ; } unsafe extern "C-unwind" { pub fn mrb_ary_join (mrb : * mut mrb_state , ary : mrb_value , sep : mrb_value) -> mrb_value ; } unsafe extern "C-unwind" { pub fn mrb_ary_resize (mrb : * mut mrb_state , ary : mrb_value , new_len : mrb_int) -> mrb_value ; } unsafe extern "C-unwind" { 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 , } # [allow (clippy :: unnecessary_operation , clippy :: identity_op)] const _ : () = { ["Size of RClass"] [:: std :: mem :: size_of :: < RClass > () - 48usize] ; ["Alignment of RClass"] [:: std :: mem :: align_of :: < RClass > () - 8usize] ; ["Offset of field: RClass::c"] [:: std :: mem :: offset_of ! (RClass , c) - 0usize] ; ["Offset of field: RClass::gcnext"] [:: std :: mem :: offset_of ! (RClass , gcnext) - 8usize] ; ["Offset of field: RClass::iv"] [:: std :: mem :: offset_of ! (RClass , iv) - 24usize] ; ["Offset of field: RClass::mt"] [:: std :: mem :: offset_of ! (RClass , mt) - 32usize] ; ["Offset of field: RClass::super_"] [:: std :: mem :: offset_of ! (RClass , super_) - 40usize] ; } ; 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 unsafe fn tt_raw (this : * const Self) -> mrb_vtype { unsafe { :: std :: mem :: transmute (< __BindgenBitfieldUnit < [u8 ; 4usize] > > :: raw_get (:: std :: ptr :: addr_of ! ((* this) . _bitfield_1) , 0usize , 8u8 ,) as u32) } } # [inline] pub unsafe fn set_tt_raw (this : * mut Self , val : mrb_vtype) { unsafe { let val : u32 = :: std :: mem :: transmute (val) ; < __BindgenBitfieldUnit < [u8 ; 4usize] > > :: raw_set (:: std :: ptr :: addr_of_mut ! ((* this) . _bitfield_1) , 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 unsafe fn color_raw (this : * const Self) -> u32 { unsafe { :: std :: mem :: transmute (< __BindgenBitfieldUnit < [u8 ; 4usize] > > :: raw_get (:: std :: ptr :: addr_of ! ((* this) . _bitfield_1) , 8usize , 3u8 ,) as u32) } } # [inline] pub unsafe fn set_color_raw (this : * mut Self , val : u32) { unsafe { let val : u32 = :: std :: mem :: transmute (val) ; < __BindgenBitfieldUnit < [u8 ; 4usize] > > :: raw_set (:: std :: ptr :: addr_of_mut ! ((* this) . _bitfield_1) , 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 unsafe fn flags_raw (this : * const Self) -> u32 { unsafe { :: std :: mem :: transmute (< __BindgenBitfieldUnit < [u8 ; 4usize] > > :: raw_get (:: std :: ptr :: addr_of ! ((* this) . _bitfield_1) , 11usize , 21u8 ,) as u32) } } # [inline] pub unsafe fn set_flags_raw (this : * mut Self , val : u32) { unsafe { let val : u32 = :: std :: mem :: transmute (val) ; < __BindgenBitfieldUnit < [u8 ; 4usize] > > :: raw_set (:: std :: ptr :: addr_of_mut ! ((* this) . _bitfield_1) , 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 } } unsafe extern "C-unwind" { pub fn mrb_define_method_raw (arg1 : * mut mrb_state , arg2 : * mut RClass , arg3 : mrb_sym , arg4 : mrb_method_t) ; } unsafe extern "C-unwind" { pub fn mrb_alias_method (arg1 : * mut mrb_state , c : * mut RClass , a : mrb_sym , b : mrb_sym) ; } unsafe extern "C-unwind" { pub fn mrb_remove_method (mrb : * mut mrb_state , c : * mut RClass , sym : mrb_sym) ; } unsafe extern "C-unwind" { pub fn mrb_method_search_vm (arg1 : * mut mrb_state , arg2 : * mut * mut RClass , arg3 : mrb_sym) -> mrb_method_t ; } unsafe extern "C-unwind" { pub fn mrb_method_search (arg1 : * mut mrb_state , arg2 : * mut RClass , arg3 : mrb_sym) -> mrb_method_t ; } unsafe extern "C-unwind" { pub fn mrb_class_real (cl : * mut RClass) -> * mut RClass ; } unsafe extern "C-unwind" { 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-unwind" fn (arg1 : * mut mrb_state , arg2 : mrb_sym , arg3 : mrb_method_t , arg4 : * mut :: std :: os :: raw :: c_void) -> :: std :: os :: raw :: c_int > ; unsafe extern "C-unwind" { 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 , } # [allow (clippy :: unnecessary_operation , clippy :: identity_op)] const _ : () = { ["Size of mrbc_context"] [:: std :: mem :: size_of :: < mrbc_context > () - 80usize] ; ["Alignment of mrbc_context"] [:: std :: mem :: align_of :: < mrbc_context > () - 8usize] ; ["Offset of field: mrbc_context::syms"] [:: std :: mem :: offset_of ! (mrbc_context , syms) - 0usize] ; ["Offset of field: mrbc_context::slen"] [:: std :: mem :: offset_of ! (mrbc_context , slen) - 8usize] ; ["Offset of field: mrbc_context::filename"] [:: std :: mem :: offset_of ! (mrbc_context , filename) - 16usize] ; ["Offset of field: mrbc_context::lineno"] [:: std :: mem :: offset_of ! (mrbc_context , lineno) - 24usize] ; ["Offset of field: mrbc_context::partial_hook"] [:: std :: mem :: offset_of ! (mrbc_context , partial_hook) - 32usize] ; ["Offset of field: mrbc_context::partial_data"] [:: std :: mem :: offset_of ! (mrbc_context , partial_data) - 40usize] ; ["Offset of field: mrbc_context::target_class"] [:: std :: mem :: offset_of ! (mrbc_context , target_class) - 48usize] ; ["Offset of field: mrbc_context::upper"] [:: std :: mem :: offset_of ! (mrbc_context , upper) - 64usize] ; ["Offset of field: mrbc_context::parser_nerr"] [:: std :: mem :: offset_of ! (mrbc_context , parser_nerr) - 72usize] ; } ; 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 unsafe fn capture_errors_raw (this : * const Self) -> mrb_bool { unsafe { :: std :: mem :: transmute (< __BindgenBitfieldUnit < [u8 ; 1usize] > > :: raw_get (:: std :: ptr :: addr_of ! ((* this) . _bitfield_1) , 0usize , 1u8 ,) as u8) } } # [inline] pub unsafe fn set_capture_errors_raw (this : * mut Self , val : mrb_bool) { unsafe { let val : u8 = :: std :: mem :: transmute (val) ; < __BindgenBitfieldUnit < [u8 ; 1usize] > > :: raw_set (:: std :: ptr :: addr_of_mut ! ((* this) . _bitfield_1) , 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 unsafe fn dump_result_raw (this : * const Self) -> mrb_bool { unsafe { :: std :: mem :: transmute (< __BindgenBitfieldUnit < [u8 ; 1usize] > > :: raw_get (:: std :: ptr :: addr_of ! ((* this) . _bitfield_1) , 1usize , 1u8 ,) as u8) } } # [inline] pub unsafe fn set_dump_result_raw (this : * mut Self , val : mrb_bool) { unsafe { let val : u8 = :: std :: mem :: transmute (val) ; < __BindgenBitfieldUnit < [u8 ; 1usize] > > :: raw_set (:: std :: ptr :: addr_of_mut ! ((* this) . _bitfield_1) , 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 unsafe fn no_exec_raw (this : * const Self) -> mrb_bool { unsafe { :: std :: mem :: transmute (< __BindgenBitfieldUnit < [u8 ; 1usize] > > :: raw_get (:: std :: ptr :: addr_of ! ((* this) . _bitfield_1) , 2usize , 1u8 ,) as u8) } } # [inline] pub unsafe fn set_no_exec_raw (this : * mut Self , val : mrb_bool) { unsafe { let val : u8 = :: std :: mem :: transmute (val) ; < __BindgenBitfieldUnit < [u8 ; 1usize] > > :: raw_set (:: std :: ptr :: addr_of_mut ! ((* this) . _bitfield_1) , 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 unsafe fn keep_lv_raw (this : * const Self) -> mrb_bool { unsafe { :: std :: mem :: transmute (< __BindgenBitfieldUnit < [u8 ; 1usize] > > :: raw_get (:: std :: ptr :: addr_of ! ((* this) . _bitfield_1) , 3usize , 1u8 ,) as u8) } } # [inline] pub unsafe fn set_keep_lv_raw (this : * mut Self , val : mrb_bool) { unsafe { let val : u8 = :: std :: mem :: transmute (val) ; < __BindgenBitfieldUnit < [u8 ; 1usize] > > :: raw_set (:: std :: ptr :: addr_of_mut ! ((* this) . _bitfield_1) , 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 unsafe fn no_optimize_raw (this : * const Self) -> mrb_bool { unsafe { :: std :: mem :: transmute (< __BindgenBitfieldUnit < [u8 ; 1usize] > > :: raw_get (:: std :: ptr :: addr_of ! ((* this) . _bitfield_1) , 4usize , 1u8 ,) as u8) } } # [inline] pub unsafe fn set_no_optimize_raw (this : * mut Self , val : mrb_bool) { unsafe { let val : u8 = :: std :: mem :: transmute (val) ; < __BindgenBitfieldUnit < [u8 ; 1usize] > > :: raw_set (:: std :: ptr :: addr_of_mut ! ((* this) . _bitfield_1) , 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 unsafe fn no_ext_ops_raw (this : * const Self) -> mrb_bool { unsafe { :: std :: mem :: transmute (< __BindgenBitfieldUnit < [u8 ; 1usize] > > :: raw_get (:: std :: ptr :: addr_of ! ((* this) . _bitfield_1) , 5usize , 1u8 ,) as u8) } } # [inline] pub unsafe fn set_no_ext_ops_raw (this : * mut Self , val : mrb_bool) { unsafe { let val : u8 = :: std :: mem :: transmute (val) ; < __BindgenBitfieldUnit < [u8 ; 1usize] > > :: raw_set (:: std :: ptr :: addr_of_mut ! ((* this) . _bitfield_1) , 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 } } unsafe extern "C-unwind" { pub fn mrbc_context_new (mrb : * mut mrb_state) -> * mut mrbc_context ; } unsafe extern "C-unwind" { pub fn mrbc_context_free (mrb : * mut mrb_state , cxt : * mut mrbc_context) ; } unsafe extern "C-unwind" { 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 ; } unsafe extern "C-unwind" { 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) ; } unsafe extern "C-unwind" { 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 , } # [allow (clippy :: unnecessary_operation , clippy :: identity_op)] const _ : () = { ["Size of mrb_ast_node"] [:: std :: mem :: size_of :: < mrb_ast_node > () - 24usize] ; ["Alignment of mrb_ast_node"] [:: std :: mem :: align_of :: < mrb_ast_node > () - 8usize] ; ["Offset of field: mrb_ast_node::car"] [:: std :: mem :: offset_of ! (mrb_ast_node , car) - 0usize] ; ["Offset of field: mrb_ast_node::cdr"] [:: std :: mem :: offset_of ! (mrb_ast_node , cdr) - 8usize] ; ["Offset of field: mrb_ast_node::lineno"] [:: std :: mem :: offset_of ! (mrb_ast_node , lineno) - 16usize] ; ["Offset of field: mrb_ast_node::filename_index"] [:: std :: mem :: offset_of ! (mrb_ast_node , filename_index) - 18usize] ; } ; # [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 , } # [allow (clippy :: unnecessary_operation , clippy :: identity_op)] const _ : () = { ["Size of mrb_parser_message"] [:: std :: mem :: size_of :: < mrb_parser_message > () - 16usize] ; ["Alignment of mrb_parser_message"] [:: std :: mem :: align_of :: < mrb_parser_message > () - 8usize] ; ["Offset of field: mrb_parser_message::lineno"] [:: std :: mem :: offset_of ! (mrb_parser_message , lineno) - 0usize] ; ["Offset of field: mrb_parser_message::column"] [:: std :: mem :: offset_of ! (mrb_parser_message , column) - 4usize] ; ["Offset of field: mrb_parser_message::message"] [:: std :: mem :: offset_of ! (mrb_parser_message , message) - 8usize] ; } ; # [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 , } # [allow (clippy :: unnecessary_operation , clippy :: identity_op)] const _ : () = { ["Size of mrb_parser_heredoc_info"] [:: std :: mem :: size_of :: < mrb_parser_heredoc_info > () - 56usize] ; ["Alignment of mrb_parser_heredoc_info"] [:: std :: mem :: align_of :: < mrb_parser_heredoc_info > () - 8usize] ; ["Offset of field: mrb_parser_heredoc_info::indent"] [:: std :: mem :: offset_of ! (mrb_parser_heredoc_info , indent) - 8usize] ; ["Offset of field: mrb_parser_heredoc_info::indented"] [:: std :: mem :: offset_of ! (mrb_parser_heredoc_info , indented) - 16usize] ; ["Offset of field: mrb_parser_heredoc_info::type_"] [:: std :: mem :: offset_of ! (mrb_parser_heredoc_info , type_) - 24usize] ; ["Offset of field: mrb_parser_heredoc_info::term"] [:: std :: mem :: offset_of ! (mrb_parser_heredoc_info , term) - 32usize] ; ["Offset of field: mrb_parser_heredoc_info::term_len"] [:: std :: mem :: offset_of ! (mrb_parser_heredoc_info , term_len) - 40usize] ; ["Offset of field: mrb_parser_heredoc_info::doc"] [:: std :: mem :: offset_of ! (mrb_parser_heredoc_info , doc) - 48usize] ; } ; 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 unsafe fn allow_indent_raw (this : * const Self) -> mrb_bool { unsafe { :: std :: mem :: transmute (< __BindgenBitfieldUnit < [u8 ; 1usize] > > :: raw_get (:: std :: ptr :: addr_of ! ((* this) . _bitfield_1) , 0usize , 1u8 ,) as u8) } } # [inline] pub unsafe fn set_allow_indent_raw (this : * mut Self , val : mrb_bool) { unsafe { let val : u8 = :: std :: mem :: transmute (val) ; < __BindgenBitfieldUnit < [u8 ; 1usize] > > :: raw_set (:: std :: ptr :: addr_of_mut ! ((* this) . _bitfield_1) , 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 unsafe fn remove_indent_raw (this : * const Self) -> mrb_bool { unsafe { :: std :: mem :: transmute (< __BindgenBitfieldUnit < [u8 ; 1usize] > > :: raw_get (:: std :: ptr :: addr_of ! ((* this) . _bitfield_1) , 1usize , 1u8 ,) as u8) } } # [inline] pub unsafe fn set_remove_indent_raw (this : * mut Self , val : mrb_bool) { unsafe { let val : u8 = :: std :: mem :: transmute (val) ; < __BindgenBitfieldUnit < [u8 ; 1usize] > > :: raw_set (:: std :: ptr :: addr_of_mut ! ((* this) . _bitfield_1) , 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 unsafe fn line_head_raw (this : * const Self) -> mrb_bool { unsafe { :: std :: mem :: transmute (< __BindgenBitfieldUnit < [u8 ; 1usize] > > :: raw_get (:: std :: ptr :: addr_of ! ((* this) . _bitfield_1) , 2usize , 1u8 ,) as u8) } } # [inline] pub unsafe fn set_line_head_raw (this : * mut Self , val : mrb_bool) { unsafe { let val : u8 = :: std :: mem :: transmute (val) ; < __BindgenBitfieldUnit < [u8 ; 1usize] > > :: raw_set (:: std :: ptr :: addr_of_mut ! ((* this) . _bitfield_1) , 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 , } # [allow (clippy :: unnecessary_operation , clippy :: identity_op)] const _ : () = { ["Size of mrb_parser_state"] [:: std :: mem :: size_of :: < mrb_parser_state > () - 800usize] ; ["Alignment of mrb_parser_state"] [:: std :: mem :: align_of :: < mrb_parser_state > () - 8usize] ; ["Offset of field: mrb_parser_state::mrb"] [:: std :: mem :: offset_of ! (mrb_parser_state , mrb) - 0usize] ; ["Offset of field: mrb_parser_state::pool"] [:: std :: mem :: offset_of ! (mrb_parser_state , pool) - 8usize] ; ["Offset of field: mrb_parser_state::cells"] [:: std :: mem :: offset_of ! (mrb_parser_state , cells) - 16usize] ; ["Offset of field: mrb_parser_state::s"] [:: std :: mem :: offset_of ! (mrb_parser_state , s) - 24usize] ; ["Offset of field: mrb_parser_state::send"] [:: std :: mem :: offset_of ! (mrb_parser_state , send) - 32usize] ; ["Offset of field: mrb_parser_state::cxt"] [:: std :: mem :: offset_of ! (mrb_parser_state , cxt) - 40usize] ; ["Offset of field: mrb_parser_state::filename_sym"] [:: std :: mem :: offset_of ! (mrb_parser_state , filename_sym) - 48usize] ; ["Offset of field: mrb_parser_state::lineno"] [:: std :: mem :: offset_of ! (mrb_parser_state , lineno) - 52usize] ; ["Offset of field: mrb_parser_state::column"] [:: std :: mem :: offset_of ! (mrb_parser_state , column) - 56usize] ; ["Offset of field: mrb_parser_state::lstate"] [:: std :: mem :: offset_of ! (mrb_parser_state , lstate) - 60usize] ; ["Offset of field: mrb_parser_state::lex_strterm"] [:: std :: mem :: offset_of ! (mrb_parser_state , lex_strterm) - 64usize] ; ["Offset of field: mrb_parser_state::cond_stack"] [:: std :: mem :: offset_of ! (mrb_parser_state , cond_stack) - 72usize] ; ["Offset of field: mrb_parser_state::cmdarg_stack"] [:: std :: mem :: offset_of ! (mrb_parser_state , cmdarg_stack) - 76usize] ; ["Offset of field: mrb_parser_state::paren_nest"] [:: std :: mem :: offset_of ! (mrb_parser_state , paren_nest) - 80usize] ; ["Offset of field: mrb_parser_state::lpar_beg"] [:: std :: mem :: offset_of ! (mrb_parser_state , lpar_beg) - 84usize] ; ["Offset of field: mrb_parser_state::in_def"] [:: std :: mem :: offset_of ! (mrb_parser_state , in_def) - 88usize] ; ["Offset of field: mrb_parser_state::in_single"] [:: std :: mem :: offset_of ! (mrb_parser_state , in_single) - 92usize] ; ["Offset of field: mrb_parser_state::locals"] [:: std :: mem :: offset_of ! (mrb_parser_state , locals) - 104usize] ; ["Offset of field: mrb_parser_state::pb"] [:: std :: mem :: offset_of ! (mrb_parser_state , pb) - 112usize] ; ["Offset of field: mrb_parser_state::tokbuf"] [:: std :: mem :: offset_of ! (mrb_parser_state , tokbuf) - 120usize] ; ["Offset of field: mrb_parser_state::buf"] [:: std :: mem :: offset_of ! (mrb_parser_state , buf) - 128usize] ; ["Offset of field: mrb_parser_state::tidx"] [:: std :: mem :: offset_of ! (mrb_parser_state , tidx) - 384usize] ; ["Offset of field: mrb_parser_state::tsiz"] [:: std :: mem :: offset_of ! (mrb_parser_state , tsiz) - 388usize] ; ["Offset of field: mrb_parser_state::heredocs_from_nextline"] [:: std :: mem :: offset_of ! (mrb_parser_state , heredocs_from_nextline) - 392usize] ; ["Offset of field: mrb_parser_state::parsing_heredoc"] [:: std :: mem :: offset_of ! (mrb_parser_state , parsing_heredoc) - 400usize] ; ["Offset of field: mrb_parser_state::ylval"] [:: std :: mem :: offset_of ! (mrb_parser_state , ylval) - 408usize] ; ["Offset of field: mrb_parser_state::nerr"] [:: std :: mem :: offset_of ! (mrb_parser_state , nerr) - 416usize] ; ["Offset of field: mrb_parser_state::nwarn"] [:: std :: mem :: offset_of ! (mrb_parser_state , nwarn) - 424usize] ; ["Offset of field: mrb_parser_state::tree"] [:: std :: mem :: offset_of ! (mrb_parser_state , tree) - 432usize] ; ["Offset of field: mrb_parser_state::upper"] [:: std :: mem :: offset_of ! (mrb_parser_state , upper) - 448usize] ; ["Offset of field: mrb_parser_state::error_buffer"] [:: std :: mem :: offset_of ! (mrb_parser_state , error_buffer) - 456usize] ; ["Offset of field: mrb_parser_state::warn_buffer"] [:: std :: mem :: offset_of ! (mrb_parser_state , warn_buffer) - 616usize] ; ["Offset of field: mrb_parser_state::filename_table"] [:: std :: mem :: offset_of ! (mrb_parser_state , filename_table) - 776usize] ; ["Offset of field: mrb_parser_state::filename_table_length"] [:: std :: mem :: offset_of ! (mrb_parser_state , filename_table_length) - 784usize] ; ["Offset of field: mrb_parser_state::current_filename_index"] [:: std :: mem :: offset_of ! (mrb_parser_state , current_filename_index) - 786usize] ; ["Offset of field: mrb_parser_state::nvars"] [:: std :: mem :: offset_of ! (mrb_parser_state , nvars) - 792usize] ; } ; 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 unsafe fn cmd_start_raw (this : * const Self) -> mrb_bool { unsafe { :: std :: mem :: transmute (< __BindgenBitfieldUnit < [u8 ; 1usize] > > :: raw_get (:: std :: ptr :: addr_of ! ((* this) . _bitfield_1) , 0usize , 1u8 ,) as u8) } } # [inline] pub unsafe fn set_cmd_start_raw (this : * mut Self , val : mrb_bool) { unsafe { let val : u8 = :: std :: mem :: transmute (val) ; < __BindgenBitfieldUnit < [u8 ; 1usize] > > :: raw_set (:: std :: ptr :: addr_of_mut ! ((* this) . _bitfield_1) , 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 unsafe fn no_optimize_raw (this : * const Self) -> mrb_bool { unsafe { :: std :: mem :: transmute (< __BindgenBitfieldUnit < [u8 ; 1usize] > > :: raw_get (:: std :: ptr :: addr_of ! ((* this) . _bitfield_2) , 0usize , 1u8 ,) as u8) } } # [inline] pub unsafe fn set_no_optimize_raw (this : * mut Self , val : mrb_bool) { unsafe { let val : u8 = :: std :: mem :: transmute (val) ; < __BindgenBitfieldUnit < [u8 ; 1usize] > > :: raw_set (:: std :: ptr :: addr_of_mut ! ((* this) . _bitfield_2) , 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 unsafe fn capture_errors_raw (this : * const Self) -> mrb_bool { unsafe { :: std :: mem :: transmute (< __BindgenBitfieldUnit < [u8 ; 1usize] > > :: raw_get (:: std :: ptr :: addr_of ! ((* this) . _bitfield_2) , 1usize , 1u8 ,) as u8) } } # [inline] pub unsafe fn set_capture_errors_raw (this : * mut Self , val : mrb_bool) { unsafe { let val : u8 = :: std :: mem :: transmute (val) ; < __BindgenBitfieldUnit < [u8 ; 1usize] > > :: raw_set (:: std :: ptr :: addr_of_mut ! ((* this) . _bitfield_2) , 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 unsafe fn no_ext_ops_raw (this : * const Self) -> mrb_bool { unsafe { :: std :: mem :: transmute (< __BindgenBitfieldUnit < [u8 ; 1usize] > > :: raw_get (:: std :: ptr :: addr_of ! ((* this) . _bitfield_2) , 2usize , 1u8 ,) as u8) } } # [inline] pub unsafe fn set_no_ext_ops_raw (this : * mut Self , val : mrb_bool) { unsafe { let val : u8 = :: std :: mem :: transmute (val) ; < __BindgenBitfieldUnit < [u8 ; 1usize] > > :: raw_set (:: std :: ptr :: addr_of_mut ! ((* this) . _bitfield_2) , 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 } } unsafe extern "C-unwind" { pub fn mrb_parser_new (arg1 : * mut mrb_state) -> * mut mrb_parser_state ; } unsafe extern "C-unwind" { pub fn mrb_parser_free (arg1 : * mut mrb_parser_state) ; } unsafe extern "C-unwind" { pub fn mrb_parser_parse (arg1 : * mut mrb_parser_state , arg2 : * mut mrbc_context) ; } unsafe extern "C-unwind" { pub fn mrb_parser_set_filename (arg1 : * mut mrb_parser_state , arg2 : * const :: std :: os :: raw :: c_char) ; } unsafe extern "C-unwind" { pub fn mrb_parser_get_filename (arg1 : * mut mrb_parser_state , idx : u16) -> mrb_sym ; } unsafe extern "C-unwind" { pub fn mrb_parse_string (arg1 : * mut mrb_state , arg2 : * const :: std :: os :: raw :: c_char , arg3 : * mut mrbc_context) -> * mut mrb_parser_state ; } unsafe extern "C-unwind" { 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 ; } unsafe extern "C-unwind" { pub fn mrb_generate_code (arg1 : * mut mrb_state , arg2 : * mut mrb_parser_state) -> * mut RProc ; } unsafe extern "C-unwind" { pub fn mrb_load_exec (mrb : * mut mrb_state , p : * mut mrb_parser_state , c : * mut mrbc_context) -> mrb_value ; } unsafe extern "C-unwind" { pub fn mrb_load_string (mrb : * mut mrb_state , s : * const :: std :: os :: raw :: c_char) -> mrb_value ; } unsafe extern "C-unwind" { pub fn mrb_load_nstring (mrb : * mut mrb_state , s : * const :: std :: os :: raw :: c_char , len : usize) -> mrb_value ; } unsafe extern "C-unwind" { pub fn mrb_load_string_cxt (mrb : * mut mrb_state , s : * const :: std :: os :: raw :: c_char , cxt : * mut mrbc_context) -> mrb_value ; } unsafe extern "C-unwind" { 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) > , } # [allow (clippy :: unnecessary_operation , clippy :: identity_op)] const _ : () = { ["Size of mrb_data_type"] [:: std :: mem :: size_of :: < mrb_data_type > () - 16usize] ; ["Alignment of mrb_data_type"] [:: std :: mem :: align_of :: < mrb_data_type > () - 8usize] ; ["Offset of field: mrb_data_type::struct_name"] [:: std :: mem :: offset_of ! (mrb_data_type , struct_name) - 0usize] ; ["Offset of field: mrb_data_type::dfree"] [:: std :: mem :: offset_of ! (mrb_data_type , dfree) - 8usize] ; } ; # [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 , } # [allow (clippy :: unnecessary_operation , clippy :: identity_op)] const _ : () = { ["Size of RData"] [:: std :: mem :: size_of :: < RData > () - 48usize] ; ["Alignment of RData"] [:: std :: mem :: align_of :: < RData > () - 8usize] ; ["Offset of field: RData::c"] [:: std :: mem :: offset_of ! (RData , c) - 0usize] ; ["Offset of field: RData::gcnext"] [:: std :: mem :: offset_of ! (RData , gcnext) - 8usize] ; ["Offset of field: RData::iv"] [:: std :: mem :: offset_of ! (RData , iv) - 24usize] ; ["Offset of field: RData::type_"] [:: std :: mem :: offset_of ! (RData , type_) - 32usize] ; ["Offset of field: RData::data"] [:: std :: mem :: offset_of ! (RData , data) - 40usize] ; } ; 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 unsafe fn tt_raw (this : * const Self) -> mrb_vtype { unsafe { :: std :: mem :: transmute (< __BindgenBitfieldUnit < [u8 ; 4usize] > > :: raw_get (:: std :: ptr :: addr_of ! ((* this) . _bitfield_1) , 0usize , 8u8 ,) as u32) } } # [inline] pub unsafe fn set_tt_raw (this : * mut Self , val : mrb_vtype) { unsafe { let val : u32 = :: std :: mem :: transmute (val) ; < __BindgenBitfieldUnit < [u8 ; 4usize] > > :: raw_set (:: std :: ptr :: addr_of_mut ! ((* this) . _bitfield_1) , 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 unsafe fn color_raw (this : * const Self) -> u32 { unsafe { :: std :: mem :: transmute (< __BindgenBitfieldUnit < [u8 ; 4usize] > > :: raw_get (:: std :: ptr :: addr_of ! ((* this) . _bitfield_1) , 8usize , 3u8 ,) as u32) } } # [inline] pub unsafe fn set_color_raw (this : * mut Self , val : u32) { unsafe { let val : u32 = :: std :: mem :: transmute (val) ; < __BindgenBitfieldUnit < [u8 ; 4usize] > > :: raw_set (:: std :: ptr :: addr_of_mut ! ((* this) . _bitfield_1) , 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 unsafe fn flags_raw (this : * const Self) -> u32 { unsafe { :: std :: mem :: transmute (< __BindgenBitfieldUnit < [u8 ; 4usize] > > :: raw_get (:: std :: ptr :: addr_of ! ((* this) . _bitfield_1) , 11usize , 21u8 ,) as u32) } } # [inline] pub unsafe fn set_flags_raw (this : * mut Self , val : u32) { unsafe { let val : u32 = :: std :: mem :: transmute (val) ; < __BindgenBitfieldUnit < [u8 ; 4usize] > > :: raw_set (:: std :: ptr :: addr_of_mut ! ((* this) . _bitfield_1) , 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 } } unsafe extern "C-unwind" { 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 ; } unsafe extern "C-unwind" { pub fn mrb_data_check_type (mrb : * mut mrb_state , arg1 : mrb_value , arg2 : * const mrb_data_type) ; } unsafe extern "C-unwind" { pub fn mrb_data_get_ptr (mrb : * mut mrb_state , arg1 : mrb_value , arg2 : * const mrb_data_type) -> * mut :: std :: os :: raw :: c_void ; } unsafe extern "C-unwind" { 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 , } # [allow (clippy :: unnecessary_operation , clippy :: identity_op)] const _ : () = { ["Size of mrb_pool_value__bindgen_ty_1"] [:: std :: mem :: size_of :: < mrb_pool_value__bindgen_ty_1 > () - 8usize] ; ["Alignment of mrb_pool_value__bindgen_ty_1"] [:: std :: mem :: align_of :: < mrb_pool_value__bindgen_ty_1 > () - 8usize] ; ["Offset of field: mrb_pool_value__bindgen_ty_1::str_"] [:: std :: mem :: offset_of ! (mrb_pool_value__bindgen_ty_1 , str_) - 0usize] ; ["Offset of field: mrb_pool_value__bindgen_ty_1::i32_"] [:: std :: mem :: offset_of ! (mrb_pool_value__bindgen_ty_1 , i32_) - 0usize] ; ["Offset of field: mrb_pool_value__bindgen_ty_1::i64_"] [:: std :: mem :: offset_of ! (mrb_pool_value__bindgen_ty_1 , i64_) - 0usize] ; ["Offset of field: mrb_pool_value__bindgen_ty_1::f"] [:: std :: mem :: offset_of ! (mrb_pool_value__bindgen_ty_1 , f) - 0usize] ; } ; # [allow (clippy :: unnecessary_operation , clippy :: identity_op)] const _ : () = { ["Size of mrb_pool_value"] [:: std :: mem :: size_of :: < mrb_pool_value > () - 16usize] ; ["Alignment of mrb_pool_value"] [:: std :: mem :: align_of :: < mrb_pool_value > () - 8usize] ; ["Offset of field: mrb_pool_value::tt"] [:: std :: mem :: offset_of ! (mrb_pool_value , tt) - 0usize] ; ["Offset of field: mrb_pool_value::u"] [:: std :: mem :: offset_of ! (mrb_pool_value , u) - 8usize] ; } ; # [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] , } # [allow (clippy :: unnecessary_operation , clippy :: identity_op)] const _ : () = { ["Size of mrb_irep_catch_handler"] [:: std :: mem :: size_of :: < mrb_irep_catch_handler > () - 13usize] ; ["Alignment of mrb_irep_catch_handler"] [:: std :: mem :: align_of :: < mrb_irep_catch_handler > () - 1usize] ; ["Offset of field: mrb_irep_catch_handler::type_"] [:: std :: mem :: offset_of ! (mrb_irep_catch_handler , type_) - 0usize] ; ["Offset of field: mrb_irep_catch_handler::begin"] [:: std :: mem :: offset_of ! (mrb_irep_catch_handler , begin) - 1usize] ; ["Offset of field: mrb_irep_catch_handler::end"] [:: std :: mem :: offset_of ! (mrb_irep_catch_handler , end) - 5usize] ; ["Offset of field: mrb_irep_catch_handler::target"] [:: std :: mem :: offset_of ! (mrb_irep_catch_handler , target) - 9usize] ; } ; # [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 , } # [allow (clippy :: unnecessary_operation , clippy :: identity_op)] const _ : () = { ["Size of mrb_irep"] [:: std :: mem :: size_of :: < mrb_irep > () - 72usize] ; ["Alignment of mrb_irep"] [:: std :: mem :: align_of :: < mrb_irep > () - 8usize] ; ["Offset of field: mrb_irep::nlocals"] [:: std :: mem :: offset_of ! (mrb_irep , nlocals) - 0usize] ; ["Offset of field: mrb_irep::nregs"] [:: std :: mem :: offset_of ! (mrb_irep , nregs) - 2usize] ; ["Offset of field: mrb_irep::clen"] [:: std :: mem :: offset_of ! (mrb_irep , clen) - 4usize] ; ["Offset of field: mrb_irep::flags"] [:: std :: mem :: offset_of ! (mrb_irep , flags) - 6usize] ; ["Offset of field: mrb_irep::iseq"] [:: std :: mem :: offset_of ! (mrb_irep , iseq) - 8usize] ; ["Offset of field: mrb_irep::pool"] [:: std :: mem :: offset_of ! (mrb_irep , pool) - 16usize] ; ["Offset of field: mrb_irep::syms"] [:: std :: mem :: offset_of ! (mrb_irep , syms) - 24usize] ; ["Offset of field: mrb_irep::reps"] [:: std :: mem :: offset_of ! (mrb_irep , reps) - 32usize] ; ["Offset of field: mrb_irep::lv"] [:: std :: mem :: offset_of ! (mrb_irep , lv) - 40usize] ; ["Offset of field: mrb_irep::debug_info"] [:: std :: mem :: offset_of ! (mrb_irep , debug_info) - 48usize] ; ["Offset of field: mrb_irep::ilen"] [:: std :: mem :: offset_of ! (mrb_irep , ilen) - 56usize] ; ["Offset of field: mrb_irep::plen"] [:: std :: mem :: offset_of ! (mrb_irep , plen) - 60usize] ; ["Offset of field: mrb_irep::slen"] [:: std :: mem :: offset_of ! (mrb_irep , slen) - 62usize] ; ["Offset of field: mrb_irep::rlen"] [:: std :: mem :: offset_of ! (mrb_irep , rlen) - 64usize] ; ["Offset of field: mrb_irep::refcnt"] [:: std :: mem :: offset_of ! (mrb_irep , refcnt) - 66usize] ; } ; unsafe extern "C-unwind" { pub fn mrb_add_irep (mrb : * mut mrb_state) -> * mut mrb_irep ; } unsafe extern "C-unwind" { pub fn mrb_load_irep (arg1 : * mut mrb_state , arg2 : * const u8) -> mrb_value ; } unsafe extern "C-unwind" { pub fn mrb_load_irep_buf (arg1 : * mut mrb_state , arg2 : * const :: std :: os :: raw :: c_void , arg3 : usize) -> mrb_value ; } unsafe extern "C-unwind" { pub fn mrb_load_irep_cxt (arg1 : * mut mrb_state , arg2 : * const u8 , arg3 : * mut mrbc_context) -> mrb_value ; } unsafe extern "C-unwind" { 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 , } # [allow (clippy :: unnecessary_operation , clippy :: identity_op)] const _ : () = { ["Size of mrb_insn_data"] [:: std :: mem :: size_of :: < mrb_insn_data > () - 24usize] ; ["Alignment of mrb_insn_data"] [:: std :: mem :: align_of :: < mrb_insn_data > () - 8usize] ; ["Offset of field: mrb_insn_data::insn"] [:: std :: mem :: offset_of ! (mrb_insn_data , insn) - 0usize] ; ["Offset of field: mrb_insn_data::a"] [:: std :: mem :: offset_of ! (mrb_insn_data , a) - 4usize] ; ["Offset of field: mrb_insn_data::b"] [:: std :: mem :: offset_of ! (mrb_insn_data , b) - 8usize] ; ["Offset of field: mrb_insn_data::c"] [:: std :: mem :: offset_of ! (mrb_insn_data , c) - 10usize] ; ["Offset of field: mrb_insn_data::addr"] [:: std :: mem :: offset_of ! (mrb_insn_data , addr) - 16usize] ; } ; unsafe extern "C-unwind" { pub fn mrb_irep_incref (arg1 : * mut mrb_state , arg2 : * mut mrb_irep) ; } unsafe extern "C-unwind" { pub fn mrb_irep_decref (arg1 : * mut mrb_state , arg2 : * mut mrb_irep) ; } unsafe extern "C-unwind" { pub fn mrb_irep_cutref (arg1 : * mut mrb_state , arg2 : * mut mrb_irep) ; } unsafe extern "C-unwind" { pub fn mrb_read_irep (arg1 : * mut mrb_state , arg2 : * const u8) -> * mut mrb_irep ; } unsafe extern "C-unwind" { pub fn mrb_read_irep_buf (arg1 : * mut mrb_state , arg2 : * const :: std :: os :: raw :: c_void , arg3 : usize) -> * mut mrb_irep ; } unsafe extern "C-unwind" { pub fn mrb_sys_fail (mrb : * mut mrb_state , mesg : * const :: std :: os :: raw :: c_char) ; } unsafe extern "C-unwind" { pub fn mrb_exc_new_str (mrb : * mut mrb_state , c : * mut RClass , str_ : mrb_value) -> mrb_value ; } unsafe extern "C-unwind" { pub fn mrb_make_exception (mrb : * mut mrb_state , argc : mrb_int , argv : * const mrb_value) -> mrb_value ; } unsafe extern "C-unwind" { pub fn mrb_no_method_error (mrb : * mut mrb_state , id : mrb_sym , args : mrb_value , fmt : * const :: std :: os :: raw :: c_char , ...) ; } unsafe extern "C-unwind" { 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-unwind" fn (mrb : * mut mrb_state , userdata : * mut :: std :: os :: raw :: c_void) -> mrb_value > ; unsafe extern "C-unwind" { 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 ; } unsafe extern "C-unwind" { pub fn mrb_protect (mrb : * mut mrb_state , body : mrb_func_t , data : mrb_value , state : * mut mrb_bool) -> mrb_value ; } unsafe extern "C-unwind" { 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 ; } unsafe extern "C-unwind" { 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 ; } unsafe extern "C-unwind" { 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 , } # [allow (clippy :: unnecessary_operation , clippy :: identity_op)] const _ : () = { ["Size of RHash__bindgen_ty_1"] [:: std :: mem :: size_of :: < RHash__bindgen_ty_1 > () - 8usize] ; ["Alignment of RHash__bindgen_ty_1"] [:: std :: mem :: align_of :: < RHash__bindgen_ty_1 > () - 8usize] ; ["Offset of field: RHash__bindgen_ty_1::ea"] [:: std :: mem :: offset_of ! (RHash__bindgen_ty_1 , ea) - 0usize] ; ["Offset of field: RHash__bindgen_ty_1::ht"] [:: std :: mem :: offset_of ! (RHash__bindgen_ty_1 , ht) - 0usize] ; } ; # [allow (clippy :: unnecessary_operation , clippy :: identity_op)] const _ : () = { ["Size of RHash"] [:: std :: mem :: size_of :: < RHash > () - 48usize] ; ["Alignment of RHash"] [:: std :: mem :: align_of :: < RHash > () - 8usize] ; ["Offset of field: RHash::c"] [:: std :: mem :: offset_of ! (RHash , c) - 0usize] ; ["Offset of field: RHash::gcnext"] [:: std :: mem :: offset_of ! (RHash , gcnext) - 8usize] ; ["Offset of field: RHash::size"] [:: std :: mem :: offset_of ! (RHash , size) - 20usize] ; ["Offset of field: RHash::iv"] [:: std :: mem :: offset_of ! (RHash , iv) - 24usize] ; ["Offset of field: RHash::ea_capa"] [:: std :: mem :: offset_of ! (RHash , ea_capa) - 32usize] ; ["Offset of field: RHash::ea_n_used"] [:: std :: mem :: offset_of ! (RHash , ea_n_used) - 36usize] ; ["Offset of field: RHash::hsh"] [:: std :: mem :: offset_of ! (RHash , hsh) - 40usize] ; } ; 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 unsafe fn tt_raw (this : * const Self) -> mrb_vtype { unsafe { :: std :: mem :: transmute (< __BindgenBitfieldUnit < [u8 ; 4usize] > > :: raw_get (:: std :: ptr :: addr_of ! ((* this) . _bitfield_1) , 0usize , 8u8 ,) as u32) } } # [inline] pub unsafe fn set_tt_raw (this : * mut Self , val : mrb_vtype) { unsafe { let val : u32 = :: std :: mem :: transmute (val) ; < __BindgenBitfieldUnit < [u8 ; 4usize] > > :: raw_set (:: std :: ptr :: addr_of_mut ! ((* this) . _bitfield_1) , 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 unsafe fn color_raw (this : * const Self) -> u32 { unsafe { :: std :: mem :: transmute (< __BindgenBitfieldUnit < [u8 ; 4usize] > > :: raw_get (:: std :: ptr :: addr_of ! ((* this) . _bitfield_1) , 8usize , 3u8 ,) as u32) } } # [inline] pub unsafe fn set_color_raw (this : * mut Self , val : u32) { unsafe { let val : u32 = :: std :: mem :: transmute (val) ; < __BindgenBitfieldUnit < [u8 ; 4usize] > > :: raw_set (:: std :: ptr :: addr_of_mut ! ((* this) . _bitfield_1) , 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 unsafe fn flags_raw (this : * const Self) -> u32 { unsafe { :: std :: mem :: transmute (< __BindgenBitfieldUnit < [u8 ; 4usize] > > :: raw_get (:: std :: ptr :: addr_of ! ((* this) . _bitfield_1) , 11usize , 21u8 ,) as u32) } } # [inline] pub unsafe fn set_flags_raw (this : * mut Self , val : u32) { unsafe { let val : u32 = :: std :: mem :: transmute (val) ; < __BindgenBitfieldUnit < [u8 ; 4usize] > > :: raw_set (:: std :: ptr :: addr_of_mut ! ((* this) . _bitfield_1) , 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 } } unsafe extern "C-unwind" { pub fn mrb_hash_new_capa (mrb : * mut mrb_state , capa : mrb_int) -> mrb_value ; } unsafe extern "C-unwind" { pub fn mrb_hash_new (mrb : * mut mrb_state) -> mrb_value ; } unsafe extern "C-unwind" { pub fn mrb_hash_set (mrb : * mut mrb_state , hash : mrb_value , key : mrb_value , val : mrb_value) ; } unsafe extern "C-unwind" { pub fn mrb_hash_get (mrb : * mut mrb_state , hash : mrb_value , key : mrb_value) -> mrb_value ; } unsafe extern "C-unwind" { pub fn mrb_hash_fetch (mrb : * mut mrb_state , hash : mrb_value , key : mrb_value , def : mrb_value) -> mrb_value ; } unsafe extern "C-unwind" { pub fn mrb_hash_delete_key (mrb : * mut mrb_state , hash : mrb_value , key : mrb_value) -> mrb_value ; } unsafe extern "C-unwind" { pub fn mrb_hash_keys (mrb : * mut mrb_state , hash : mrb_value) -> mrb_value ; } unsafe extern "C-unwind" { pub fn mrb_hash_key_p (mrb : * mut mrb_state , hash : mrb_value , key : mrb_value) -> mrb_bool ; } unsafe extern "C-unwind" { pub fn mrb_hash_empty_p (mrb : * mut mrb_state , self_ : mrb_value) -> mrb_bool ; } unsafe extern "C-unwind" { pub fn mrb_hash_values (mrb : * mut mrb_state , hash : mrb_value) -> mrb_value ; } unsafe extern "C-unwind" { pub fn mrb_hash_clear (mrb : * mut mrb_state , hash : mrb_value) -> mrb_value ; } unsafe extern "C-unwind" { pub fn mrb_hash_size (mrb : * mut mrb_state , hash : mrb_value) -> mrb_int ; } unsafe extern "C-unwind" { pub fn mrb_hash_dup (mrb : * mut mrb_state , hash : mrb_value) -> mrb_value ; } unsafe extern "C-unwind" { 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-unwind" fn (mrb : * mut mrb_state , key : mrb_value , val : mrb_value , data : * mut :: std :: os :: raw :: c_void) -> :: std :: os :: raw :: c_int > ; unsafe extern "C-unwind" { pub fn mrb_hash_foreach (mrb : * mut mrb_state , hash : * mut RHash , func : mrb_hash_foreach_func , p : * mut :: std :: os :: raw :: c_void) ; } unsafe extern "C-unwind" { pub fn mrb_num_add (mrb : * mut mrb_state , x : mrb_value , y : mrb_value) -> mrb_value ; } unsafe extern "C-unwind" { pub fn mrb_num_sub (mrb : * mut mrb_state , x : mrb_value , y : mrb_value) -> mrb_value ; } unsafe extern "C-unwind" { pub fn mrb_num_mul (mrb : * mut mrb_state , x : mrb_value , y : mrb_value) -> mrb_value ; } unsafe extern "C-unwind" { pub fn mrb_integer_to_str (mrb : * mut mrb_state , x : mrb_value , base : mrb_int) -> mrb_value ; } unsafe extern "C-unwind" { 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 ; } unsafe extern "C-unwind" { pub fn mrb_float_to_integer (mrb : * mut mrb_state , val : mrb_value) -> mrb_value ; } unsafe extern "C-unwind" { pub fn mrb_div_float (x : mrb_float , y : mrb_float) -> mrb_float ; } unsafe extern "C-unwind" { pub fn mrb_float_to_str (mrb : * mut mrb_state , x : mrb_value , fmt : * const :: std :: os :: raw :: c_char) -> mrb_value ; } unsafe extern "C-unwind" { 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 , } # [allow (clippy :: unnecessary_operation , clippy :: identity_op)] const _ : () = { ["Size of REnv"] [:: std :: mem :: size_of :: < REnv > () - 48usize] ; ["Alignment of REnv"] [:: std :: mem :: align_of :: < REnv > () - 8usize] ; ["Offset of field: REnv::c"] [:: std :: mem :: offset_of ! (REnv , c) - 0usize] ; ["Offset of field: REnv::gcnext"] [:: std :: mem :: offset_of ! (REnv , gcnext) - 8usize] ; ["Offset of field: REnv::stack"] [:: std :: mem :: offset_of ! (REnv , stack) - 24usize] ; ["Offset of field: REnv::cxt"] [:: std :: mem :: offset_of ! (REnv , cxt) - 32usize] ; ["Offset of field: REnv::mid"] [:: std :: mem :: offset_of ! (REnv , mid) - 40usize] ; } ; 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 unsafe fn tt_raw (this : * const Self) -> mrb_vtype { unsafe { :: std :: mem :: transmute (< __BindgenBitfieldUnit < [u8 ; 4usize] > > :: raw_get (:: std :: ptr :: addr_of ! ((* this) . _bitfield_1) , 0usize , 8u8 ,) as u32) } } # [inline] pub unsafe fn set_tt_raw (this : * mut Self , val : mrb_vtype) { unsafe { let val : u32 = :: std :: mem :: transmute (val) ; < __BindgenBitfieldUnit < [u8 ; 4usize] > > :: raw_set (:: std :: ptr :: addr_of_mut ! ((* this) . _bitfield_1) , 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 unsafe fn color_raw (this : * const Self) -> u32 { unsafe { :: std :: mem :: transmute (< __BindgenBitfieldUnit < [u8 ; 4usize] > > :: raw_get (:: std :: ptr :: addr_of ! ((* this) . _bitfield_1) , 8usize , 3u8 ,) as u32) } } # [inline] pub unsafe fn set_color_raw (this : * mut Self , val : u32) { unsafe { let val : u32 = :: std :: mem :: transmute (val) ; < __BindgenBitfieldUnit < [u8 ; 4usize] > > :: raw_set (:: std :: ptr :: addr_of_mut ! ((* this) . _bitfield_1) , 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 unsafe fn flags_raw (this : * const Self) -> u32 { unsafe { :: std :: mem :: transmute (< __BindgenBitfieldUnit < [u8 ; 4usize] > > :: raw_get (:: std :: ptr :: addr_of ! ((* this) . _bitfield_1) , 11usize , 21u8 ,) as u32) } } # [inline] pub unsafe fn set_flags_raw (this : * mut Self , val : u32) { unsafe { let val : u32 = :: std :: mem :: transmute (val) ; < __BindgenBitfieldUnit < [u8 ; 4usize] > > :: raw_set (:: std :: ptr :: addr_of_mut ! ((* this) . _bitfield_1) , 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 } } unsafe extern "C-unwind" { 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 , } # [allow (clippy :: unnecessary_operation , clippy :: identity_op)] const _ : () = { ["Size of RProc__bindgen_ty_1"] [:: std :: mem :: size_of :: < RProc__bindgen_ty_1 > () - 8usize] ; ["Alignment of RProc__bindgen_ty_1"] [:: std :: mem :: align_of :: < RProc__bindgen_ty_1 > () - 8usize] ; ["Offset of field: RProc__bindgen_ty_1::irep"] [:: std :: mem :: offset_of ! (RProc__bindgen_ty_1 , irep) - 0usize] ; ["Offset of field: RProc__bindgen_ty_1::func"] [:: std :: mem :: offset_of ! (RProc__bindgen_ty_1 , func) - 0usize] ; } ; # [repr (C)] # [derive (Copy , Clone)] pub union RProc__bindgen_ty_2 { pub target_class : * mut RClass , pub env : * mut REnv , } # [allow (clippy :: unnecessary_operation , clippy :: identity_op)] const _ : () = { ["Size of RProc__bindgen_ty_2"] [:: std :: mem :: size_of :: < RProc__bindgen_ty_2 > () - 8usize] ; ["Alignment of RProc__bindgen_ty_2"] [:: std :: mem :: align_of :: < RProc__bindgen_ty_2 > () - 8usize] ; ["Offset of field: RProc__bindgen_ty_2::target_class"] [:: std :: mem :: offset_of ! (RProc__bindgen_ty_2 , target_class) - 0usize] ; ["Offset of field: RProc__bindgen_ty_2::env"] [:: std :: mem :: offset_of ! (RProc__bindgen_ty_2 , env) - 0usize] ; } ; # [allow (clippy :: unnecessary_operation , clippy :: identity_op)] const _ : () = { ["Size of RProc"] [:: std :: mem :: size_of :: < RProc > () - 48usize] ; ["Alignment of RProc"] [:: std :: mem :: align_of :: < RProc > () - 8usize] ; ["Offset of field: RProc::c"] [:: std :: mem :: offset_of ! (RProc , c) - 0usize] ; ["Offset of field: RProc::gcnext"] [:: std :: mem :: offset_of ! (RProc , gcnext) - 8usize] ; ["Offset of field: RProc::body"] [:: std :: mem :: offset_of ! (RProc , body) - 24usize] ; ["Offset of field: RProc::upper"] [:: std :: mem :: offset_of ! (RProc , upper) - 32usize] ; ["Offset of field: RProc::e"] [:: std :: mem :: offset_of ! (RProc , e) - 40usize] ; } ; 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 unsafe fn tt_raw (this : * const Self) -> mrb_vtype { unsafe { :: std :: mem :: transmute (< __BindgenBitfieldUnit < [u8 ; 4usize] > > :: raw_get (:: std :: ptr :: addr_of ! ((* this) . _bitfield_1) , 0usize , 8u8 ,) as u32) } } # [inline] pub unsafe fn set_tt_raw (this : * mut Self , val : mrb_vtype) { unsafe { let val : u32 = :: std :: mem :: transmute (val) ; < __BindgenBitfieldUnit < [u8 ; 4usize] > > :: raw_set (:: std :: ptr :: addr_of_mut ! ((* this) . _bitfield_1) , 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 unsafe fn color_raw (this : * const Self) -> u32 { unsafe { :: std :: mem :: transmute (< __BindgenBitfieldUnit < [u8 ; 4usize] > > :: raw_get (:: std :: ptr :: addr_of ! ((* this) . _bitfield_1) , 8usize , 3u8 ,) as u32) } } # [inline] pub unsafe fn set_color_raw (this : * mut Self , val : u32) { unsafe { let val : u32 = :: std :: mem :: transmute (val) ; < __BindgenBitfieldUnit < [u8 ; 4usize] > > :: raw_set (:: std :: ptr :: addr_of_mut ! ((* this) . _bitfield_1) , 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 unsafe fn flags_raw (this : * const Self) -> u32 { unsafe { :: std :: mem :: transmute (< __BindgenBitfieldUnit < [u8 ; 4usize] > > :: raw_get (:: std :: ptr :: addr_of ! ((* this) . _bitfield_1) , 11usize , 21u8 ,) as u32) } } # [inline] pub unsafe fn set_flags_raw (this : * mut Self , val : u32) { unsafe { let val : u32 = :: std :: mem :: transmute (val) ; < __BindgenBitfieldUnit < [u8 ; 4usize] > > :: raw_set (:: std :: ptr :: addr_of_mut ! ((* this) . _bitfield_1) , 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 } } unsafe extern "C-unwind" { pub fn mrb_proc_new (arg1 : * mut mrb_state , arg2 : * const mrb_irep) -> * mut RProc ; } unsafe extern "C-unwind" { pub fn mrb_proc_new_cfunc (arg1 : * mut mrb_state , arg2 : mrb_func_t) -> * mut RProc ; } unsafe extern "C-unwind" { pub fn mrb_closure_new_cfunc (mrb : * mut mrb_state , func : mrb_func_t , nlocals : :: std :: os :: raw :: c_int) -> * mut RProc ; } unsafe extern "C-unwind" { 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 ; } unsafe extern "C-unwind" { pub fn mrb_proc_cfunc_env_get (mrb : * mut mrb_state , idx : mrb_int) -> mrb_value ; } unsafe extern "C-unwind" { pub fn mrb_load_proc (mrb : * mut mrb_state , proc_ : * const RProc) -> mrb_value ; } unsafe extern "C-unwind" { pub fn mrb_vm_ci_proc_set (ci : * mut mrb_callinfo , p : * const RProc) ; } unsafe extern "C-unwind" { pub fn mrb_vm_ci_target_class (ci : * const mrb_callinfo) -> * mut RClass ; } unsafe extern "C-unwind" { pub fn mrb_vm_ci_target_class_set (ci : * mut mrb_callinfo , tc : * mut RClass) ; } unsafe extern "C-unwind" { pub fn mrb_vm_ci_env (ci : * const mrb_callinfo) -> * mut REnv ; } unsafe extern "C-unwind" { 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 , } # [allow (clippy :: unnecessary_operation , clippy :: identity_op)] const _ : () = { ["Size of mrb_range_edges"] [:: std :: mem :: size_of :: < mrb_range_edges > () - 32usize] ; ["Alignment of mrb_range_edges"] [:: std :: mem :: align_of :: < mrb_range_edges > () - 8usize] ; ["Offset of field: mrb_range_edges::beg"] [:: std :: mem :: offset_of ! (mrb_range_edges , beg) - 0usize] ; ["Offset of field: mrb_range_edges::end"] [:: std :: mem :: offset_of ! (mrb_range_edges , end) - 16usize] ; } ; # [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 , } # [allow (clippy :: unnecessary_operation , clippy :: identity_op)] const _ : () = { ["Size of RRange"] [:: std :: mem :: size_of :: < RRange > () - 40usize] ; ["Alignment of RRange"] [:: std :: mem :: align_of :: < RRange > () - 8usize] ; ["Offset of field: RRange::c"] [:: std :: mem :: offset_of ! (RRange , c) - 0usize] ; ["Offset of field: RRange::gcnext"] [:: std :: mem :: offset_of ! (RRange , gcnext) - 8usize] ; ["Offset of field: RRange::edges"] [:: std :: mem :: offset_of ! (RRange , edges) - 24usize] ; ["Offset of field: RRange::excl"] [:: std :: mem :: offset_of ! (RRange , excl) - 32usize] ; } ; 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 unsafe fn tt_raw (this : * const Self) -> mrb_vtype { unsafe { :: std :: mem :: transmute (< __BindgenBitfieldUnit < [u8 ; 4usize] > > :: raw_get (:: std :: ptr :: addr_of ! ((* this) . _bitfield_1) , 0usize , 8u8 ,) as u32) } } # [inline] pub unsafe fn set_tt_raw (this : * mut Self , val : mrb_vtype) { unsafe { let val : u32 = :: std :: mem :: transmute (val) ; < __BindgenBitfieldUnit < [u8 ; 4usize] > > :: raw_set (:: std :: ptr :: addr_of_mut ! ((* this) . _bitfield_1) , 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 unsafe fn color_raw (this : * const Self) -> u32 { unsafe { :: std :: mem :: transmute (< __BindgenBitfieldUnit < [u8 ; 4usize] > > :: raw_get (:: std :: ptr :: addr_of ! ((* this) . _bitfield_1) , 8usize , 3u8 ,) as u32) } } # [inline] pub unsafe fn set_color_raw (this : * mut Self , val : u32) { unsafe { let val : u32 = :: std :: mem :: transmute (val) ; < __BindgenBitfieldUnit < [u8 ; 4usize] > > :: raw_set (:: std :: ptr :: addr_of_mut ! ((* this) . _bitfield_1) , 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 unsafe fn flags_raw (this : * const Self) -> u32 { unsafe { :: std :: mem :: transmute (< __BindgenBitfieldUnit < [u8 ; 4usize] > > :: raw_get (:: std :: ptr :: addr_of ! ((* this) . _bitfield_1) , 11usize , 21u8 ,) as u32) } } # [inline] pub unsafe fn set_flags_raw (this : * mut Self , val : u32) { unsafe { let val : u32 = :: std :: mem :: transmute (val) ; < __BindgenBitfieldUnit < [u8 ; 4usize] > > :: raw_set (:: std :: ptr :: addr_of_mut ! ((* this) . _bitfield_1) , 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 } } unsafe extern "C-unwind" { pub fn mrb_range_ptr (mrb : * mut mrb_state , range : mrb_value) -> * mut RRange ; } unsafe extern "C-unwind" { 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 , } unsafe extern "C-unwind" { 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 ; } unsafe 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 , } # [allow (clippy :: unnecessary_operation , clippy :: identity_op)] const _ : () = { ["Size of RString__bindgen_ty_1__bindgen_ty_1__bindgen_ty_1"] [:: std :: mem :: size_of :: < RString__bindgen_ty_1__bindgen_ty_1__bindgen_ty_1 > () - 8usize] ; ["Alignment of RString__bindgen_ty_1__bindgen_ty_1__bindgen_ty_1"] [:: std :: mem :: align_of :: < RString__bindgen_ty_1__bindgen_ty_1__bindgen_ty_1 > () - 8usize] ; ["Offset of field: RString__bindgen_ty_1__bindgen_ty_1__bindgen_ty_1::capa"] [:: std :: mem :: offset_of ! (RString__bindgen_ty_1__bindgen_ty_1__bindgen_ty_1 , capa) - 0usize] ; ["Offset of field: RString__bindgen_ty_1__bindgen_ty_1__bindgen_ty_1::shared"] [:: std :: mem :: offset_of ! (RString__bindgen_ty_1__bindgen_ty_1__bindgen_ty_1 , shared) - 0usize] ; ["Offset of field: RString__bindgen_ty_1__bindgen_ty_1__bindgen_ty_1::fshared"] [:: std :: mem :: offset_of ! (RString__bindgen_ty_1__bindgen_ty_1__bindgen_ty_1 , fshared) - 0usize] ; } ; # [allow (clippy :: unnecessary_operation , clippy :: identity_op)] const _ : () = { ["Size of RString__bindgen_ty_1__bindgen_ty_1"] [:: std :: mem :: size_of :: < RString__bindgen_ty_1__bindgen_ty_1 > () - 24usize] ; ["Alignment of RString__bindgen_ty_1__bindgen_ty_1"] [:: std :: mem :: align_of :: < RString__bindgen_ty_1__bindgen_ty_1 > () - 8usize] ; ["Offset of field: RString__bindgen_ty_1__bindgen_ty_1::len"] [:: std :: mem :: offset_of ! (RString__bindgen_ty_1__bindgen_ty_1 , len) - 0usize] ; ["Offset of field: RString__bindgen_ty_1__bindgen_ty_1::aux"] [:: std :: mem :: offset_of ! (RString__bindgen_ty_1__bindgen_ty_1 , aux) - 8usize] ; ["Offset of field: RString__bindgen_ty_1__bindgen_ty_1::ptr"] [:: std :: mem :: offset_of ! (RString__bindgen_ty_1__bindgen_ty_1 , ptr) - 16usize] ; } ; # [allow (clippy :: unnecessary_operation , clippy :: identity_op)] const _ : () = { ["Size of RString__bindgen_ty_1"] [:: std :: mem :: size_of :: < RString__bindgen_ty_1 > () - 24usize] ; ["Alignment of RString__bindgen_ty_1"] [:: std :: mem :: align_of :: < RString__bindgen_ty_1 > () - 8usize] ; ["Offset of field: RString__bindgen_ty_1::heap"] [:: std :: mem :: offset_of ! (RString__bindgen_ty_1 , heap) - 0usize] ; } ; # [allow (clippy :: unnecessary_operation , clippy :: identity_op)] const _ : () = { ["Size of RString"] [:: std :: mem :: size_of :: < RString > () - 48usize] ; ["Alignment of RString"] [:: std :: mem :: align_of :: < RString > () - 8usize] ; ["Offset of field: RString::c"] [:: std :: mem :: offset_of ! (RString , c) - 0usize] ; ["Offset of field: RString::gcnext"] [:: std :: mem :: offset_of ! (RString , gcnext) - 8usize] ; ["Offset of field: RString::as_"] [:: std :: mem :: offset_of ! (RString , as_) - 24usize] ; } ; 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 unsafe fn tt_raw (this : * const Self) -> mrb_vtype { unsafe { :: std :: mem :: transmute (< __BindgenBitfieldUnit < [u8 ; 4usize] > > :: raw_get (:: std :: ptr :: addr_of ! ((* this) . _bitfield_1) , 0usize , 8u8 ,) as u32) } } # [inline] pub unsafe fn set_tt_raw (this : * mut Self , val : mrb_vtype) { unsafe { let val : u32 = :: std :: mem :: transmute (val) ; < __BindgenBitfieldUnit < [u8 ; 4usize] > > :: raw_set (:: std :: ptr :: addr_of_mut ! ((* this) . _bitfield_1) , 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 unsafe fn color_raw (this : * const Self) -> u32 { unsafe { :: std :: mem :: transmute (< __BindgenBitfieldUnit < [u8 ; 4usize] > > :: raw_get (:: std :: ptr :: addr_of ! ((* this) . _bitfield_1) , 8usize , 3u8 ,) as u32) } } # [inline] pub unsafe fn set_color_raw (this : * mut Self , val : u32) { unsafe { let val : u32 = :: std :: mem :: transmute (val) ; < __BindgenBitfieldUnit < [u8 ; 4usize] > > :: raw_set (:: std :: ptr :: addr_of_mut ! ((* this) . _bitfield_1) , 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 unsafe fn flags_raw (this : * const Self) -> u32 { unsafe { :: std :: mem :: transmute (< __BindgenBitfieldUnit < [u8 ; 4usize] > > :: raw_get (:: std :: ptr :: addr_of ! ((* this) . _bitfield_1) , 11usize , 21u8 ,) as u32) } } # [inline] pub unsafe fn set_flags_raw (this : * mut Self , val : u32) { unsafe { let val : u32 = :: std :: mem :: transmute (val) ; < __BindgenBitfieldUnit < [u8 ; 4usize] > > :: raw_set (:: std :: ptr :: addr_of_mut ! ((* this) . _bitfield_1) , 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 } } unsafe extern "C-unwind" { pub fn mrb_str_modify (mrb : * mut mrb_state , s : * mut RString) ; } unsafe extern "C-unwind" { pub fn mrb_str_modify_keep_ascii (mrb : * mut mrb_state , s : * mut RString) ; } unsafe extern "C-unwind" { 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 ; } unsafe extern "C-unwind" { pub fn mrb_str_concat (mrb : * mut mrb_state , self_ : mrb_value , other : mrb_value) ; } unsafe extern "C-unwind" { pub fn mrb_str_plus (mrb : * mut mrb_state , a : mrb_value , b : mrb_value) -> mrb_value ; } unsafe extern "C-unwind" { pub fn mrb_ptr_to_str (mrb : * mut mrb_state , p : * mut :: std :: os :: raw :: c_void) -> mrb_value ; } unsafe extern "C-unwind" { pub fn mrb_obj_as_string (mrb : * mut mrb_state , obj : mrb_value) -> mrb_value ; } unsafe extern "C-unwind" { pub fn mrb_str_resize (mrb : * mut mrb_state , str_ : mrb_value , len : mrb_int) -> mrb_value ; } unsafe extern "C-unwind" { pub fn mrb_str_substr (mrb : * mut mrb_state , str_ : mrb_value , beg : mrb_int , len : mrb_int) -> mrb_value ; } unsafe extern "C-unwind" { pub fn mrb_str_new_capa (mrb : * mut mrb_state , capa : mrb_int) -> mrb_value ; } unsafe extern "C-unwind" { pub fn mrb_string_cstr (mrb : * mut mrb_state , str_ : mrb_value) -> * const :: std :: os :: raw :: c_char ; } unsafe extern "C-unwind" { pub fn mrb_string_value_cstr (mrb : * mut mrb_state , str_ : * mut mrb_value) -> * const :: std :: os :: raw :: c_char ; } unsafe extern "C-unwind" { pub fn mrb_str_dup (mrb : * mut mrb_state , str_ : mrb_value) -> mrb_value ; } unsafe extern "C-unwind" { pub fn mrb_str_intern (mrb : * mut mrb_state , self_ : mrb_value) -> mrb_value ; } unsafe extern "C-unwind" { pub fn mrb_str_to_integer (mrb : * mut mrb_state , str_ : mrb_value , base : mrb_int , badcheck : mrb_bool) -> mrb_value ; } unsafe extern "C-unwind" { pub fn mrb_str_to_dbl (mrb : * mut mrb_state , str_ : mrb_value , badcheck : mrb_bool) -> f64 ; } unsafe extern "C-unwind" { pub fn mrb_str_equal (mrb : * mut mrb_state , str1 : mrb_value , str2 : mrb_value) -> mrb_bool ; } unsafe extern "C-unwind" { pub fn mrb_str_cat (mrb : * mut mrb_state , str_ : mrb_value , ptr : * const :: std :: os :: raw :: c_char , len : usize) -> mrb_value ; } unsafe extern "C-unwind" { pub fn mrb_str_cat_cstr (mrb : * mut mrb_state , str_ : mrb_value , ptr : * const :: std :: os :: raw :: c_char) -> mrb_value ; } unsafe extern "C-unwind" { pub fn mrb_str_cat_str (mrb : * mut mrb_state , str_ : mrb_value , str2 : mrb_value) -> mrb_value ; } unsafe extern "C-unwind" { pub fn mrb_str_append (mrb : * mut mrb_state , str_ : mrb_value , str2 : mrb_value) -> mrb_value ; } unsafe extern "C-unwind" { pub fn mrb_str_cmp (mrb : * mut mrb_state , str1 : mrb_value , str2 : mrb_value) -> :: std :: os :: raw :: c_int ; } unsafe extern "C-unwind" { 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 , } # [allow (clippy :: unnecessary_operation , clippy :: identity_op)] const _ : () = { ["Size of __jmp_buf_tag"] [:: std :: mem :: size_of :: < __jmp_buf_tag > () - 200usize] ; ["Alignment of __jmp_buf_tag"] [:: std :: mem :: align_of :: < __jmp_buf_tag > () - 8usize] ; ["Offset of field: __jmp_buf_tag::__jmpbuf"] [:: std :: mem :: offset_of ! (__jmp_buf_tag , __jmpbuf) - 0usize] ; ["Offset of field: __jmp_buf_tag::__mask_was_saved"] [:: std :: mem :: offset_of ! (__jmp_buf_tag , __mask_was_saved) - 64usize] ; ["Offset of field: __jmp_buf_tag::__saved_mask"] [:: std :: mem :: offset_of ! (__jmp_buf_tag , __saved_mask) - 72usize] ; } ; pub type jmp_buf = [__jmp_buf_tag ; 1usize] ; # [repr (C)] # [derive (Debug , Copy , Clone)] pub struct mrb_jmpbuf { pub impl_ : jmp_buf , } # [allow (clippy :: unnecessary_operation , clippy :: identity_op)] const _ : () = { ["Size of mrb_jmpbuf"] [:: std :: mem :: size_of :: < mrb_jmpbuf > () - 200usize] ; ["Alignment of mrb_jmpbuf"] [:: std :: mem :: align_of :: < mrb_jmpbuf > () - 8usize] ; ["Offset of field: mrb_jmpbuf::impl_"] [:: std :: mem :: offset_of ! (mrb_jmpbuf , impl_) - 0usize] ; } ; unsafe extern "C-unwind" { pub fn mrb_const_get (arg1 : * mut mrb_state , arg2 : mrb_value , arg3 : mrb_sym) -> mrb_value ; } unsafe extern "C-unwind" { pub fn mrb_const_set (arg1 : * mut mrb_state , arg2 : mrb_value , arg3 : mrb_sym , arg4 : mrb_value) ; } unsafe extern "C-unwind" { pub fn mrb_const_defined (arg1 : * mut mrb_state , arg2 : mrb_value , arg3 : mrb_sym) -> mrb_bool ; } unsafe extern "C-unwind" { pub fn mrb_const_remove (arg1 : * mut mrb_state , arg2 : mrb_value , arg3 : mrb_sym) ; } unsafe extern "C-unwind" { pub fn mrb_iv_name_sym_p (mrb : * mut mrb_state , sym : mrb_sym) -> mrb_bool ; } unsafe extern "C-unwind" { pub fn mrb_iv_name_sym_check (mrb : * mut mrb_state , sym : mrb_sym) ; } unsafe extern "C-unwind" { pub fn mrb_obj_iv_get (mrb : * mut mrb_state , obj : * mut RObject , sym : mrb_sym) -> mrb_value ; } unsafe extern "C-unwind" { pub fn mrb_obj_iv_set (mrb : * mut mrb_state , obj : * mut RObject , sym : mrb_sym , v : mrb_value) ; } unsafe extern "C-unwind" { pub fn mrb_obj_iv_defined (mrb : * mut mrb_state , obj : * mut RObject , sym : mrb_sym) -> mrb_bool ; } unsafe extern "C-unwind" { pub fn mrb_iv_get (mrb : * mut mrb_state , obj : mrb_value , sym : mrb_sym) -> mrb_value ; } unsafe extern "C-unwind" { pub fn mrb_iv_set (mrb : * mut mrb_state , obj : mrb_value , sym : mrb_sym , v : mrb_value) ; } unsafe extern "C-unwind" { pub fn mrb_iv_defined (arg1 : * mut mrb_state , arg2 : mrb_value , arg3 : mrb_sym) -> mrb_bool ; } unsafe extern "C-unwind" { pub fn mrb_iv_remove (mrb : * mut mrb_state , obj : mrb_value , sym : mrb_sym) -> mrb_value ; } unsafe extern "C-unwind" { pub fn mrb_iv_copy (mrb : * mut mrb_state , dst : mrb_value , src : mrb_value) ; } unsafe extern "C-unwind" { pub fn mrb_const_defined_at (mrb : * mut mrb_state , mod_ : mrb_value , id : mrb_sym) -> mrb_bool ; } unsafe extern "C-unwind" { pub fn mrb_gv_get (mrb : * mut mrb_state , sym : mrb_sym) -> mrb_value ; } unsafe extern "C-unwind" { pub fn mrb_gv_set (mrb : * mut mrb_state , sym : mrb_sym , val : mrb_value) ; } unsafe extern "C-unwind" { pub fn mrb_gv_remove (mrb : * mut mrb_state , sym : mrb_sym) ; } unsafe extern "C-unwind" { pub fn mrb_cv_get (mrb : * mut mrb_state , mod_ : mrb_value , sym : mrb_sym) -> mrb_value ; } unsafe extern "C-unwind" { pub fn mrb_mod_cv_set (mrb : * mut mrb_state , c : * mut RClass , sym : mrb_sym , v : mrb_value) ; } unsafe extern "C-unwind" { pub fn mrb_cv_set (mrb : * mut mrb_state , mod_ : mrb_value , sym : mrb_sym , v : mrb_value) ; } unsafe extern "C-unwind" { 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-unwind" fn (arg1 : * mut mrb_state , arg2 : mrb_sym , arg3 : mrb_value , arg4 : * mut :: std :: os :: raw :: c_void) -> :: std :: os :: raw :: c_int > ; unsafe extern "C-unwind" { pub fn mrb_iv_foreach (mrb : * mut mrb_state , obj : mrb_value , func : mrb_iv_foreach_func , p : * mut :: std :: os :: raw :: c_void) ; } unsafe extern "C-unwind" { pub fn mrb_sys_value_has_method (mrb : * mut mrb_state , value : mrb_value , method : mrb_sym) -> bool ; } unsafe extern "C-unwind" { pub fn mrb_sys_value_is_nil (value : mrb_value) -> bool ; } unsafe extern "C-unwind" { pub fn mrb_sys_value_is_false (value : mrb_value) -> bool ; } unsafe extern "C-unwind" { pub fn mrb_sys_value_is_true (value : mrb_value) -> bool ; } unsafe extern "C-unwind" { pub fn mrb_sys_range_excl (mrb : * mut mrb_state , value : mrb_value) -> bool ; } unsafe extern "C-unwind" { pub fn mrb_sys_obj_frozen (mrb : * mut mrb_state , value : mrb_value) -> bool ; } unsafe extern "C-unwind" { pub fn mrb_sys_fixnum_to_cint (value : mrb_value) -> mrb_int ; } unsafe extern "C-unwind" { pub fn mrb_sys_float_to_cdouble (value : mrb_value) -> mrb_float ; } unsafe extern "C-unwind" { pub fn mrb_sys_cptr_ptr (value : mrb_value) -> * mut :: std :: os :: raw :: c_void ; } unsafe extern "C-unwind" { pub fn mrb_sys_basic_ptr (value : mrb_value) -> * mut RBasic ; } unsafe extern "C-unwind" { pub fn mrb_sys_obj_ptr (value : mrb_value) -> * mut RObject ; } unsafe extern "C-unwind" { pub fn mrb_sys_proc_ptr (value : mrb_value) -> * mut RProc ; } unsafe extern "C-unwind" { pub fn mrb_sys_class_ptr (value : mrb_value) -> * mut RClass ; } unsafe extern "C-unwind" { pub fn mrb_sys_class_to_rclass (value : mrb_value) -> * mut RClass ; } unsafe extern "C-unwind" { pub fn mrb_sys_class_of_value (mrb : * mut mrb_state , value : mrb_value) -> * mut RClass ; } unsafe extern "C-unwind" { pub fn mrb_sys_nil_value () -> mrb_value ; } unsafe extern "C-unwind" { pub fn mrb_sys_false_value () -> mrb_value ; } unsafe extern "C-unwind" { pub fn mrb_sys_true_value () -> mrb_value ; } unsafe extern "C-unwind" { pub fn mrb_sys_fixnum_value (value : mrb_int) -> mrb_value ; } unsafe extern "C-unwind" { pub fn mrb_sys_float_value (mrb : * mut mrb_state , value : mrb_float) -> mrb_value ; } unsafe extern "C-unwind" { pub fn mrb_sys_cptr_value (mrb : * mut mrb_state , ptr : * mut :: std :: os :: raw :: c_void) -> mrb_value ; } unsafe extern "C-unwind" { pub fn mrb_sys_obj_value (p : * mut :: std :: os :: raw :: c_void) -> mrb_value ; } unsafe extern "C-unwind" { pub fn mrb_sys_class_value (klass : * mut RClass) -> mrb_value ; } unsafe extern "C-unwind" { pub fn mrb_sys_module_value (module : * mut RClass) -> mrb_value ; } unsafe extern "C-unwind" { pub fn mrb_sys_data_value (data : * mut RData) -> mrb_value ; } unsafe extern "C-unwind" { pub fn mrb_sys_proc_value (mrb : * mut mrb_state , proc_ : * mut RProc) -> mrb_value ; } unsafe extern "C-unwind" { pub fn mrb_sys_new_symbol (id : mrb_sym) -> mrb_value ; } unsafe extern "C-unwind" { pub fn mrb_sys_set_instance_tt (klass : * mut RClass , type_ : mrb_vtype) ; } unsafe extern "C-unwind" { pub fn mrb_sys_data_init (value : * mut mrb_value , ptr : * mut :: std :: os :: raw :: c_void , type_ : * const mrb_data_type) ; } unsafe extern "C-unwind" { pub fn mrb_sys_raise (mrb : * mut mrb_state , eklass : * const :: std :: os :: raw :: c_char , msg : * const :: std :: os :: raw :: c_char) ; } unsafe extern "C-unwind" { pub fn mrb_sys_raise_current_exception (mrb : * mut mrb_state) ; } unsafe extern "C-unwind" { pub fn mrb_sys_alloc_rarray (mrb : * mut mrb_state , ptr : * mut mrb_value , len : mrb_int , capa : mrb_int) -> mrb_value ; } unsafe extern "C-unwind" { pub fn mrb_sys_repack_into_rarray (ptr : * mut mrb_value , len : mrb_int , capa : mrb_int , into : mrb_value) ; } unsafe extern "C-unwind" { 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 ; } unsafe extern "C-unwind" { 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 ; } unsafe extern "C-unwind" { pub fn mrb_sys_gc_arena_save (mrb : * mut mrb_state) -> :: std :: os :: raw :: c_int ; } unsafe extern "C-unwind" { pub fn mrb_sys_gc_arena_restore (mrb : * mut mrb_state , arena_index : :: std :: os :: raw :: c_int) ; } unsafe extern "C-unwind" { pub fn mrb_sys_gc_disable (mrb : * mut mrb_state) -> bool ; } unsafe extern "C-unwind" { pub fn mrb_sys_gc_enable (mrb : * mut mrb_state) -> bool ; } unsafe extern "C-unwind" { pub fn mrb_sys_value_is_dead (_mrb : * mut mrb_state , value : mrb_value) -> bool ; } unsafe extern "C-unwind" { pub fn mrb_sys_gc_live_objects (mrb : * mut mrb_state) -> usize ; } unsafe extern "C-unwind" { pub fn mrb_sys_safe_gc_mark (mrb : * mut mrb_state , value : mrb_value) ; } unsafe extern "C-unwind" { 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 , } # [allow (clippy :: unnecessary_operation , clippy :: identity_op)] const _ : () = { ["Size of __va_list_tag"] [:: std :: mem :: size_of :: < __va_list_tag > () - 24usize] ; ["Alignment of __va_list_tag"] [:: std :: mem :: align_of :: < __va_list_tag > () - 8usize] ; ["Offset of field: __va_list_tag::gp_offset"] [:: std :: mem :: offset_of ! (__va_list_tag , gp_offset) - 0usize] ; ["Offset of field: __va_list_tag::fp_offset"] [:: std :: mem :: offset_of ! (__va_list_tag , fp_offset) - 4usize] ; ["Offset of field: __va_list_tag::overflow_arg_area"] [:: std :: mem :: offset_of ! (__va_list_tag , overflow_arg_area) - 8usize] ; ["Offset of field: __va_list_tag::reg_save_area"] [:: std :: mem :: offset_of ! (__va_list_tag , reg_save_area) - 16usize] ; } ; # [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 , }