1 #![allow(
2 dead_code,
3 non_snake_case,
4 non_camel_case_types,
5 non_upper_case_globals
6 )]
7
8 #[repr(C)]
9 #[derive(Copy, Clone, Debug, Default, Eq, Hash, Ord, PartialEq, PartialOrd)]
10 pub struct __BindgenBitfieldUnit<Storage> {
11 storage: Storage,
12 }
13 impl<Storage> __BindgenBitfieldUnit<Storage> {
14 #[inline]
new(storage: Storage) -> Self15 pub const fn new(storage: Storage) -> Self {
16 Self { storage }
17 }
18 }
19 impl<Storage> __BindgenBitfieldUnit<Storage>
20 where
21 Storage: AsRef<[u8]> + AsMut<[u8]>,
22 {
23 #[inline]
get_bit(&self, index: usize) -> bool24 pub fn get_bit(&self, index: usize) -> bool {
25 debug_assert!(index / 8 < self.storage.as_ref().len());
26 let byte_index = index / 8;
27 let byte = self.storage.as_ref()[byte_index];
28 let bit_index = if cfg!(target_endian = "big") {
29 7 - (index % 8)
30 } else {
31 index % 8
32 };
33 let mask = 1 << bit_index;
34 byte & mask == mask
35 }
36 #[inline]
set_bit(&mut self, index: usize, val: bool)37 pub fn set_bit(&mut self, index: usize, val: bool) {
38 debug_assert!(index / 8 < self.storage.as_ref().len());
39 let byte_index = index / 8;
40 let byte = &mut self.storage.as_mut()[byte_index];
41 let bit_index = if cfg!(target_endian = "big") {
42 7 - (index % 8)
43 } else {
44 index % 8
45 };
46 let mask = 1 << bit_index;
47 if val {
48 *byte |= mask;
49 } else {
50 *byte &= !mask;
51 }
52 }
53 #[inline]
get(&self, bit_offset: usize, bit_width: u8) -> u6454 pub fn get(&self, bit_offset: usize, bit_width: u8) -> u64 {
55 debug_assert!(bit_width <= 64);
56 debug_assert!(bit_offset / 8 < self.storage.as_ref().len());
57 debug_assert!(
58 (bit_offset + (bit_width as usize)) / 8 <=
59 self.storage.as_ref().len()
60 );
61 let mut val = 0;
62 for i in 0..(bit_width as usize) {
63 if self.get_bit(i + bit_offset) {
64 let index = if cfg!(target_endian = "big") {
65 bit_width as usize - 1 - i
66 } else {
67 i
68 };
69 val |= 1 << index;
70 }
71 }
72 val
73 }
74 #[inline]
set(&mut self, bit_offset: usize, bit_width: u8, val: u64)75 pub fn set(&mut self, bit_offset: usize, bit_width: u8, val: u64) {
76 debug_assert!(bit_width <= 64);
77 debug_assert!(bit_offset / 8 < self.storage.as_ref().len());
78 debug_assert!(
79 (bit_offset + (bit_width as usize)) / 8 <=
80 self.storage.as_ref().len()
81 );
82 for i in 0..(bit_width as usize) {
83 let mask = 1 << i;
84 let val_bit_is_set = val & mask == mask;
85 let index = if cfg!(target_endian = "big") {
86 bit_width as usize - 1 - i
87 } else {
88 i
89 };
90 self.set_bit(index + bit_offset, val_bit_is_set);
91 }
92 }
93 }
94 #[repr(C)]
95 #[repr(align(4))]
96 #[derive(Debug, Default, Copy, Clone)]
97 pub struct mach_msg_type_descriptor_t {
98 pub _bitfield_align_1: [u32; 0],
99 pub _bitfield_1: __BindgenBitfieldUnit<[u8; 4usize]>,
100 }
101 #[test]
bindgen_test_layout_mach_msg_type_descriptor_t()102 fn bindgen_test_layout_mach_msg_type_descriptor_t() {
103 assert_eq!(
104 ::std::mem::size_of::<mach_msg_type_descriptor_t>(),
105 4usize,
106 concat!("Size of: ", stringify!(mach_msg_type_descriptor_t))
107 );
108 assert_eq!(
109 ::std::mem::align_of::<mach_msg_type_descriptor_t>(),
110 4usize,
111 concat!("Alignment of ", stringify!(mach_msg_type_descriptor_t))
112 );
113 }
114 impl mach_msg_type_descriptor_t {
115 #[inline]
pad3(&self) -> ::std::os::raw::c_uint116 pub fn pad3(&self) -> ::std::os::raw::c_uint {
117 unsafe {
118 ::std::mem::transmute(self._bitfield_1.get(0usize, 24u8) as u32)
119 }
120 }
121 #[inline]
set_pad3(&mut self, val: ::std::os::raw::c_uint)122 pub fn set_pad3(&mut self, val: ::std::os::raw::c_uint) {
123 unsafe {
124 let val: u32 = ::std::mem::transmute(val);
125 self._bitfield_1.set(0usize, 24u8, val as u64)
126 }
127 }
128 #[inline]
type_(&self) -> ::std::os::raw::c_uint129 pub fn type_(&self) -> ::std::os::raw::c_uint {
130 unsafe {
131 ::std::mem::transmute(self._bitfield_1.get(24usize, 8u8) as u32)
132 }
133 }
134 #[inline]
set_type(&mut self, val: ::std::os::raw::c_uint)135 pub fn set_type(&mut self, val: ::std::os::raw::c_uint) {
136 unsafe {
137 let val: u32 = ::std::mem::transmute(val);
138 self._bitfield_1.set(24usize, 8u8, val as u64)
139 }
140 }
141 #[inline]
new_bitfield_1( pad3: ::std::os::raw::c_uint, type_: ::std::os::raw::c_uint, ) -> __BindgenBitfieldUnit<[u8; 4usize]>142 pub fn new_bitfield_1(
143 pad3: ::std::os::raw::c_uint,
144 type_: ::std::os::raw::c_uint,
145 ) -> __BindgenBitfieldUnit<[u8; 4usize]> {
146 let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 4usize]> =
147 Default::default();
148 __bindgen_bitfield_unit.set(0usize, 24u8, {
149 let pad3: u32 = unsafe { ::std::mem::transmute(pad3) };
150 pad3 as u64
151 });
152 __bindgen_bitfield_unit.set(24usize, 8u8, {
153 let type_: u32 = unsafe { ::std::mem::transmute(type_) };
154 type_ as u64
155 });
156 __bindgen_bitfield_unit
157 }
158 }
159