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 A {
98 pub x: ::std::os::raw::c_uchar,
99 pub _bitfield_align_1: [u8; 0],
100 pub _bitfield_1: __BindgenBitfieldUnit<[u8; 2usize]>,
101 pub y: ::std::os::raw::c_uchar,
102 }
103 #[test]
bindgen_test_layout_A()104 fn bindgen_test_layout_A() {
105 const UNINIT: ::std::mem::MaybeUninit<A> =
106 ::std::mem::MaybeUninit::uninit();
107 let ptr = UNINIT.as_ptr();
108 assert_eq!(
109 ::std::mem::size_of::<A>(),
110 4usize,
111 concat!("Size of: ", stringify!(A))
112 );
113 assert_eq!(
114 ::std::mem::align_of::<A>(),
115 4usize,
116 concat!("Alignment of ", stringify!(A))
117 );
118 assert_eq!(
119 unsafe { ::std::ptr::addr_of!((*ptr).x) as usize - ptr as usize },
120 0usize,
121 concat!("Offset of field: ", stringify!(A), "::", stringify!(x))
122 );
123 assert_eq!(
124 unsafe { ::std::ptr::addr_of!((*ptr).y) as usize - ptr as usize },
125 3usize,
126 concat!("Offset of field: ", stringify!(A), "::", stringify!(y))
127 );
128 }
129 impl A {
130 #[inline]
b1(&self) -> ::std::os::raw::c_uint131 pub fn b1(&self) -> ::std::os::raw::c_uint {
132 unsafe {
133 ::std::mem::transmute(self._bitfield_1.get(0usize, 1u8) as u32)
134 }
135 }
136 #[inline]
set_b1(&mut self, val: ::std::os::raw::c_uint)137 pub fn set_b1(&mut self, val: ::std::os::raw::c_uint) {
138 unsafe {
139 let val: u32 = ::std::mem::transmute(val);
140 self._bitfield_1.set(0usize, 1u8, val as u64)
141 }
142 }
143 #[inline]
b2(&self) -> ::std::os::raw::c_uint144 pub fn b2(&self) -> ::std::os::raw::c_uint {
145 unsafe {
146 ::std::mem::transmute(self._bitfield_1.get(1usize, 1u8) as u32)
147 }
148 }
149 #[inline]
set_b2(&mut self, val: ::std::os::raw::c_uint)150 pub fn set_b2(&mut self, val: ::std::os::raw::c_uint) {
151 unsafe {
152 let val: u32 = ::std::mem::transmute(val);
153 self._bitfield_1.set(1usize, 1u8, val as u64)
154 }
155 }
156 #[inline]
b3(&self) -> ::std::os::raw::c_uint157 pub fn b3(&self) -> ::std::os::raw::c_uint {
158 unsafe {
159 ::std::mem::transmute(self._bitfield_1.get(2usize, 1u8) as u32)
160 }
161 }
162 #[inline]
set_b3(&mut self, val: ::std::os::raw::c_uint)163 pub fn set_b3(&mut self, val: ::std::os::raw::c_uint) {
164 unsafe {
165 let val: u32 = ::std::mem::transmute(val);
166 self._bitfield_1.set(2usize, 1u8, val as u64)
167 }
168 }
169 #[inline]
b4(&self) -> ::std::os::raw::c_uint170 pub fn b4(&self) -> ::std::os::raw::c_uint {
171 unsafe {
172 ::std::mem::transmute(self._bitfield_1.get(3usize, 1u8) as u32)
173 }
174 }
175 #[inline]
set_b4(&mut self, val: ::std::os::raw::c_uint)176 pub fn set_b4(&mut self, val: ::std::os::raw::c_uint) {
177 unsafe {
178 let val: u32 = ::std::mem::transmute(val);
179 self._bitfield_1.set(3usize, 1u8, val as u64)
180 }
181 }
182 #[inline]
b5(&self) -> ::std::os::raw::c_uint183 pub fn b5(&self) -> ::std::os::raw::c_uint {
184 unsafe {
185 ::std::mem::transmute(self._bitfield_1.get(4usize, 1u8) as u32)
186 }
187 }
188 #[inline]
set_b5(&mut self, val: ::std::os::raw::c_uint)189 pub fn set_b5(&mut self, val: ::std::os::raw::c_uint) {
190 unsafe {
191 let val: u32 = ::std::mem::transmute(val);
192 self._bitfield_1.set(4usize, 1u8, val as u64)
193 }
194 }
195 #[inline]
b6(&self) -> ::std::os::raw::c_uint196 pub fn b6(&self) -> ::std::os::raw::c_uint {
197 unsafe {
198 ::std::mem::transmute(self._bitfield_1.get(5usize, 1u8) as u32)
199 }
200 }
201 #[inline]
set_b6(&mut self, val: ::std::os::raw::c_uint)202 pub fn set_b6(&mut self, val: ::std::os::raw::c_uint) {
203 unsafe {
204 let val: u32 = ::std::mem::transmute(val);
205 self._bitfield_1.set(5usize, 1u8, val as u64)
206 }
207 }
208 #[inline]
b7(&self) -> ::std::os::raw::c_uint209 pub fn b7(&self) -> ::std::os::raw::c_uint {
210 unsafe {
211 ::std::mem::transmute(self._bitfield_1.get(6usize, 1u8) as u32)
212 }
213 }
214 #[inline]
set_b7(&mut self, val: ::std::os::raw::c_uint)215 pub fn set_b7(&mut self, val: ::std::os::raw::c_uint) {
216 unsafe {
217 let val: u32 = ::std::mem::transmute(val);
218 self._bitfield_1.set(6usize, 1u8, val as u64)
219 }
220 }
221 #[inline]
b8(&self) -> ::std::os::raw::c_uint222 pub fn b8(&self) -> ::std::os::raw::c_uint {
223 unsafe {
224 ::std::mem::transmute(self._bitfield_1.get(7usize, 1u8) as u32)
225 }
226 }
227 #[inline]
set_b8(&mut self, val: ::std::os::raw::c_uint)228 pub fn set_b8(&mut self, val: ::std::os::raw::c_uint) {
229 unsafe {
230 let val: u32 = ::std::mem::transmute(val);
231 self._bitfield_1.set(7usize, 1u8, val as u64)
232 }
233 }
234 #[inline]
b9(&self) -> ::std::os::raw::c_uint235 pub fn b9(&self) -> ::std::os::raw::c_uint {
236 unsafe {
237 ::std::mem::transmute(self._bitfield_1.get(8usize, 1u8) as u32)
238 }
239 }
240 #[inline]
set_b9(&mut self, val: ::std::os::raw::c_uint)241 pub fn set_b9(&mut self, val: ::std::os::raw::c_uint) {
242 unsafe {
243 let val: u32 = ::std::mem::transmute(val);
244 self._bitfield_1.set(8usize, 1u8, val as u64)
245 }
246 }
247 #[inline]
b10(&self) -> ::std::os::raw::c_uint248 pub fn b10(&self) -> ::std::os::raw::c_uint {
249 unsafe {
250 ::std::mem::transmute(self._bitfield_1.get(9usize, 1u8) as u32)
251 }
252 }
253 #[inline]
set_b10(&mut self, val: ::std::os::raw::c_uint)254 pub fn set_b10(&mut self, val: ::std::os::raw::c_uint) {
255 unsafe {
256 let val: u32 = ::std::mem::transmute(val);
257 self._bitfield_1.set(9usize, 1u8, val as u64)
258 }
259 }
260 #[inline]
new_bitfield_1( b1: ::std::os::raw::c_uint, b2: ::std::os::raw::c_uint, b3: ::std::os::raw::c_uint, b4: ::std::os::raw::c_uint, b5: ::std::os::raw::c_uint, b6: ::std::os::raw::c_uint, b7: ::std::os::raw::c_uint, b8: ::std::os::raw::c_uint, b9: ::std::os::raw::c_uint, b10: ::std::os::raw::c_uint, ) -> __BindgenBitfieldUnit<[u8; 2usize]>261 pub fn new_bitfield_1(
262 b1: ::std::os::raw::c_uint,
263 b2: ::std::os::raw::c_uint,
264 b3: ::std::os::raw::c_uint,
265 b4: ::std::os::raw::c_uint,
266 b5: ::std::os::raw::c_uint,
267 b6: ::std::os::raw::c_uint,
268 b7: ::std::os::raw::c_uint,
269 b8: ::std::os::raw::c_uint,
270 b9: ::std::os::raw::c_uint,
271 b10: ::std::os::raw::c_uint,
272 ) -> __BindgenBitfieldUnit<[u8; 2usize]> {
273 let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 2usize]> =
274 Default::default();
275 __bindgen_bitfield_unit.set(0usize, 1u8, {
276 let b1: u32 = unsafe { ::std::mem::transmute(b1) };
277 b1 as u64
278 });
279 __bindgen_bitfield_unit.set(1usize, 1u8, {
280 let b2: u32 = unsafe { ::std::mem::transmute(b2) };
281 b2 as u64
282 });
283 __bindgen_bitfield_unit.set(2usize, 1u8, {
284 let b3: u32 = unsafe { ::std::mem::transmute(b3) };
285 b3 as u64
286 });
287 __bindgen_bitfield_unit.set(3usize, 1u8, {
288 let b4: u32 = unsafe { ::std::mem::transmute(b4) };
289 b4 as u64
290 });
291 __bindgen_bitfield_unit.set(4usize, 1u8, {
292 let b5: u32 = unsafe { ::std::mem::transmute(b5) };
293 b5 as u64
294 });
295 __bindgen_bitfield_unit.set(5usize, 1u8, {
296 let b6: u32 = unsafe { ::std::mem::transmute(b6) };
297 b6 as u64
298 });
299 __bindgen_bitfield_unit.set(6usize, 1u8, {
300 let b7: u32 = unsafe { ::std::mem::transmute(b7) };
301 b7 as u64
302 });
303 __bindgen_bitfield_unit.set(7usize, 1u8, {
304 let b8: u32 = unsafe { ::std::mem::transmute(b8) };
305 b8 as u64
306 });
307 __bindgen_bitfield_unit.set(8usize, 1u8, {
308 let b9: u32 = unsafe { ::std::mem::transmute(b9) };
309 b9 as u64
310 });
311 __bindgen_bitfield_unit.set(9usize, 1u8, {
312 let b10: u32 = unsafe { ::std::mem::transmute(b10) };
313 b10 as u64
314 });
315 __bindgen_bitfield_unit
316 }
317 }
318 #[repr(C)]
319 #[repr(align(4))]
320 #[derive(Debug, Default, Copy, Clone)]
321 pub struct B {
322 pub _bitfield_align_1: [u32; 0],
323 pub _bitfield_1: __BindgenBitfieldUnit<[u8; 4usize]>,
324 }
325 #[test]
bindgen_test_layout_B()326 fn bindgen_test_layout_B() {
327 assert_eq!(
328 ::std::mem::size_of::<B>(),
329 4usize,
330 concat!("Size of: ", stringify!(B))
331 );
332 assert_eq!(
333 ::std::mem::align_of::<B>(),
334 4usize,
335 concat!("Alignment of ", stringify!(B))
336 );
337 }
338 impl B {
339 #[inline]
foo(&self) -> ::std::os::raw::c_uint340 pub fn foo(&self) -> ::std::os::raw::c_uint {
341 unsafe {
342 ::std::mem::transmute(self._bitfield_1.get(0usize, 31u8) as u32)
343 }
344 }
345 #[inline]
set_foo(&mut self, val: ::std::os::raw::c_uint)346 pub fn set_foo(&mut self, val: ::std::os::raw::c_uint) {
347 unsafe {
348 let val: u32 = ::std::mem::transmute(val);
349 self._bitfield_1.set(0usize, 31u8, val as u64)
350 }
351 }
352 #[inline]
bar(&self) -> ::std::os::raw::c_uchar353 pub fn bar(&self) -> ::std::os::raw::c_uchar {
354 unsafe {
355 ::std::mem::transmute(self._bitfield_1.get(31usize, 1u8) as u8)
356 }
357 }
358 #[inline]
set_bar(&mut self, val: ::std::os::raw::c_uchar)359 pub fn set_bar(&mut self, val: ::std::os::raw::c_uchar) {
360 unsafe {
361 let val: u8 = ::std::mem::transmute(val);
362 self._bitfield_1.set(31usize, 1u8, val as u64)
363 }
364 }
365 #[inline]
new_bitfield_1( foo: ::std::os::raw::c_uint, bar: ::std::os::raw::c_uchar, ) -> __BindgenBitfieldUnit<[u8; 4usize]>366 pub fn new_bitfield_1(
367 foo: ::std::os::raw::c_uint,
368 bar: ::std::os::raw::c_uchar,
369 ) -> __BindgenBitfieldUnit<[u8; 4usize]> {
370 let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 4usize]> =
371 Default::default();
372 __bindgen_bitfield_unit.set(0usize, 31u8, {
373 let foo: u32 = unsafe { ::std::mem::transmute(foo) };
374 foo as u64
375 });
376 __bindgen_bitfield_unit.set(31usize, 1u8, {
377 let bar: u8 = unsafe { ::std::mem::transmute(bar) };
378 bar as u64
379 });
380 __bindgen_bitfield_unit
381 }
382 }
383 #[repr(C)]
384 #[derive(Debug, Default, Copy, Clone)]
385 pub struct C {
386 pub x: ::std::os::raw::c_uchar,
387 pub _bitfield_align_1: [u8; 0],
388 pub _bitfield_1: __BindgenBitfieldUnit<[u8; 1usize]>,
389 pub baz: ::std::os::raw::c_uint,
390 }
391 #[test]
bindgen_test_layout_C()392 fn bindgen_test_layout_C() {
393 const UNINIT: ::std::mem::MaybeUninit<C> =
394 ::std::mem::MaybeUninit::uninit();
395 let ptr = UNINIT.as_ptr();
396 assert_eq!(
397 ::std::mem::size_of::<C>(),
398 8usize,
399 concat!("Size of: ", stringify!(C))
400 );
401 assert_eq!(
402 ::std::mem::align_of::<C>(),
403 4usize,
404 concat!("Alignment of ", stringify!(C))
405 );
406 assert_eq!(
407 unsafe { ::std::ptr::addr_of!((*ptr).x) as usize - ptr as usize },
408 0usize,
409 concat!("Offset of field: ", stringify!(C), "::", stringify!(x))
410 );
411 assert_eq!(
412 unsafe { ::std::ptr::addr_of!((*ptr).baz) as usize - ptr as usize },
413 4usize,
414 concat!("Offset of field: ", stringify!(C), "::", stringify!(baz))
415 );
416 }
417 impl C {
418 #[inline]
b1(&self) -> ::std::os::raw::c_uint419 pub fn b1(&self) -> ::std::os::raw::c_uint {
420 unsafe {
421 ::std::mem::transmute(self._bitfield_1.get(0usize, 1u8) as u32)
422 }
423 }
424 #[inline]
set_b1(&mut self, val: ::std::os::raw::c_uint)425 pub fn set_b1(&mut self, val: ::std::os::raw::c_uint) {
426 unsafe {
427 let val: u32 = ::std::mem::transmute(val);
428 self._bitfield_1.set(0usize, 1u8, val as u64)
429 }
430 }
431 #[inline]
b2(&self) -> ::std::os::raw::c_uint432 pub fn b2(&self) -> ::std::os::raw::c_uint {
433 unsafe {
434 ::std::mem::transmute(self._bitfield_1.get(1usize, 1u8) as u32)
435 }
436 }
437 #[inline]
set_b2(&mut self, val: ::std::os::raw::c_uint)438 pub fn set_b2(&mut self, val: ::std::os::raw::c_uint) {
439 unsafe {
440 let val: u32 = ::std::mem::transmute(val);
441 self._bitfield_1.set(1usize, 1u8, val as u64)
442 }
443 }
444 #[inline]
new_bitfield_1( b1: ::std::os::raw::c_uint, b2: ::std::os::raw::c_uint, ) -> __BindgenBitfieldUnit<[u8; 1usize]>445 pub fn new_bitfield_1(
446 b1: ::std::os::raw::c_uint,
447 b2: ::std::os::raw::c_uint,
448 ) -> __BindgenBitfieldUnit<[u8; 1usize]> {
449 let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 1usize]> =
450 Default::default();
451 __bindgen_bitfield_unit.set(0usize, 1u8, {
452 let b1: u32 = unsafe { ::std::mem::transmute(b1) };
453 b1 as u64
454 });
455 __bindgen_bitfield_unit.set(1usize, 1u8, {
456 let b2: u32 = unsafe { ::std::mem::transmute(b2) };
457 b2 as u64
458 });
459 __bindgen_bitfield_unit
460 }
461 }
462 #[repr(C)]
463 #[repr(align(2))]
464 #[derive(Debug, Default, Copy, Clone)]
465 pub struct Date1 {
466 pub _bitfield_align_1: [u8; 0],
467 pub _bitfield_1: __BindgenBitfieldUnit<[u8; 3usize]>,
468 pub __bindgen_padding_0: u8,
469 }
470 #[test]
bindgen_test_layout_Date1()471 fn bindgen_test_layout_Date1() {
472 assert_eq!(
473 ::std::mem::size_of::<Date1>(),
474 4usize,
475 concat!("Size of: ", stringify!(Date1))
476 );
477 assert_eq!(
478 ::std::mem::align_of::<Date1>(),
479 2usize,
480 concat!("Alignment of ", stringify!(Date1))
481 );
482 }
483 impl Date1 {
484 #[inline]
nWeekDay(&self) -> ::std::os::raw::c_ushort485 pub fn nWeekDay(&self) -> ::std::os::raw::c_ushort {
486 unsafe {
487 ::std::mem::transmute(self._bitfield_1.get(0usize, 3u8) as u16)
488 }
489 }
490 #[inline]
set_nWeekDay(&mut self, val: ::std::os::raw::c_ushort)491 pub fn set_nWeekDay(&mut self, val: ::std::os::raw::c_ushort) {
492 unsafe {
493 let val: u16 = ::std::mem::transmute(val);
494 self._bitfield_1.set(0usize, 3u8, val as u64)
495 }
496 }
497 #[inline]
nMonthDay(&self) -> ::std::os::raw::c_ushort498 pub fn nMonthDay(&self) -> ::std::os::raw::c_ushort {
499 unsafe {
500 ::std::mem::transmute(self._bitfield_1.get(3usize, 6u8) as u16)
501 }
502 }
503 #[inline]
set_nMonthDay(&mut self, val: ::std::os::raw::c_ushort)504 pub fn set_nMonthDay(&mut self, val: ::std::os::raw::c_ushort) {
505 unsafe {
506 let val: u16 = ::std::mem::transmute(val);
507 self._bitfield_1.set(3usize, 6u8, val as u64)
508 }
509 }
510 #[inline]
nMonth(&self) -> ::std::os::raw::c_ushort511 pub fn nMonth(&self) -> ::std::os::raw::c_ushort {
512 unsafe {
513 ::std::mem::transmute(self._bitfield_1.get(9usize, 5u8) as u16)
514 }
515 }
516 #[inline]
set_nMonth(&mut self, val: ::std::os::raw::c_ushort)517 pub fn set_nMonth(&mut self, val: ::std::os::raw::c_ushort) {
518 unsafe {
519 let val: u16 = ::std::mem::transmute(val);
520 self._bitfield_1.set(9usize, 5u8, val as u64)
521 }
522 }
523 #[inline]
nYear(&self) -> ::std::os::raw::c_ushort524 pub fn nYear(&self) -> ::std::os::raw::c_ushort {
525 unsafe {
526 ::std::mem::transmute(self._bitfield_1.get(16usize, 8u8) as u16)
527 }
528 }
529 #[inline]
set_nYear(&mut self, val: ::std::os::raw::c_ushort)530 pub fn set_nYear(&mut self, val: ::std::os::raw::c_ushort) {
531 unsafe {
532 let val: u16 = ::std::mem::transmute(val);
533 self._bitfield_1.set(16usize, 8u8, val as u64)
534 }
535 }
536 #[inline]
new_bitfield_1( nWeekDay: ::std::os::raw::c_ushort, nMonthDay: ::std::os::raw::c_ushort, nMonth: ::std::os::raw::c_ushort, nYear: ::std::os::raw::c_ushort, ) -> __BindgenBitfieldUnit<[u8; 3usize]>537 pub fn new_bitfield_1(
538 nWeekDay: ::std::os::raw::c_ushort,
539 nMonthDay: ::std::os::raw::c_ushort,
540 nMonth: ::std::os::raw::c_ushort,
541 nYear: ::std::os::raw::c_ushort,
542 ) -> __BindgenBitfieldUnit<[u8; 3usize]> {
543 let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 3usize]> =
544 Default::default();
545 __bindgen_bitfield_unit.set(0usize, 3u8, {
546 let nWeekDay: u16 = unsafe { ::std::mem::transmute(nWeekDay) };
547 nWeekDay as u64
548 });
549 __bindgen_bitfield_unit.set(3usize, 6u8, {
550 let nMonthDay: u16 = unsafe { ::std::mem::transmute(nMonthDay) };
551 nMonthDay as u64
552 });
553 __bindgen_bitfield_unit.set(9usize, 5u8, {
554 let nMonth: u16 = unsafe { ::std::mem::transmute(nMonth) };
555 nMonth as u64
556 });
557 __bindgen_bitfield_unit.set(16usize, 8u8, {
558 let nYear: u16 = unsafe { ::std::mem::transmute(nYear) };
559 nYear as u64
560 });
561 __bindgen_bitfield_unit
562 }
563 }
564 #[repr(C)]
565 #[repr(align(2))]
566 #[derive(Debug, Default, Copy, Clone)]
567 pub struct Date2 {
568 pub _bitfield_align_1: [u8; 0],
569 pub _bitfield_1: __BindgenBitfieldUnit<[u8; 4usize]>,
570 }
571 #[test]
bindgen_test_layout_Date2()572 fn bindgen_test_layout_Date2() {
573 assert_eq!(
574 ::std::mem::size_of::<Date2>(),
575 4usize,
576 concat!("Size of: ", stringify!(Date2))
577 );
578 assert_eq!(
579 ::std::mem::align_of::<Date2>(),
580 2usize,
581 concat!("Alignment of ", stringify!(Date2))
582 );
583 }
584 impl Date2 {
585 #[inline]
nWeekDay(&self) -> ::std::os::raw::c_ushort586 pub fn nWeekDay(&self) -> ::std::os::raw::c_ushort {
587 unsafe {
588 ::std::mem::transmute(self._bitfield_1.get(0usize, 3u8) as u16)
589 }
590 }
591 #[inline]
set_nWeekDay(&mut self, val: ::std::os::raw::c_ushort)592 pub fn set_nWeekDay(&mut self, val: ::std::os::raw::c_ushort) {
593 unsafe {
594 let val: u16 = ::std::mem::transmute(val);
595 self._bitfield_1.set(0usize, 3u8, val as u64)
596 }
597 }
598 #[inline]
nMonthDay(&self) -> ::std::os::raw::c_ushort599 pub fn nMonthDay(&self) -> ::std::os::raw::c_ushort {
600 unsafe {
601 ::std::mem::transmute(self._bitfield_1.get(3usize, 6u8) as u16)
602 }
603 }
604 #[inline]
set_nMonthDay(&mut self, val: ::std::os::raw::c_ushort)605 pub fn set_nMonthDay(&mut self, val: ::std::os::raw::c_ushort) {
606 unsafe {
607 let val: u16 = ::std::mem::transmute(val);
608 self._bitfield_1.set(3usize, 6u8, val as u64)
609 }
610 }
611 #[inline]
nMonth(&self) -> ::std::os::raw::c_ushort612 pub fn nMonth(&self) -> ::std::os::raw::c_ushort {
613 unsafe {
614 ::std::mem::transmute(self._bitfield_1.get(9usize, 5u8) as u16)
615 }
616 }
617 #[inline]
set_nMonth(&mut self, val: ::std::os::raw::c_ushort)618 pub fn set_nMonth(&mut self, val: ::std::os::raw::c_ushort) {
619 unsafe {
620 let val: u16 = ::std::mem::transmute(val);
621 self._bitfield_1.set(9usize, 5u8, val as u64)
622 }
623 }
624 #[inline]
nYear(&self) -> ::std::os::raw::c_ushort625 pub fn nYear(&self) -> ::std::os::raw::c_ushort {
626 unsafe {
627 ::std::mem::transmute(self._bitfield_1.get(16usize, 8u8) as u16)
628 }
629 }
630 #[inline]
set_nYear(&mut self, val: ::std::os::raw::c_ushort)631 pub fn set_nYear(&mut self, val: ::std::os::raw::c_ushort) {
632 unsafe {
633 let val: u16 = ::std::mem::transmute(val);
634 self._bitfield_1.set(16usize, 8u8, val as u64)
635 }
636 }
637 #[inline]
byte(&self) -> ::std::os::raw::c_uchar638 pub fn byte(&self) -> ::std::os::raw::c_uchar {
639 unsafe {
640 ::std::mem::transmute(self._bitfield_1.get(24usize, 8u8) as u8)
641 }
642 }
643 #[inline]
set_byte(&mut self, val: ::std::os::raw::c_uchar)644 pub fn set_byte(&mut self, val: ::std::os::raw::c_uchar) {
645 unsafe {
646 let val: u8 = ::std::mem::transmute(val);
647 self._bitfield_1.set(24usize, 8u8, val as u64)
648 }
649 }
650 #[inline]
new_bitfield_1( nWeekDay: ::std::os::raw::c_ushort, nMonthDay: ::std::os::raw::c_ushort, nMonth: ::std::os::raw::c_ushort, nYear: ::std::os::raw::c_ushort, byte: ::std::os::raw::c_uchar, ) -> __BindgenBitfieldUnit<[u8; 4usize]>651 pub fn new_bitfield_1(
652 nWeekDay: ::std::os::raw::c_ushort,
653 nMonthDay: ::std::os::raw::c_ushort,
654 nMonth: ::std::os::raw::c_ushort,
655 nYear: ::std::os::raw::c_ushort,
656 byte: ::std::os::raw::c_uchar,
657 ) -> __BindgenBitfieldUnit<[u8; 4usize]> {
658 let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 4usize]> =
659 Default::default();
660 __bindgen_bitfield_unit.set(0usize, 3u8, {
661 let nWeekDay: u16 = unsafe { ::std::mem::transmute(nWeekDay) };
662 nWeekDay as u64
663 });
664 __bindgen_bitfield_unit.set(3usize, 6u8, {
665 let nMonthDay: u16 = unsafe { ::std::mem::transmute(nMonthDay) };
666 nMonthDay as u64
667 });
668 __bindgen_bitfield_unit.set(9usize, 5u8, {
669 let nMonth: u16 = unsafe { ::std::mem::transmute(nMonth) };
670 nMonth as u64
671 });
672 __bindgen_bitfield_unit.set(16usize, 8u8, {
673 let nYear: u16 = unsafe { ::std::mem::transmute(nYear) };
674 nYear as u64
675 });
676 __bindgen_bitfield_unit.set(24usize, 8u8, {
677 let byte: u8 = unsafe { ::std::mem::transmute(byte) };
678 byte as u64
679 });
680 __bindgen_bitfield_unit
681 }
682 }
683 #[repr(C)]
684 #[repr(align(2))]
685 #[derive(Debug, Default, Copy, Clone)]
686 pub struct Date3 {
687 pub _bitfield_align_1: [u8; 0],
688 pub _bitfield_1: __BindgenBitfieldUnit<[u8; 3usize]>,
689 pub byte: ::std::os::raw::c_uchar,
690 }
691 #[test]
bindgen_test_layout_Date3()692 fn bindgen_test_layout_Date3() {
693 const UNINIT: ::std::mem::MaybeUninit<Date3> =
694 ::std::mem::MaybeUninit::uninit();
695 let ptr = UNINIT.as_ptr();
696 assert_eq!(
697 ::std::mem::size_of::<Date3>(),
698 4usize,
699 concat!("Size of: ", stringify!(Date3))
700 );
701 assert_eq!(
702 ::std::mem::align_of::<Date3>(),
703 2usize,
704 concat!("Alignment of ", stringify!(Date3))
705 );
706 assert_eq!(
707 unsafe { ::std::ptr::addr_of!((*ptr).byte) as usize - ptr as usize },
708 3usize,
709 concat!(
710 "Offset of field: ",
711 stringify!(Date3),
712 "::",
713 stringify!(byte)
714 )
715 );
716 }
717 impl Date3 {
718 #[inline]
nWeekDay(&self) -> ::std::os::raw::c_ushort719 pub fn nWeekDay(&self) -> ::std::os::raw::c_ushort {
720 unsafe {
721 ::std::mem::transmute(self._bitfield_1.get(0usize, 3u8) as u16)
722 }
723 }
724 #[inline]
set_nWeekDay(&mut self, val: ::std::os::raw::c_ushort)725 pub fn set_nWeekDay(&mut self, val: ::std::os::raw::c_ushort) {
726 unsafe {
727 let val: u16 = ::std::mem::transmute(val);
728 self._bitfield_1.set(0usize, 3u8, val as u64)
729 }
730 }
731 #[inline]
nMonthDay(&self) -> ::std::os::raw::c_ushort732 pub fn nMonthDay(&self) -> ::std::os::raw::c_ushort {
733 unsafe {
734 ::std::mem::transmute(self._bitfield_1.get(3usize, 6u8) as u16)
735 }
736 }
737 #[inline]
set_nMonthDay(&mut self, val: ::std::os::raw::c_ushort)738 pub fn set_nMonthDay(&mut self, val: ::std::os::raw::c_ushort) {
739 unsafe {
740 let val: u16 = ::std::mem::transmute(val);
741 self._bitfield_1.set(3usize, 6u8, val as u64)
742 }
743 }
744 #[inline]
nMonth(&self) -> ::std::os::raw::c_ushort745 pub fn nMonth(&self) -> ::std::os::raw::c_ushort {
746 unsafe {
747 ::std::mem::transmute(self._bitfield_1.get(9usize, 5u8) as u16)
748 }
749 }
750 #[inline]
set_nMonth(&mut self, val: ::std::os::raw::c_ushort)751 pub fn set_nMonth(&mut self, val: ::std::os::raw::c_ushort) {
752 unsafe {
753 let val: u16 = ::std::mem::transmute(val);
754 self._bitfield_1.set(9usize, 5u8, val as u64)
755 }
756 }
757 #[inline]
nYear(&self) -> ::std::os::raw::c_ushort758 pub fn nYear(&self) -> ::std::os::raw::c_ushort {
759 unsafe {
760 ::std::mem::transmute(self._bitfield_1.get(16usize, 8u8) as u16)
761 }
762 }
763 #[inline]
set_nYear(&mut self, val: ::std::os::raw::c_ushort)764 pub fn set_nYear(&mut self, val: ::std::os::raw::c_ushort) {
765 unsafe {
766 let val: u16 = ::std::mem::transmute(val);
767 self._bitfield_1.set(16usize, 8u8, val as u64)
768 }
769 }
770 #[inline]
new_bitfield_1( nWeekDay: ::std::os::raw::c_ushort, nMonthDay: ::std::os::raw::c_ushort, nMonth: ::std::os::raw::c_ushort, nYear: ::std::os::raw::c_ushort, ) -> __BindgenBitfieldUnit<[u8; 3usize]>771 pub fn new_bitfield_1(
772 nWeekDay: ::std::os::raw::c_ushort,
773 nMonthDay: ::std::os::raw::c_ushort,
774 nMonth: ::std::os::raw::c_ushort,
775 nYear: ::std::os::raw::c_ushort,
776 ) -> __BindgenBitfieldUnit<[u8; 3usize]> {
777 let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 3usize]> =
778 Default::default();
779 __bindgen_bitfield_unit.set(0usize, 3u8, {
780 let nWeekDay: u16 = unsafe { ::std::mem::transmute(nWeekDay) };
781 nWeekDay as u64
782 });
783 __bindgen_bitfield_unit.set(3usize, 6u8, {
784 let nMonthDay: u16 = unsafe { ::std::mem::transmute(nMonthDay) };
785 nMonthDay as u64
786 });
787 __bindgen_bitfield_unit.set(9usize, 5u8, {
788 let nMonth: u16 = unsafe { ::std::mem::transmute(nMonth) };
789 nMonth as u64
790 });
791 __bindgen_bitfield_unit.set(16usize, 8u8, {
792 let nYear: u16 = unsafe { ::std::mem::transmute(nYear) };
793 nYear as u64
794 });
795 __bindgen_bitfield_unit
796 }
797 }
798