1#![allow(non_snake_case, non_camel_case_types, non_upper_case_globals)]
4#[allow(unused_imports)]
5pub type releasehookType = ::std::option::Option<
6 unsafe extern "C" fn(val: *mut ::std::os::raw::c_void, size: ::std::os::raw::c_int),
7>;
8pub type SQFloat = f32;
9pub type SQInteger = ::std::os::raw::c_long;
10pub type SQUnsignedInteger = ::std::os::raw::c_ulong;
11pub type SQChar = ::std::os::raw::c_char;
12pub type SQBool = SQUnsignedInteger;
13
14#[repr(i32)]
15#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
16pub enum SQObjectType {
17 RT_NULL = 1,
18 RT_INTEGER = 2,
19 RT_FLOAT = 4,
20 RT_BOOL = 8,
21 RT_STRING = 16,
22 RT_TABLE = 32,
23 RT_ARRAY = 64,
24 RT_USERDATA = 128,
25 RT_CLOSURE = 256,
26 RT_NATIVECLOSURE = 512,
27 RT_GENERATOR = 1024,
28 OT_USERPOINTER = 2048, RT_THREAD = 4096,
31 RT_FUNCPROTO = 8192,
32 RT_CLASS = 16384,
33 RT_INSTANCE = 32768,
34 RT_WEAKREF = 65536,
35 OT_VECTOR = 262144,
36 SQOBJECT_CANBEFALSE = 16777216,
37 OT_NULL = 16777217,
38 OT_BOOL = 16777224,
39 SQOBJECT_DELEGABLE = 33554432,
40 SQOBJECT_NUMERIC = 67108864,
41 OT_INTEGER = 83886082,
42 OT_FLOAT = 83886084,
43 SQOBJECT_REF_COUNTED = 134217728,
44 OT_STRING = 134217744,
45 OT_ARRAY = 134217792,
46 OT_CLOSURE = 134217984,
47 OT_NATIVECLOSURE = 134218240,
48 OT_ASSET = 134218752,
49 OT_THREAD = 134221824,
50 OT_FUNCPROTO = 134225920,
51 OT_CLASS = 134234112,
52 OT_STRUCT = 136314880,
53 OT_WEAKREF = 134283264,
54 OT_TABLE = 167772192,
55 OT_USERDATA = 167772288,
56 OT_INSTANCE = 167804928,
57 OT_ENTITY = 171966464,
58}
59#[repr(C)]
60#[derive(Copy, Clone)]
61pub union SQObjectValue {
62 pub asString: *mut SQString,
63 pub asTable: *mut SQTable,
64 pub asClosure: *mut SQClosure,
65 pub asFuncProto: *mut SQFunctionProto,
66 pub asStructDef: *mut SQStructDef,
67 pub as64Integer: ::std::os::raw::c_longlong,
68 pub asNativeClosure: *mut SQNativeClosure,
69 pub asArray: *mut SQArray,
70 pub asThread: *mut HSquirrelVM,
71 pub asFloat: f32,
72 pub asInteger: ::std::os::raw::c_int,
73 pub asUserdata: *mut SQUserData,
74 pub asStructInstance: *mut SQStructInstance,
75}
76impl std::fmt::Debug for SQObjectValue {
77 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
78 f.write_str("SQObjectValue: unk union field")
79 }
80}
81#[test]
82fn bindgen_test_layout_SQObjectValue() {
83 const UNINIT: ::std::mem::MaybeUninit<SQObjectValue> = ::std::mem::MaybeUninit::uninit();
84 let ptr = UNINIT.as_ptr();
85 assert_eq!(
86 ::std::mem::size_of::<SQObjectValue>(),
87 8usize,
88 concat!("Size of: ", stringify!(SQObjectValue))
89 );
90 assert_eq!(
91 ::std::mem::align_of::<SQObjectValue>(),
92 8usize,
93 concat!("Alignment of ", stringify!(SQObjectValue))
94 );
95 assert_eq!(
96 unsafe { ::std::ptr::addr_of!((*ptr).asString) as usize - ptr as usize },
97 0usize,
98 concat!(
99 "Offset of field: ",
100 stringify!(SQObjectValue),
101 "::",
102 stringify!(asString)
103 )
104 );
105 assert_eq!(
106 unsafe { ::std::ptr::addr_of!((*ptr).asTable) as usize - ptr as usize },
107 0usize,
108 concat!(
109 "Offset of field: ",
110 stringify!(SQObjectValue),
111 "::",
112 stringify!(asTable)
113 )
114 );
115 assert_eq!(
116 unsafe { ::std::ptr::addr_of!((*ptr).asClosure) as usize - ptr as usize },
117 0usize,
118 concat!(
119 "Offset of field: ",
120 stringify!(SQObjectValue),
121 "::",
122 stringify!(asClosure)
123 )
124 );
125 assert_eq!(
126 unsafe { ::std::ptr::addr_of!((*ptr).asFuncProto) as usize - ptr as usize },
127 0usize,
128 concat!(
129 "Offset of field: ",
130 stringify!(SQObjectValue),
131 "::",
132 stringify!(asFuncProto)
133 )
134 );
135 assert_eq!(
136 unsafe { ::std::ptr::addr_of!((*ptr).asStructDef) as usize - ptr as usize },
137 0usize,
138 concat!(
139 "Offset of field: ",
140 stringify!(SQObjectValue),
141 "::",
142 stringify!(asStructDef)
143 )
144 );
145 assert_eq!(
146 unsafe { ::std::ptr::addr_of!((*ptr).as64Integer) as usize - ptr as usize },
147 0usize,
148 concat!(
149 "Offset of field: ",
150 stringify!(SQObjectValue),
151 "::",
152 stringify!(as64Integer)
153 )
154 );
155 assert_eq!(
156 unsafe { ::std::ptr::addr_of!((*ptr).asNativeClosure) as usize - ptr as usize },
157 0usize,
158 concat!(
159 "Offset of field: ",
160 stringify!(SQObjectValue),
161 "::",
162 stringify!(asNativeClosure)
163 )
164 );
165 assert_eq!(
166 unsafe { ::std::ptr::addr_of!((*ptr).asArray) as usize - ptr as usize },
167 0usize,
168 concat!(
169 "Offset of field: ",
170 stringify!(SQObjectValue),
171 "::",
172 stringify!(asArray)
173 )
174 );
175 assert_eq!(
176 unsafe { ::std::ptr::addr_of!((*ptr).asThread) as usize - ptr as usize },
177 0usize,
178 concat!(
179 "Offset of field: ",
180 stringify!(SQObjectValue),
181 "::",
182 stringify!(asThread)
183 )
184 );
185 assert_eq!(
186 unsafe { ::std::ptr::addr_of!((*ptr).asFloat) as usize - ptr as usize },
187 0usize,
188 concat!(
189 "Offset of field: ",
190 stringify!(SQObjectValue),
191 "::",
192 stringify!(asFloat)
193 )
194 );
195 assert_eq!(
196 unsafe { ::std::ptr::addr_of!((*ptr).asInteger) as usize - ptr as usize },
197 0usize,
198 concat!(
199 "Offset of field: ",
200 stringify!(SQObjectValue),
201 "::",
202 stringify!(asInteger)
203 )
204 );
205 assert_eq!(
206 unsafe { ::std::ptr::addr_of!((*ptr).asUserdata) as usize - ptr as usize },
207 0usize,
208 concat!(
209 "Offset of field: ",
210 stringify!(SQObjectValue),
211 "::",
212 stringify!(asUserdata)
213 )
214 );
215 assert_eq!(
216 unsafe { ::std::ptr::addr_of!((*ptr).asStructInstance) as usize - ptr as usize },
217 0usize,
218 concat!(
219 "Offset of field: ",
220 stringify!(SQObjectValue),
221 "::",
222 stringify!(asStructInstance)
223 )
224 );
225}
226#[repr(C)]
227#[derive(Debug, Copy, Clone)]
228pub struct SQVector {
229 pub _Type: SQObjectType,
230 pub x: f32,
231 pub y: f32,
232 pub z: f32,
233}
234#[test]
235fn bindgen_test_layout_SQVector() {
236 const UNINIT: ::std::mem::MaybeUninit<SQVector> = ::std::mem::MaybeUninit::uninit();
237 let ptr = UNINIT.as_ptr();
238 assert_eq!(
239 ::std::mem::size_of::<SQVector>(),
240 16usize,
241 concat!("Size of: ", stringify!(SQVector))
242 );
243 assert_eq!(
244 ::std::mem::align_of::<SQVector>(),
245 4usize,
246 concat!("Alignment of ", stringify!(SQVector))
247 );
248 assert_eq!(
249 unsafe { ::std::ptr::addr_of!((*ptr)._Type) as usize - ptr as usize },
250 0usize,
251 concat!(
252 "Offset of field: ",
253 stringify!(SQVector),
254 "::",
255 stringify!(_Type)
256 )
257 );
258 assert_eq!(
259 unsafe { ::std::ptr::addr_of!((*ptr).x) as usize - ptr as usize },
260 4usize,
261 concat!(
262 "Offset of field: ",
263 stringify!(SQVector),
264 "::",
265 stringify!(x)
266 )
267 );
268 assert_eq!(
269 unsafe { ::std::ptr::addr_of!((*ptr).y) as usize - ptr as usize },
270 8usize,
271 concat!(
272 "Offset of field: ",
273 stringify!(SQVector),
274 "::",
275 stringify!(y)
276 )
277 );
278 assert_eq!(
279 unsafe { ::std::ptr::addr_of!((*ptr).z) as usize - ptr as usize },
280 12usize,
281 concat!(
282 "Offset of field: ",
283 stringify!(SQVector),
284 "::",
285 stringify!(z)
286 )
287 );
288}
289#[repr(C)]
290#[derive(Copy, Clone, Debug)]
291pub struct SQObject {
292 pub _Type: SQObjectType,
293 pub structNumber: ::std::os::raw::c_int,
294 pub _VAL: SQObjectValue,
295}
296#[test]
297fn bindgen_test_layout_SQObject() {
298 const UNINIT: ::std::mem::MaybeUninit<SQObject> = ::std::mem::MaybeUninit::uninit();
299 let ptr = UNINIT.as_ptr();
300 assert_eq!(
301 ::std::mem::size_of::<SQObject>(),
302 16usize,
303 concat!("Size of: ", stringify!(SQObject))
304 );
305 assert_eq!(
306 ::std::mem::align_of::<SQObject>(),
307 8usize,
308 concat!("Alignment of ", stringify!(SQObject))
309 );
310 assert_eq!(
311 unsafe { ::std::ptr::addr_of!((*ptr)._Type) as usize - ptr as usize },
312 0usize,
313 concat!(
314 "Offset of field: ",
315 stringify!(SQObject),
316 "::",
317 stringify!(_Type)
318 )
319 );
320 assert_eq!(
321 unsafe { ::std::ptr::addr_of!((*ptr).structNumber) as usize - ptr as usize },
322 4usize,
323 concat!(
324 "Offset of field: ",
325 stringify!(SQObject),
326 "::",
327 stringify!(structNumber)
328 )
329 );
330 assert_eq!(
331 unsafe { ::std::ptr::addr_of!((*ptr)._VAL) as usize - ptr as usize },
332 8usize,
333 concat!(
334 "Offset of field: ",
335 stringify!(SQObject),
336 "::",
337 stringify!(_VAL)
338 )
339 );
340}
341#[repr(C)]
342#[derive(Debug, Copy, Clone)]
343pub struct SQString {
344 pub vftable: *mut ::std::os::raw::c_void,
345 pub uiRef: ::std::os::raw::c_int,
346 pub padding: ::std::os::raw::c_int,
347 pub _next_maybe: *mut SQString,
348 pub sharedState: *mut SQSharedState,
349 pub length: ::std::os::raw::c_int,
350 pub gap_24: [::std::os::raw::c_uchar; 4usize],
351 pub _hash: [::std::os::raw::c_char; 8usize],
352 pub _val: [::std::os::raw::c_char; 1usize],
353}
354#[test]
355fn bindgen_test_layout_SQString() {
356 const UNINIT: ::std::mem::MaybeUninit<SQString> = ::std::mem::MaybeUninit::uninit();
357 let ptr = UNINIT.as_ptr();
358 assert_eq!(
359 ::std::mem::size_of::<SQString>(),
360 56usize,
361 concat!("Size of: ", stringify!(SQString))
362 );
363 assert_eq!(
364 ::std::mem::align_of::<SQString>(),
365 8usize,
366 concat!("Alignment of ", stringify!(SQString))
367 );
368 assert_eq!(
369 unsafe { ::std::ptr::addr_of!((*ptr).vftable) as usize - ptr as usize },
370 0usize,
371 concat!(
372 "Offset of field: ",
373 stringify!(SQString),
374 "::",
375 stringify!(vftable)
376 )
377 );
378 assert_eq!(
379 unsafe { ::std::ptr::addr_of!((*ptr).uiRef) as usize - ptr as usize },
380 8usize,
381 concat!(
382 "Offset of field: ",
383 stringify!(SQString),
384 "::",
385 stringify!(uiRef)
386 )
387 );
388 assert_eq!(
389 unsafe { ::std::ptr::addr_of!((*ptr).padding) as usize - ptr as usize },
390 12usize,
391 concat!(
392 "Offset of field: ",
393 stringify!(SQString),
394 "::",
395 stringify!(padding)
396 )
397 );
398 assert_eq!(
399 unsafe { ::std::ptr::addr_of!((*ptr)._next_maybe) as usize - ptr as usize },
400 16usize,
401 concat!(
402 "Offset of field: ",
403 stringify!(SQString),
404 "::",
405 stringify!(_next_maybe)
406 )
407 );
408 assert_eq!(
409 unsafe { ::std::ptr::addr_of!((*ptr).sharedState) as usize - ptr as usize },
410 24usize,
411 concat!(
412 "Offset of field: ",
413 stringify!(SQString),
414 "::",
415 stringify!(sharedState)
416 )
417 );
418 assert_eq!(
419 unsafe { ::std::ptr::addr_of!((*ptr).length) as usize - ptr as usize },
420 32usize,
421 concat!(
422 "Offset of field: ",
423 stringify!(SQString),
424 "::",
425 stringify!(length)
426 )
427 );
428 assert_eq!(
429 unsafe { ::std::ptr::addr_of!((*ptr).gap_24) as usize - ptr as usize },
430 36usize,
431 concat!(
432 "Offset of field: ",
433 stringify!(SQString),
434 "::",
435 stringify!(gap_24)
436 )
437 );
438 assert_eq!(
439 unsafe { ::std::ptr::addr_of!((*ptr)._hash) as usize - ptr as usize },
440 40usize,
441 concat!(
442 "Offset of field: ",
443 stringify!(SQString),
444 "::",
445 stringify!(_hash)
446 )
447 );
448 assert_eq!(
449 unsafe { ::std::ptr::addr_of!((*ptr)._val) as usize - ptr as usize },
450 48usize,
451 concat!(
452 "Offset of field: ",
453 stringify!(SQString),
454 "::",
455 stringify!(_val)
456 )
457 );
458}
459#[repr(C)]
460#[derive(Debug, Copy, Clone)]
461pub struct SQTable {
462 pub vftable: *mut ::std::os::raw::c_void,
463 pub gap_08: [::std::os::raw::c_uchar; 4usize],
464 pub uiRef: ::std::os::raw::c_int,
465 pub gap_10: [::std::os::raw::c_uchar; 8usize],
466 pub pointer_18: *mut ::std::os::raw::c_void,
467 pub pointer_20: *mut ::std::os::raw::c_void,
468 pub _sharedState: *mut ::std::os::raw::c_void,
469 pub field_30: ::std::os::raw::c_longlong,
470 pub _nodes: *mut tableNode,
471 pub _numOfNodes: ::std::os::raw::c_int,
472 pub size: ::std::os::raw::c_int,
473 pub field_48: ::std::os::raw::c_int,
474 pub _usedNodes: ::std::os::raw::c_int,
475 pub _gap_50: [::std::os::raw::c_uchar; 20usize],
476 pub field_64: ::std::os::raw::c_int,
477 pub _gap_68: [::std::os::raw::c_uchar; 80usize],
478}
479#[test]
480fn bindgen_test_layout_SQTable() {
481 const UNINIT: ::std::mem::MaybeUninit<SQTable> = ::std::mem::MaybeUninit::uninit();
482 let ptr = UNINIT.as_ptr();
483 assert_eq!(
484 ::std::mem::size_of::<SQTable>(),
485 184usize,
486 concat!("Size of: ", stringify!(SQTable))
487 );
488 assert_eq!(
489 ::std::mem::align_of::<SQTable>(),
490 8usize,
491 concat!("Alignment of ", stringify!(SQTable))
492 );
493 assert_eq!(
494 unsafe { ::std::ptr::addr_of!((*ptr).vftable) as usize - ptr as usize },
495 0usize,
496 concat!(
497 "Offset of field: ",
498 stringify!(SQTable),
499 "::",
500 stringify!(vftable)
501 )
502 );
503 assert_eq!(
504 unsafe { ::std::ptr::addr_of!((*ptr).gap_08) as usize - ptr as usize },
505 8usize,
506 concat!(
507 "Offset of field: ",
508 stringify!(SQTable),
509 "::",
510 stringify!(gap_08)
511 )
512 );
513 assert_eq!(
514 unsafe { ::std::ptr::addr_of!((*ptr).uiRef) as usize - ptr as usize },
515 12usize,
516 concat!(
517 "Offset of field: ",
518 stringify!(SQTable),
519 "::",
520 stringify!(uiRef)
521 )
522 );
523 assert_eq!(
524 unsafe { ::std::ptr::addr_of!((*ptr).gap_10) as usize - ptr as usize },
525 16usize,
526 concat!(
527 "Offset of field: ",
528 stringify!(SQTable),
529 "::",
530 stringify!(gap_10)
531 )
532 );
533 assert_eq!(
534 unsafe { ::std::ptr::addr_of!((*ptr).pointer_18) as usize - ptr as usize },
535 24usize,
536 concat!(
537 "Offset of field: ",
538 stringify!(SQTable),
539 "::",
540 stringify!(pointer_18)
541 )
542 );
543 assert_eq!(
544 unsafe { ::std::ptr::addr_of!((*ptr).pointer_20) as usize - ptr as usize },
545 32usize,
546 concat!(
547 "Offset of field: ",
548 stringify!(SQTable),
549 "::",
550 stringify!(pointer_20)
551 )
552 );
553 assert_eq!(
554 unsafe { ::std::ptr::addr_of!((*ptr)._sharedState) as usize - ptr as usize },
555 40usize,
556 concat!(
557 "Offset of field: ",
558 stringify!(SQTable),
559 "::",
560 stringify!(_sharedState)
561 )
562 );
563 assert_eq!(
564 unsafe { ::std::ptr::addr_of!((*ptr).field_30) as usize - ptr as usize },
565 48usize,
566 concat!(
567 "Offset of field: ",
568 stringify!(SQTable),
569 "::",
570 stringify!(field_30)
571 )
572 );
573 assert_eq!(
574 unsafe { ::std::ptr::addr_of!((*ptr)._nodes) as usize - ptr as usize },
575 56usize,
576 concat!(
577 "Offset of field: ",
578 stringify!(SQTable),
579 "::",
580 stringify!(_nodes)
581 )
582 );
583 assert_eq!(
584 unsafe { ::std::ptr::addr_of!((*ptr)._numOfNodes) as usize - ptr as usize },
585 64usize,
586 concat!(
587 "Offset of field: ",
588 stringify!(SQTable),
589 "::",
590 stringify!(_numOfNodes)
591 )
592 );
593 assert_eq!(
594 unsafe { ::std::ptr::addr_of!((*ptr).size) as usize - ptr as usize },
595 68usize,
596 concat!(
597 "Offset of field: ",
598 stringify!(SQTable),
599 "::",
600 stringify!(size)
601 )
602 );
603 assert_eq!(
604 unsafe { ::std::ptr::addr_of!((*ptr).field_48) as usize - ptr as usize },
605 72usize,
606 concat!(
607 "Offset of field: ",
608 stringify!(SQTable),
609 "::",
610 stringify!(field_48)
611 )
612 );
613 assert_eq!(
614 unsafe { ::std::ptr::addr_of!((*ptr)._usedNodes) as usize - ptr as usize },
615 76usize,
616 concat!(
617 "Offset of field: ",
618 stringify!(SQTable),
619 "::",
620 stringify!(_usedNodes)
621 )
622 );
623 assert_eq!(
624 unsafe { ::std::ptr::addr_of!((*ptr)._gap_50) as usize - ptr as usize },
625 80usize,
626 concat!(
627 "Offset of field: ",
628 stringify!(SQTable),
629 "::",
630 stringify!(_gap_50)
631 )
632 );
633 assert_eq!(
634 unsafe { ::std::ptr::addr_of!((*ptr).field_64) as usize - ptr as usize },
635 100usize,
636 concat!(
637 "Offset of field: ",
638 stringify!(SQTable),
639 "::",
640 stringify!(field_64)
641 )
642 );
643 assert_eq!(
644 unsafe { ::std::ptr::addr_of!((*ptr)._gap_68) as usize - ptr as usize },
645 104usize,
646 concat!(
647 "Offset of field: ",
648 stringify!(SQTable),
649 "::",
650 stringify!(_gap_68)
651 )
652 );
653}
654#[repr(C)]
655#[derive(Copy, Clone)]
656pub struct SQClosure {
657 pub vftable: *mut ::std::os::raw::c_void,
658 pub gap_08: [::std::os::raw::c_uchar; 4usize],
659 pub uiRef: ::std::os::raw::c_int,
660 pub pointer_10: *mut ::std::os::raw::c_void,
661 pub pointer_18: *mut ::std::os::raw::c_void,
662 pub pointer_20: *mut ::std::os::raw::c_void,
663 pub sharedState: *mut ::std::os::raw::c_void,
664 pub obj_30: SQObject,
665 pub _function: SQObject,
666 pub _outervalues: *mut SQObject,
667 pub gap_58: [::std::os::raw::c_uchar; 8usize],
668 pub gap_60: [::std::os::raw::c_uchar; 96usize],
669 pub objectPointer_C0: *mut SQObject,
670 pub gap_C8: [::std::os::raw::c_uchar; 16usize],
671}
672#[test]
673fn bindgen_test_layout_SQClosure() {
674 const UNINIT: ::std::mem::MaybeUninit<SQClosure> = ::std::mem::MaybeUninit::uninit();
675 let ptr = UNINIT.as_ptr();
676 assert_eq!(
677 ::std::mem::size_of::<SQClosure>(),
678 216usize,
679 concat!("Size of: ", stringify!(SQClosure))
680 );
681 assert_eq!(
682 ::std::mem::align_of::<SQClosure>(),
683 8usize,
684 concat!("Alignment of ", stringify!(SQClosure))
685 );
686 assert_eq!(
687 unsafe { ::std::ptr::addr_of!((*ptr).vftable) as usize - ptr as usize },
688 0usize,
689 concat!(
690 "Offset of field: ",
691 stringify!(SQClosure),
692 "::",
693 stringify!(vftable)
694 )
695 );
696 assert_eq!(
697 unsafe { ::std::ptr::addr_of!((*ptr).gap_08) as usize - ptr as usize },
698 8usize,
699 concat!(
700 "Offset of field: ",
701 stringify!(SQClosure),
702 "::",
703 stringify!(gap_08)
704 )
705 );
706 assert_eq!(
707 unsafe { ::std::ptr::addr_of!((*ptr).uiRef) as usize - ptr as usize },
708 12usize,
709 concat!(
710 "Offset of field: ",
711 stringify!(SQClosure),
712 "::",
713 stringify!(uiRef)
714 )
715 );
716 assert_eq!(
717 unsafe { ::std::ptr::addr_of!((*ptr).pointer_10) as usize - ptr as usize },
718 16usize,
719 concat!(
720 "Offset of field: ",
721 stringify!(SQClosure),
722 "::",
723 stringify!(pointer_10)
724 )
725 );
726 assert_eq!(
727 unsafe { ::std::ptr::addr_of!((*ptr).pointer_18) as usize - ptr as usize },
728 24usize,
729 concat!(
730 "Offset of field: ",
731 stringify!(SQClosure),
732 "::",
733 stringify!(pointer_18)
734 )
735 );
736 assert_eq!(
737 unsafe { ::std::ptr::addr_of!((*ptr).pointer_20) as usize - ptr as usize },
738 32usize,
739 concat!(
740 "Offset of field: ",
741 stringify!(SQClosure),
742 "::",
743 stringify!(pointer_20)
744 )
745 );
746 assert_eq!(
747 unsafe { ::std::ptr::addr_of!((*ptr).sharedState) as usize - ptr as usize },
748 40usize,
749 concat!(
750 "Offset of field: ",
751 stringify!(SQClosure),
752 "::",
753 stringify!(sharedState)
754 )
755 );
756 assert_eq!(
757 unsafe { ::std::ptr::addr_of!((*ptr).obj_30) as usize - ptr as usize },
758 48usize,
759 concat!(
760 "Offset of field: ",
761 stringify!(SQClosure),
762 "::",
763 stringify!(obj_30)
764 )
765 );
766 assert_eq!(
767 unsafe { ::std::ptr::addr_of!((*ptr)._function) as usize - ptr as usize },
768 64usize,
769 concat!(
770 "Offset of field: ",
771 stringify!(SQClosure),
772 "::",
773 stringify!(_function)
774 )
775 );
776 assert_eq!(
777 unsafe { ::std::ptr::addr_of!((*ptr)._outervalues) as usize - ptr as usize },
778 80usize,
779 concat!(
780 "Offset of field: ",
781 stringify!(SQClosure),
782 "::",
783 stringify!(_outervalues)
784 )
785 );
786 assert_eq!(
787 unsafe { ::std::ptr::addr_of!((*ptr).gap_58) as usize - ptr as usize },
788 88usize,
789 concat!(
790 "Offset of field: ",
791 stringify!(SQClosure),
792 "::",
793 stringify!(gap_58)
794 )
795 );
796 assert_eq!(
797 unsafe { ::std::ptr::addr_of!((*ptr).gap_60) as usize - ptr as usize },
798 96usize,
799 concat!(
800 "Offset of field: ",
801 stringify!(SQClosure),
802 "::",
803 stringify!(gap_60)
804 )
805 );
806 assert_eq!(
807 unsafe { ::std::ptr::addr_of!((*ptr).objectPointer_C0) as usize - ptr as usize },
808 192usize,
809 concat!(
810 "Offset of field: ",
811 stringify!(SQClosure),
812 "::",
813 stringify!(objectPointer_C0)
814 )
815 );
816 assert_eq!(
817 unsafe { ::std::ptr::addr_of!((*ptr).gap_C8) as usize - ptr as usize },
818 200usize,
819 concat!(
820 "Offset of field: ",
821 stringify!(SQClosure),
822 "::",
823 stringify!(gap_C8)
824 )
825 );
826}
827#[repr(C)]
828#[derive(Copy, Clone)]
829pub struct SQFunctionProto {
830 pub vftable: *mut ::std::os::raw::c_void,
831 pub gap_08: [::std::os::raw::c_uchar; 4usize],
832 pub uiRef: ::std::os::raw::c_int,
833 pub gap_10: [::std::os::raw::c_uchar; 8usize],
834 pub pointer_18: *mut ::std::os::raw::c_void,
835 pub pointer_20: *mut ::std::os::raw::c_void,
836 pub sharedState: *mut ::std::os::raw::c_void,
837 pub pointer_30: *mut ::std::os::raw::c_void,
838 pub _fileNameType: SQObjectType,
839 pub _fileName: *mut SQString,
840 pub _funcNameType: SQObjectType,
841 pub _funcName: *mut SQString,
842 pub obj_58: SQObject,
843 pub gap_68: [::std::os::raw::c_uchar; 12usize],
844 pub _stacksize: ::std::os::raw::c_int,
845 pub gap_78: [::std::os::raw::c_uchar; 48usize],
846 pub nParameters: ::std::os::raw::c_int,
847 pub gap_AC: [::std::os::raw::c_uchar; 60usize],
848 pub nDefaultParams: ::std::os::raw::c_int,
849 pub gap_EC: [::std::os::raw::c_uchar; 200usize],
850}
851#[test]
852fn bindgen_test_layout_SQFunctionProto() {
853 const UNINIT: ::std::mem::MaybeUninit<SQFunctionProto> = ::std::mem::MaybeUninit::uninit();
854 let ptr = UNINIT.as_ptr();
855 assert_eq!(
856 ::std::mem::size_of::<SQFunctionProto>(),
857 440usize,
858 concat!("Size of: ", stringify!(SQFunctionProto))
859 );
860 assert_eq!(
861 ::std::mem::align_of::<SQFunctionProto>(),
862 8usize,
863 concat!("Alignment of ", stringify!(SQFunctionProto))
864 );
865 assert_eq!(
866 unsafe { ::std::ptr::addr_of!((*ptr).vftable) as usize - ptr as usize },
867 0usize,
868 concat!(
869 "Offset of field: ",
870 stringify!(SQFunctionProto),
871 "::",
872 stringify!(vftable)
873 )
874 );
875 assert_eq!(
876 unsafe { ::std::ptr::addr_of!((*ptr).gap_08) as usize - ptr as usize },
877 8usize,
878 concat!(
879 "Offset of field: ",
880 stringify!(SQFunctionProto),
881 "::",
882 stringify!(gap_08)
883 )
884 );
885 assert_eq!(
886 unsafe { ::std::ptr::addr_of!((*ptr).uiRef) as usize - ptr as usize },
887 12usize,
888 concat!(
889 "Offset of field: ",
890 stringify!(SQFunctionProto),
891 "::",
892 stringify!(uiRef)
893 )
894 );
895 assert_eq!(
896 unsafe { ::std::ptr::addr_of!((*ptr).gap_10) as usize - ptr as usize },
897 16usize,
898 concat!(
899 "Offset of field: ",
900 stringify!(SQFunctionProto),
901 "::",
902 stringify!(gap_10)
903 )
904 );
905 assert_eq!(
906 unsafe { ::std::ptr::addr_of!((*ptr).pointer_18) as usize - ptr as usize },
907 24usize,
908 concat!(
909 "Offset of field: ",
910 stringify!(SQFunctionProto),
911 "::",
912 stringify!(pointer_18)
913 )
914 );
915 assert_eq!(
916 unsafe { ::std::ptr::addr_of!((*ptr).pointer_20) as usize - ptr as usize },
917 32usize,
918 concat!(
919 "Offset of field: ",
920 stringify!(SQFunctionProto),
921 "::",
922 stringify!(pointer_20)
923 )
924 );
925 assert_eq!(
926 unsafe { ::std::ptr::addr_of!((*ptr).sharedState) as usize - ptr as usize },
927 40usize,
928 concat!(
929 "Offset of field: ",
930 stringify!(SQFunctionProto),
931 "::",
932 stringify!(sharedState)
933 )
934 );
935 assert_eq!(
936 unsafe { ::std::ptr::addr_of!((*ptr).pointer_30) as usize - ptr as usize },
937 48usize,
938 concat!(
939 "Offset of field: ",
940 stringify!(SQFunctionProto),
941 "::",
942 stringify!(pointer_30)
943 )
944 );
945 assert_eq!(
946 unsafe { ::std::ptr::addr_of!((*ptr)._fileNameType) as usize - ptr as usize },
947 56usize,
948 concat!(
949 "Offset of field: ",
950 stringify!(SQFunctionProto),
951 "::",
952 stringify!(_fileNameType)
953 )
954 );
955 assert_eq!(
956 unsafe { ::std::ptr::addr_of!((*ptr)._fileName) as usize - ptr as usize },
957 64usize,
958 concat!(
959 "Offset of field: ",
960 stringify!(SQFunctionProto),
961 "::",
962 stringify!(_fileName)
963 )
964 );
965 assert_eq!(
966 unsafe { ::std::ptr::addr_of!((*ptr)._funcNameType) as usize - ptr as usize },
967 72usize,
968 concat!(
969 "Offset of field: ",
970 stringify!(SQFunctionProto),
971 "::",
972 stringify!(_funcNameType)
973 )
974 );
975 assert_eq!(
976 unsafe { ::std::ptr::addr_of!((*ptr)._funcName) as usize - ptr as usize },
977 80usize,
978 concat!(
979 "Offset of field: ",
980 stringify!(SQFunctionProto),
981 "::",
982 stringify!(_funcName)
983 )
984 );
985 assert_eq!(
986 unsafe { ::std::ptr::addr_of!((*ptr).obj_58) as usize - ptr as usize },
987 88usize,
988 concat!(
989 "Offset of field: ",
990 stringify!(SQFunctionProto),
991 "::",
992 stringify!(obj_58)
993 )
994 );
995 assert_eq!(
996 unsafe { ::std::ptr::addr_of!((*ptr).gap_68) as usize - ptr as usize },
997 104usize,
998 concat!(
999 "Offset of field: ",
1000 stringify!(SQFunctionProto),
1001 "::",
1002 stringify!(gap_68)
1003 )
1004 );
1005 assert_eq!(
1006 unsafe { ::std::ptr::addr_of!((*ptr)._stacksize) as usize - ptr as usize },
1007 116usize,
1008 concat!(
1009 "Offset of field: ",
1010 stringify!(SQFunctionProto),
1011 "::",
1012 stringify!(_stacksize)
1013 )
1014 );
1015 assert_eq!(
1016 unsafe { ::std::ptr::addr_of!((*ptr).gap_78) as usize - ptr as usize },
1017 120usize,
1018 concat!(
1019 "Offset of field: ",
1020 stringify!(SQFunctionProto),
1021 "::",
1022 stringify!(gap_78)
1023 )
1024 );
1025 assert_eq!(
1026 unsafe { ::std::ptr::addr_of!((*ptr).nParameters) as usize - ptr as usize },
1027 168usize,
1028 concat!(
1029 "Offset of field: ",
1030 stringify!(SQFunctionProto),
1031 "::",
1032 stringify!(nParameters)
1033 )
1034 );
1035 assert_eq!(
1036 unsafe { ::std::ptr::addr_of!((*ptr).gap_AC) as usize - ptr as usize },
1037 172usize,
1038 concat!(
1039 "Offset of field: ",
1040 stringify!(SQFunctionProto),
1041 "::",
1042 stringify!(gap_AC)
1043 )
1044 );
1045 assert_eq!(
1046 unsafe { ::std::ptr::addr_of!((*ptr).nDefaultParams) as usize - ptr as usize },
1047 232usize,
1048 concat!(
1049 "Offset of field: ",
1050 stringify!(SQFunctionProto),
1051 "::",
1052 stringify!(nDefaultParams)
1053 )
1054 );
1055 assert_eq!(
1056 unsafe { ::std::ptr::addr_of!((*ptr).gap_EC) as usize - ptr as usize },
1057 236usize,
1058 concat!(
1059 "Offset of field: ",
1060 stringify!(SQFunctionProto),
1061 "::",
1062 stringify!(gap_EC)
1063 )
1064 );
1065}
1066#[repr(C)]
1067#[derive(Debug, Copy, Clone)]
1068pub struct SQStructDef {
1069 pub vtable: *mut ::std::os::raw::c_void,
1070 pub uiRef: ::std::os::raw::c_int,
1071 pub padding_C: [::std::os::raw::c_uchar; 4usize],
1072 pub unknown: [::std::os::raw::c_uchar; 24usize],
1073 pub sharedState: *mut SQSharedState,
1074 pub _nameType: SQObjectType,
1075 pub _name: *mut SQString,
1076 pub gap_38: [::std::os::raw::c_uchar; 16usize],
1077 pub _variableNamesType: SQObjectType,
1078 pub _variableNames: *mut SQTable,
1079 pub gap_: [::std::os::raw::c_uchar; 32usize],
1080}
1081#[test]
1082fn bindgen_test_layout_SQStructDef() {
1083 const UNINIT: ::std::mem::MaybeUninit<SQStructDef> = ::std::mem::MaybeUninit::uninit();
1084 let ptr = UNINIT.as_ptr();
1085 assert_eq!(
1086 ::std::mem::size_of::<SQStructDef>(),
1087 128usize,
1088 concat!("Size of: ", stringify!(SQStructDef))
1089 );
1090 assert_eq!(
1091 ::std::mem::align_of::<SQStructDef>(),
1092 8usize,
1093 concat!("Alignment of ", stringify!(SQStructDef))
1094 );
1095 assert_eq!(
1096 unsafe { ::std::ptr::addr_of!((*ptr).vtable) as usize - ptr as usize },
1097 0usize,
1098 concat!(
1099 "Offset of field: ",
1100 stringify!(SQStructDef),
1101 "::",
1102 stringify!(vtable)
1103 )
1104 );
1105 assert_eq!(
1106 unsafe { ::std::ptr::addr_of!((*ptr).uiRef) as usize - ptr as usize },
1107 8usize,
1108 concat!(
1109 "Offset of field: ",
1110 stringify!(SQStructDef),
1111 "::",
1112 stringify!(uiRef)
1113 )
1114 );
1115 assert_eq!(
1116 unsafe { ::std::ptr::addr_of!((*ptr).padding_C) as usize - ptr as usize },
1117 12usize,
1118 concat!(
1119 "Offset of field: ",
1120 stringify!(SQStructDef),
1121 "::",
1122 stringify!(padding_C)
1123 )
1124 );
1125 assert_eq!(
1126 unsafe { ::std::ptr::addr_of!((*ptr).unknown) as usize - ptr as usize },
1127 16usize,
1128 concat!(
1129 "Offset of field: ",
1130 stringify!(SQStructDef),
1131 "::",
1132 stringify!(unknown)
1133 )
1134 );
1135 assert_eq!(
1136 unsafe { ::std::ptr::addr_of!((*ptr).sharedState) as usize - ptr as usize },
1137 40usize,
1138 concat!(
1139 "Offset of field: ",
1140 stringify!(SQStructDef),
1141 "::",
1142 stringify!(sharedState)
1143 )
1144 );
1145 assert_eq!(
1146 unsafe { ::std::ptr::addr_of!((*ptr)._nameType) as usize - ptr as usize },
1147 48usize,
1148 concat!(
1149 "Offset of field: ",
1150 stringify!(SQStructDef),
1151 "::",
1152 stringify!(_nameType)
1153 )
1154 );
1155 assert_eq!(
1156 unsafe { ::std::ptr::addr_of!((*ptr)._name) as usize - ptr as usize },
1157 56usize,
1158 concat!(
1159 "Offset of field: ",
1160 stringify!(SQStructDef),
1161 "::",
1162 stringify!(_name)
1163 )
1164 );
1165 assert_eq!(
1166 unsafe { ::std::ptr::addr_of!((*ptr).gap_38) as usize - ptr as usize },
1167 64usize,
1168 concat!(
1169 "Offset of field: ",
1170 stringify!(SQStructDef),
1171 "::",
1172 stringify!(gap_38)
1173 )
1174 );
1175 assert_eq!(
1176 unsafe { ::std::ptr::addr_of!((*ptr)._variableNamesType) as usize - ptr as usize },
1177 80usize,
1178 concat!(
1179 "Offset of field: ",
1180 stringify!(SQStructDef),
1181 "::",
1182 stringify!(_variableNamesType)
1183 )
1184 );
1185 assert_eq!(
1186 unsafe { ::std::ptr::addr_of!((*ptr)._variableNames) as usize - ptr as usize },
1187 88usize,
1188 concat!(
1189 "Offset of field: ",
1190 stringify!(SQStructDef),
1191 "::",
1192 stringify!(_variableNames)
1193 )
1194 );
1195 assert_eq!(
1196 unsafe { ::std::ptr::addr_of!((*ptr).gap_) as usize - ptr as usize },
1197 96usize,
1198 concat!(
1199 "Offset of field: ",
1200 stringify!(SQStructDef),
1201 "::",
1202 stringify!(gap_)
1203 )
1204 );
1205}
1206#[repr(C)]
1207#[derive(Debug, Copy, Clone)]
1208pub struct SQNativeClosure {
1209 pub vftable: *mut ::std::os::raw::c_void,
1210 pub uiRef: ::std::os::raw::c_int,
1211 pub gap_C: [::std::os::raw::c_uchar; 4usize],
1212 pub value_10: ::std::os::raw::c_longlong,
1213 pub value_18: ::std::os::raw::c_longlong,
1214 pub value_20: ::std::os::raw::c_longlong,
1215 pub sharedState: *mut SQSharedState,
1216 pub unknown_30: ::std::os::raw::c_char,
1217 pub padding_34: [::std::os::raw::c_uchar; 7usize],
1218 pub value_38: ::std::os::raw::c_longlong,
1219 pub value_40: ::std::os::raw::c_longlong,
1220 pub value_48: ::std::os::raw::c_longlong,
1221 pub value_50: ::std::os::raw::c_longlong,
1222 pub value_58: ::std::os::raw::c_longlong,
1223 pub _nameType: SQObjectType,
1224 pub _name: *mut SQString,
1225 pub value_70: ::std::os::raw::c_longlong,
1226 pub value_78: ::std::os::raw::c_longlong,
1227 pub justInCaseGap_80: [::std::os::raw::c_uchar; 300usize],
1228}
1229#[test]
1230fn bindgen_test_layout_SQNativeClosure() {
1231 const UNINIT: ::std::mem::MaybeUninit<SQNativeClosure> = ::std::mem::MaybeUninit::uninit();
1232 let ptr = UNINIT.as_ptr();
1233 assert_eq!(
1234 ::std::mem::size_of::<SQNativeClosure>(),
1235 432usize,
1236 concat!("Size of: ", stringify!(SQNativeClosure))
1237 );
1238 assert_eq!(
1239 ::std::mem::align_of::<SQNativeClosure>(),
1240 8usize,
1241 concat!("Alignment of ", stringify!(SQNativeClosure))
1242 );
1243 assert_eq!(
1244 unsafe { ::std::ptr::addr_of!((*ptr).vftable) as usize - ptr as usize },
1245 0usize,
1246 concat!(
1247 "Offset of field: ",
1248 stringify!(SQNativeClosure),
1249 "::",
1250 stringify!(vftable)
1251 )
1252 );
1253 assert_eq!(
1254 unsafe { ::std::ptr::addr_of!((*ptr).uiRef) as usize - ptr as usize },
1255 8usize,
1256 concat!(
1257 "Offset of field: ",
1258 stringify!(SQNativeClosure),
1259 "::",
1260 stringify!(uiRef)
1261 )
1262 );
1263 assert_eq!(
1264 unsafe { ::std::ptr::addr_of!((*ptr).gap_C) as usize - ptr as usize },
1265 12usize,
1266 concat!(
1267 "Offset of field: ",
1268 stringify!(SQNativeClosure),
1269 "::",
1270 stringify!(gap_C)
1271 )
1272 );
1273 assert_eq!(
1274 unsafe { ::std::ptr::addr_of!((*ptr).value_10) as usize - ptr as usize },
1275 16usize,
1276 concat!(
1277 "Offset of field: ",
1278 stringify!(SQNativeClosure),
1279 "::",
1280 stringify!(value_10)
1281 )
1282 );
1283 assert_eq!(
1284 unsafe { ::std::ptr::addr_of!((*ptr).value_18) as usize - ptr as usize },
1285 24usize,
1286 concat!(
1287 "Offset of field: ",
1288 stringify!(SQNativeClosure),
1289 "::",
1290 stringify!(value_18)
1291 )
1292 );
1293 assert_eq!(
1294 unsafe { ::std::ptr::addr_of!((*ptr).value_20) as usize - ptr as usize },
1295 32usize,
1296 concat!(
1297 "Offset of field: ",
1298 stringify!(SQNativeClosure),
1299 "::",
1300 stringify!(value_20)
1301 )
1302 );
1303 assert_eq!(
1304 unsafe { ::std::ptr::addr_of!((*ptr).sharedState) as usize - ptr as usize },
1305 40usize,
1306 concat!(
1307 "Offset of field: ",
1308 stringify!(SQNativeClosure),
1309 "::",
1310 stringify!(sharedState)
1311 )
1312 );
1313 assert_eq!(
1314 unsafe { ::std::ptr::addr_of!((*ptr).unknown_30) as usize - ptr as usize },
1315 48usize,
1316 concat!(
1317 "Offset of field: ",
1318 stringify!(SQNativeClosure),
1319 "::",
1320 stringify!(unknown_30)
1321 )
1322 );
1323 assert_eq!(
1324 unsafe { ::std::ptr::addr_of!((*ptr).padding_34) as usize - ptr as usize },
1325 49usize,
1326 concat!(
1327 "Offset of field: ",
1328 stringify!(SQNativeClosure),
1329 "::",
1330 stringify!(padding_34)
1331 )
1332 );
1333 assert_eq!(
1334 unsafe { ::std::ptr::addr_of!((*ptr).value_38) as usize - ptr as usize },
1335 56usize,
1336 concat!(
1337 "Offset of field: ",
1338 stringify!(SQNativeClosure),
1339 "::",
1340 stringify!(value_38)
1341 )
1342 );
1343 assert_eq!(
1344 unsafe { ::std::ptr::addr_of!((*ptr).value_40) as usize - ptr as usize },
1345 64usize,
1346 concat!(
1347 "Offset of field: ",
1348 stringify!(SQNativeClosure),
1349 "::",
1350 stringify!(value_40)
1351 )
1352 );
1353 assert_eq!(
1354 unsafe { ::std::ptr::addr_of!((*ptr).value_48) as usize - ptr as usize },
1355 72usize,
1356 concat!(
1357 "Offset of field: ",
1358 stringify!(SQNativeClosure),
1359 "::",
1360 stringify!(value_48)
1361 )
1362 );
1363 assert_eq!(
1364 unsafe { ::std::ptr::addr_of!((*ptr).value_50) as usize - ptr as usize },
1365 80usize,
1366 concat!(
1367 "Offset of field: ",
1368 stringify!(SQNativeClosure),
1369 "::",
1370 stringify!(value_50)
1371 )
1372 );
1373 assert_eq!(
1374 unsafe { ::std::ptr::addr_of!((*ptr).value_58) as usize - ptr as usize },
1375 88usize,
1376 concat!(
1377 "Offset of field: ",
1378 stringify!(SQNativeClosure),
1379 "::",
1380 stringify!(value_58)
1381 )
1382 );
1383 assert_eq!(
1384 unsafe { ::std::ptr::addr_of!((*ptr)._nameType) as usize - ptr as usize },
1385 96usize,
1386 concat!(
1387 "Offset of field: ",
1388 stringify!(SQNativeClosure),
1389 "::",
1390 stringify!(_nameType)
1391 )
1392 );
1393 assert_eq!(
1394 unsafe { ::std::ptr::addr_of!((*ptr)._name) as usize - ptr as usize },
1395 104usize,
1396 concat!(
1397 "Offset of field: ",
1398 stringify!(SQNativeClosure),
1399 "::",
1400 stringify!(_name)
1401 )
1402 );
1403 assert_eq!(
1404 unsafe { ::std::ptr::addr_of!((*ptr).value_70) as usize - ptr as usize },
1405 112usize,
1406 concat!(
1407 "Offset of field: ",
1408 stringify!(SQNativeClosure),
1409 "::",
1410 stringify!(value_70)
1411 )
1412 );
1413 assert_eq!(
1414 unsafe { ::std::ptr::addr_of!((*ptr).value_78) as usize - ptr as usize },
1415 120usize,
1416 concat!(
1417 "Offset of field: ",
1418 stringify!(SQNativeClosure),
1419 "::",
1420 stringify!(value_78)
1421 )
1422 );
1423 assert_eq!(
1424 unsafe { ::std::ptr::addr_of!((*ptr).justInCaseGap_80) as usize - ptr as usize },
1425 128usize,
1426 concat!(
1427 "Offset of field: ",
1428 stringify!(SQNativeClosure),
1429 "::",
1430 stringify!(justInCaseGap_80)
1431 )
1432 );
1433}
1434#[repr(C)]
1435#[derive(Debug, Copy, Clone)]
1436pub struct SQArray {
1437 pub vftable: *mut ::std::os::raw::c_void,
1438 pub uiRef: ::std::os::raw::c_int,
1439 pub gap_24: [::std::os::raw::c_uchar; 36usize],
1440 pub _values: *mut SQObject,
1441 pub _usedSlots: ::std::os::raw::c_int,
1442 pub _allocated: ::std::os::raw::c_int,
1443}
1444#[test]
1445fn bindgen_test_layout_SQArray() {
1446 const UNINIT: ::std::mem::MaybeUninit<SQArray> = ::std::mem::MaybeUninit::uninit();
1447 let ptr = UNINIT.as_ptr();
1448 assert_eq!(
1449 ::std::mem::size_of::<SQArray>(),
1450 64usize,
1451 concat!("Size of: ", stringify!(SQArray))
1452 );
1453 assert_eq!(
1454 ::std::mem::align_of::<SQArray>(),
1455 8usize,
1456 concat!("Alignment of ", stringify!(SQArray))
1457 );
1458 assert_eq!(
1459 unsafe { ::std::ptr::addr_of!((*ptr).vftable) as usize - ptr as usize },
1460 0usize,
1461 concat!(
1462 "Offset of field: ",
1463 stringify!(SQArray),
1464 "::",
1465 stringify!(vftable)
1466 )
1467 );
1468 assert_eq!(
1469 unsafe { ::std::ptr::addr_of!((*ptr).uiRef) as usize - ptr as usize },
1470 8usize,
1471 concat!(
1472 "Offset of field: ",
1473 stringify!(SQArray),
1474 "::",
1475 stringify!(uiRef)
1476 )
1477 );
1478 assert_eq!(
1479 unsafe { ::std::ptr::addr_of!((*ptr).gap_24) as usize - ptr as usize },
1480 12usize,
1481 concat!(
1482 "Offset of field: ",
1483 stringify!(SQArray),
1484 "::",
1485 stringify!(gap_24)
1486 )
1487 );
1488 assert_eq!(
1489 unsafe { ::std::ptr::addr_of!((*ptr)._values) as usize - ptr as usize },
1490 48usize,
1491 concat!(
1492 "Offset of field: ",
1493 stringify!(SQArray),
1494 "::",
1495 stringify!(_values)
1496 )
1497 );
1498 assert_eq!(
1499 unsafe { ::std::ptr::addr_of!((*ptr)._usedSlots) as usize - ptr as usize },
1500 56usize,
1501 concat!(
1502 "Offset of field: ",
1503 stringify!(SQArray),
1504 "::",
1505 stringify!(_usedSlots)
1506 )
1507 );
1508 assert_eq!(
1509 unsafe { ::std::ptr::addr_of!((*ptr)._allocated) as usize - ptr as usize },
1510 60usize,
1511 concat!(
1512 "Offset of field: ",
1513 stringify!(SQArray),
1514 "::",
1515 stringify!(_allocated)
1516 )
1517 );
1518}
1519#[repr(C)]
1520pub struct HSquirrelVM {
1521 pub vftable: *mut ::std::os::raw::c_void,
1522 pub uiRef: ::std::os::raw::c_int,
1523 pub gap_8: [::std::os::raw::c_uchar; 12usize],
1524 pub _toString: *mut ::std::os::raw::c_void,
1525 pub _roottable_pointer: *mut ::std::os::raw::c_void,
1526 pub pointer_28: *mut ::std::os::raw::c_void,
1527 pub ci: *mut CallInfo,
1528 pub _callstack: *mut CallInfo,
1529 pub _callstacksize: ::std::os::raw::c_int,
1530 pub _stackbase: ::std::os::raw::c_int,
1531 pub _stackOfCurrentFunction: *mut SQObject,
1532 pub sharedState: *mut SQSharedState,
1533 pub pointer_58: *mut ::std::os::raw::c_void,
1534 pub pointer_60: *mut ::std::os::raw::c_void,
1535 pub _top: ::std::os::raw::c_int,
1536 pub _stack: *mut SQObject,
1537 pub gap_78: [::std::os::raw::c_uchar; 8usize],
1538 pub _vargvstack: *mut SQObject,
1539 pub gap_88: [::std::os::raw::c_uchar; 8usize],
1540 pub temp_reg: SQObject,
1541 pub gapA0: [::std::os::raw::c_uchar; 8usize],
1542 pub pointer_A8: *mut ::std::os::raw::c_void,
1543 pub gap_B0: [::std::os::raw::c_uchar; 8usize],
1544 pub _roottable_object: SQObject,
1545 pub _lasterror: SQObject,
1546 pub _errorHandler: SQObject,
1547 pub field_E8: ::std::os::raw::c_longlong,
1548 pub traps: ::std::os::raw::c_int,
1549 pub gap_F4: [::std::os::raw::c_uchar; 12usize],
1550 pub _nnativecalls: ::std::os::raw::c_int,
1551 pub _suspended: ::std::os::raw::c_int,
1552 pub _suspended_root: ::std::os::raw::c_int,
1553 pub _unk: ::std::os::raw::c_int,
1554 pub _suspended_target: ::std::os::raw::c_int,
1555 pub trapAmount: ::std::os::raw::c_int,
1556 pub _suspend_varargs: ::std::os::raw::c_int,
1557 pub unknown_field_11C: ::std::os::raw::c_int,
1558 pub object_120: SQObject,
1559}
1560#[test]
1561fn bindgen_test_layout_HSquirrelVM() {
1562 const UNINIT: ::std::mem::MaybeUninit<HSquirrelVM> = ::std::mem::MaybeUninit::uninit();
1563 let ptr = UNINIT.as_ptr();
1564 assert_eq!(
1565 ::std::mem::size_of::<HSquirrelVM>(),
1566 304usize,
1567 concat!("Size of: ", stringify!(HSquirrelVM))
1568 );
1569 assert_eq!(
1570 ::std::mem::align_of::<HSquirrelVM>(),
1571 8usize,
1572 concat!("Alignment of ", stringify!(HSquirrelVM))
1573 );
1574 assert_eq!(
1575 unsafe { ::std::ptr::addr_of!((*ptr).vftable) as usize - ptr as usize },
1576 0usize,
1577 concat!(
1578 "Offset of field: ",
1579 stringify!(HSquirrelVM),
1580 "::",
1581 stringify!(vftable)
1582 )
1583 );
1584 assert_eq!(
1585 unsafe { ::std::ptr::addr_of!((*ptr).uiRef) as usize - ptr as usize },
1586 8usize,
1587 concat!(
1588 "Offset of field: ",
1589 stringify!(HSquirrelVM),
1590 "::",
1591 stringify!(uiRef)
1592 )
1593 );
1594 assert_eq!(
1595 unsafe { ::std::ptr::addr_of!((*ptr).gap_8) as usize - ptr as usize },
1596 12usize,
1597 concat!(
1598 "Offset of field: ",
1599 stringify!(HSquirrelVM),
1600 "::",
1601 stringify!(gap_8)
1602 )
1603 );
1604 assert_eq!(
1605 unsafe { ::std::ptr::addr_of!((*ptr)._toString) as usize - ptr as usize },
1606 24usize,
1607 concat!(
1608 "Offset of field: ",
1609 stringify!(HSquirrelVM),
1610 "::",
1611 stringify!(_toString)
1612 )
1613 );
1614 assert_eq!(
1615 unsafe { ::std::ptr::addr_of!((*ptr)._roottable_pointer) as usize - ptr as usize },
1616 32usize,
1617 concat!(
1618 "Offset of field: ",
1619 stringify!(HSquirrelVM),
1620 "::",
1621 stringify!(_roottable_pointer)
1622 )
1623 );
1624 assert_eq!(
1625 unsafe { ::std::ptr::addr_of!((*ptr).pointer_28) as usize - ptr as usize },
1626 40usize,
1627 concat!(
1628 "Offset of field: ",
1629 stringify!(HSquirrelVM),
1630 "::",
1631 stringify!(pointer_28)
1632 )
1633 );
1634 assert_eq!(
1635 unsafe { ::std::ptr::addr_of!((*ptr).ci) as usize - ptr as usize },
1636 48usize,
1637 concat!(
1638 "Offset of field: ",
1639 stringify!(HSquirrelVM),
1640 "::",
1641 stringify!(ci)
1642 )
1643 );
1644 assert_eq!(
1645 unsafe { ::std::ptr::addr_of!((*ptr)._callstack) as usize - ptr as usize },
1646 56usize,
1647 concat!(
1648 "Offset of field: ",
1649 stringify!(HSquirrelVM),
1650 "::",
1651 stringify!(_callstack)
1652 )
1653 );
1654 assert_eq!(
1655 unsafe { ::std::ptr::addr_of!((*ptr)._callstacksize) as usize - ptr as usize },
1656 64usize,
1657 concat!(
1658 "Offset of field: ",
1659 stringify!(HSquirrelVM),
1660 "::",
1661 stringify!(_callstacksize)
1662 )
1663 );
1664 assert_eq!(
1665 unsafe { ::std::ptr::addr_of!((*ptr)._stackbase) as usize - ptr as usize },
1666 68usize,
1667 concat!(
1668 "Offset of field: ",
1669 stringify!(HSquirrelVM),
1670 "::",
1671 stringify!(_stackbase)
1672 )
1673 );
1674 assert_eq!(
1675 unsafe { ::std::ptr::addr_of!((*ptr)._stackOfCurrentFunction) as usize - ptr as usize },
1676 72usize,
1677 concat!(
1678 "Offset of field: ",
1679 stringify!(HSquirrelVM),
1680 "::",
1681 stringify!(_stackOfCurrentFunction)
1682 )
1683 );
1684 assert_eq!(
1685 unsafe { ::std::ptr::addr_of!((*ptr).sharedState) as usize - ptr as usize },
1686 80usize,
1687 concat!(
1688 "Offset of field: ",
1689 stringify!(HSquirrelVM),
1690 "::",
1691 stringify!(sharedState)
1692 )
1693 );
1694 assert_eq!(
1695 unsafe { ::std::ptr::addr_of!((*ptr).pointer_58) as usize - ptr as usize },
1696 88usize,
1697 concat!(
1698 "Offset of field: ",
1699 stringify!(HSquirrelVM),
1700 "::",
1701 stringify!(pointer_58)
1702 )
1703 );
1704 assert_eq!(
1705 unsafe { ::std::ptr::addr_of!((*ptr).pointer_60) as usize - ptr as usize },
1706 96usize,
1707 concat!(
1708 "Offset of field: ",
1709 stringify!(HSquirrelVM),
1710 "::",
1711 stringify!(pointer_60)
1712 )
1713 );
1714 assert_eq!(
1715 unsafe { ::std::ptr::addr_of!((*ptr)._top) as usize - ptr as usize },
1716 104usize,
1717 concat!(
1718 "Offset of field: ",
1719 stringify!(HSquirrelVM),
1720 "::",
1721 stringify!(_top)
1722 )
1723 );
1724 assert_eq!(
1725 unsafe { ::std::ptr::addr_of!((*ptr)._stack) as usize - ptr as usize },
1726 112usize,
1727 concat!(
1728 "Offset of field: ",
1729 stringify!(HSquirrelVM),
1730 "::",
1731 stringify!(_stack)
1732 )
1733 );
1734 assert_eq!(
1735 unsafe { ::std::ptr::addr_of!((*ptr).gap_78) as usize - ptr as usize },
1736 120usize,
1737 concat!(
1738 "Offset of field: ",
1739 stringify!(HSquirrelVM),
1740 "::",
1741 stringify!(gap_78)
1742 )
1743 );
1744 assert_eq!(
1745 unsafe { ::std::ptr::addr_of!((*ptr)._vargvstack) as usize - ptr as usize },
1746 128usize,
1747 concat!(
1748 "Offset of field: ",
1749 stringify!(HSquirrelVM),
1750 "::",
1751 stringify!(_vargvstack)
1752 )
1753 );
1754 assert_eq!(
1755 unsafe { ::std::ptr::addr_of!((*ptr).gap_88) as usize - ptr as usize },
1756 136usize,
1757 concat!(
1758 "Offset of field: ",
1759 stringify!(HSquirrelVM),
1760 "::",
1761 stringify!(gap_88)
1762 )
1763 );
1764 assert_eq!(
1765 unsafe { ::std::ptr::addr_of!((*ptr).temp_reg) as usize - ptr as usize },
1766 144usize,
1767 concat!(
1768 "Offset of field: ",
1769 stringify!(HSquirrelVM),
1770 "::",
1771 stringify!(temp_reg)
1772 )
1773 );
1774 assert_eq!(
1775 unsafe { ::std::ptr::addr_of!((*ptr).gapA0) as usize - ptr as usize },
1776 160usize,
1777 concat!(
1778 "Offset of field: ",
1779 stringify!(HSquirrelVM),
1780 "::",
1781 stringify!(gapA0)
1782 )
1783 );
1784 assert_eq!(
1785 unsafe { ::std::ptr::addr_of!((*ptr).pointer_A8) as usize - ptr as usize },
1786 168usize,
1787 concat!(
1788 "Offset of field: ",
1789 stringify!(HSquirrelVM),
1790 "::",
1791 stringify!(pointer_A8)
1792 )
1793 );
1794 assert_eq!(
1795 unsafe { ::std::ptr::addr_of!((*ptr).gap_B0) as usize - ptr as usize },
1796 176usize,
1797 concat!(
1798 "Offset of field: ",
1799 stringify!(HSquirrelVM),
1800 "::",
1801 stringify!(gap_B0)
1802 )
1803 );
1804 assert_eq!(
1805 unsafe { ::std::ptr::addr_of!((*ptr)._roottable_object) as usize - ptr as usize },
1806 184usize,
1807 concat!(
1808 "Offset of field: ",
1809 stringify!(HSquirrelVM),
1810 "::",
1811 stringify!(_roottable_object)
1812 )
1813 );
1814 assert_eq!(
1815 unsafe { ::std::ptr::addr_of!((*ptr)._lasterror) as usize - ptr as usize },
1816 200usize,
1817 concat!(
1818 "Offset of field: ",
1819 stringify!(HSquirrelVM),
1820 "::",
1821 stringify!(_lasterror)
1822 )
1823 );
1824 assert_eq!(
1825 unsafe { ::std::ptr::addr_of!((*ptr)._errorHandler) as usize - ptr as usize },
1826 216usize,
1827 concat!(
1828 "Offset of field: ",
1829 stringify!(HSquirrelVM),
1830 "::",
1831 stringify!(_errorHandler)
1832 )
1833 );
1834 assert_eq!(
1835 unsafe { ::std::ptr::addr_of!((*ptr).field_E8) as usize - ptr as usize },
1836 232usize,
1837 concat!(
1838 "Offset of field: ",
1839 stringify!(HSquirrelVM),
1840 "::",
1841 stringify!(field_E8)
1842 )
1843 );
1844 assert_eq!(
1845 unsafe { ::std::ptr::addr_of!((*ptr).traps) as usize - ptr as usize },
1846 240usize,
1847 concat!(
1848 "Offset of field: ",
1849 stringify!(HSquirrelVM),
1850 "::",
1851 stringify!(traps)
1852 )
1853 );
1854 assert_eq!(
1855 unsafe { ::std::ptr::addr_of!((*ptr).gap_F4) as usize - ptr as usize },
1856 244usize,
1857 concat!(
1858 "Offset of field: ",
1859 stringify!(HSquirrelVM),
1860 "::",
1861 stringify!(gap_F4)
1862 )
1863 );
1864 assert_eq!(
1865 unsafe { ::std::ptr::addr_of!((*ptr)._nnativecalls) as usize - ptr as usize },
1866 256usize,
1867 concat!(
1868 "Offset of field: ",
1869 stringify!(HSquirrelVM),
1870 "::",
1871 stringify!(_nnativecalls)
1872 )
1873 );
1874 assert_eq!(
1875 unsafe { ::std::ptr::addr_of!((*ptr)._suspended) as usize - ptr as usize },
1876 260usize,
1877 concat!(
1878 "Offset of field: ",
1879 stringify!(HSquirrelVM),
1880 "::",
1881 stringify!(_suspended)
1882 )
1883 );
1884 assert_eq!(
1885 unsafe { ::std::ptr::addr_of!((*ptr)._suspended_root) as usize - ptr as usize },
1886 264usize,
1887 concat!(
1888 "Offset of field: ",
1889 stringify!(HSquirrelVM),
1890 "::",
1891 stringify!(_suspended_root)
1892 )
1893 );
1894 assert_eq!(
1895 unsafe { ::std::ptr::addr_of!((*ptr)._unk) as usize - ptr as usize },
1896 268usize,
1897 concat!(
1898 "Offset of field: ",
1899 stringify!(HSquirrelVM),
1900 "::",
1901 stringify!(_unk)
1902 )
1903 );
1904 assert_eq!(
1905 unsafe { ::std::ptr::addr_of!((*ptr)._suspended_target) as usize - ptr as usize },
1906 272usize,
1907 concat!(
1908 "Offset of field: ",
1909 stringify!(HSquirrelVM),
1910 "::",
1911 stringify!(_suspended_target)
1912 )
1913 );
1914 assert_eq!(
1915 unsafe { ::std::ptr::addr_of!((*ptr).trapAmount) as usize - ptr as usize },
1916 276usize,
1917 concat!(
1918 "Offset of field: ",
1919 stringify!(HSquirrelVM),
1920 "::",
1921 stringify!(trapAmount)
1922 )
1923 );
1924 assert_eq!(
1925 unsafe { ::std::ptr::addr_of!((*ptr)._suspend_varargs) as usize - ptr as usize },
1926 280usize,
1927 concat!(
1928 "Offset of field: ",
1929 stringify!(HSquirrelVM),
1930 "::",
1931 stringify!(_suspend_varargs)
1932 )
1933 );
1934 assert_eq!(
1935 unsafe { ::std::ptr::addr_of!((*ptr).unknown_field_11C) as usize - ptr as usize },
1936 284usize,
1937 concat!(
1938 "Offset of field: ",
1939 stringify!(HSquirrelVM),
1940 "::",
1941 stringify!(unknown_field_11C)
1942 )
1943 );
1944 assert_eq!(
1945 unsafe { ::std::ptr::addr_of!((*ptr).object_120) as usize - ptr as usize },
1946 288usize,
1947 concat!(
1948 "Offset of field: ",
1949 stringify!(HSquirrelVM),
1950 "::",
1951 stringify!(object_120)
1952 )
1953 );
1954}
1955#[repr(C)]
1956#[derive(Copy, Clone)]
1957pub struct SQStructInstance {
1958 pub vftable: *mut ::std::os::raw::c_void,
1959 pub uiRef: ::std::os::raw::c_int,
1960 pub gap_C: [::std::os::raw::c_uchar; 4usize],
1961 pub unknown_10: ::std::os::raw::c_longlong,
1962 pub pointer_18: *mut ::std::os::raw::c_void,
1963 pub unknown_20: ::std::os::raw::c_longlong,
1964 pub _sharedState: *mut SQSharedState,
1965 pub size: ::std::os::raw::c_uint,
1966 pub gap_34: [::std::os::raw::c_uchar; 4usize],
1967 pub data: [SQObject; 1usize],
1968}
1969#[test]
1970fn bindgen_test_layout_SQStructInstance() {
1971 const UNINIT: ::std::mem::MaybeUninit<SQStructInstance> = ::std::mem::MaybeUninit::uninit();
1972 let ptr = UNINIT.as_ptr();
1973 assert_eq!(
1974 ::std::mem::size_of::<SQStructInstance>(),
1975 72usize,
1976 concat!("Size of: ", stringify!(SQStructInstance))
1977 );
1978 assert_eq!(
1979 ::std::mem::align_of::<SQStructInstance>(),
1980 8usize,
1981 concat!("Alignment of ", stringify!(SQStructInstance))
1982 );
1983 assert_eq!(
1984 unsafe { ::std::ptr::addr_of!((*ptr).vftable) as usize - ptr as usize },
1985 0usize,
1986 concat!(
1987 "Offset of field: ",
1988 stringify!(SQStructInstance),
1989 "::",
1990 stringify!(vftable)
1991 )
1992 );
1993 assert_eq!(
1994 unsafe { ::std::ptr::addr_of!((*ptr).uiRef) as usize - ptr as usize },
1995 8usize,
1996 concat!(
1997 "Offset of field: ",
1998 stringify!(SQStructInstance),
1999 "::",
2000 stringify!(uiRef)
2001 )
2002 );
2003 assert_eq!(
2004 unsafe { ::std::ptr::addr_of!((*ptr).gap_C) as usize - ptr as usize },
2005 12usize,
2006 concat!(
2007 "Offset of field: ",
2008 stringify!(SQStructInstance),
2009 "::",
2010 stringify!(gap_C)
2011 )
2012 );
2013 assert_eq!(
2014 unsafe { ::std::ptr::addr_of!((*ptr).unknown_10) as usize - ptr as usize },
2015 16usize,
2016 concat!(
2017 "Offset of field: ",
2018 stringify!(SQStructInstance),
2019 "::",
2020 stringify!(unknown_10)
2021 )
2022 );
2023 assert_eq!(
2024 unsafe { ::std::ptr::addr_of!((*ptr).pointer_18) as usize - ptr as usize },
2025 24usize,
2026 concat!(
2027 "Offset of field: ",
2028 stringify!(SQStructInstance),
2029 "::",
2030 stringify!(pointer_18)
2031 )
2032 );
2033 assert_eq!(
2034 unsafe { ::std::ptr::addr_of!((*ptr).unknown_20) as usize - ptr as usize },
2035 32usize,
2036 concat!(
2037 "Offset of field: ",
2038 stringify!(SQStructInstance),
2039 "::",
2040 stringify!(unknown_20)
2041 )
2042 );
2043 assert_eq!(
2044 unsafe { ::std::ptr::addr_of!((*ptr)._sharedState) as usize - ptr as usize },
2045 40usize,
2046 concat!(
2047 "Offset of field: ",
2048 stringify!(SQStructInstance),
2049 "::",
2050 stringify!(_sharedState)
2051 )
2052 );
2053 assert_eq!(
2054 unsafe { ::std::ptr::addr_of!((*ptr).size) as usize - ptr as usize },
2055 48usize,
2056 concat!(
2057 "Offset of field: ",
2058 stringify!(SQStructInstance),
2059 "::",
2060 stringify!(size)
2061 )
2062 );
2063 assert_eq!(
2064 unsafe { ::std::ptr::addr_of!((*ptr).gap_34) as usize - ptr as usize },
2065 52usize,
2066 concat!(
2067 "Offset of field: ",
2068 stringify!(SQStructInstance),
2069 "::",
2070 stringify!(gap_34)
2071 )
2072 );
2073 assert_eq!(
2074 unsafe { ::std::ptr::addr_of!((*ptr).data) as usize - ptr as usize },
2075 56usize,
2076 concat!(
2077 "Offset of field: ",
2078 stringify!(SQStructInstance),
2079 "::",
2080 stringify!(data)
2081 )
2082 );
2083}
2084#[repr(C)]
2085#[derive(Debug, Copy, Clone)]
2086pub struct SQSharedState {
2087 pub gap_0: [::std::os::raw::c_uchar; 72usize],
2088 pub unknown: *mut ::std::os::raw::c_void,
2089 pub gap_50: [::std::os::raw::c_uchar; 16344usize],
2090 pub _unknownTableType00: SQObjectType,
2091 pub _unknownTableValue00: ::std::os::raw::c_longlong,
2092 pub gap_4038: [::std::os::raw::c_uchar; 16usize],
2093 pub _stringTable: *mut StringTable,
2094 pub gap_4050: [::std::os::raw::c_uchar; 32usize],
2095 pub _unknownTableType0: SQObjectType,
2096 pub _unknownTableValue0: ::std::os::raw::c_longlong,
2097 pub _unknownObjectType1: SQObjectType,
2098 pub _unknownObjectValue1: ::std::os::raw::c_longlong,
2099 pub gap_4090: [::std::os::raw::c_uchar; 8usize],
2100 pub _unknownArrayType2: SQObjectType,
2101 pub _unknownArrayValue2: ::std::os::raw::c_longlong,
2102 pub _gobalsArrayType: SQObjectType,
2103 pub _globalsArray: *mut SQStructInstance,
2104 pub gap_40B8: [::std::os::raw::c_uchar; 16usize],
2105 pub _nativeClosuresType: SQObjectType,
2106 pub _nativeClosures: *mut SQTable,
2107 pub _typedConstantsType: SQObjectType,
2108 pub _typedConstants: *mut SQTable,
2109 pub _untypedConstantsType: SQObjectType,
2110 pub _untypedConstants: *mut SQTable,
2111 pub _globalsMaybeType: SQObjectType,
2112 pub _globals: *mut SQTable,
2113 pub _functionsType: SQObjectType,
2114 pub _functions: *mut SQTable,
2115 pub _structsType: SQObjectType,
2116 pub _structs: *mut SQTable,
2117 pub _typeDefsType: SQObjectType,
2118 pub _typeDefs: *mut SQTable,
2119 pub unknownTableType: SQObjectType,
2120 pub unknownTable: *mut SQTable,
2121 pub _squirrelFilesType: SQObjectType,
2122 pub _squirrelFiles: *mut SQTable,
2123 pub gap_4158: [::std::os::raw::c_uchar; 80usize],
2124 pub _nativeClosures2Type: SQObjectType,
2125 pub _nativeClosures2: *mut SQTable,
2126 pub _entityTypesMaybeType: SQObjectType,
2127 pub _entityTypesMaybe: *mut SQTable,
2128 pub unknownTable2Type: SQObjectType,
2129 pub unknownTable2: *mut SQTable,
2130 pub gap_41D8: [::std::os::raw::c_uchar; 72usize],
2131 pub _compilerKeywordsType: SQObjectType,
2132 pub _compilerKeywords: *mut SQTable,
2133 pub _currentThreadMaybe: *mut HSquirrelVM,
2134 pub gap_4238: [::std::os::raw::c_uchar; 8usize],
2135 pub unknownTable3Type: SQObjectType,
2136 pub unknownTable3: *mut SQTable,
2137 pub gap_4250: [::std::os::raw::c_uchar; 16usize],
2138 pub unknownThreadType: SQObjectType,
2139 pub unknownThread: *mut SQTable,
2140 pub _tableNativeFunctionsType: SQObjectType,
2141 pub _tableNativeFunctions: *mut SQTable,
2142 pub _unknownTableType4: SQObjectType,
2143 pub _unknownObjectValue4: ::std::os::raw::c_longlong,
2144 pub _unknownObjectType5: SQObjectType,
2145 pub _unknownObjectValue5: ::std::os::raw::c_longlong,
2146 pub _unknownObjectType6: SQObjectType,
2147 pub _unknownObjectValue6: ::std::os::raw::c_longlong,
2148 pub _unknownObjectType7: SQObjectType,
2149 pub _unknownObjectValue7: ::std::os::raw::c_longlong,
2150 pub _unknownObjectType8: SQObjectType,
2151 pub _unknownObjectValue8: ::std::os::raw::c_longlong,
2152 pub _unknownObjectType9: SQObjectType,
2153 pub _unknownObjectValue9: ::std::os::raw::c_longlong,
2154 pub _unknownObjectType10: SQObjectType,
2155 pub _unknownObjectValue10: ::std::os::raw::c_longlong,
2156 pub _unknownObjectType11: SQObjectType,
2157 pub _unknownObjectValue11: ::std::os::raw::c_longlong,
2158 pub _unknownObjectType12: SQObjectType,
2159 pub _unknownObjectValue12: ::std::os::raw::c_longlong,
2160 pub _unknownObjectType13: SQObjectType,
2161 pub _unknownObjectValue13: ::std::os::raw::c_longlong,
2162 pub _unknownObjectType14: SQObjectType,
2163 pub _unknownObjectValue14: ::std::os::raw::c_longlong,
2164 pub _unknownObjectType15: SQObjectType,
2165 pub _unknownObjectValue15: ::std::os::raw::c_longlong,
2166 pub gap_4340: [::std::os::raw::c_uchar; 16usize],
2167 pub printFunction: *mut ::std::os::raw::c_void,
2168 pub gap_4358: [::std::os::raw::c_uchar; 16usize],
2169 pub logEntityFunction: *mut ::std::os::raw::c_void,
2170 pub gap_4370: [::std::os::raw::c_uchar; 40usize],
2171 pub _waitStringType: SQObjectType,
2172 pub _waitStringValue: *mut SQString,
2173 pub _SpinOffAndWaitForStringType: SQObjectType,
2174 pub _SpinOffAndWaitForStringValue: *mut SQString,
2175 pub _SpinOffAndWaitForSoloStringType: SQObjectType,
2176 pub _SpinOffAndWaitForSoloStringValue: *mut SQString,
2177 pub _SpinOffStringType: SQObjectType,
2178 pub _SpinOffStringValue: *mut SQString,
2179 pub _SpinOffDelayedStringType: SQObjectType,
2180 pub _SpinOffDelayedStringValue: *mut SQString,
2181 pub cSquirrelVM: *mut CSquirrelVM,
2182 pub enableDebugInfo: bool,
2183 pub gap_43F1: [::std::os::raw::c_uchar; 23usize],
2184}
2185#[test]
2186fn bindgen_test_layout_SQSharedState() {
2187 const UNINIT: ::std::mem::MaybeUninit<SQSharedState> = ::std::mem::MaybeUninit::uninit();
2188 let ptr = UNINIT.as_ptr();
2189 assert_eq!(
2190 ::std::mem::size_of::<SQSharedState>(),
2191 17416usize,
2192 concat!("Size of: ", stringify!(SQSharedState))
2193 );
2194 assert_eq!(
2195 ::std::mem::align_of::<SQSharedState>(),
2196 8usize,
2197 concat!("Alignment of ", stringify!(SQSharedState))
2198 );
2199 assert_eq!(
2200 unsafe { ::std::ptr::addr_of!((*ptr).gap_0) as usize - ptr as usize },
2201 0usize,
2202 concat!(
2203 "Offset of field: ",
2204 stringify!(SQSharedState),
2205 "::",
2206 stringify!(gap_0)
2207 )
2208 );
2209 assert_eq!(
2210 unsafe { ::std::ptr::addr_of!((*ptr).unknown) as usize - ptr as usize },
2211 72usize,
2212 concat!(
2213 "Offset of field: ",
2214 stringify!(SQSharedState),
2215 "::",
2216 stringify!(unknown)
2217 )
2218 );
2219 assert_eq!(
2220 unsafe { ::std::ptr::addr_of!((*ptr).gap_50) as usize - ptr as usize },
2221 80usize,
2222 concat!(
2223 "Offset of field: ",
2224 stringify!(SQSharedState),
2225 "::",
2226 stringify!(gap_50)
2227 )
2228 );
2229 assert_eq!(
2230 unsafe { ::std::ptr::addr_of!((*ptr)._unknownTableType00) as usize - ptr as usize },
2231 16424usize,
2232 concat!(
2233 "Offset of field: ",
2234 stringify!(SQSharedState),
2235 "::",
2236 stringify!(_unknownTableType00)
2237 )
2238 );
2239 assert_eq!(
2240 unsafe { ::std::ptr::addr_of!((*ptr)._unknownTableValue00) as usize - ptr as usize },
2241 16432usize,
2242 concat!(
2243 "Offset of field: ",
2244 stringify!(SQSharedState),
2245 "::",
2246 stringify!(_unknownTableValue00)
2247 )
2248 );
2249 assert_eq!(
2250 unsafe { ::std::ptr::addr_of!((*ptr).gap_4038) as usize - ptr as usize },
2251 16440usize,
2252 concat!(
2253 "Offset of field: ",
2254 stringify!(SQSharedState),
2255 "::",
2256 stringify!(gap_4038)
2257 )
2258 );
2259 assert_eq!(
2260 unsafe { ::std::ptr::addr_of!((*ptr)._stringTable) as usize - ptr as usize },
2261 16456usize,
2262 concat!(
2263 "Offset of field: ",
2264 stringify!(SQSharedState),
2265 "::",
2266 stringify!(_stringTable)
2267 )
2268 );
2269 assert_eq!(
2270 unsafe { ::std::ptr::addr_of!((*ptr).gap_4050) as usize - ptr as usize },
2271 16464usize,
2272 concat!(
2273 "Offset of field: ",
2274 stringify!(SQSharedState),
2275 "::",
2276 stringify!(gap_4050)
2277 )
2278 );
2279 assert_eq!(
2280 unsafe { ::std::ptr::addr_of!((*ptr)._unknownTableType0) as usize - ptr as usize },
2281 16496usize,
2282 concat!(
2283 "Offset of field: ",
2284 stringify!(SQSharedState),
2285 "::",
2286 stringify!(_unknownTableType0)
2287 )
2288 );
2289 assert_eq!(
2290 unsafe { ::std::ptr::addr_of!((*ptr)._unknownTableValue0) as usize - ptr as usize },
2291 16504usize,
2292 concat!(
2293 "Offset of field: ",
2294 stringify!(SQSharedState),
2295 "::",
2296 stringify!(_unknownTableValue0)
2297 )
2298 );
2299 assert_eq!(
2300 unsafe { ::std::ptr::addr_of!((*ptr)._unknownObjectType1) as usize - ptr as usize },
2301 16512usize,
2302 concat!(
2303 "Offset of field: ",
2304 stringify!(SQSharedState),
2305 "::",
2306 stringify!(_unknownObjectType1)
2307 )
2308 );
2309 assert_eq!(
2310 unsafe { ::std::ptr::addr_of!((*ptr)._unknownObjectValue1) as usize - ptr as usize },
2311 16520usize,
2312 concat!(
2313 "Offset of field: ",
2314 stringify!(SQSharedState),
2315 "::",
2316 stringify!(_unknownObjectValue1)
2317 )
2318 );
2319 assert_eq!(
2320 unsafe { ::std::ptr::addr_of!((*ptr).gap_4090) as usize - ptr as usize },
2321 16528usize,
2322 concat!(
2323 "Offset of field: ",
2324 stringify!(SQSharedState),
2325 "::",
2326 stringify!(gap_4090)
2327 )
2328 );
2329 assert_eq!(
2330 unsafe { ::std::ptr::addr_of!((*ptr)._unknownArrayType2) as usize - ptr as usize },
2331 16536usize,
2332 concat!(
2333 "Offset of field: ",
2334 stringify!(SQSharedState),
2335 "::",
2336 stringify!(_unknownArrayType2)
2337 )
2338 );
2339 assert_eq!(
2340 unsafe { ::std::ptr::addr_of!((*ptr)._unknownArrayValue2) as usize - ptr as usize },
2341 16544usize,
2342 concat!(
2343 "Offset of field: ",
2344 stringify!(SQSharedState),
2345 "::",
2346 stringify!(_unknownArrayValue2)
2347 )
2348 );
2349 assert_eq!(
2350 unsafe { ::std::ptr::addr_of!((*ptr)._gobalsArrayType) as usize - ptr as usize },
2351 16552usize,
2352 concat!(
2353 "Offset of field: ",
2354 stringify!(SQSharedState),
2355 "::",
2356 stringify!(_gobalsArrayType)
2357 )
2358 );
2359 assert_eq!(
2360 unsafe { ::std::ptr::addr_of!((*ptr)._globalsArray) as usize - ptr as usize },
2361 16560usize,
2362 concat!(
2363 "Offset of field: ",
2364 stringify!(SQSharedState),
2365 "::",
2366 stringify!(_globalsArray)
2367 )
2368 );
2369 assert_eq!(
2370 unsafe { ::std::ptr::addr_of!((*ptr).gap_40B8) as usize - ptr as usize },
2371 16568usize,
2372 concat!(
2373 "Offset of field: ",
2374 stringify!(SQSharedState),
2375 "::",
2376 stringify!(gap_40B8)
2377 )
2378 );
2379 assert_eq!(
2380 unsafe { ::std::ptr::addr_of!((*ptr)._nativeClosuresType) as usize - ptr as usize },
2381 16584usize,
2382 concat!(
2383 "Offset of field: ",
2384 stringify!(SQSharedState),
2385 "::",
2386 stringify!(_nativeClosuresType)
2387 )
2388 );
2389 assert_eq!(
2390 unsafe { ::std::ptr::addr_of!((*ptr)._nativeClosures) as usize - ptr as usize },
2391 16592usize,
2392 concat!(
2393 "Offset of field: ",
2394 stringify!(SQSharedState),
2395 "::",
2396 stringify!(_nativeClosures)
2397 )
2398 );
2399 assert_eq!(
2400 unsafe { ::std::ptr::addr_of!((*ptr)._typedConstantsType) as usize - ptr as usize },
2401 16600usize,
2402 concat!(
2403 "Offset of field: ",
2404 stringify!(SQSharedState),
2405 "::",
2406 stringify!(_typedConstantsType)
2407 )
2408 );
2409 assert_eq!(
2410 unsafe { ::std::ptr::addr_of!((*ptr)._typedConstants) as usize - ptr as usize },
2411 16608usize,
2412 concat!(
2413 "Offset of field: ",
2414 stringify!(SQSharedState),
2415 "::",
2416 stringify!(_typedConstants)
2417 )
2418 );
2419 assert_eq!(
2420 unsafe { ::std::ptr::addr_of!((*ptr)._untypedConstantsType) as usize - ptr as usize },
2421 16616usize,
2422 concat!(
2423 "Offset of field: ",
2424 stringify!(SQSharedState),
2425 "::",
2426 stringify!(_untypedConstantsType)
2427 )
2428 );
2429 assert_eq!(
2430 unsafe { ::std::ptr::addr_of!((*ptr)._untypedConstants) as usize - ptr as usize },
2431 16624usize,
2432 concat!(
2433 "Offset of field: ",
2434 stringify!(SQSharedState),
2435 "::",
2436 stringify!(_untypedConstants)
2437 )
2438 );
2439 assert_eq!(
2440 unsafe { ::std::ptr::addr_of!((*ptr)._globalsMaybeType) as usize - ptr as usize },
2441 16632usize,
2442 concat!(
2443 "Offset of field: ",
2444 stringify!(SQSharedState),
2445 "::",
2446 stringify!(_globalsMaybeType)
2447 )
2448 );
2449 assert_eq!(
2450 unsafe { ::std::ptr::addr_of!((*ptr)._globals) as usize - ptr as usize },
2451 16640usize,
2452 concat!(
2453 "Offset of field: ",
2454 stringify!(SQSharedState),
2455 "::",
2456 stringify!(_globals)
2457 )
2458 );
2459 assert_eq!(
2460 unsafe { ::std::ptr::addr_of!((*ptr)._functionsType) as usize - ptr as usize },
2461 16648usize,
2462 concat!(
2463 "Offset of field: ",
2464 stringify!(SQSharedState),
2465 "::",
2466 stringify!(_functionsType)
2467 )
2468 );
2469 assert_eq!(
2470 unsafe { ::std::ptr::addr_of!((*ptr)._functions) as usize - ptr as usize },
2471 16656usize,
2472 concat!(
2473 "Offset of field: ",
2474 stringify!(SQSharedState),
2475 "::",
2476 stringify!(_functions)
2477 )
2478 );
2479 assert_eq!(
2480 unsafe { ::std::ptr::addr_of!((*ptr)._structsType) as usize - ptr as usize },
2481 16664usize,
2482 concat!(
2483 "Offset of field: ",
2484 stringify!(SQSharedState),
2485 "::",
2486 stringify!(_structsType)
2487 )
2488 );
2489 assert_eq!(
2490 unsafe { ::std::ptr::addr_of!((*ptr)._structs) as usize - ptr as usize },
2491 16672usize,
2492 concat!(
2493 "Offset of field: ",
2494 stringify!(SQSharedState),
2495 "::",
2496 stringify!(_structs)
2497 )
2498 );
2499 assert_eq!(
2500 unsafe { ::std::ptr::addr_of!((*ptr)._typeDefsType) as usize - ptr as usize },
2501 16680usize,
2502 concat!(
2503 "Offset of field: ",
2504 stringify!(SQSharedState),
2505 "::",
2506 stringify!(_typeDefsType)
2507 )
2508 );
2509 assert_eq!(
2510 unsafe { ::std::ptr::addr_of!((*ptr)._typeDefs) as usize - ptr as usize },
2511 16688usize,
2512 concat!(
2513 "Offset of field: ",
2514 stringify!(SQSharedState),
2515 "::",
2516 stringify!(_typeDefs)
2517 )
2518 );
2519 assert_eq!(
2520 unsafe { ::std::ptr::addr_of!((*ptr).unknownTableType) as usize - ptr as usize },
2521 16696usize,
2522 concat!(
2523 "Offset of field: ",
2524 stringify!(SQSharedState),
2525 "::",
2526 stringify!(unknownTableType)
2527 )
2528 );
2529 assert_eq!(
2530 unsafe { ::std::ptr::addr_of!((*ptr).unknownTable) as usize - ptr as usize },
2531 16704usize,
2532 concat!(
2533 "Offset of field: ",
2534 stringify!(SQSharedState),
2535 "::",
2536 stringify!(unknownTable)
2537 )
2538 );
2539 assert_eq!(
2540 unsafe { ::std::ptr::addr_of!((*ptr)._squirrelFilesType) as usize - ptr as usize },
2541 16712usize,
2542 concat!(
2543 "Offset of field: ",
2544 stringify!(SQSharedState),
2545 "::",
2546 stringify!(_squirrelFilesType)
2547 )
2548 );
2549 assert_eq!(
2550 unsafe { ::std::ptr::addr_of!((*ptr)._squirrelFiles) as usize - ptr as usize },
2551 16720usize,
2552 concat!(
2553 "Offset of field: ",
2554 stringify!(SQSharedState),
2555 "::",
2556 stringify!(_squirrelFiles)
2557 )
2558 );
2559 assert_eq!(
2560 unsafe { ::std::ptr::addr_of!((*ptr).gap_4158) as usize - ptr as usize },
2561 16728usize,
2562 concat!(
2563 "Offset of field: ",
2564 stringify!(SQSharedState),
2565 "::",
2566 stringify!(gap_4158)
2567 )
2568 );
2569 assert_eq!(
2570 unsafe { ::std::ptr::addr_of!((*ptr)._nativeClosures2Type) as usize - ptr as usize },
2571 16808usize,
2572 concat!(
2573 "Offset of field: ",
2574 stringify!(SQSharedState),
2575 "::",
2576 stringify!(_nativeClosures2Type)
2577 )
2578 );
2579 assert_eq!(
2580 unsafe { ::std::ptr::addr_of!((*ptr)._nativeClosures2) as usize - ptr as usize },
2581 16816usize,
2582 concat!(
2583 "Offset of field: ",
2584 stringify!(SQSharedState),
2585 "::",
2586 stringify!(_nativeClosures2)
2587 )
2588 );
2589 assert_eq!(
2590 unsafe { ::std::ptr::addr_of!((*ptr)._entityTypesMaybeType) as usize - ptr as usize },
2591 16824usize,
2592 concat!(
2593 "Offset of field: ",
2594 stringify!(SQSharedState),
2595 "::",
2596 stringify!(_entityTypesMaybeType)
2597 )
2598 );
2599 assert_eq!(
2600 unsafe { ::std::ptr::addr_of!((*ptr)._entityTypesMaybe) as usize - ptr as usize },
2601 16832usize,
2602 concat!(
2603 "Offset of field: ",
2604 stringify!(SQSharedState),
2605 "::",
2606 stringify!(_entityTypesMaybe)
2607 )
2608 );
2609 assert_eq!(
2610 unsafe { ::std::ptr::addr_of!((*ptr).unknownTable2Type) as usize - ptr as usize },
2611 16840usize,
2612 concat!(
2613 "Offset of field: ",
2614 stringify!(SQSharedState),
2615 "::",
2616 stringify!(unknownTable2Type)
2617 )
2618 );
2619 assert_eq!(
2620 unsafe { ::std::ptr::addr_of!((*ptr).unknownTable2) as usize - ptr as usize },
2621 16848usize,
2622 concat!(
2623 "Offset of field: ",
2624 stringify!(SQSharedState),
2625 "::",
2626 stringify!(unknownTable2)
2627 )
2628 );
2629 assert_eq!(
2630 unsafe { ::std::ptr::addr_of!((*ptr).gap_41D8) as usize - ptr as usize },
2631 16856usize,
2632 concat!(
2633 "Offset of field: ",
2634 stringify!(SQSharedState),
2635 "::",
2636 stringify!(gap_41D8)
2637 )
2638 );
2639 assert_eq!(
2640 unsafe { ::std::ptr::addr_of!((*ptr)._compilerKeywordsType) as usize - ptr as usize },
2641 16928usize,
2642 concat!(
2643 "Offset of field: ",
2644 stringify!(SQSharedState),
2645 "::",
2646 stringify!(_compilerKeywordsType)
2647 )
2648 );
2649 assert_eq!(
2650 unsafe { ::std::ptr::addr_of!((*ptr)._compilerKeywords) as usize - ptr as usize },
2651 16936usize,
2652 concat!(
2653 "Offset of field: ",
2654 stringify!(SQSharedState),
2655 "::",
2656 stringify!(_compilerKeywords)
2657 )
2658 );
2659 assert_eq!(
2660 unsafe { ::std::ptr::addr_of!((*ptr)._currentThreadMaybe) as usize - ptr as usize },
2661 16944usize,
2662 concat!(
2663 "Offset of field: ",
2664 stringify!(SQSharedState),
2665 "::",
2666 stringify!(_currentThreadMaybe)
2667 )
2668 );
2669 assert_eq!(
2670 unsafe { ::std::ptr::addr_of!((*ptr).gap_4238) as usize - ptr as usize },
2671 16952usize,
2672 concat!(
2673 "Offset of field: ",
2674 stringify!(SQSharedState),
2675 "::",
2676 stringify!(gap_4238)
2677 )
2678 );
2679 assert_eq!(
2680 unsafe { ::std::ptr::addr_of!((*ptr).unknownTable3Type) as usize - ptr as usize },
2681 16960usize,
2682 concat!(
2683 "Offset of field: ",
2684 stringify!(SQSharedState),
2685 "::",
2686 stringify!(unknownTable3Type)
2687 )
2688 );
2689 assert_eq!(
2690 unsafe { ::std::ptr::addr_of!((*ptr).unknownTable3) as usize - ptr as usize },
2691 16968usize,
2692 concat!(
2693 "Offset of field: ",
2694 stringify!(SQSharedState),
2695 "::",
2696 stringify!(unknownTable3)
2697 )
2698 );
2699 assert_eq!(
2700 unsafe { ::std::ptr::addr_of!((*ptr).gap_4250) as usize - ptr as usize },
2701 16976usize,
2702 concat!(
2703 "Offset of field: ",
2704 stringify!(SQSharedState),
2705 "::",
2706 stringify!(gap_4250)
2707 )
2708 );
2709 assert_eq!(
2710 unsafe { ::std::ptr::addr_of!((*ptr).unknownThreadType) as usize - ptr as usize },
2711 16992usize,
2712 concat!(
2713 "Offset of field: ",
2714 stringify!(SQSharedState),
2715 "::",
2716 stringify!(unknownThreadType)
2717 )
2718 );
2719 assert_eq!(
2720 unsafe { ::std::ptr::addr_of!((*ptr).unknownThread) as usize - ptr as usize },
2721 17000usize,
2722 concat!(
2723 "Offset of field: ",
2724 stringify!(SQSharedState),
2725 "::",
2726 stringify!(unknownThread)
2727 )
2728 );
2729 assert_eq!(
2730 unsafe { ::std::ptr::addr_of!((*ptr)._tableNativeFunctionsType) as usize - ptr as usize },
2731 17008usize,
2732 concat!(
2733 "Offset of field: ",
2734 stringify!(SQSharedState),
2735 "::",
2736 stringify!(_tableNativeFunctionsType)
2737 )
2738 );
2739 assert_eq!(
2740 unsafe { ::std::ptr::addr_of!((*ptr)._tableNativeFunctions) as usize - ptr as usize },
2741 17016usize,
2742 concat!(
2743 "Offset of field: ",
2744 stringify!(SQSharedState),
2745 "::",
2746 stringify!(_tableNativeFunctions)
2747 )
2748 );
2749 assert_eq!(
2750 unsafe { ::std::ptr::addr_of!((*ptr)._unknownTableType4) as usize - ptr as usize },
2751 17024usize,
2752 concat!(
2753 "Offset of field: ",
2754 stringify!(SQSharedState),
2755 "::",
2756 stringify!(_unknownTableType4)
2757 )
2758 );
2759 assert_eq!(
2760 unsafe { ::std::ptr::addr_of!((*ptr)._unknownObjectValue4) as usize - ptr as usize },
2761 17032usize,
2762 concat!(
2763 "Offset of field: ",
2764 stringify!(SQSharedState),
2765 "::",
2766 stringify!(_unknownObjectValue4)
2767 )
2768 );
2769 assert_eq!(
2770 unsafe { ::std::ptr::addr_of!((*ptr)._unknownObjectType5) as usize - ptr as usize },
2771 17040usize,
2772 concat!(
2773 "Offset of field: ",
2774 stringify!(SQSharedState),
2775 "::",
2776 stringify!(_unknownObjectType5)
2777 )
2778 );
2779 assert_eq!(
2780 unsafe { ::std::ptr::addr_of!((*ptr)._unknownObjectValue5) as usize - ptr as usize },
2781 17048usize,
2782 concat!(
2783 "Offset of field: ",
2784 stringify!(SQSharedState),
2785 "::",
2786 stringify!(_unknownObjectValue5)
2787 )
2788 );
2789 assert_eq!(
2790 unsafe { ::std::ptr::addr_of!((*ptr)._unknownObjectType6) as usize - ptr as usize },
2791 17056usize,
2792 concat!(
2793 "Offset of field: ",
2794 stringify!(SQSharedState),
2795 "::",
2796 stringify!(_unknownObjectType6)
2797 )
2798 );
2799 assert_eq!(
2800 unsafe { ::std::ptr::addr_of!((*ptr)._unknownObjectValue6) as usize - ptr as usize },
2801 17064usize,
2802 concat!(
2803 "Offset of field: ",
2804 stringify!(SQSharedState),
2805 "::",
2806 stringify!(_unknownObjectValue6)
2807 )
2808 );
2809 assert_eq!(
2810 unsafe { ::std::ptr::addr_of!((*ptr)._unknownObjectType7) as usize - ptr as usize },
2811 17072usize,
2812 concat!(
2813 "Offset of field: ",
2814 stringify!(SQSharedState),
2815 "::",
2816 stringify!(_unknownObjectType7)
2817 )
2818 );
2819 assert_eq!(
2820 unsafe { ::std::ptr::addr_of!((*ptr)._unknownObjectValue7) as usize - ptr as usize },
2821 17080usize,
2822 concat!(
2823 "Offset of field: ",
2824 stringify!(SQSharedState),
2825 "::",
2826 stringify!(_unknownObjectValue7)
2827 )
2828 );
2829 assert_eq!(
2830 unsafe { ::std::ptr::addr_of!((*ptr)._unknownObjectType8) as usize - ptr as usize },
2831 17088usize,
2832 concat!(
2833 "Offset of field: ",
2834 stringify!(SQSharedState),
2835 "::",
2836 stringify!(_unknownObjectType8)
2837 )
2838 );
2839 assert_eq!(
2840 unsafe { ::std::ptr::addr_of!((*ptr)._unknownObjectValue8) as usize - ptr as usize },
2841 17096usize,
2842 concat!(
2843 "Offset of field: ",
2844 stringify!(SQSharedState),
2845 "::",
2846 stringify!(_unknownObjectValue8)
2847 )
2848 );
2849 assert_eq!(
2850 unsafe { ::std::ptr::addr_of!((*ptr)._unknownObjectType9) as usize - ptr as usize },
2851 17104usize,
2852 concat!(
2853 "Offset of field: ",
2854 stringify!(SQSharedState),
2855 "::",
2856 stringify!(_unknownObjectType9)
2857 )
2858 );
2859 assert_eq!(
2860 unsafe { ::std::ptr::addr_of!((*ptr)._unknownObjectValue9) as usize - ptr as usize },
2861 17112usize,
2862 concat!(
2863 "Offset of field: ",
2864 stringify!(SQSharedState),
2865 "::",
2866 stringify!(_unknownObjectValue9)
2867 )
2868 );
2869 assert_eq!(
2870 unsafe { ::std::ptr::addr_of!((*ptr)._unknownObjectType10) as usize - ptr as usize },
2871 17120usize,
2872 concat!(
2873 "Offset of field: ",
2874 stringify!(SQSharedState),
2875 "::",
2876 stringify!(_unknownObjectType10)
2877 )
2878 );
2879 assert_eq!(
2880 unsafe { ::std::ptr::addr_of!((*ptr)._unknownObjectValue10) as usize - ptr as usize },
2881 17128usize,
2882 concat!(
2883 "Offset of field: ",
2884 stringify!(SQSharedState),
2885 "::",
2886 stringify!(_unknownObjectValue10)
2887 )
2888 );
2889 assert_eq!(
2890 unsafe { ::std::ptr::addr_of!((*ptr)._unknownObjectType11) as usize - ptr as usize },
2891 17136usize,
2892 concat!(
2893 "Offset of field: ",
2894 stringify!(SQSharedState),
2895 "::",
2896 stringify!(_unknownObjectType11)
2897 )
2898 );
2899 assert_eq!(
2900 unsafe { ::std::ptr::addr_of!((*ptr)._unknownObjectValue11) as usize - ptr as usize },
2901 17144usize,
2902 concat!(
2903 "Offset of field: ",
2904 stringify!(SQSharedState),
2905 "::",
2906 stringify!(_unknownObjectValue11)
2907 )
2908 );
2909 assert_eq!(
2910 unsafe { ::std::ptr::addr_of!((*ptr)._unknownObjectType12) as usize - ptr as usize },
2911 17152usize,
2912 concat!(
2913 "Offset of field: ",
2914 stringify!(SQSharedState),
2915 "::",
2916 stringify!(_unknownObjectType12)
2917 )
2918 );
2919 assert_eq!(
2920 unsafe { ::std::ptr::addr_of!((*ptr)._unknownObjectValue12) as usize - ptr as usize },
2921 17160usize,
2922 concat!(
2923 "Offset of field: ",
2924 stringify!(SQSharedState),
2925 "::",
2926 stringify!(_unknownObjectValue12)
2927 )
2928 );
2929 assert_eq!(
2930 unsafe { ::std::ptr::addr_of!((*ptr)._unknownObjectType13) as usize - ptr as usize },
2931 17168usize,
2932 concat!(
2933 "Offset of field: ",
2934 stringify!(SQSharedState),
2935 "::",
2936 stringify!(_unknownObjectType13)
2937 )
2938 );
2939 assert_eq!(
2940 unsafe { ::std::ptr::addr_of!((*ptr)._unknownObjectValue13) as usize - ptr as usize },
2941 17176usize,
2942 concat!(
2943 "Offset of field: ",
2944 stringify!(SQSharedState),
2945 "::",
2946 stringify!(_unknownObjectValue13)
2947 )
2948 );
2949 assert_eq!(
2950 unsafe { ::std::ptr::addr_of!((*ptr)._unknownObjectType14) as usize - ptr as usize },
2951 17184usize,
2952 concat!(
2953 "Offset of field: ",
2954 stringify!(SQSharedState),
2955 "::",
2956 stringify!(_unknownObjectType14)
2957 )
2958 );
2959 assert_eq!(
2960 unsafe { ::std::ptr::addr_of!((*ptr)._unknownObjectValue14) as usize - ptr as usize },
2961 17192usize,
2962 concat!(
2963 "Offset of field: ",
2964 stringify!(SQSharedState),
2965 "::",
2966 stringify!(_unknownObjectValue14)
2967 )
2968 );
2969 assert_eq!(
2970 unsafe { ::std::ptr::addr_of!((*ptr)._unknownObjectType15) as usize - ptr as usize },
2971 17200usize,
2972 concat!(
2973 "Offset of field: ",
2974 stringify!(SQSharedState),
2975 "::",
2976 stringify!(_unknownObjectType15)
2977 )
2978 );
2979 assert_eq!(
2980 unsafe { ::std::ptr::addr_of!((*ptr)._unknownObjectValue15) as usize - ptr as usize },
2981 17208usize,
2982 concat!(
2983 "Offset of field: ",
2984 stringify!(SQSharedState),
2985 "::",
2986 stringify!(_unknownObjectValue15)
2987 )
2988 );
2989 assert_eq!(
2990 unsafe { ::std::ptr::addr_of!((*ptr).gap_4340) as usize - ptr as usize },
2991 17216usize,
2992 concat!(
2993 "Offset of field: ",
2994 stringify!(SQSharedState),
2995 "::",
2996 stringify!(gap_4340)
2997 )
2998 );
2999 assert_eq!(
3000 unsafe { ::std::ptr::addr_of!((*ptr).printFunction) as usize - ptr as usize },
3001 17232usize,
3002 concat!(
3003 "Offset of field: ",
3004 stringify!(SQSharedState),
3005 "::",
3006 stringify!(printFunction)
3007 )
3008 );
3009 assert_eq!(
3010 unsafe { ::std::ptr::addr_of!((*ptr).gap_4358) as usize - ptr as usize },
3011 17240usize,
3012 concat!(
3013 "Offset of field: ",
3014 stringify!(SQSharedState),
3015 "::",
3016 stringify!(gap_4358)
3017 )
3018 );
3019 assert_eq!(
3020 unsafe { ::std::ptr::addr_of!((*ptr).logEntityFunction) as usize - ptr as usize },
3021 17256usize,
3022 concat!(
3023 "Offset of field: ",
3024 stringify!(SQSharedState),
3025 "::",
3026 stringify!(logEntityFunction)
3027 )
3028 );
3029 assert_eq!(
3030 unsafe { ::std::ptr::addr_of!((*ptr).gap_4370) as usize - ptr as usize },
3031 17264usize,
3032 concat!(
3033 "Offset of field: ",
3034 stringify!(SQSharedState),
3035 "::",
3036 stringify!(gap_4370)
3037 )
3038 );
3039 assert_eq!(
3040 unsafe { ::std::ptr::addr_of!((*ptr)._waitStringType) as usize - ptr as usize },
3041 17304usize,
3042 concat!(
3043 "Offset of field: ",
3044 stringify!(SQSharedState),
3045 "::",
3046 stringify!(_waitStringType)
3047 )
3048 );
3049 assert_eq!(
3050 unsafe { ::std::ptr::addr_of!((*ptr)._waitStringValue) as usize - ptr as usize },
3051 17312usize,
3052 concat!(
3053 "Offset of field: ",
3054 stringify!(SQSharedState),
3055 "::",
3056 stringify!(_waitStringValue)
3057 )
3058 );
3059 assert_eq!(
3060 unsafe {
3061 ::std::ptr::addr_of!((*ptr)._SpinOffAndWaitForStringType) as usize - ptr as usize
3062 },
3063 17320usize,
3064 concat!(
3065 "Offset of field: ",
3066 stringify!(SQSharedState),
3067 "::",
3068 stringify!(_SpinOffAndWaitForStringType)
3069 )
3070 );
3071 assert_eq!(
3072 unsafe {
3073 ::std::ptr::addr_of!((*ptr)._SpinOffAndWaitForStringValue) as usize - ptr as usize
3074 },
3075 17328usize,
3076 concat!(
3077 "Offset of field: ",
3078 stringify!(SQSharedState),
3079 "::",
3080 stringify!(_SpinOffAndWaitForStringValue)
3081 )
3082 );
3083 assert_eq!(
3084 unsafe {
3085 ::std::ptr::addr_of!((*ptr)._SpinOffAndWaitForSoloStringType) as usize - ptr as usize
3086 },
3087 17336usize,
3088 concat!(
3089 "Offset of field: ",
3090 stringify!(SQSharedState),
3091 "::",
3092 stringify!(_SpinOffAndWaitForSoloStringType)
3093 )
3094 );
3095 assert_eq!(
3096 unsafe {
3097 ::std::ptr::addr_of!((*ptr)._SpinOffAndWaitForSoloStringValue) as usize - ptr as usize
3098 },
3099 17344usize,
3100 concat!(
3101 "Offset of field: ",
3102 stringify!(SQSharedState),
3103 "::",
3104 stringify!(_SpinOffAndWaitForSoloStringValue)
3105 )
3106 );
3107 assert_eq!(
3108 unsafe { ::std::ptr::addr_of!((*ptr)._SpinOffStringType) as usize - ptr as usize },
3109 17352usize,
3110 concat!(
3111 "Offset of field: ",
3112 stringify!(SQSharedState),
3113 "::",
3114 stringify!(_SpinOffStringType)
3115 )
3116 );
3117 assert_eq!(
3118 unsafe { ::std::ptr::addr_of!((*ptr)._SpinOffStringValue) as usize - ptr as usize },
3119 17360usize,
3120 concat!(
3121 "Offset of field: ",
3122 stringify!(SQSharedState),
3123 "::",
3124 stringify!(_SpinOffStringValue)
3125 )
3126 );
3127 assert_eq!(
3128 unsafe { ::std::ptr::addr_of!((*ptr)._SpinOffDelayedStringType) as usize - ptr as usize },
3129 17368usize,
3130 concat!(
3131 "Offset of field: ",
3132 stringify!(SQSharedState),
3133 "::",
3134 stringify!(_SpinOffDelayedStringType)
3135 )
3136 );
3137 assert_eq!(
3138 unsafe { ::std::ptr::addr_of!((*ptr)._SpinOffDelayedStringValue) as usize - ptr as usize },
3139 17376usize,
3140 concat!(
3141 "Offset of field: ",
3142 stringify!(SQSharedState),
3143 "::",
3144 stringify!(_SpinOffDelayedStringValue)
3145 )
3146 );
3147 assert_eq!(
3148 unsafe { ::std::ptr::addr_of!((*ptr).cSquirrelVM) as usize - ptr as usize },
3149 17384usize,
3150 concat!(
3151 "Offset of field: ",
3152 stringify!(SQSharedState),
3153 "::",
3154 stringify!(cSquirrelVM)
3155 )
3156 );
3157 assert_eq!(
3158 unsafe { ::std::ptr::addr_of!((*ptr).enableDebugInfo) as usize - ptr as usize },
3159 17392usize,
3160 concat!(
3161 "Offset of field: ",
3162 stringify!(SQSharedState),
3163 "::",
3164 stringify!(enableDebugInfo)
3165 )
3166 );
3167 assert_eq!(
3168 unsafe { ::std::ptr::addr_of!((*ptr).gap_43F1) as usize - ptr as usize },
3169 17393usize,
3170 concat!(
3171 "Offset of field: ",
3172 stringify!(SQSharedState),
3173 "::",
3174 stringify!(gap_43F1)
3175 )
3176 );
3177}
3178#[repr(C)]
3179#[derive(Copy, Clone)]
3180pub struct tableNode {
3181 pub val: SQObject,
3182 pub key: SQObject,
3183 pub next: *mut tableNode,
3184}
3185#[test]
3186fn bindgen_test_layout_tableNode() {
3187 const UNINIT: ::std::mem::MaybeUninit<tableNode> = ::std::mem::MaybeUninit::uninit();
3188 let ptr = UNINIT.as_ptr();
3189 assert_eq!(
3190 ::std::mem::size_of::<tableNode>(),
3191 40usize,
3192 concat!("Size of: ", stringify!(tableNode))
3193 );
3194 assert_eq!(
3195 ::std::mem::align_of::<tableNode>(),
3196 8usize,
3197 concat!("Alignment of ", stringify!(tableNode))
3198 );
3199 assert_eq!(
3200 unsafe { ::std::ptr::addr_of!((*ptr).val) as usize - ptr as usize },
3201 0usize,
3202 concat!(
3203 "Offset of field: ",
3204 stringify!(tableNode),
3205 "::",
3206 stringify!(val)
3207 )
3208 );
3209 assert_eq!(
3210 unsafe { ::std::ptr::addr_of!((*ptr).key) as usize - ptr as usize },
3211 16usize,
3212 concat!(
3213 "Offset of field: ",
3214 stringify!(tableNode),
3215 "::",
3216 stringify!(key)
3217 )
3218 );
3219 assert_eq!(
3220 unsafe { ::std::ptr::addr_of!((*ptr).next) as usize - ptr as usize },
3221 32usize,
3222 concat!(
3223 "Offset of field: ",
3224 stringify!(tableNode),
3225 "::",
3226 stringify!(next)
3227 )
3228 );
3229}
3230#[repr(C)]
3231#[derive(Copy, Clone)]
3232pub struct CallInfo {
3233 pub ip: ::std::os::raw::c_longlong,
3234 pub _literals: *mut SQObject,
3235 pub obj10: SQObject,
3236 pub closure: SQObject,
3237 pub _etraps: [::std::os::raw::c_int; 4usize],
3238 pub _root: ::std::os::raw::c_int,
3239 pub _vargs_size: ::std::os::raw::c_short,
3240 pub _vargs_base: ::std::os::raw::c_short,
3241 pub gap: [::std::os::raw::c_uchar; 16usize],
3242}
3243#[test]
3244fn bindgen_test_layout_CallInfo() {
3245 const UNINIT: ::std::mem::MaybeUninit<CallInfo> = ::std::mem::MaybeUninit::uninit();
3246 let ptr = UNINIT.as_ptr();
3247 assert_eq!(
3248 ::std::mem::size_of::<CallInfo>(),
3249 88usize,
3250 concat!("Size of: ", stringify!(CallInfo))
3251 );
3252 assert_eq!(
3253 ::std::mem::align_of::<CallInfo>(),
3254 8usize,
3255 concat!("Alignment of ", stringify!(CallInfo))
3256 );
3257 assert_eq!(
3258 unsafe { ::std::ptr::addr_of!((*ptr).ip) as usize - ptr as usize },
3259 0usize,
3260 concat!(
3261 "Offset of field: ",
3262 stringify!(CallInfo),
3263 "::",
3264 stringify!(ip)
3265 )
3266 );
3267 assert_eq!(
3268 unsafe { ::std::ptr::addr_of!((*ptr)._literals) as usize - ptr as usize },
3269 8usize,
3270 concat!(
3271 "Offset of field: ",
3272 stringify!(CallInfo),
3273 "::",
3274 stringify!(_literals)
3275 )
3276 );
3277 assert_eq!(
3278 unsafe { ::std::ptr::addr_of!((*ptr).obj10) as usize - ptr as usize },
3279 16usize,
3280 concat!(
3281 "Offset of field: ",
3282 stringify!(CallInfo),
3283 "::",
3284 stringify!(obj10)
3285 )
3286 );
3287 assert_eq!(
3288 unsafe { ::std::ptr::addr_of!((*ptr).closure) as usize - ptr as usize },
3289 32usize,
3290 concat!(
3291 "Offset of field: ",
3292 stringify!(CallInfo),
3293 "::",
3294 stringify!(closure)
3295 )
3296 );
3297 assert_eq!(
3298 unsafe { ::std::ptr::addr_of!((*ptr)._etraps) as usize - ptr as usize },
3299 48usize,
3300 concat!(
3301 "Offset of field: ",
3302 stringify!(CallInfo),
3303 "::",
3304 stringify!(_etraps)
3305 )
3306 );
3307 assert_eq!(
3308 unsafe { ::std::ptr::addr_of!((*ptr)._root) as usize - ptr as usize },
3309 64usize,
3310 concat!(
3311 "Offset of field: ",
3312 stringify!(CallInfo),
3313 "::",
3314 stringify!(_root)
3315 )
3316 );
3317 assert_eq!(
3318 unsafe { ::std::ptr::addr_of!((*ptr)._vargs_size) as usize - ptr as usize },
3319 68usize,
3320 concat!(
3321 "Offset of field: ",
3322 stringify!(CallInfo),
3323 "::",
3324 stringify!(_vargs_size)
3325 )
3326 );
3327 assert_eq!(
3328 unsafe { ::std::ptr::addr_of!((*ptr)._vargs_base) as usize - ptr as usize },
3329 70usize,
3330 concat!(
3331 "Offset of field: ",
3332 stringify!(CallInfo),
3333 "::",
3334 stringify!(_vargs_base)
3335 )
3336 );
3337 assert_eq!(
3338 unsafe { ::std::ptr::addr_of!((*ptr).gap) as usize - ptr as usize },
3339 72usize,
3340 concat!(
3341 "Offset of field: ",
3342 stringify!(CallInfo),
3343 "::",
3344 stringify!(gap)
3345 )
3346 );
3347}
3348#[repr(C)]
3349#[derive(Debug, Copy, Clone)]
3350pub struct StringTable {
3351 pub gap_0: [::std::os::raw::c_uchar; 12usize],
3352 pub _numofslots: ::std::os::raw::c_int,
3353 pub gap_10: [::std::os::raw::c_uchar; 200usize],
3354}
3355#[test]
3356fn bindgen_test_layout_StringTable() {
3357 const UNINIT: ::std::mem::MaybeUninit<StringTable> = ::std::mem::MaybeUninit::uninit();
3358 let ptr = UNINIT.as_ptr();
3359 assert_eq!(
3360 ::std::mem::size_of::<StringTable>(),
3361 216usize,
3362 concat!("Size of: ", stringify!(StringTable))
3363 );
3364 assert_eq!(
3365 ::std::mem::align_of::<StringTable>(),
3366 4usize,
3367 concat!("Alignment of ", stringify!(StringTable))
3368 );
3369 assert_eq!(
3370 unsafe { ::std::ptr::addr_of!((*ptr).gap_0) as usize - ptr as usize },
3371 0usize,
3372 concat!(
3373 "Offset of field: ",
3374 stringify!(StringTable),
3375 "::",
3376 stringify!(gap_0)
3377 )
3378 );
3379 assert_eq!(
3380 unsafe { ::std::ptr::addr_of!((*ptr)._numofslots) as usize - ptr as usize },
3381 12usize,
3382 concat!(
3383 "Offset of field: ",
3384 stringify!(StringTable),
3385 "::",
3386 stringify!(_numofslots)
3387 )
3388 );
3389 assert_eq!(
3390 unsafe { ::std::ptr::addr_of!((*ptr).gap_10) as usize - ptr as usize },
3391 16usize,
3392 concat!(
3393 "Offset of field: ",
3394 stringify!(StringTable),
3395 "::",
3396 stringify!(gap_10)
3397 )
3398 );
3399}
3400#[repr(C)]
3401#[derive(Debug, Copy, Clone)]
3402pub struct SQStackInfos {
3403 pub _name: *mut ::std::os::raw::c_char,
3404 pub _sourceName: *mut ::std::os::raw::c_char,
3405 pub _line: ::std::os::raw::c_int,
3406}
3407#[test]
3408fn bindgen_test_layout_SQStackInfos() {
3409 const UNINIT: ::std::mem::MaybeUninit<SQStackInfos> = ::std::mem::MaybeUninit::uninit();
3410 let ptr = UNINIT.as_ptr();
3411 assert_eq!(
3412 ::std::mem::size_of::<SQStackInfos>(),
3413 24usize,
3414 concat!("Size of: ", stringify!(SQStackInfos))
3415 );
3416 assert_eq!(
3417 ::std::mem::align_of::<SQStackInfos>(),
3418 8usize,
3419 concat!("Alignment of ", stringify!(SQStackInfos))
3420 );
3421 assert_eq!(
3422 unsafe { ::std::ptr::addr_of!((*ptr)._name) as usize - ptr as usize },
3423 0usize,
3424 concat!(
3425 "Offset of field: ",
3426 stringify!(SQStackInfos),
3427 "::",
3428 stringify!(_name)
3429 )
3430 );
3431 assert_eq!(
3432 unsafe { ::std::ptr::addr_of!((*ptr)._sourceName) as usize - ptr as usize },
3433 8usize,
3434 concat!(
3435 "Offset of field: ",
3436 stringify!(SQStackInfos),
3437 "::",
3438 stringify!(_sourceName)
3439 )
3440 );
3441 assert_eq!(
3442 unsafe { ::std::ptr::addr_of!((*ptr)._line) as usize - ptr as usize },
3443 16usize,
3444 concat!(
3445 "Offset of field: ",
3446 stringify!(SQStackInfos),
3447 "::",
3448 stringify!(_line)
3449 )
3450 );
3451}
3452#[repr(C)]
3453#[derive(Debug, Copy, Clone)]
3454pub struct SQInstruction {
3455 pub op: ::std::os::raw::c_int,
3456 pub arg1: ::std::os::raw::c_int,
3457 pub output: ::std::os::raw::c_int,
3458 pub arg2: ::std::os::raw::c_short,
3459 pub arg3: ::std::os::raw::c_short,
3460}
3461#[test]
3462fn bindgen_test_layout_SQInstruction() {
3463 const UNINIT: ::std::mem::MaybeUninit<SQInstruction> = ::std::mem::MaybeUninit::uninit();
3464 let ptr = UNINIT.as_ptr();
3465 assert_eq!(
3466 ::std::mem::size_of::<SQInstruction>(),
3467 16usize,
3468 concat!("Size of: ", stringify!(SQInstruction))
3469 );
3470 assert_eq!(
3471 ::std::mem::align_of::<SQInstruction>(),
3472 4usize,
3473 concat!("Alignment of ", stringify!(SQInstruction))
3474 );
3475 assert_eq!(
3476 unsafe { ::std::ptr::addr_of!((*ptr).op) as usize - ptr as usize },
3477 0usize,
3478 concat!(
3479 "Offset of field: ",
3480 stringify!(SQInstruction),
3481 "::",
3482 stringify!(op)
3483 )
3484 );
3485 assert_eq!(
3486 unsafe { ::std::ptr::addr_of!((*ptr).arg1) as usize - ptr as usize },
3487 4usize,
3488 concat!(
3489 "Offset of field: ",
3490 stringify!(SQInstruction),
3491 "::",
3492 stringify!(arg1)
3493 )
3494 );
3495 assert_eq!(
3496 unsafe { ::std::ptr::addr_of!((*ptr).output) as usize - ptr as usize },
3497 8usize,
3498 concat!(
3499 "Offset of field: ",
3500 stringify!(SQInstruction),
3501 "::",
3502 stringify!(output)
3503 )
3504 );
3505 assert_eq!(
3506 unsafe { ::std::ptr::addr_of!((*ptr).arg2) as usize - ptr as usize },
3507 12usize,
3508 concat!(
3509 "Offset of field: ",
3510 stringify!(SQInstruction),
3511 "::",
3512 stringify!(arg2)
3513 )
3514 );
3515 assert_eq!(
3516 unsafe { ::std::ptr::addr_of!((*ptr).arg3) as usize - ptr as usize },
3517 14usize,
3518 concat!(
3519 "Offset of field: ",
3520 stringify!(SQInstruction),
3521 "::",
3522 stringify!(arg3)
3523 )
3524 );
3525}
3526#[repr(C)]
3527#[derive(Debug, Copy, Clone)]
3528pub struct SQLexer {
3529 pub gap_0: [::std::os::raw::c_uchar; 112usize],
3530}
3531#[test]
3532fn bindgen_test_layout_SQLexer() {
3533 const UNINIT: ::std::mem::MaybeUninit<SQLexer> = ::std::mem::MaybeUninit::uninit();
3534 let ptr = UNINIT.as_ptr();
3535 assert_eq!(
3536 ::std::mem::size_of::<SQLexer>(),
3537 112usize,
3538 concat!("Size of: ", stringify!(SQLexer))
3539 );
3540 assert_eq!(
3541 ::std::mem::align_of::<SQLexer>(),
3542 1usize,
3543 concat!("Alignment of ", stringify!(SQLexer))
3544 );
3545 assert_eq!(
3546 unsafe { ::std::ptr::addr_of!((*ptr).gap_0) as usize - ptr as usize },
3547 0usize,
3548 concat!(
3549 "Offset of field: ",
3550 stringify!(SQLexer),
3551 "::",
3552 stringify!(gap_0)
3553 )
3554 );
3555}
3556#[repr(C)]
3557#[derive(Copy, Clone)]
3558pub struct SQCompiler {
3559 pub gap_0: [::std::os::raw::c_uchar; 4usize],
3560 pub _token: ::std::os::raw::c_int,
3561 pub gap_8: [::std::os::raw::c_uchar; 8usize],
3562 pub object_10: SQObject,
3563 pub lexer: SQLexer,
3564 pub gap_90: [::std::os::raw::c_uchar; 752usize],
3565 pub sqvm: *mut HSquirrelVM,
3566 pub gap_288: [::std::os::raw::c_uchar; 8usize],
3567}
3568#[test]
3569fn bindgen_test_layout_SQCompiler() {
3570 const UNINIT: ::std::mem::MaybeUninit<SQCompiler> = ::std::mem::MaybeUninit::uninit();
3571 let ptr = UNINIT.as_ptr();
3572 assert_eq!(
3573 ::std::mem::size_of::<SQCompiler>(),
3574 912usize,
3575 concat!("Size of: ", stringify!(SQCompiler))
3576 );
3577 assert_eq!(
3578 ::std::mem::align_of::<SQCompiler>(),
3579 8usize,
3580 concat!("Alignment of ", stringify!(SQCompiler))
3581 );
3582 assert_eq!(
3583 unsafe { ::std::ptr::addr_of!((*ptr).gap_0) as usize - ptr as usize },
3584 0usize,
3585 concat!(
3586 "Offset of field: ",
3587 stringify!(SQCompiler),
3588 "::",
3589 stringify!(gap_0)
3590 )
3591 );
3592 assert_eq!(
3593 unsafe { ::std::ptr::addr_of!((*ptr)._token) as usize - ptr as usize },
3594 4usize,
3595 concat!(
3596 "Offset of field: ",
3597 stringify!(SQCompiler),
3598 "::",
3599 stringify!(_token)
3600 )
3601 );
3602 assert_eq!(
3603 unsafe { ::std::ptr::addr_of!((*ptr).gap_8) as usize - ptr as usize },
3604 8usize,
3605 concat!(
3606 "Offset of field: ",
3607 stringify!(SQCompiler),
3608 "::",
3609 stringify!(gap_8)
3610 )
3611 );
3612 assert_eq!(
3613 unsafe { ::std::ptr::addr_of!((*ptr).object_10) as usize - ptr as usize },
3614 16usize,
3615 concat!(
3616 "Offset of field: ",
3617 stringify!(SQCompiler),
3618 "::",
3619 stringify!(object_10)
3620 )
3621 );
3622 assert_eq!(
3623 unsafe { ::std::ptr::addr_of!((*ptr).lexer) as usize - ptr as usize },
3624 32usize,
3625 concat!(
3626 "Offset of field: ",
3627 stringify!(SQCompiler),
3628 "::",
3629 stringify!(lexer)
3630 )
3631 );
3632 assert_eq!(
3633 unsafe { ::std::ptr::addr_of!((*ptr).gap_90) as usize - ptr as usize },
3634 144usize,
3635 concat!(
3636 "Offset of field: ",
3637 stringify!(SQCompiler),
3638 "::",
3639 stringify!(gap_90)
3640 )
3641 );
3642 assert_eq!(
3643 unsafe { ::std::ptr::addr_of!((*ptr).sqvm) as usize - ptr as usize },
3644 896usize,
3645 concat!(
3646 "Offset of field: ",
3647 stringify!(SQCompiler),
3648 "::",
3649 stringify!(sqvm)
3650 )
3651 );
3652 assert_eq!(
3653 unsafe { ::std::ptr::addr_of!((*ptr).gap_288) as usize - ptr as usize },
3654 904usize,
3655 concat!(
3656 "Offset of field: ",
3657 stringify!(SQCompiler),
3658 "::",
3659 stringify!(gap_288)
3660 )
3661 );
3662}
3663#[repr(C)]
3664#[derive(Copy, Clone)]
3665pub struct CSquirrelVM {
3666 pub gap_0: [::std::os::raw::c_uchar; 8usize],
3667 pub sqvm: *mut HSquirrelVM,
3668 pub gap_10: [::std::os::raw::c_uchar; 8usize],
3669 pub unknownObject_18: SQObject,
3670 pub unknown_28: ::std::os::raw::c_longlong,
3671 pub gap_30: [::std::os::raw::c_uchar; 12usize],
3672 pub vmContext: ::std::os::raw::c_int,
3673 pub gap_40: [::std::os::raw::c_uchar; 648usize],
3674 pub formatString: ::std::option::Option<
3675 unsafe extern "C" fn(
3676 a1: ::std::os::raw::c_longlong,
3677 format: *const ::std::os::raw::c_char,
3678 ...
3679 ) -> *mut ::std::os::raw::c_char,
3680 >,
3681 pub gap_2D0: [::std::os::raw::c_uchar; 24usize],
3682}
3683#[test]
3684fn bindgen_test_layout_CSquirrelVM() {
3685 const UNINIT: ::std::mem::MaybeUninit<CSquirrelVM> = ::std::mem::MaybeUninit::uninit();
3686 let ptr = UNINIT.as_ptr();
3687 assert_eq!(
3688 ::std::mem::size_of::<CSquirrelVM>(),
3689 744usize,
3690 concat!("Size of: ", stringify!(CSquirrelVM))
3691 );
3692 assert_eq!(
3693 ::std::mem::align_of::<CSquirrelVM>(),
3694 8usize,
3695 concat!("Alignment of ", stringify!(CSquirrelVM))
3696 );
3697 assert_eq!(
3698 unsafe { ::std::ptr::addr_of!((*ptr).gap_0) as usize - ptr as usize },
3699 0usize,
3700 concat!(
3701 "Offset of field: ",
3702 stringify!(CSquirrelVM),
3703 "::",
3704 stringify!(gap_0)
3705 )
3706 );
3707 assert_eq!(
3708 unsafe { ::std::ptr::addr_of!((*ptr).sqvm) as usize - ptr as usize },
3709 8usize,
3710 concat!(
3711 "Offset of field: ",
3712 stringify!(CSquirrelVM),
3713 "::",
3714 stringify!(sqvm)
3715 )
3716 );
3717 assert_eq!(
3718 unsafe { ::std::ptr::addr_of!((*ptr).gap_10) as usize - ptr as usize },
3719 16usize,
3720 concat!(
3721 "Offset of field: ",
3722 stringify!(CSquirrelVM),
3723 "::",
3724 stringify!(gap_10)
3725 )
3726 );
3727 assert_eq!(
3728 unsafe { ::std::ptr::addr_of!((*ptr).unknownObject_18) as usize - ptr as usize },
3729 24usize,
3730 concat!(
3731 "Offset of field: ",
3732 stringify!(CSquirrelVM),
3733 "::",
3734 stringify!(unknownObject_18)
3735 )
3736 );
3737 assert_eq!(
3738 unsafe { ::std::ptr::addr_of!((*ptr).unknown_28) as usize - ptr as usize },
3739 40usize,
3740 concat!(
3741 "Offset of field: ",
3742 stringify!(CSquirrelVM),
3743 "::",
3744 stringify!(unknown_28)
3745 )
3746 );
3747 assert_eq!(
3748 unsafe { ::std::ptr::addr_of!((*ptr).gap_30) as usize - ptr as usize },
3749 48usize,
3750 concat!(
3751 "Offset of field: ",
3752 stringify!(CSquirrelVM),
3753 "::",
3754 stringify!(gap_30)
3755 )
3756 );
3757 assert_eq!(
3758 unsafe { ::std::ptr::addr_of!((*ptr).vmContext) as usize - ptr as usize },
3759 60usize,
3760 concat!(
3761 "Offset of field: ",
3762 stringify!(CSquirrelVM),
3763 "::",
3764 stringify!(vmContext)
3765 )
3766 );
3767 assert_eq!(
3768 unsafe { ::std::ptr::addr_of!((*ptr).gap_40) as usize - ptr as usize },
3769 64usize,
3770 concat!(
3771 "Offset of field: ",
3772 stringify!(CSquirrelVM),
3773 "::",
3774 stringify!(gap_40)
3775 )
3776 );
3777 assert_eq!(
3778 unsafe { ::std::ptr::addr_of!((*ptr).formatString) as usize - ptr as usize },
3779 712usize,
3780 concat!(
3781 "Offset of field: ",
3782 stringify!(CSquirrelVM),
3783 "::",
3784 stringify!(formatString)
3785 )
3786 );
3787 assert_eq!(
3788 unsafe { ::std::ptr::addr_of!((*ptr).gap_2D0) as usize - ptr as usize },
3789 720usize,
3790 concat!(
3791 "Offset of field: ",
3792 stringify!(CSquirrelVM),
3793 "::",
3794 stringify!(gap_2D0)
3795 )
3796 );
3797}
3798#[repr(C)]
3799#[derive(Debug, Copy, Clone)]
3800pub struct SQUserData {
3801 pub vftable: *mut ::std::os::raw::c_void,
3802 pub uiRef: ::std::os::raw::c_int,
3803 pub gap_12: [::std::os::raw::c_char; 4usize],
3804 pub unknown_10: ::std::os::raw::c_longlong,
3805 pub unknown_18: ::std::os::raw::c_longlong,
3806 pub unknown_20: ::std::os::raw::c_longlong,
3807 pub sharedState: ::std::os::raw::c_longlong,
3808 pub unknown_30: ::std::os::raw::c_longlong,
3809 pub size: ::std::os::raw::c_int,
3810 pub padding1: [::std::os::raw::c_char; 4usize],
3811 pub releaseHook: releasehookType,
3812 pub typeId: ::std::os::raw::c_longlong,
3813 pub data: [::std::os::raw::c_char; 1usize],
3814}
3815#[test]
3816fn bindgen_test_layout_SQUserData() {
3817 const UNINIT: ::std::mem::MaybeUninit<SQUserData> = ::std::mem::MaybeUninit::uninit();
3818 let ptr = UNINIT.as_ptr();
3819 assert_eq!(
3820 ::std::mem::size_of::<SQUserData>(),
3821 88usize,
3822 concat!("Size of: ", stringify!(SQUserData))
3823 );
3824 assert_eq!(
3825 ::std::mem::align_of::<SQUserData>(),
3826 8usize,
3827 concat!("Alignment of ", stringify!(SQUserData))
3828 );
3829 assert_eq!(
3830 unsafe { ::std::ptr::addr_of!((*ptr).vftable) as usize - ptr as usize },
3831 0usize,
3832 concat!(
3833 "Offset of field: ",
3834 stringify!(SQUserData),
3835 "::",
3836 stringify!(vftable)
3837 )
3838 );
3839 assert_eq!(
3840 unsafe { ::std::ptr::addr_of!((*ptr).uiRef) as usize - ptr as usize },
3841 8usize,
3842 concat!(
3843 "Offset of field: ",
3844 stringify!(SQUserData),
3845 "::",
3846 stringify!(uiRef)
3847 )
3848 );
3849 assert_eq!(
3850 unsafe { ::std::ptr::addr_of!((*ptr).gap_12) as usize - ptr as usize },
3851 12usize,
3852 concat!(
3853 "Offset of field: ",
3854 stringify!(SQUserData),
3855 "::",
3856 stringify!(gap_12)
3857 )
3858 );
3859 assert_eq!(
3860 unsafe { ::std::ptr::addr_of!((*ptr).unknown_10) as usize - ptr as usize },
3861 16usize,
3862 concat!(
3863 "Offset of field: ",
3864 stringify!(SQUserData),
3865 "::",
3866 stringify!(unknown_10)
3867 )
3868 );
3869 assert_eq!(
3870 unsafe { ::std::ptr::addr_of!((*ptr).unknown_18) as usize - ptr as usize },
3871 24usize,
3872 concat!(
3873 "Offset of field: ",
3874 stringify!(SQUserData),
3875 "::",
3876 stringify!(unknown_18)
3877 )
3878 );
3879 assert_eq!(
3880 unsafe { ::std::ptr::addr_of!((*ptr).unknown_20) as usize - ptr as usize },
3881 32usize,
3882 concat!(
3883 "Offset of field: ",
3884 stringify!(SQUserData),
3885 "::",
3886 stringify!(unknown_20)
3887 )
3888 );
3889 assert_eq!(
3890 unsafe { ::std::ptr::addr_of!((*ptr).sharedState) as usize - ptr as usize },
3891 40usize,
3892 concat!(
3893 "Offset of field: ",
3894 stringify!(SQUserData),
3895 "::",
3896 stringify!(sharedState)
3897 )
3898 );
3899 assert_eq!(
3900 unsafe { ::std::ptr::addr_of!((*ptr).unknown_30) as usize - ptr as usize },
3901 48usize,
3902 concat!(
3903 "Offset of field: ",
3904 stringify!(SQUserData),
3905 "::",
3906 stringify!(unknown_30)
3907 )
3908 );
3909 assert_eq!(
3910 unsafe { ::std::ptr::addr_of!((*ptr).size) as usize - ptr as usize },
3911 56usize,
3912 concat!(
3913 "Offset of field: ",
3914 stringify!(SQUserData),
3915 "::",
3916 stringify!(size)
3917 )
3918 );
3919 assert_eq!(
3920 unsafe { ::std::ptr::addr_of!((*ptr).padding1) as usize - ptr as usize },
3921 60usize,
3922 concat!(
3923 "Offset of field: ",
3924 stringify!(SQUserData),
3925 "::",
3926 stringify!(padding1)
3927 )
3928 );
3929 assert_eq!(
3930 unsafe { ::std::ptr::addr_of!((*ptr).releaseHook) as usize - ptr as usize },
3931 64usize,
3932 concat!(
3933 "Offset of field: ",
3934 stringify!(SQUserData),
3935 "::",
3936 stringify!(releaseHook)
3937 )
3938 );
3939 assert_eq!(
3940 unsafe { ::std::ptr::addr_of!((*ptr).typeId) as usize - ptr as usize },
3941 72usize,
3942 concat!(
3943 "Offset of field: ",
3944 stringify!(SQUserData),
3945 "::",
3946 stringify!(typeId)
3947 )
3948 );
3949 assert_eq!(
3950 unsafe { ::std::ptr::addr_of!((*ptr).data) as usize - ptr as usize },
3951 80usize,
3952 concat!(
3953 "Offset of field: ",
3954 stringify!(SQUserData),
3955 "::",
3956 stringify!(data)
3957 )
3958 );
3959}