1 #![allow(
2 dead_code,
3 non_snake_case,
4 non_camel_case_types,
5 non_upper_case_globals
6 )]
7 #![cfg(not(target_os = "windows"))]
8
9 #[repr(C)]
10 #[derive(Copy, Clone, Debug, Default, Eq, Hash, Ord, PartialEq, PartialOrd)]
11 pub struct __BindgenBitfieldUnit<Storage> {
12 storage: Storage,
13 }
14 impl<Storage> __BindgenBitfieldUnit<Storage> {
15 #[inline]
new(storage: Storage) -> Self16 pub const fn new(storage: Storage) -> Self {
17 Self { storage }
18 }
19 }
20 impl<Storage> __BindgenBitfieldUnit<Storage>
21 where
22 Storage: AsRef<[u8]> + AsMut<[u8]>,
23 {
24 #[inline]
get_bit(&self, index: usize) -> bool25 pub fn get_bit(&self, index: usize) -> bool {
26 debug_assert!(index / 8 < self.storage.as_ref().len());
27 let byte_index = index / 8;
28 let byte = self.storage.as_ref()[byte_index];
29 let bit_index = if cfg!(target_endian = "big") {
30 7 - (index % 8)
31 } else {
32 index % 8
33 };
34 let mask = 1 << bit_index;
35 byte & mask == mask
36 }
37 #[inline]
set_bit(&mut self, index: usize, val: bool)38 pub fn set_bit(&mut self, index: usize, val: bool) {
39 debug_assert!(index / 8 < self.storage.as_ref().len());
40 let byte_index = index / 8;
41 let byte = &mut self.storage.as_mut()[byte_index];
42 let bit_index = if cfg!(target_endian = "big") {
43 7 - (index % 8)
44 } else {
45 index % 8
46 };
47 let mask = 1 << bit_index;
48 if val {
49 *byte |= mask;
50 } else {
51 *byte &= !mask;
52 }
53 }
54 #[inline]
get(&self, bit_offset: usize, bit_width: u8) -> u6455 pub fn get(&self, bit_offset: usize, bit_width: u8) -> u64 {
56 debug_assert!(bit_width <= 64);
57 debug_assert!(bit_offset / 8 < self.storage.as_ref().len());
58 debug_assert!(
59 (bit_offset + (bit_width as usize)) / 8 <=
60 self.storage.as_ref().len()
61 );
62 let mut val = 0;
63 for i in 0..(bit_width as usize) {
64 if self.get_bit(i + bit_offset) {
65 let index = if cfg!(target_endian = "big") {
66 bit_width as usize - 1 - i
67 } else {
68 i
69 };
70 val |= 1 << index;
71 }
72 }
73 val
74 }
75 #[inline]
set(&mut self, bit_offset: usize, bit_width: u8, val: u64)76 pub fn set(&mut self, bit_offset: usize, bit_width: u8, val: u64) {
77 debug_assert!(bit_width <= 64);
78 debug_assert!(bit_offset / 8 < self.storage.as_ref().len());
79 debug_assert!(
80 (bit_offset + (bit_width as usize)) / 8 <=
81 self.storage.as_ref().len()
82 );
83 for i in 0..(bit_width as usize) {
84 let mask = 1 << i;
85 let val_bit_is_set = val & mask == mask;
86 let index = if cfg!(target_endian = "big") {
87 bit_width as usize - 1 - i
88 } else {
89 i
90 };
91 self.set_bit(index + bit_offset, val_bit_is_set);
92 }
93 }
94 }
95 #[repr(u32)]
96 #[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
97 pub enum MyEnum {
98 ONE = 0,
99 TWO = 1,
100 THREE = 2,
101 FOUR = 3,
102 }
103 #[repr(C)]
104 #[repr(align(8))]
105 #[derive(Debug, Copy, Clone)]
106 pub struct TaggedPtr {
107 pub _bitfield_align_1: [u64; 0],
108 pub _bitfield_1: __BindgenBitfieldUnit<[u8; 8usize]>,
109 }
110 #[test]
bindgen_test_layout_TaggedPtr()111 fn bindgen_test_layout_TaggedPtr() {
112 assert_eq!(
113 ::std::mem::size_of::<TaggedPtr>(),
114 8usize,
115 concat!("Size of: ", stringify!(TaggedPtr))
116 );
117 assert_eq!(
118 ::std::mem::align_of::<TaggedPtr>(),
119 8usize,
120 concat!("Alignment of ", stringify!(TaggedPtr))
121 );
122 }
123 impl Default for TaggedPtr {
default() -> Self124 fn default() -> Self {
125 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
126 unsafe {
127 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
128 s.assume_init()
129 }
130 }
131 }
132 impl TaggedPtr {
133 #[inline]
tag(&self) -> MyEnum134 pub fn tag(&self) -> MyEnum {
135 unsafe {
136 ::std::mem::transmute(self._bitfield_1.get(0usize, 2u8) as u32)
137 }
138 }
139 #[inline]
set_tag(&mut self, val: MyEnum)140 pub fn set_tag(&mut self, val: MyEnum) {
141 unsafe {
142 let val: u32 = ::std::mem::transmute(val);
143 self._bitfield_1.set(0usize, 2u8, val as u64)
144 }
145 }
146 #[inline]
ptr(&self) -> ::std::os::raw::c_long147 pub fn ptr(&self) -> ::std::os::raw::c_long {
148 unsafe {
149 ::std::mem::transmute(self._bitfield_1.get(2usize, 62u8) as u64)
150 }
151 }
152 #[inline]
set_ptr(&mut self, val: ::std::os::raw::c_long)153 pub fn set_ptr(&mut self, val: ::std::os::raw::c_long) {
154 unsafe {
155 let val: u64 = ::std::mem::transmute(val);
156 self._bitfield_1.set(2usize, 62u8, val as u64)
157 }
158 }
159 #[inline]
new_bitfield_1( tag: MyEnum, ptr: ::std::os::raw::c_long, ) -> __BindgenBitfieldUnit<[u8; 8usize]>160 pub fn new_bitfield_1(
161 tag: MyEnum,
162 ptr: ::std::os::raw::c_long,
163 ) -> __BindgenBitfieldUnit<[u8; 8usize]> {
164 let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 8usize]> =
165 Default::default();
166 __bindgen_bitfield_unit.set(0usize, 2u8, {
167 let tag: u32 = unsafe { ::std::mem::transmute(tag) };
168 tag as u64
169 });
170 __bindgen_bitfield_unit.set(2usize, 62u8, {
171 let ptr: u64 = unsafe { ::std::mem::transmute(ptr) };
172 ptr as u64
173 });
174 __bindgen_bitfield_unit
175 }
176 }
177