1#[repr(C)]
4#[derive(Copy, Clone, Debug, Default, Eq, Hash, Ord, PartialEq, PartialOrd)]
5pub struct __BindgenBitfieldUnit<Storage, Align> {
6 storage: Storage,
7 align: [Align; 0],
8}
9impl<Storage, Align> __BindgenBitfieldUnit<Storage, Align> {
10 #[inline]
11 pub const fn new(storage: Storage) -> Self {
12 Self { storage, align: [] }
13 }
14}
15impl<Storage, Align> __BindgenBitfieldUnit<Storage, Align>
16where
17 Storage: AsRef<[u8]> + AsMut<[u8]>,
18{
19 #[inline]
20 pub fn get_bit(&self, index: usize) -> bool {
21 debug_assert!(index / 8 < self.storage.as_ref().len());
22 let byte_index = index / 8;
23 let byte = self.storage.as_ref()[byte_index];
24 let bit_index = if cfg!(target_endian = "big") {
25 7 - (index % 8)
26 } else {
27 index % 8
28 };
29 let mask = 1 << bit_index;
30 byte & mask == mask
31 }
32 #[inline]
33 pub fn set_bit(&mut self, index: usize, val: bool) {
34 debug_assert!(index / 8 < self.storage.as_ref().len());
35 let byte_index = index / 8;
36 let byte = &mut self.storage.as_mut()[byte_index];
37 let bit_index = if cfg!(target_endian = "big") {
38 7 - (index % 8)
39 } else {
40 index % 8
41 };
42 let mask = 1 << bit_index;
43 if val {
44 *byte |= mask;
45 } else {
46 *byte &= !mask;
47 }
48 }
49 #[inline]
50 pub fn get(&self, bit_offset: usize, bit_width: u8) -> u64 {
51 debug_assert!(bit_width <= 64);
52 debug_assert!(bit_offset / 8 < self.storage.as_ref().len());
53 debug_assert!((bit_offset + (bit_width as usize)) / 8 <= self.storage.as_ref().len());
54 let mut val = 0;
55 for i in 0..(bit_width as usize) {
56 if self.get_bit(i + bit_offset) {
57 let index = if cfg!(target_endian = "big") {
58 bit_width as usize - 1 - i
59 } else {
60 i
61 };
62 val |= 1 << index;
63 }
64 }
65 val
66 }
67 #[inline]
68 pub fn set(&mut self, bit_offset: usize, bit_width: u8, val: u64) {
69 debug_assert!(bit_width <= 64);
70 debug_assert!(bit_offset / 8 < self.storage.as_ref().len());
71 debug_assert!((bit_offset + (bit_width as usize)) / 8 <= self.storage.as_ref().len());
72 for i in 0..(bit_width as usize) {
73 let mask = 1 << i;
74 let val_bit_is_set = val & mask == mask;
75 let index = if cfg!(target_endian = "big") {
76 bit_width as usize - 1 - i
77 } else {
78 i
79 };
80 self.set_bit(index + bit_offset, val_bit_is_set);
81 }
82 }
83}
84pub const GP_NONE: u32 = 0;
85pub const GP_GLIST: u32 = 1;
86pub const GP_ARRAY: u32 = 2;
87pub const CLASS_DEFAULT: u32 = 0;
88pub const CLASS_PD: u32 = 1;
89pub const CLASS_GOBJ: u32 = 2;
90pub const CLASS_PATCHABLE: u32 = 3;
91pub const CLASS_NOINLET: u32 = 8;
92pub const CLASS_TYPEMASK: u32 = 3;
93pub type __off_t = ::std::os::raw::c_long;
94pub type __off64_t = ::std::os::raw::c_long;
95pub type FILE = _IO_FILE;
96pub type _IO_lock_t = ::std::os::raw::c_void;
97#[repr(C)]
98#[derive(Debug, Copy, Clone)]
99pub struct _IO_marker {
100 pub _next: *mut _IO_marker,
101 pub _sbuf: *mut _IO_FILE,
102 pub _pos: ::std::os::raw::c_int,
103}
104#[test]
105fn bindgen_test_layout__IO_marker() {
106 assert_eq!(
107 ::std::mem::size_of::<_IO_marker>(),
108 24usize,
109 concat!("Size of: ", stringify!(_IO_marker))
110 );
111 assert_eq!(
112 ::std::mem::align_of::<_IO_marker>(),
113 8usize,
114 concat!("Alignment of ", stringify!(_IO_marker))
115 );
116 assert_eq!(
117 unsafe { &(*(::std::ptr::null::<_IO_marker>()))._next as *const _ as usize },
118 0usize,
119 concat!(
120 "Offset of field: ",
121 stringify!(_IO_marker),
122 "::",
123 stringify!(_next)
124 )
125 );
126 assert_eq!(
127 unsafe { &(*(::std::ptr::null::<_IO_marker>()))._sbuf as *const _ as usize },
128 8usize,
129 concat!(
130 "Offset of field: ",
131 stringify!(_IO_marker),
132 "::",
133 stringify!(_sbuf)
134 )
135 );
136 assert_eq!(
137 unsafe { &(*(::std::ptr::null::<_IO_marker>()))._pos as *const _ as usize },
138 16usize,
139 concat!(
140 "Offset of field: ",
141 stringify!(_IO_marker),
142 "::",
143 stringify!(_pos)
144 )
145 );
146}
147#[repr(C)]
148#[derive(Debug, Copy, Clone)]
149pub struct _IO_FILE {
150 pub _flags: ::std::os::raw::c_int,
151 pub _IO_read_ptr: *mut ::std::os::raw::c_char,
152 pub _IO_read_end: *mut ::std::os::raw::c_char,
153 pub _IO_read_base: *mut ::std::os::raw::c_char,
154 pub _IO_write_base: *mut ::std::os::raw::c_char,
155 pub _IO_write_ptr: *mut ::std::os::raw::c_char,
156 pub _IO_write_end: *mut ::std::os::raw::c_char,
157 pub _IO_buf_base: *mut ::std::os::raw::c_char,
158 pub _IO_buf_end: *mut ::std::os::raw::c_char,
159 pub _IO_save_base: *mut ::std::os::raw::c_char,
160 pub _IO_backup_base: *mut ::std::os::raw::c_char,
161 pub _IO_save_end: *mut ::std::os::raw::c_char,
162 pub _markers: *mut _IO_marker,
163 pub _chain: *mut _IO_FILE,
164 pub _fileno: ::std::os::raw::c_int,
165 pub _flags2: ::std::os::raw::c_int,
166 pub _old_offset: __off_t,
167 pub _cur_column: ::std::os::raw::c_ushort,
168 pub _vtable_offset: ::std::os::raw::c_schar,
169 pub _shortbuf: [::std::os::raw::c_char; 1usize],
170 pub _lock: *mut _IO_lock_t,
171 pub _offset: __off64_t,
172 pub __pad1: *mut ::std::os::raw::c_void,
173 pub __pad2: *mut ::std::os::raw::c_void,
174 pub __pad3: *mut ::std::os::raw::c_void,
175 pub __pad4: *mut ::std::os::raw::c_void,
176 pub __pad5: usize,
177 pub _mode: ::std::os::raw::c_int,
178 pub _unused2: [::std::os::raw::c_char; 20usize],
179}
180#[test]
181fn bindgen_test_layout__IO_FILE() {
182 assert_eq!(
183 ::std::mem::size_of::<_IO_FILE>(),
184 216usize,
185 concat!("Size of: ", stringify!(_IO_FILE))
186 );
187 assert_eq!(
188 ::std::mem::align_of::<_IO_FILE>(),
189 8usize,
190 concat!("Alignment of ", stringify!(_IO_FILE))
191 );
192 assert_eq!(
193 unsafe { &(*(::std::ptr::null::<_IO_FILE>()))._flags as *const _ as usize },
194 0usize,
195 concat!(
196 "Offset of field: ",
197 stringify!(_IO_FILE),
198 "::",
199 stringify!(_flags)
200 )
201 );
202 assert_eq!(
203 unsafe { &(*(::std::ptr::null::<_IO_FILE>()))._IO_read_ptr as *const _ as usize },
204 8usize,
205 concat!(
206 "Offset of field: ",
207 stringify!(_IO_FILE),
208 "::",
209 stringify!(_IO_read_ptr)
210 )
211 );
212 assert_eq!(
213 unsafe { &(*(::std::ptr::null::<_IO_FILE>()))._IO_read_end as *const _ as usize },
214 16usize,
215 concat!(
216 "Offset of field: ",
217 stringify!(_IO_FILE),
218 "::",
219 stringify!(_IO_read_end)
220 )
221 );
222 assert_eq!(
223 unsafe { &(*(::std::ptr::null::<_IO_FILE>()))._IO_read_base as *const _ as usize },
224 24usize,
225 concat!(
226 "Offset of field: ",
227 stringify!(_IO_FILE),
228 "::",
229 stringify!(_IO_read_base)
230 )
231 );
232 assert_eq!(
233 unsafe { &(*(::std::ptr::null::<_IO_FILE>()))._IO_write_base as *const _ as usize },
234 32usize,
235 concat!(
236 "Offset of field: ",
237 stringify!(_IO_FILE),
238 "::",
239 stringify!(_IO_write_base)
240 )
241 );
242 assert_eq!(
243 unsafe { &(*(::std::ptr::null::<_IO_FILE>()))._IO_write_ptr as *const _ as usize },
244 40usize,
245 concat!(
246 "Offset of field: ",
247 stringify!(_IO_FILE),
248 "::",
249 stringify!(_IO_write_ptr)
250 )
251 );
252 assert_eq!(
253 unsafe { &(*(::std::ptr::null::<_IO_FILE>()))._IO_write_end as *const _ as usize },
254 48usize,
255 concat!(
256 "Offset of field: ",
257 stringify!(_IO_FILE),
258 "::",
259 stringify!(_IO_write_end)
260 )
261 );
262 assert_eq!(
263 unsafe { &(*(::std::ptr::null::<_IO_FILE>()))._IO_buf_base as *const _ as usize },
264 56usize,
265 concat!(
266 "Offset of field: ",
267 stringify!(_IO_FILE),
268 "::",
269 stringify!(_IO_buf_base)
270 )
271 );
272 assert_eq!(
273 unsafe { &(*(::std::ptr::null::<_IO_FILE>()))._IO_buf_end as *const _ as usize },
274 64usize,
275 concat!(
276 "Offset of field: ",
277 stringify!(_IO_FILE),
278 "::",
279 stringify!(_IO_buf_end)
280 )
281 );
282 assert_eq!(
283 unsafe { &(*(::std::ptr::null::<_IO_FILE>()))._IO_save_base as *const _ as usize },
284 72usize,
285 concat!(
286 "Offset of field: ",
287 stringify!(_IO_FILE),
288 "::",
289 stringify!(_IO_save_base)
290 )
291 );
292 assert_eq!(
293 unsafe { &(*(::std::ptr::null::<_IO_FILE>()))._IO_backup_base as *const _ as usize },
294 80usize,
295 concat!(
296 "Offset of field: ",
297 stringify!(_IO_FILE),
298 "::",
299 stringify!(_IO_backup_base)
300 )
301 );
302 assert_eq!(
303 unsafe { &(*(::std::ptr::null::<_IO_FILE>()))._IO_save_end as *const _ as usize },
304 88usize,
305 concat!(
306 "Offset of field: ",
307 stringify!(_IO_FILE),
308 "::",
309 stringify!(_IO_save_end)
310 )
311 );
312 assert_eq!(
313 unsafe { &(*(::std::ptr::null::<_IO_FILE>()))._markers as *const _ as usize },
314 96usize,
315 concat!(
316 "Offset of field: ",
317 stringify!(_IO_FILE),
318 "::",
319 stringify!(_markers)
320 )
321 );
322 assert_eq!(
323 unsafe { &(*(::std::ptr::null::<_IO_FILE>()))._chain as *const _ as usize },
324 104usize,
325 concat!(
326 "Offset of field: ",
327 stringify!(_IO_FILE),
328 "::",
329 stringify!(_chain)
330 )
331 );
332 assert_eq!(
333 unsafe { &(*(::std::ptr::null::<_IO_FILE>()))._fileno as *const _ as usize },
334 112usize,
335 concat!(
336 "Offset of field: ",
337 stringify!(_IO_FILE),
338 "::",
339 stringify!(_fileno)
340 )
341 );
342 assert_eq!(
343 unsafe { &(*(::std::ptr::null::<_IO_FILE>()))._flags2 as *const _ as usize },
344 116usize,
345 concat!(
346 "Offset of field: ",
347 stringify!(_IO_FILE),
348 "::",
349 stringify!(_flags2)
350 )
351 );
352 assert_eq!(
353 unsafe { &(*(::std::ptr::null::<_IO_FILE>()))._old_offset as *const _ as usize },
354 120usize,
355 concat!(
356 "Offset of field: ",
357 stringify!(_IO_FILE),
358 "::",
359 stringify!(_old_offset)
360 )
361 );
362 assert_eq!(
363 unsafe { &(*(::std::ptr::null::<_IO_FILE>()))._cur_column as *const _ as usize },
364 128usize,
365 concat!(
366 "Offset of field: ",
367 stringify!(_IO_FILE),
368 "::",
369 stringify!(_cur_column)
370 )
371 );
372 assert_eq!(
373 unsafe { &(*(::std::ptr::null::<_IO_FILE>()))._vtable_offset as *const _ as usize },
374 130usize,
375 concat!(
376 "Offset of field: ",
377 stringify!(_IO_FILE),
378 "::",
379 stringify!(_vtable_offset)
380 )
381 );
382 assert_eq!(
383 unsafe { &(*(::std::ptr::null::<_IO_FILE>()))._shortbuf as *const _ as usize },
384 131usize,
385 concat!(
386 "Offset of field: ",
387 stringify!(_IO_FILE),
388 "::",
389 stringify!(_shortbuf)
390 )
391 );
392 assert_eq!(
393 unsafe { &(*(::std::ptr::null::<_IO_FILE>()))._lock as *const _ as usize },
394 136usize,
395 concat!(
396 "Offset of field: ",
397 stringify!(_IO_FILE),
398 "::",
399 stringify!(_lock)
400 )
401 );
402 assert_eq!(
403 unsafe { &(*(::std::ptr::null::<_IO_FILE>()))._offset as *const _ as usize },
404 144usize,
405 concat!(
406 "Offset of field: ",
407 stringify!(_IO_FILE),
408 "::",
409 stringify!(_offset)
410 )
411 );
412 assert_eq!(
413 unsafe { &(*(::std::ptr::null::<_IO_FILE>())).__pad1 as *const _ as usize },
414 152usize,
415 concat!(
416 "Offset of field: ",
417 stringify!(_IO_FILE),
418 "::",
419 stringify!(__pad1)
420 )
421 );
422 assert_eq!(
423 unsafe { &(*(::std::ptr::null::<_IO_FILE>())).__pad2 as *const _ as usize },
424 160usize,
425 concat!(
426 "Offset of field: ",
427 stringify!(_IO_FILE),
428 "::",
429 stringify!(__pad2)
430 )
431 );
432 assert_eq!(
433 unsafe { &(*(::std::ptr::null::<_IO_FILE>())).__pad3 as *const _ as usize },
434 168usize,
435 concat!(
436 "Offset of field: ",
437 stringify!(_IO_FILE),
438 "::",
439 stringify!(__pad3)
440 )
441 );
442 assert_eq!(
443 unsafe { &(*(::std::ptr::null::<_IO_FILE>())).__pad4 as *const _ as usize },
444 176usize,
445 concat!(
446 "Offset of field: ",
447 stringify!(_IO_FILE),
448 "::",
449 stringify!(__pad4)
450 )
451 );
452 assert_eq!(
453 unsafe { &(*(::std::ptr::null::<_IO_FILE>())).__pad5 as *const _ as usize },
454 184usize,
455 concat!(
456 "Offset of field: ",
457 stringify!(_IO_FILE),
458 "::",
459 stringify!(__pad5)
460 )
461 );
462 assert_eq!(
463 unsafe { &(*(::std::ptr::null::<_IO_FILE>()))._mode as *const _ as usize },
464 192usize,
465 concat!(
466 "Offset of field: ",
467 stringify!(_IO_FILE),
468 "::",
469 stringify!(_mode)
470 )
471 );
472 assert_eq!(
473 unsafe { &(*(::std::ptr::null::<_IO_FILE>()))._unused2 as *const _ as usize },
474 196usize,
475 concat!(
476 "Offset of field: ",
477 stringify!(_IO_FILE),
478 "::",
479 stringify!(_unused2)
480 )
481 );
482}
483pub type t_int = ::std::os::raw::c_long;
484pub type t_float = f32;
485pub type t_floatarg = f32;
486#[repr(C)]
487#[derive(Debug, Copy, Clone)]
488pub struct _symbol {
489 pub s_name: *const ::std::os::raw::c_char,
490 pub s_thing: *mut *mut _class,
491 pub s_next: *mut _symbol,
492}
493#[test]
494fn bindgen_test_layout__symbol() {
495 assert_eq!(
496 ::std::mem::size_of::<_symbol>(),
497 24usize,
498 concat!("Size of: ", stringify!(_symbol))
499 );
500 assert_eq!(
501 ::std::mem::align_of::<_symbol>(),
502 8usize,
503 concat!("Alignment of ", stringify!(_symbol))
504 );
505 assert_eq!(
506 unsafe { &(*(::std::ptr::null::<_symbol>())).s_name as *const _ as usize },
507 0usize,
508 concat!(
509 "Offset of field: ",
510 stringify!(_symbol),
511 "::",
512 stringify!(s_name)
513 )
514 );
515 assert_eq!(
516 unsafe { &(*(::std::ptr::null::<_symbol>())).s_thing as *const _ as usize },
517 8usize,
518 concat!(
519 "Offset of field: ",
520 stringify!(_symbol),
521 "::",
522 stringify!(s_thing)
523 )
524 );
525 assert_eq!(
526 unsafe { &(*(::std::ptr::null::<_symbol>())).s_next as *const _ as usize },
527 16usize,
528 concat!(
529 "Offset of field: ",
530 stringify!(_symbol),
531 "::",
532 stringify!(s_next)
533 )
534 );
535}
536pub type t_symbol = _symbol;
537#[repr(C)]
538#[derive(Debug, Copy, Clone)]
539pub struct _array {
540 _unused: [u8; 0],
541}
542#[repr(C)]
543#[derive(Copy, Clone)]
544pub struct _gstub {
545 pub gs_un: _gstub__bindgen_ty_1,
546 pub gs_which: ::std::os::raw::c_int,
547 pub gs_refcount: ::std::os::raw::c_int,
548}
549#[repr(C)]
550#[derive(Copy, Clone)]
551pub union _gstub__bindgen_ty_1 {
552 pub gs_glist: *mut _glist,
553 pub gs_array: *mut _array,
554 _bindgen_union_align: u64,
555}
556#[test]
557fn bindgen_test_layout__gstub__bindgen_ty_1() {
558 assert_eq!(
559 ::std::mem::size_of::<_gstub__bindgen_ty_1>(),
560 8usize,
561 concat!("Size of: ", stringify!(_gstub__bindgen_ty_1))
562 );
563 assert_eq!(
564 ::std::mem::align_of::<_gstub__bindgen_ty_1>(),
565 8usize,
566 concat!("Alignment of ", stringify!(_gstub__bindgen_ty_1))
567 );
568 assert_eq!(
569 unsafe { &(*(::std::ptr::null::<_gstub__bindgen_ty_1>())).gs_glist as *const _ as usize },
570 0usize,
571 concat!(
572 "Offset of field: ",
573 stringify!(_gstub__bindgen_ty_1),
574 "::",
575 stringify!(gs_glist)
576 )
577 );
578 assert_eq!(
579 unsafe { &(*(::std::ptr::null::<_gstub__bindgen_ty_1>())).gs_array as *const _ as usize },
580 0usize,
581 concat!(
582 "Offset of field: ",
583 stringify!(_gstub__bindgen_ty_1),
584 "::",
585 stringify!(gs_array)
586 )
587 );
588}
589#[test]
590fn bindgen_test_layout__gstub() {
591 assert_eq!(
592 ::std::mem::size_of::<_gstub>(),
593 16usize,
594 concat!("Size of: ", stringify!(_gstub))
595 );
596 assert_eq!(
597 ::std::mem::align_of::<_gstub>(),
598 8usize,
599 concat!("Alignment of ", stringify!(_gstub))
600 );
601 assert_eq!(
602 unsafe { &(*(::std::ptr::null::<_gstub>())).gs_un as *const _ as usize },
603 0usize,
604 concat!(
605 "Offset of field: ",
606 stringify!(_gstub),
607 "::",
608 stringify!(gs_un)
609 )
610 );
611 assert_eq!(
612 unsafe { &(*(::std::ptr::null::<_gstub>())).gs_which as *const _ as usize },
613 8usize,
614 concat!(
615 "Offset of field: ",
616 stringify!(_gstub),
617 "::",
618 stringify!(gs_which)
619 )
620 );
621 assert_eq!(
622 unsafe { &(*(::std::ptr::null::<_gstub>())).gs_refcount as *const _ as usize },
623 12usize,
624 concat!(
625 "Offset of field: ",
626 stringify!(_gstub),
627 "::",
628 stringify!(gs_refcount)
629 )
630 );
631}
632pub type t_gstub = _gstub;
633#[repr(C)]
634#[derive(Copy, Clone)]
635pub struct _gpointer {
636 pub gp_un: _gpointer__bindgen_ty_1,
637 pub gp_valid: ::std::os::raw::c_int,
638 pub gp_stub: *mut t_gstub,
639}
640#[repr(C)]
641#[derive(Copy, Clone)]
642pub union _gpointer__bindgen_ty_1 {
643 pub gp_scalar: *mut _scalar,
644 pub gp_w: *mut word,
645 _bindgen_union_align: u64,
646}
647#[test]
648fn bindgen_test_layout__gpointer__bindgen_ty_1() {
649 assert_eq!(
650 ::std::mem::size_of::<_gpointer__bindgen_ty_1>(),
651 8usize,
652 concat!("Size of: ", stringify!(_gpointer__bindgen_ty_1))
653 );
654 assert_eq!(
655 ::std::mem::align_of::<_gpointer__bindgen_ty_1>(),
656 8usize,
657 concat!("Alignment of ", stringify!(_gpointer__bindgen_ty_1))
658 );
659 assert_eq!(
660 unsafe {
661 &(*(::std::ptr::null::<_gpointer__bindgen_ty_1>())).gp_scalar as *const _ as usize
662 },
663 0usize,
664 concat!(
665 "Offset of field: ",
666 stringify!(_gpointer__bindgen_ty_1),
667 "::",
668 stringify!(gp_scalar)
669 )
670 );
671 assert_eq!(
672 unsafe { &(*(::std::ptr::null::<_gpointer__bindgen_ty_1>())).gp_w as *const _ as usize },
673 0usize,
674 concat!(
675 "Offset of field: ",
676 stringify!(_gpointer__bindgen_ty_1),
677 "::",
678 stringify!(gp_w)
679 )
680 );
681}
682#[test]
683fn bindgen_test_layout__gpointer() {
684 assert_eq!(
685 ::std::mem::size_of::<_gpointer>(),
686 24usize,
687 concat!("Size of: ", stringify!(_gpointer))
688 );
689 assert_eq!(
690 ::std::mem::align_of::<_gpointer>(),
691 8usize,
692 concat!("Alignment of ", stringify!(_gpointer))
693 );
694 assert_eq!(
695 unsafe { &(*(::std::ptr::null::<_gpointer>())).gp_un as *const _ as usize },
696 0usize,
697 concat!(
698 "Offset of field: ",
699 stringify!(_gpointer),
700 "::",
701 stringify!(gp_un)
702 )
703 );
704 assert_eq!(
705 unsafe { &(*(::std::ptr::null::<_gpointer>())).gp_valid as *const _ as usize },
706 8usize,
707 concat!(
708 "Offset of field: ",
709 stringify!(_gpointer),
710 "::",
711 stringify!(gp_valid)
712 )
713 );
714 assert_eq!(
715 unsafe { &(*(::std::ptr::null::<_gpointer>())).gp_stub as *const _ as usize },
716 16usize,
717 concat!(
718 "Offset of field: ",
719 stringify!(_gpointer),
720 "::",
721 stringify!(gp_stub)
722 )
723 );
724}
725pub type t_gpointer = _gpointer;
726#[repr(C)]
727#[derive(Copy, Clone)]
728pub union word {
729 pub w_float: t_float,
730 pub w_symbol: *mut t_symbol,
731 pub w_gpointer: *mut t_gpointer,
732 pub w_array: *mut _array,
733 pub w_binbuf: *mut _binbuf,
734 pub w_index: ::std::os::raw::c_int,
735 _bindgen_union_align: u64,
736}
737#[test]
738fn bindgen_test_layout_word() {
739 assert_eq!(
740 ::std::mem::size_of::<word>(),
741 8usize,
742 concat!("Size of: ", stringify!(word))
743 );
744 assert_eq!(
745 ::std::mem::align_of::<word>(),
746 8usize,
747 concat!("Alignment of ", stringify!(word))
748 );
749 assert_eq!(
750 unsafe { &(*(::std::ptr::null::<word>())).w_float as *const _ as usize },
751 0usize,
752 concat!(
753 "Offset of field: ",
754 stringify!(word),
755 "::",
756 stringify!(w_float)
757 )
758 );
759 assert_eq!(
760 unsafe { &(*(::std::ptr::null::<word>())).w_symbol as *const _ as usize },
761 0usize,
762 concat!(
763 "Offset of field: ",
764 stringify!(word),
765 "::",
766 stringify!(w_symbol)
767 )
768 );
769 assert_eq!(
770 unsafe { &(*(::std::ptr::null::<word>())).w_gpointer as *const _ as usize },
771 0usize,
772 concat!(
773 "Offset of field: ",
774 stringify!(word),
775 "::",
776 stringify!(w_gpointer)
777 )
778 );
779 assert_eq!(
780 unsafe { &(*(::std::ptr::null::<word>())).w_array as *const _ as usize },
781 0usize,
782 concat!(
783 "Offset of field: ",
784 stringify!(word),
785 "::",
786 stringify!(w_array)
787 )
788 );
789 assert_eq!(
790 unsafe { &(*(::std::ptr::null::<word>())).w_binbuf as *const _ as usize },
791 0usize,
792 concat!(
793 "Offset of field: ",
794 stringify!(word),
795 "::",
796 stringify!(w_binbuf)
797 )
798 );
799 assert_eq!(
800 unsafe { &(*(::std::ptr::null::<word>())).w_index as *const _ as usize },
801 0usize,
802 concat!(
803 "Offset of field: ",
804 stringify!(word),
805 "::",
806 stringify!(w_index)
807 )
808 );
809}
810pub type t_word = word;
811pub mod t_atomtype {
812 pub type Type = u32;
813 pub const A_NULL: Type = 0;
814 pub const A_FLOAT: Type = 1;
815 pub const A_SYMBOL: Type = 2;
816 pub const A_POINTER: Type = 3;
817 pub const A_SEMI: Type = 4;
818 pub const A_COMMA: Type = 5;
819 pub const A_DEFFLOAT: Type = 6;
820 pub const A_DEFSYM: Type = 7;
821 pub const A_DOLLAR: Type = 8;
822 pub const A_DOLLSYM: Type = 9;
823 pub const A_GIMME: Type = 10;
824 pub const A_CANT: Type = 11;
825}
826#[repr(C)]
827#[derive(Copy, Clone)]
828pub struct _atom {
829 pub a_type: t_atomtype::Type,
830 pub a_w: word,
831}
832#[test]
833fn bindgen_test_layout__atom() {
834 assert_eq!(
835 ::std::mem::size_of::<_atom>(),
836 16usize,
837 concat!("Size of: ", stringify!(_atom))
838 );
839 assert_eq!(
840 ::std::mem::align_of::<_atom>(),
841 8usize,
842 concat!("Alignment of ", stringify!(_atom))
843 );
844 assert_eq!(
845 unsafe { &(*(::std::ptr::null::<_atom>())).a_type as *const _ as usize },
846 0usize,
847 concat!(
848 "Offset of field: ",
849 stringify!(_atom),
850 "::",
851 stringify!(a_type)
852 )
853 );
854 assert_eq!(
855 unsafe { &(*(::std::ptr::null::<_atom>())).a_w as *const _ as usize },
856 8usize,
857 concat!(
858 "Offset of field: ",
859 stringify!(_atom),
860 "::",
861 stringify!(a_w)
862 )
863 );
864}
865pub type t_atom = _atom;
866#[repr(C)]
867#[derive(Debug, Copy, Clone)]
868pub struct _class {
869 _unused: [u8; 0],
870}
871#[repr(C)]
872#[derive(Debug, Copy, Clone)]
873pub struct _outlet {
874 _unused: [u8; 0],
875}
876#[repr(C)]
877#[derive(Debug, Copy, Clone)]
878pub struct _inlet {
879 _unused: [u8; 0],
880}
881#[repr(C)]
882#[derive(Debug, Copy, Clone)]
883pub struct _binbuf {
884 _unused: [u8; 0],
885}
886#[repr(C)]
887#[derive(Debug, Copy, Clone)]
888pub struct _clock {
889 _unused: [u8; 0],
890}
891#[repr(C)]
892#[derive(Debug, Copy, Clone)]
893pub struct _glist {
894 _unused: [u8; 0],
895}
896pub type t_pd = *mut _class;
897#[repr(C)]
898#[derive(Debug, Copy, Clone)]
899pub struct _gobj {
900 pub g_pd: t_pd,
901 pub g_next: *mut _gobj,
902}
903#[test]
904fn bindgen_test_layout__gobj() {
905 assert_eq!(
906 ::std::mem::size_of::<_gobj>(),
907 16usize,
908 concat!("Size of: ", stringify!(_gobj))
909 );
910 assert_eq!(
911 ::std::mem::align_of::<_gobj>(),
912 8usize,
913 concat!("Alignment of ", stringify!(_gobj))
914 );
915 assert_eq!(
916 unsafe { &(*(::std::ptr::null::<_gobj>())).g_pd as *const _ as usize },
917 0usize,
918 concat!(
919 "Offset of field: ",
920 stringify!(_gobj),
921 "::",
922 stringify!(g_pd)
923 )
924 );
925 assert_eq!(
926 unsafe { &(*(::std::ptr::null::<_gobj>())).g_next as *const _ as usize },
927 8usize,
928 concat!(
929 "Offset of field: ",
930 stringify!(_gobj),
931 "::",
932 stringify!(g_next)
933 )
934 );
935}
936pub type t_gobj = _gobj;
937#[repr(C)]
938#[derive(Copy, Clone)]
939pub struct _scalar {
940 pub sc_gobj: t_gobj,
941 pub sc_template: *mut t_symbol,
942 pub sc_vec: [t_word; 1usize],
943}
944#[test]
945fn bindgen_test_layout__scalar() {
946 assert_eq!(
947 ::std::mem::size_of::<_scalar>(),
948 32usize,
949 concat!("Size of: ", stringify!(_scalar))
950 );
951 assert_eq!(
952 ::std::mem::align_of::<_scalar>(),
953 8usize,
954 concat!("Alignment of ", stringify!(_scalar))
955 );
956 assert_eq!(
957 unsafe { &(*(::std::ptr::null::<_scalar>())).sc_gobj as *const _ as usize },
958 0usize,
959 concat!(
960 "Offset of field: ",
961 stringify!(_scalar),
962 "::",
963 stringify!(sc_gobj)
964 )
965 );
966 assert_eq!(
967 unsafe { &(*(::std::ptr::null::<_scalar>())).sc_template as *const _ as usize },
968 16usize,
969 concat!(
970 "Offset of field: ",
971 stringify!(_scalar),
972 "::",
973 stringify!(sc_template)
974 )
975 );
976 assert_eq!(
977 unsafe { &(*(::std::ptr::null::<_scalar>())).sc_vec as *const _ as usize },
978 24usize,
979 concat!(
980 "Offset of field: ",
981 stringify!(_scalar),
982 "::",
983 stringify!(sc_vec)
984 )
985 );
986}
987pub type t_scalar = _scalar;
988#[repr(C)]
989#[derive(Debug, Copy, Clone)]
990pub struct _text {
991 pub te_g: t_gobj,
992 pub te_binbuf: *mut _binbuf,
993 pub te_outlet: *mut _outlet,
994 pub te_inlet: *mut _inlet,
995 pub te_xpix: ::std::os::raw::c_short,
996 pub te_ypix: ::std::os::raw::c_short,
997 pub te_width: ::std::os::raw::c_short,
998 pub _bitfield_1: __BindgenBitfieldUnit<[u8; 1usize], u8>,
999 pub __bindgen_padding_0: u8,
1000}
1001#[test]
1002fn bindgen_test_layout__text() {
1003 assert_eq!(
1004 ::std::mem::size_of::<_text>(),
1005 48usize,
1006 concat!("Size of: ", stringify!(_text))
1007 );
1008 assert_eq!(
1009 ::std::mem::align_of::<_text>(),
1010 8usize,
1011 concat!("Alignment of ", stringify!(_text))
1012 );
1013 assert_eq!(
1014 unsafe { &(*(::std::ptr::null::<_text>())).te_g as *const _ as usize },
1015 0usize,
1016 concat!(
1017 "Offset of field: ",
1018 stringify!(_text),
1019 "::",
1020 stringify!(te_g)
1021 )
1022 );
1023 assert_eq!(
1024 unsafe { &(*(::std::ptr::null::<_text>())).te_binbuf as *const _ as usize },
1025 16usize,
1026 concat!(
1027 "Offset of field: ",
1028 stringify!(_text),
1029 "::",
1030 stringify!(te_binbuf)
1031 )
1032 );
1033 assert_eq!(
1034 unsafe { &(*(::std::ptr::null::<_text>())).te_outlet as *const _ as usize },
1035 24usize,
1036 concat!(
1037 "Offset of field: ",
1038 stringify!(_text),
1039 "::",
1040 stringify!(te_outlet)
1041 )
1042 );
1043 assert_eq!(
1044 unsafe { &(*(::std::ptr::null::<_text>())).te_inlet as *const _ as usize },
1045 32usize,
1046 concat!(
1047 "Offset of field: ",
1048 stringify!(_text),
1049 "::",
1050 stringify!(te_inlet)
1051 )
1052 );
1053 assert_eq!(
1054 unsafe { &(*(::std::ptr::null::<_text>())).te_xpix as *const _ as usize },
1055 40usize,
1056 concat!(
1057 "Offset of field: ",
1058 stringify!(_text),
1059 "::",
1060 stringify!(te_xpix)
1061 )
1062 );
1063 assert_eq!(
1064 unsafe { &(*(::std::ptr::null::<_text>())).te_ypix as *const _ as usize },
1065 42usize,
1066 concat!(
1067 "Offset of field: ",
1068 stringify!(_text),
1069 "::",
1070 stringify!(te_ypix)
1071 )
1072 );
1073 assert_eq!(
1074 unsafe { &(*(::std::ptr::null::<_text>())).te_width as *const _ as usize },
1075 44usize,
1076 concat!(
1077 "Offset of field: ",
1078 stringify!(_text),
1079 "::",
1080 stringify!(te_width)
1081 )
1082 );
1083}
1084impl _text {
1085 #[inline]
1086 pub fn te_type(&self) -> ::std::os::raw::c_uint {
1087 unsafe { ::std::mem::transmute(self._bitfield_1.get(0usize, 2u8) as u32) }
1088 }
1089 #[inline]
1090 pub fn set_te_type(&mut self, val: ::std::os::raw::c_uint) {
1091 unsafe {
1092 let val: u32 = ::std::mem::transmute(val);
1093 self._bitfield_1.set(0usize, 2u8, val as u64)
1094 }
1095 }
1096 #[inline]
1097 pub fn new_bitfield_1(
1098 te_type: ::std::os::raw::c_uint,
1099 ) -> __BindgenBitfieldUnit<[u8; 1usize], u8> {
1100 let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 1usize], u8> =
1101 Default::default();
1102 __bindgen_bitfield_unit.set(0usize, 2u8, {
1103 let te_type: u32 = unsafe { ::std::mem::transmute(te_type) };
1104 te_type as u64
1105 });
1106 __bindgen_bitfield_unit
1107 }
1108}
1109pub type t_object = _text;
1110pub type t_method = ::std::option::Option<unsafe extern "C" fn()>;
1111pub type t_newmethod = ::std::option::Option<unsafe extern "C" fn() -> *mut ::std::os::raw::c_void>;
1112extern "C" {
1113 pub fn pd_typedmess(
1114 x: *mut t_pd,
1115 s: *mut t_symbol,
1116 argc: ::std::os::raw::c_int,
1117 argv: *mut t_atom,
1118 );
1119}
1120extern "C" {
1121 pub fn pd_forwardmess(x: *mut t_pd, argc: ::std::os::raw::c_int, argv: *mut t_atom);
1122}
1123extern "C" {
1124 pub fn gensym(s: *const ::std::os::raw::c_char) -> *mut t_symbol;
1125}
1126extern "C" {
1127 pub fn pd_vmess(x: *mut t_pd, s: *mut t_symbol, fmt: *mut ::std::os::raw::c_char, ...);
1128}
1129extern "C" {
1130 pub fn obj_list(
1131 x: *mut t_object,
1132 s: *mut t_symbol,
1133 argc: ::std::os::raw::c_int,
1134 argv: *mut t_atom,
1135 );
1136}
1137extern "C" {
1138 pub fn pd_newest() -> *mut t_pd;
1139}
1140extern "C" {
1141 pub fn getbytes(nbytes: usize) -> *mut ::std::os::raw::c_void;
1142}
1143extern "C" {
1144 pub fn getzbytes(nbytes: usize) -> *mut ::std::os::raw::c_void;
1145}
1146extern "C" {
1147 pub fn copybytes(
1148 src: *const ::std::os::raw::c_void,
1149 nbytes: usize,
1150 ) -> *mut ::std::os::raw::c_void;
1151}
1152extern "C" {
1153 pub fn freebytes(x: *mut ::std::os::raw::c_void, nbytes: usize);
1154}
1155extern "C" {
1156 pub fn resizebytes(
1157 x: *mut ::std::os::raw::c_void,
1158 oldsize: usize,
1159 newsize: usize,
1160 ) -> *mut ::std::os::raw::c_void;
1161}
1162extern "C" {
1163 pub fn atom_getfloat(a: *const t_atom) -> t_float;
1164}
1165extern "C" {
1166 pub fn atom_getint(a: *const t_atom) -> t_int;
1167}
1168extern "C" {
1169 pub fn atom_getsymbol(a: *const t_atom) -> *mut t_symbol;
1170}
1171extern "C" {
1172 pub fn atom_gensym(a: *const t_atom) -> *mut t_symbol;
1173}
1174extern "C" {
1175 pub fn atom_getfloatarg(
1176 which: ::std::os::raw::c_int,
1177 argc: ::std::os::raw::c_int,
1178 argv: *const t_atom,
1179 ) -> t_float;
1180}
1181extern "C" {
1182 pub fn atom_getintarg(
1183 which: ::std::os::raw::c_int,
1184 argc: ::std::os::raw::c_int,
1185 argv: *const t_atom,
1186 ) -> t_int;
1187}
1188extern "C" {
1189 pub fn atom_getsymbolarg(
1190 which: ::std::os::raw::c_int,
1191 argc: ::std::os::raw::c_int,
1192 argv: *const t_atom,
1193 ) -> *mut t_symbol;
1194}
1195extern "C" {
1196 pub fn atom_string(
1197 a: *const t_atom,
1198 buf: *mut ::std::os::raw::c_char,
1199 bufsize: ::std::os::raw::c_uint,
1200 );
1201}
1202extern "C" {
1203 pub fn binbuf_new() -> *mut _binbuf;
1204}
1205extern "C" {
1206 pub fn binbuf_free(x: *mut _binbuf);
1207}
1208extern "C" {
1209 pub fn binbuf_duplicate(y: *const _binbuf) -> *mut _binbuf;
1210}
1211extern "C" {
1212 pub fn binbuf_text(x: *mut _binbuf, text: *const ::std::os::raw::c_char, size: usize);
1213}
1214extern "C" {
1215 pub fn binbuf_gettext(
1216 x: *const _binbuf,
1217 bufp: *mut *mut ::std::os::raw::c_char,
1218 lengthp: *mut ::std::os::raw::c_int,
1219 );
1220}
1221extern "C" {
1222 pub fn binbuf_clear(x: *mut _binbuf);
1223}
1224extern "C" {
1225 pub fn binbuf_add(x: *mut _binbuf, argc: ::std::os::raw::c_int, argv: *const t_atom);
1226}
1227extern "C" {
1228 pub fn binbuf_addv(x: *mut _binbuf, fmt: *const ::std::os::raw::c_char, ...);
1229}
1230extern "C" {
1231 pub fn binbuf_addbinbuf(x: *mut _binbuf, y: *const _binbuf);
1232}
1233extern "C" {
1234 pub fn binbuf_addsemi(x: *mut _binbuf);
1235}
1236extern "C" {
1237 pub fn binbuf_restore(x: *mut _binbuf, argc: ::std::os::raw::c_int, argv: *const t_atom);
1238}
1239extern "C" {
1240 pub fn binbuf_print(x: *const _binbuf);
1241}
1242extern "C" {
1243 pub fn binbuf_getnatom(x: *const _binbuf) -> ::std::os::raw::c_int;
1244}
1245extern "C" {
1246 pub fn binbuf_getvec(x: *const _binbuf) -> *mut t_atom;
1247}
1248extern "C" {
1249 pub fn binbuf_resize(x: *mut _binbuf, newsize: ::std::os::raw::c_int) -> ::std::os::raw::c_int;
1250}
1251extern "C" {
1252 pub fn binbuf_eval(
1253 x: *const _binbuf,
1254 target: *mut t_pd,
1255 argc: ::std::os::raw::c_int,
1256 argv: *const t_atom,
1257 );
1258}
1259extern "C" {
1260 pub fn binbuf_read(
1261 b: *mut _binbuf,
1262 filename: *const ::std::os::raw::c_char,
1263 dirname: *const ::std::os::raw::c_char,
1264 crflag: ::std::os::raw::c_int,
1265 ) -> ::std::os::raw::c_int;
1266}
1267extern "C" {
1268 pub fn binbuf_read_via_canvas(
1269 b: *mut _binbuf,
1270 filename: *const ::std::os::raw::c_char,
1271 canvas: *const _glist,
1272 crflag: ::std::os::raw::c_int,
1273 ) -> ::std::os::raw::c_int;
1274}
1275extern "C" {
1276 pub fn binbuf_read_via_path(
1277 b: *mut _binbuf,
1278 filename: *const ::std::os::raw::c_char,
1279 dirname: *const ::std::os::raw::c_char,
1280 crflag: ::std::os::raw::c_int,
1281 ) -> ::std::os::raw::c_int;
1282}
1283extern "C" {
1284 pub fn binbuf_write(
1285 x: *const _binbuf,
1286 filename: *const ::std::os::raw::c_char,
1287 dir: *const ::std::os::raw::c_char,
1288 crflag: ::std::os::raw::c_int,
1289 ) -> ::std::os::raw::c_int;
1290}
1291extern "C" {
1292 pub fn binbuf_evalfile(name: *mut t_symbol, dir: *mut t_symbol);
1293}
1294extern "C" {
1295 pub fn binbuf_realizedollsym(
1296 s: *mut t_symbol,
1297 ac: ::std::os::raw::c_int,
1298 av: *const t_atom,
1299 tonew: ::std::os::raw::c_int,
1300 ) -> *mut t_symbol;
1301}
1302extern "C" {
1303 pub fn clock_new(owner: *mut ::std::os::raw::c_void, fn_: t_method) -> *mut _clock;
1304}
1305extern "C" {
1306 pub fn clock_set(x: *mut _clock, systime: f64);
1307}
1308extern "C" {
1309 pub fn clock_delay(x: *mut _clock, delaytime: f64);
1310}
1311extern "C" {
1312 pub fn clock_unset(x: *mut _clock);
1313}
1314extern "C" {
1315 pub fn clock_setunit(x: *mut _clock, timeunit: f64, sampflag: ::std::os::raw::c_int);
1316}
1317extern "C" {
1318 pub fn clock_getlogicaltime() -> f64;
1319}
1320extern "C" {
1321 pub fn clock_getsystime() -> f64;
1322}
1323extern "C" {
1324 pub fn clock_gettimesince(prevsystime: f64) -> f64;
1325}
1326extern "C" {
1327 pub fn clock_gettimesincewithunits(
1328 prevsystime: f64,
1329 units: f64,
1330 sampflag: ::std::os::raw::c_int,
1331 ) -> f64;
1332}
1333extern "C" {
1334 pub fn clock_getsystimeafter(delaytime: f64) -> f64;
1335}
1336extern "C" {
1337 pub fn clock_free(x: *mut _clock);
1338}
1339extern "C" {
1340 pub fn pd_new(cls: *mut _class) -> *mut t_pd;
1341}
1342extern "C" {
1343 pub fn pd_free(x: *mut t_pd);
1344}
1345extern "C" {
1346 pub fn pd_bind(x: *mut t_pd, s: *mut t_symbol);
1347}
1348extern "C" {
1349 pub fn pd_unbind(x: *mut t_pd, s: *mut t_symbol);
1350}
1351extern "C" {
1352 pub fn pd_findbyclass(s: *mut t_symbol, c: *const _class) -> *mut t_pd;
1353}
1354extern "C" {
1355 pub fn pd_pushsym(x: *mut t_pd);
1356}
1357extern "C" {
1358 pub fn pd_popsym(x: *mut t_pd);
1359}
1360extern "C" {
1361 pub fn pd_bang(x: *mut t_pd);
1362}
1363extern "C" {
1364 pub fn pd_pointer(x: *mut t_pd, gp: *mut t_gpointer);
1365}
1366extern "C" {
1367 pub fn pd_float(x: *mut t_pd, f: t_float);
1368}
1369extern "C" {
1370 pub fn pd_symbol(x: *mut t_pd, s: *mut t_symbol);
1371}
1372extern "C" {
1373 pub fn pd_list(x: *mut t_pd, s: *mut t_symbol, argc: ::std::os::raw::c_int, argv: *mut t_atom);
1374}
1375extern "C" {
1376 pub fn pd_anything(
1377 x: *mut t_pd,
1378 s: *mut t_symbol,
1379 argc: ::std::os::raw::c_int,
1380 argv: *mut t_atom,
1381 );
1382}
1383extern "C" {
1384 pub fn gpointer_init(gp: *mut t_gpointer);
1385}
1386extern "C" {
1387 pub fn gpointer_copy(gpfrom: *const t_gpointer, gpto: *mut t_gpointer);
1388}
1389extern "C" {
1390 pub fn gpointer_unset(gp: *mut t_gpointer);
1391}
1392extern "C" {
1393 pub fn gpointer_check(
1394 gp: *const t_gpointer,
1395 headok: ::std::os::raw::c_int,
1396 ) -> ::std::os::raw::c_int;
1397}
1398extern "C" {
1399 pub fn inlet_new(
1400 owner: *mut t_object,
1401 dest: *mut t_pd,
1402 s1: *mut t_symbol,
1403 s2: *mut t_symbol,
1404 ) -> *mut _inlet;
1405}
1406extern "C" {
1407 pub fn pointerinlet_new(owner: *mut t_object, gp: *mut t_gpointer) -> *mut _inlet;
1408}
1409extern "C" {
1410 pub fn floatinlet_new(owner: *mut t_object, fp: *mut t_float) -> *mut _inlet;
1411}
1412extern "C" {
1413 pub fn symbolinlet_new(owner: *mut t_object, sp: *mut *mut t_symbol) -> *mut _inlet;
1414}
1415extern "C" {
1416 pub fn signalinlet_new(owner: *mut t_object, f: t_float) -> *mut _inlet;
1417}
1418extern "C" {
1419 pub fn inlet_free(x: *mut _inlet);
1420}
1421extern "C" {
1422 pub fn outlet_new(owner: *mut t_object, s: *mut t_symbol) -> *mut _outlet;
1423}
1424extern "C" {
1425 pub fn outlet_bang(x: *mut _outlet);
1426}
1427extern "C" {
1428 pub fn outlet_pointer(x: *mut _outlet, gp: *mut t_gpointer);
1429}
1430extern "C" {
1431 pub fn outlet_float(x: *mut _outlet, f: t_float);
1432}
1433extern "C" {
1434 pub fn outlet_symbol(x: *mut _outlet, s: *mut t_symbol);
1435}
1436extern "C" {
1437 pub fn outlet_list(
1438 x: *mut _outlet,
1439 s: *mut t_symbol,
1440 argc: ::std::os::raw::c_int,
1441 argv: *mut t_atom,
1442 );
1443}
1444extern "C" {
1445 pub fn outlet_anything(
1446 x: *mut _outlet,
1447 s: *mut t_symbol,
1448 argc: ::std::os::raw::c_int,
1449 argv: *mut t_atom,
1450 );
1451}
1452extern "C" {
1453 pub fn outlet_getsymbol(x: *mut _outlet) -> *mut t_symbol;
1454}
1455extern "C" {
1456 pub fn outlet_free(x: *mut _outlet);
1457}
1458extern "C" {
1459 pub fn pd_checkobject(x: *mut t_pd) -> *mut t_object;
1460}
1461extern "C" {
1462 pub fn glob_setfilename(
1463 dummy: *mut ::std::os::raw::c_void,
1464 name: *mut t_symbol,
1465 dir: *mut t_symbol,
1466 );
1467}
1468extern "C" {
1469 pub fn canvas_setargs(argc: ::std::os::raw::c_int, argv: *const t_atom);
1470}
1471extern "C" {
1472 pub fn canvas_getargs(argcp: *mut ::std::os::raw::c_int, argvp: *mut *mut t_atom);
1473}
1474extern "C" {
1475 pub fn canvas_getcurrentdir() -> *mut t_symbol;
1476}
1477extern "C" {
1478 pub fn canvas_getcurrent() -> *mut _glist;
1479}
1480extern "C" {
1481 pub fn canvas_makefilename(
1482 c: *const _glist,
1483 file: *const ::std::os::raw::c_char,
1484 result: *mut ::std::os::raw::c_char,
1485 resultsize: ::std::os::raw::c_int,
1486 );
1487}
1488extern "C" {
1489 pub fn canvas_getdir(x: *const _glist) -> *mut t_symbol;
1490}
1491extern "C" {
1492 pub fn sys_hostfontsize(
1493 fontsize: ::std::os::raw::c_int,
1494 zoom: ::std::os::raw::c_int,
1495 ) -> ::std::os::raw::c_int;
1496}
1497extern "C" {
1498 pub fn sys_zoomfontwidth(
1499 fontsize: ::std::os::raw::c_int,
1500 zoom: ::std::os::raw::c_int,
1501 worstcase: ::std::os::raw::c_int,
1502 ) -> ::std::os::raw::c_int;
1503}
1504extern "C" {
1505 pub fn sys_zoomfontheight(
1506 fontsize: ::std::os::raw::c_int,
1507 zoom: ::std::os::raw::c_int,
1508 worstcase: ::std::os::raw::c_int,
1509 ) -> ::std::os::raw::c_int;
1510}
1511extern "C" {
1512 pub fn sys_fontwidth(fontsize: ::std::os::raw::c_int) -> ::std::os::raw::c_int;
1513}
1514extern "C" {
1515 pub fn sys_fontheight(fontsize: ::std::os::raw::c_int) -> ::std::os::raw::c_int;
1516}
1517extern "C" {
1518 pub fn canvas_dataproperties(x: *mut _glist, sc: *mut t_scalar, b: *mut _binbuf);
1519}
1520extern "C" {
1521 pub fn canvas_open(
1522 x: *const _glist,
1523 name: *const ::std::os::raw::c_char,
1524 ext: *const ::std::os::raw::c_char,
1525 dirresult: *mut ::std::os::raw::c_char,
1526 nameresult: *mut *mut ::std::os::raw::c_char,
1527 size: ::std::os::raw::c_uint,
1528 bin: ::std::os::raw::c_int,
1529 ) -> ::std::os::raw::c_int;
1530}
1531#[repr(C)]
1532#[derive(Debug, Copy, Clone)]
1533pub struct _widgetbehavior {
1534 _unused: [u8; 0],
1535}
1536#[repr(C)]
1537#[derive(Debug, Copy, Clone)]
1538pub struct _parentwidgetbehavior {
1539 _unused: [u8; 0],
1540}
1541extern "C" {
1542 pub fn pd_getparentwidget(x: *mut t_pd) -> *const _parentwidgetbehavior;
1543}
1544extern "C" {
1545 pub fn class_new(
1546 name: *mut t_symbol,
1547 newmethod: t_newmethod,
1548 freemethod: t_method,
1549 size: usize,
1550 flags: ::std::os::raw::c_int,
1551 arg1: t_atomtype::Type,
1552 ...
1553 ) -> *mut _class;
1554}
1555extern "C" {
1556 pub fn class_new64(
1557 name: *mut t_symbol,
1558 newmethod: t_newmethod,
1559 freemethod: t_method,
1560 size: usize,
1561 flags: ::std::os::raw::c_int,
1562 arg1: t_atomtype::Type,
1563 ...
1564 ) -> *mut _class;
1565}
1566extern "C" {
1567 pub fn class_addcreator(newmethod: t_newmethod, s: *mut t_symbol, type1: t_atomtype::Type, ...);
1568}
1569extern "C" {
1570 pub fn class_addmethod(
1571 c: *mut _class,
1572 fn_: t_method,
1573 sel: *mut t_symbol,
1574 arg1: t_atomtype::Type,
1575 ...
1576 );
1577}
1578extern "C" {
1579 pub fn class_addbang(c: *mut _class, fn_: t_method);
1580}
1581extern "C" {
1582 pub fn class_addpointer(c: *mut _class, fn_: t_method);
1583}
1584extern "C" {
1585 pub fn class_doaddfloat(c: *mut _class, fn_: t_method);
1586}
1587extern "C" {
1588 pub fn class_addsymbol(c: *mut _class, fn_: t_method);
1589}
1590extern "C" {
1591 pub fn class_addlist(c: *mut _class, fn_: t_method);
1592}
1593extern "C" {
1594 pub fn class_addanything(c: *mut _class, fn_: t_method);
1595}
1596extern "C" {
1597 pub fn class_sethelpsymbol(c: *mut _class, s: *mut t_symbol);
1598}
1599extern "C" {
1600 pub fn class_setwidget(c: *mut _class, w: *const _widgetbehavior);
1601}
1602extern "C" {
1603 pub fn class_setparentwidget(c: *mut _class, w: *const _parentwidgetbehavior);
1604}
1605extern "C" {
1606 pub fn class_getname(c: *const _class) -> *const ::std::os::raw::c_char;
1607}
1608extern "C" {
1609 pub fn class_gethelpname(c: *const _class) -> *const ::std::os::raw::c_char;
1610}
1611extern "C" {
1612 pub fn class_gethelpdir(c: *const _class) -> *const ::std::os::raw::c_char;
1613}
1614extern "C" {
1615 pub fn class_setdrawcommand(c: *mut _class);
1616}
1617extern "C" {
1618 pub fn class_isdrawcommand(c: *const _class) -> ::std::os::raw::c_int;
1619}
1620extern "C" {
1621 pub fn class_domainsignalin(c: *mut _class, onset: ::std::os::raw::c_int);
1622}
1623extern "C" {
1624 pub fn class_set_extern_dir(s: *mut t_symbol);
1625}
1626pub type t_savefn = ::std::option::Option<unsafe extern "C" fn(x: *mut t_gobj, b: *mut _binbuf)>;
1627extern "C" {
1628 pub fn class_setsavefn(c: *mut _class, f: t_savefn);
1629}
1630extern "C" {
1631 pub fn class_getsavefn(c: *const _class) -> t_savefn;
1632}
1633extern "C" {
1634 pub fn obj_saveformat(x: *const t_object, bb: *mut _binbuf);
1635}
1636pub type t_propertiesfn =
1637 ::std::option::Option<unsafe extern "C" fn(x: *mut t_gobj, glist: *mut _glist)>;
1638extern "C" {
1639 pub fn class_setpropertiesfn(c: *mut _class, f: t_propertiesfn);
1640}
1641extern "C" {
1642 pub fn class_getpropertiesfn(c: *const _class) -> t_propertiesfn;
1643}
1644extern "C" {
1645 pub fn post(fmt: *const ::std::os::raw::c_char, ...);
1646}
1647extern "C" {
1648 pub fn startpost(fmt: *const ::std::os::raw::c_char, ...);
1649}
1650extern "C" {
1651 pub fn poststring(s: *const ::std::os::raw::c_char);
1652}
1653extern "C" {
1654 pub fn postfloat(f: t_floatarg);
1655}
1656extern "C" {
1657 pub fn postatom(argc: ::std::os::raw::c_int, argv: *const t_atom);
1658}
1659extern "C" {
1660 pub fn endpost();
1661}
1662extern "C" {
1663 pub fn error(fmt: *const ::std::os::raw::c_char, ...);
1664}
1665extern "C" {
1666 pub fn verbose(level: ::std::os::raw::c_int, fmt: *const ::std::os::raw::c_char, ...);
1667}
1668extern "C" {
1669 pub fn bug(fmt: *const ::std::os::raw::c_char, ...);
1670}
1671extern "C" {
1672 pub fn pd_error(object: *const ::std::os::raw::c_void, fmt: *const ::std::os::raw::c_char, ...);
1673}
1674extern "C" {
1675 pub fn logpost(
1676 object: *const ::std::os::raw::c_void,
1677 level: ::std::os::raw::c_int,
1678 fmt: *const ::std::os::raw::c_char,
1679 ...
1680 );
1681}
1682extern "C" {
1683 pub fn sys_logerror(object: *const ::std::os::raw::c_char, s: *const ::std::os::raw::c_char);
1684}
1685extern "C" {
1686 pub fn sys_unixerror(object: *const ::std::os::raw::c_char);
1687}
1688extern "C" {
1689 pub fn sys_ouch();
1690}
1691extern "C" {
1692 pub fn sys_isabsolutepath(dir: *const ::std::os::raw::c_char) -> ::std::os::raw::c_int;
1693}
1694extern "C" {
1695 pub fn sys_bashfilename(from: *const ::std::os::raw::c_char, to: *mut ::std::os::raw::c_char);
1696}
1697extern "C" {
1698 pub fn sys_unbashfilename(from: *const ::std::os::raw::c_char, to: *mut ::std::os::raw::c_char);
1699}
1700extern "C" {
1701 pub fn sys_getrealtime() -> f64;
1702}
1703extern "C" {
1704 pub fn sys_open(
1705 path: *const ::std::os::raw::c_char,
1706 oflag: ::std::os::raw::c_int,
1707 ...
1708 ) -> ::std::os::raw::c_int;
1709}
1710extern "C" {
1711 pub fn sys_close(fd: ::std::os::raw::c_int) -> ::std::os::raw::c_int;
1712}
1713extern "C" {
1714 pub fn sys_fopen(
1715 filename: *const ::std::os::raw::c_char,
1716 mode: *const ::std::os::raw::c_char,
1717 ) -> *mut FILE;
1718}
1719extern "C" {
1720 pub fn sys_fclose(stream: *mut FILE) -> ::std::os::raw::c_int;
1721}
1722extern "C" {
1723 pub fn sys_lock();
1724}
1725extern "C" {
1726 pub fn sys_unlock();
1727}
1728extern "C" {
1729 pub fn sys_trylock() -> ::std::os::raw::c_int;
1730}
1731pub type t_sample = f32;
1732#[repr(C)]
1733#[derive(Debug, Copy, Clone)]
1734pub struct _signal {
1735 pub s_n: ::std::os::raw::c_int,
1736 pub s_vec: *mut t_sample,
1737 pub s_sr: t_float,
1738 pub s_refcount: ::std::os::raw::c_int,
1739 pub s_isborrowed: ::std::os::raw::c_int,
1740 pub s_borrowedfrom: *mut _signal,
1741 pub s_nextfree: *mut _signal,
1742 pub s_nextused: *mut _signal,
1743 pub s_vecsize: ::std::os::raw::c_int,
1744}
1745#[test]
1746fn bindgen_test_layout__signal() {
1747 assert_eq!(
1748 ::std::mem::size_of::<_signal>(),
1749 64usize,
1750 concat!("Size of: ", stringify!(_signal))
1751 );
1752 assert_eq!(
1753 ::std::mem::align_of::<_signal>(),
1754 8usize,
1755 concat!("Alignment of ", stringify!(_signal))
1756 );
1757 assert_eq!(
1758 unsafe { &(*(::std::ptr::null::<_signal>())).s_n as *const _ as usize },
1759 0usize,
1760 concat!(
1761 "Offset of field: ",
1762 stringify!(_signal),
1763 "::",
1764 stringify!(s_n)
1765 )
1766 );
1767 assert_eq!(
1768 unsafe { &(*(::std::ptr::null::<_signal>())).s_vec as *const _ as usize },
1769 8usize,
1770 concat!(
1771 "Offset of field: ",
1772 stringify!(_signal),
1773 "::",
1774 stringify!(s_vec)
1775 )
1776 );
1777 assert_eq!(
1778 unsafe { &(*(::std::ptr::null::<_signal>())).s_sr as *const _ as usize },
1779 16usize,
1780 concat!(
1781 "Offset of field: ",
1782 stringify!(_signal),
1783 "::",
1784 stringify!(s_sr)
1785 )
1786 );
1787 assert_eq!(
1788 unsafe { &(*(::std::ptr::null::<_signal>())).s_refcount as *const _ as usize },
1789 20usize,
1790 concat!(
1791 "Offset of field: ",
1792 stringify!(_signal),
1793 "::",
1794 stringify!(s_refcount)
1795 )
1796 );
1797 assert_eq!(
1798 unsafe { &(*(::std::ptr::null::<_signal>())).s_isborrowed as *const _ as usize },
1799 24usize,
1800 concat!(
1801 "Offset of field: ",
1802 stringify!(_signal),
1803 "::",
1804 stringify!(s_isborrowed)
1805 )
1806 );
1807 assert_eq!(
1808 unsafe { &(*(::std::ptr::null::<_signal>())).s_borrowedfrom as *const _ as usize },
1809 32usize,
1810 concat!(
1811 "Offset of field: ",
1812 stringify!(_signal),
1813 "::",
1814 stringify!(s_borrowedfrom)
1815 )
1816 );
1817 assert_eq!(
1818 unsafe { &(*(::std::ptr::null::<_signal>())).s_nextfree as *const _ as usize },
1819 40usize,
1820 concat!(
1821 "Offset of field: ",
1822 stringify!(_signal),
1823 "::",
1824 stringify!(s_nextfree)
1825 )
1826 );
1827 assert_eq!(
1828 unsafe { &(*(::std::ptr::null::<_signal>())).s_nextused as *const _ as usize },
1829 48usize,
1830 concat!(
1831 "Offset of field: ",
1832 stringify!(_signal),
1833 "::",
1834 stringify!(s_nextused)
1835 )
1836 );
1837 assert_eq!(
1838 unsafe { &(*(::std::ptr::null::<_signal>())).s_vecsize as *const _ as usize },
1839 56usize,
1840 concat!(
1841 "Offset of field: ",
1842 stringify!(_signal),
1843 "::",
1844 stringify!(s_vecsize)
1845 )
1846 );
1847}
1848pub type t_signal = _signal;
1849pub type t_perfroutine =
1850 ::std::option::Option<unsafe extern "C" fn(args: *mut t_int) -> *mut t_int>;
1851extern "C" {
1852 pub fn plus_perform(args: *mut t_int) -> *mut t_int;
1853}
1854extern "C" {
1855 pub fn zero_perform(args: *mut t_int) -> *mut t_int;
1856}
1857extern "C" {
1858 pub fn copy_perform(args: *mut t_int) -> *mut t_int;
1859}
1860extern "C" {
1861 pub fn dsp_add_plus(
1862 in1: *mut t_sample,
1863 in2: *mut t_sample,
1864 out: *mut t_sample,
1865 n: ::std::os::raw::c_int,
1866 );
1867}
1868extern "C" {
1869 pub fn dsp_add_copy(in_: *mut t_sample, out: *mut t_sample, n: ::std::os::raw::c_int);
1870}
1871extern "C" {
1872 pub fn dsp_add_scalarcopy(in_: *mut t_float, out: *mut t_sample, n: ::std::os::raw::c_int);
1873}
1874extern "C" {
1875 pub fn dsp_add_zero(out: *mut t_sample, n: ::std::os::raw::c_int);
1876}
1877extern "C" {
1878 pub fn sys_getblksize() -> ::std::os::raw::c_int;
1879}
1880extern "C" {
1881 pub fn sys_getsr() -> t_float;
1882}
1883extern "C" {
1884 pub fn sys_get_inchannels() -> ::std::os::raw::c_int;
1885}
1886extern "C" {
1887 pub fn sys_get_outchannels() -> ::std::os::raw::c_int;
1888}
1889extern "C" {
1890 pub fn dsp_add(f: t_perfroutine, n: ::std::os::raw::c_int, ...);
1891}
1892extern "C" {
1893 pub fn dsp_addv(f: t_perfroutine, n: ::std::os::raw::c_int, vec: *mut t_int);
1894}
1895extern "C" {
1896 pub fn pd_fft(
1897 buf: *mut t_float,
1898 npoints: ::std::os::raw::c_int,
1899 inverse: ::std::os::raw::c_int,
1900 );
1901}
1902extern "C" {
1903 pub fn ilog2(n: ::std::os::raw::c_int) -> ::std::os::raw::c_int;
1904}
1905extern "C" {
1906 pub fn mayer_fht(fz: *mut t_sample, n: ::std::os::raw::c_int);
1907}
1908extern "C" {
1909 pub fn mayer_fft(n: ::std::os::raw::c_int, real: *mut t_sample, imag: *mut t_sample);
1910}
1911extern "C" {
1912 pub fn mayer_ifft(n: ::std::os::raw::c_int, real: *mut t_sample, imag: *mut t_sample);
1913}
1914extern "C" {
1915 pub fn mayer_realfft(n: ::std::os::raw::c_int, real: *mut t_sample);
1916}
1917extern "C" {
1918 pub fn mayer_realifft(n: ::std::os::raw::c_int, real: *mut t_sample);
1919}
1920extern "C" {
1921 pub fn canvas_suspend_dsp() -> ::std::os::raw::c_int;
1922}
1923extern "C" {
1924 pub fn canvas_resume_dsp(oldstate: ::std::os::raw::c_int);
1925}
1926extern "C" {
1927 pub fn canvas_update_dsp();
1928}
1929#[repr(C)]
1930#[derive(Debug, Copy, Clone)]
1931pub struct _resample {
1932 pub method: ::std::os::raw::c_int,
1933 pub downsample: ::std::os::raw::c_int,
1934 pub upsample: ::std::os::raw::c_int,
1935 pub s_vec: *mut t_sample,
1936 pub s_n: ::std::os::raw::c_int,
1937 pub coeffs: *mut t_sample,
1938 pub coefsize: ::std::os::raw::c_int,
1939 pub buffer: *mut t_sample,
1940 pub bufsize: ::std::os::raw::c_int,
1941}
1942#[test]
1943fn bindgen_test_layout__resample() {
1944 assert_eq!(
1945 ::std::mem::size_of::<_resample>(),
1946 64usize,
1947 concat!("Size of: ", stringify!(_resample))
1948 );
1949 assert_eq!(
1950 ::std::mem::align_of::<_resample>(),
1951 8usize,
1952 concat!("Alignment of ", stringify!(_resample))
1953 );
1954 assert_eq!(
1955 unsafe { &(*(::std::ptr::null::<_resample>())).method as *const _ as usize },
1956 0usize,
1957 concat!(
1958 "Offset of field: ",
1959 stringify!(_resample),
1960 "::",
1961 stringify!(method)
1962 )
1963 );
1964 assert_eq!(
1965 unsafe { &(*(::std::ptr::null::<_resample>())).downsample as *const _ as usize },
1966 4usize,
1967 concat!(
1968 "Offset of field: ",
1969 stringify!(_resample),
1970 "::",
1971 stringify!(downsample)
1972 )
1973 );
1974 assert_eq!(
1975 unsafe { &(*(::std::ptr::null::<_resample>())).upsample as *const _ as usize },
1976 8usize,
1977 concat!(
1978 "Offset of field: ",
1979 stringify!(_resample),
1980 "::",
1981 stringify!(upsample)
1982 )
1983 );
1984 assert_eq!(
1985 unsafe { &(*(::std::ptr::null::<_resample>())).s_vec as *const _ as usize },
1986 16usize,
1987 concat!(
1988 "Offset of field: ",
1989 stringify!(_resample),
1990 "::",
1991 stringify!(s_vec)
1992 )
1993 );
1994 assert_eq!(
1995 unsafe { &(*(::std::ptr::null::<_resample>())).s_n as *const _ as usize },
1996 24usize,
1997 concat!(
1998 "Offset of field: ",
1999 stringify!(_resample),
2000 "::",
2001 stringify!(s_n)
2002 )
2003 );
2004 assert_eq!(
2005 unsafe { &(*(::std::ptr::null::<_resample>())).coeffs as *const _ as usize },
2006 32usize,
2007 concat!(
2008 "Offset of field: ",
2009 stringify!(_resample),
2010 "::",
2011 stringify!(coeffs)
2012 )
2013 );
2014 assert_eq!(
2015 unsafe { &(*(::std::ptr::null::<_resample>())).coefsize as *const _ as usize },
2016 40usize,
2017 concat!(
2018 "Offset of field: ",
2019 stringify!(_resample),
2020 "::",
2021 stringify!(coefsize)
2022 )
2023 );
2024 assert_eq!(
2025 unsafe { &(*(::std::ptr::null::<_resample>())).buffer as *const _ as usize },
2026 48usize,
2027 concat!(
2028 "Offset of field: ",
2029 stringify!(_resample),
2030 "::",
2031 stringify!(buffer)
2032 )
2033 );
2034 assert_eq!(
2035 unsafe { &(*(::std::ptr::null::<_resample>())).bufsize as *const _ as usize },
2036 56usize,
2037 concat!(
2038 "Offset of field: ",
2039 stringify!(_resample),
2040 "::",
2041 stringify!(bufsize)
2042 )
2043 );
2044}
2045pub type t_resample = _resample;
2046extern "C" {
2047 pub fn resample_init(x: *mut t_resample);
2048}
2049extern "C" {
2050 pub fn resample_free(x: *mut t_resample);
2051}
2052extern "C" {
2053 pub fn resample_dsp(
2054 x: *mut t_resample,
2055 in_: *mut t_sample,
2056 insize: ::std::os::raw::c_int,
2057 out: *mut t_sample,
2058 outsize: ::std::os::raw::c_int,
2059 method: ::std::os::raw::c_int,
2060 );
2061}
2062extern "C" {
2063 pub fn resamplefrom_dsp(
2064 x: *mut t_resample,
2065 in_: *mut t_sample,
2066 insize: ::std::os::raw::c_int,
2067 outsize: ::std::os::raw::c_int,
2068 method: ::std::os::raw::c_int,
2069 );
2070}
2071extern "C" {
2072 pub fn resampleto_dsp(
2073 x: *mut t_resample,
2074 out: *mut t_sample,
2075 insize: ::std::os::raw::c_int,
2076 outsize: ::std::os::raw::c_int,
2077 method: ::std::os::raw::c_int,
2078 );
2079}
2080#[repr(C)]
2081#[derive(Debug, Copy, Clone)]
2082pub struct _garray {
2083 _unused: [u8; 0],
2084}
2085extern "C" {
2086 pub fn garray_getfloatarray(
2087 x: *mut _garray,
2088 size: *mut ::std::os::raw::c_int,
2089 vec: *mut *mut t_float,
2090 ) -> ::std::os::raw::c_int;
2091}
2092extern "C" {
2093 pub fn garray_getfloatwords(
2094 x: *mut _garray,
2095 size: *mut ::std::os::raw::c_int,
2096 vec: *mut *mut t_word,
2097 ) -> ::std::os::raw::c_int;
2098}
2099extern "C" {
2100 pub fn garray_redraw(x: *mut _garray);
2101}
2102extern "C" {
2103 pub fn garray_npoints(x: *mut _garray) -> ::std::os::raw::c_int;
2104}
2105extern "C" {
2106 pub fn garray_vec(x: *mut _garray) -> *mut ::std::os::raw::c_char;
2107}
2108extern "C" {
2109 pub fn garray_resize(x: *mut _garray, f: t_floatarg);
2110}
2111extern "C" {
2112 pub fn garray_resize_long(x: *mut _garray, n: ::std::os::raw::c_long);
2113}
2114extern "C" {
2115 pub fn garray_usedindsp(x: *mut _garray);
2116}
2117extern "C" {
2118 pub fn garray_setsaveit(x: *mut _garray, saveit: ::std::os::raw::c_int);
2119}
2120extern "C" {
2121 pub fn garray_getglist(x: *mut _garray) -> *mut _glist;
2122}
2123extern "C" {
2124 pub fn garray_getarray(x: *mut _garray) -> *mut _array;
2125}
2126extern "C" {
2127 pub fn value_get(s: *mut t_symbol) -> *mut t_float;
2128}
2129extern "C" {
2130 pub fn value_release(s: *mut t_symbol);
2131}
2132extern "C" {
2133 pub fn value_getfloat(s: *mut t_symbol, f: *mut t_float) -> ::std::os::raw::c_int;
2134}
2135extern "C" {
2136 pub fn value_setfloat(s: *mut t_symbol, f: t_float) -> ::std::os::raw::c_int;
2137}
2138pub type t_guicallbackfn =
2139 ::std::option::Option<unsafe extern "C" fn(client: *mut t_gobj, glist: *mut _glist)>;
2140extern "C" {
2141 pub fn sys_vgui(fmt: *mut ::std::os::raw::c_char, ...);
2142}
2143extern "C" {
2144 pub fn sys_gui(s: *mut ::std::os::raw::c_char);
2145}
2146extern "C" {
2147 pub fn sys_pretendguibytes(n: ::std::os::raw::c_int);
2148}
2149extern "C" {
2150 pub fn sys_queuegui(
2151 client: *mut ::std::os::raw::c_void,
2152 glist: *mut _glist,
2153 f: t_guicallbackfn,
2154 );
2155}
2156extern "C" {
2157 pub fn sys_unqueuegui(client: *mut ::std::os::raw::c_void);
2158}
2159extern "C" {
2160 pub fn sys_getversion(
2161 major: *mut ::std::os::raw::c_int,
2162 minor: *mut ::std::os::raw::c_int,
2163 bugfix: *mut ::std::os::raw::c_int,
2164 );
2165}
2166extern "C" {
2167 pub static mut s_pointer: t_symbol;
2168}
2169extern "C" {
2170 pub static mut s_float: t_symbol;
2171}
2172extern "C" {
2173 pub static mut s_symbol: t_symbol;
2174}
2175extern "C" {
2176 pub static mut s_bang: t_symbol;
2177}
2178extern "C" {
2179 pub static mut s_list: t_symbol;
2180}
2181extern "C" {
2182 pub static mut s_anything: t_symbol;
2183}
2184extern "C" {
2185 pub static mut s_signal: t_symbol;
2186}
2187extern "C" {
2188 pub static mut s__N: t_symbol;
2189}
2190extern "C" {
2191 pub static mut s__X: t_symbol;
2192}
2193extern "C" {
2194 pub static mut s_x: t_symbol;
2195}
2196extern "C" {
2197 pub static mut s_y: t_symbol;
2198}
2199extern "C" {
2200 pub static mut s_: t_symbol;
2201}
2202extern "C" {
2203 pub fn pd_getcanvaslist() -> *mut _glist;
2204}
2205extern "C" {
2206 pub fn pd_getdspstate() -> ::std::os::raw::c_int;
2207}