1 // This file was generated by gir (https://github.com/gtk-rs/gir)
2 // from gir-files (https://github.com/gtk-rs/gir-files)
3 // DO NOT EDIT
4
5 use gio_sys::*;
6 use std::env;
7 use std::error::Error;
8 use std::ffi::OsString;
9 use std::mem::{align_of, size_of};
10 use std::path::Path;
11 use std::process::Command;
12 use std::str;
13 use tempfile::Builder;
14
15 static PACKAGES: &[&str] = &["gio-2.0"];
16
17 #[derive(Clone, Debug)]
18 struct Compiler {
19 pub args: Vec<String>,
20 }
21
22 impl Compiler {
new() -> Result<Self, Box<dyn Error>>23 pub fn new() -> Result<Self, Box<dyn Error>> {
24 let mut args = get_var("CC", "cc")?;
25 args.push("-Wno-deprecated-declarations".to_owned());
26 // For _Generic
27 args.push("-std=c11".to_owned());
28 // For %z support in printf when using MinGW.
29 args.push("-D__USE_MINGW_ANSI_STDIO".to_owned());
30 args.extend(get_var("CFLAGS", "")?);
31 args.extend(get_var("CPPFLAGS", "")?);
32 args.extend(pkg_config_cflags(PACKAGES)?);
33 Ok(Self { args })
34 }
35
compile(&self, src: &Path, out: &Path) -> Result<(), Box<dyn Error>>36 pub fn compile(&self, src: &Path, out: &Path) -> Result<(), Box<dyn Error>> {
37 let mut cmd = self.to_command();
38 cmd.arg(src);
39 cmd.arg("-o");
40 cmd.arg(out);
41 let status = cmd.spawn()?.wait()?;
42 if !status.success() {
43 return Err(format!("compilation command {:?} failed, {}", &cmd, status).into());
44 }
45 Ok(())
46 }
47
to_command(&self) -> Command48 fn to_command(&self) -> Command {
49 let mut cmd = Command::new(&self.args[0]);
50 cmd.args(&self.args[1..]);
51 cmd
52 }
53 }
54
get_var(name: &str, default: &str) -> Result<Vec<String>, Box<dyn Error>>55 fn get_var(name: &str, default: &str) -> Result<Vec<String>, Box<dyn Error>> {
56 match env::var(name) {
57 Ok(value) => Ok(shell_words::split(&value)?),
58 Err(env::VarError::NotPresent) => Ok(shell_words::split(default)?),
59 Err(err) => Err(format!("{} {}", name, err).into()),
60 }
61 }
62
pkg_config_cflags(packages: &[&str]) -> Result<Vec<String>, Box<dyn Error>>63 fn pkg_config_cflags(packages: &[&str]) -> Result<Vec<String>, Box<dyn Error>> {
64 if packages.is_empty() {
65 return Ok(Vec::new());
66 }
67 let pkg_config = env::var_os("PKG_CONFIG").unwrap_or_else(|| OsString::from("pkg-config"));
68 let mut cmd = Command::new(pkg_config);
69 cmd.arg("--cflags");
70 cmd.args(packages);
71 let out = cmd.output()?;
72 if !out.status.success() {
73 return Err(format!("command {:?} returned {}", &cmd, out.status).into());
74 }
75 let stdout = str::from_utf8(&out.stdout)?;
76 Ok(shell_words::split(stdout.trim())?)
77 }
78
79 #[derive(Copy, Clone, Debug, Eq, PartialEq)]
80 struct Layout {
81 size: usize,
82 alignment: usize,
83 }
84
85 #[derive(Copy, Clone, Debug, Default, Eq, PartialEq)]
86 struct Results {
87 /// Number of successfully completed tests.
88 passed: usize,
89 /// Total number of failed tests (including those that failed to compile).
90 failed: usize,
91 }
92
93 impl Results {
record_passed(&mut self)94 fn record_passed(&mut self) {
95 self.passed += 1;
96 }
record_failed(&mut self)97 fn record_failed(&mut self) {
98 self.failed += 1;
99 }
summary(&self) -> String100 fn summary(&self) -> String {
101 format!("{} passed; {} failed", self.passed, self.failed)
102 }
expect_total_success(&self)103 fn expect_total_success(&self) {
104 if self.failed == 0 {
105 println!("OK: {}", self.summary());
106 } else {
107 panic!("FAILED: {}", self.summary());
108 };
109 }
110 }
111
112 #[test]
cross_validate_constants_with_c()113 fn cross_validate_constants_with_c() {
114 let mut c_constants: Vec<(String, String)> = Vec::new();
115
116 for l in get_c_output("constant").unwrap().lines() {
117 let mut words = l.trim().split(';');
118 let name = words.next().expect("Failed to parse name").to_owned();
119 let value = words
120 .next()
121 .and_then(|s| s.parse().ok())
122 .expect("Failed to parse value");
123 c_constants.push((name, value));
124 }
125
126 let mut results = Results::default();
127
128 for ((rust_name, rust_value), (c_name, c_value)) in
129 RUST_CONSTANTS.iter().zip(c_constants.iter())
130 {
131 if rust_name != c_name {
132 results.record_failed();
133 eprintln!("Name mismatch:\nRust: {:?}\nC: {:?}", rust_name, c_name,);
134 continue;
135 }
136
137 if rust_value != c_value {
138 results.record_failed();
139 eprintln!(
140 "Constant value mismatch for {}\nRust: {:?}\nC: {:?}",
141 rust_name, rust_value, &c_value
142 );
143 continue;
144 }
145
146 results.record_passed();
147 }
148
149 results.expect_total_success();
150 }
151
152 #[test]
cross_validate_layout_with_c()153 fn cross_validate_layout_with_c() {
154 let mut c_layouts = Vec::new();
155
156 for l in get_c_output("layout").unwrap().lines() {
157 let mut words = l.trim().split(';');
158 let name = words.next().expect("Failed to parse name").to_owned();
159 let size = words
160 .next()
161 .and_then(|s| s.parse().ok())
162 .expect("Failed to parse size");
163 let alignment = words
164 .next()
165 .and_then(|s| s.parse().ok())
166 .expect("Failed to parse alignment");
167 c_layouts.push((name, Layout { size, alignment }));
168 }
169
170 let mut results = Results::default();
171
172 for ((rust_name, rust_layout), (c_name, c_layout)) in RUST_LAYOUTS.iter().zip(c_layouts.iter())
173 {
174 if rust_name != c_name {
175 results.record_failed();
176 eprintln!("Name mismatch:\nRust: {:?}\nC: {:?}", rust_name, c_name,);
177 continue;
178 }
179
180 if rust_layout != c_layout {
181 results.record_failed();
182 eprintln!(
183 "Layout mismatch for {}\nRust: {:?}\nC: {:?}",
184 rust_name, rust_layout, &c_layout
185 );
186 continue;
187 }
188
189 results.record_passed();
190 }
191
192 results.expect_total_success();
193 }
194
get_c_output(name: &str) -> Result<String, Box<dyn Error>>195 fn get_c_output(name: &str) -> Result<String, Box<dyn Error>> {
196 let tmpdir = Builder::new().prefix("abi").tempdir()?;
197 let exe = tmpdir.path().join(name);
198 let c_file = Path::new("tests").join(name).with_extension("c");
199
200 let cc = Compiler::new().expect("configured compiler");
201 cc.compile(&c_file, &exe)?;
202
203 let mut abi_cmd = Command::new(exe);
204 let output = abi_cmd.output()?;
205 if !output.status.success() {
206 return Err(format!("command {:?} failed, {:?}", &abi_cmd, &output).into());
207 }
208
209 Ok(String::from_utf8(output.stdout)?)
210 }
211
212 const RUST_LAYOUTS: &[(&str, Layout)] = &[
213 (
214 "GActionEntry",
215 Layout {
216 size: size_of::<GActionEntry>(),
217 alignment: align_of::<GActionEntry>(),
218 },
219 ),
220 (
221 "GActionGroupInterface",
222 Layout {
223 size: size_of::<GActionGroupInterface>(),
224 alignment: align_of::<GActionGroupInterface>(),
225 },
226 ),
227 (
228 "GActionInterface",
229 Layout {
230 size: size_of::<GActionInterface>(),
231 alignment: align_of::<GActionInterface>(),
232 },
233 ),
234 (
235 "GActionMapInterface",
236 Layout {
237 size: size_of::<GActionMapInterface>(),
238 alignment: align_of::<GActionMapInterface>(),
239 },
240 ),
241 (
242 "GAppInfoCreateFlags",
243 Layout {
244 size: size_of::<GAppInfoCreateFlags>(),
245 alignment: align_of::<GAppInfoCreateFlags>(),
246 },
247 ),
248 (
249 "GAppInfoIface",
250 Layout {
251 size: size_of::<GAppInfoIface>(),
252 alignment: align_of::<GAppInfoIface>(),
253 },
254 ),
255 (
256 "GAppLaunchContext",
257 Layout {
258 size: size_of::<GAppLaunchContext>(),
259 alignment: align_of::<GAppLaunchContext>(),
260 },
261 ),
262 (
263 "GAppLaunchContextClass",
264 Layout {
265 size: size_of::<GAppLaunchContextClass>(),
266 alignment: align_of::<GAppLaunchContextClass>(),
267 },
268 ),
269 (
270 "GApplication",
271 Layout {
272 size: size_of::<GApplication>(),
273 alignment: align_of::<GApplication>(),
274 },
275 ),
276 (
277 "GApplicationClass",
278 Layout {
279 size: size_of::<GApplicationClass>(),
280 alignment: align_of::<GApplicationClass>(),
281 },
282 ),
283 (
284 "GApplicationCommandLine",
285 Layout {
286 size: size_of::<GApplicationCommandLine>(),
287 alignment: align_of::<GApplicationCommandLine>(),
288 },
289 ),
290 (
291 "GApplicationCommandLineClass",
292 Layout {
293 size: size_of::<GApplicationCommandLineClass>(),
294 alignment: align_of::<GApplicationCommandLineClass>(),
295 },
296 ),
297 (
298 "GApplicationFlags",
299 Layout {
300 size: size_of::<GApplicationFlags>(),
301 alignment: align_of::<GApplicationFlags>(),
302 },
303 ),
304 (
305 "GAskPasswordFlags",
306 Layout {
307 size: size_of::<GAskPasswordFlags>(),
308 alignment: align_of::<GAskPasswordFlags>(),
309 },
310 ),
311 (
312 "GAsyncInitableIface",
313 Layout {
314 size: size_of::<GAsyncInitableIface>(),
315 alignment: align_of::<GAsyncInitableIface>(),
316 },
317 ),
318 (
319 "GAsyncResultIface",
320 Layout {
321 size: size_of::<GAsyncResultIface>(),
322 alignment: align_of::<GAsyncResultIface>(),
323 },
324 ),
325 (
326 "GBufferedInputStream",
327 Layout {
328 size: size_of::<GBufferedInputStream>(),
329 alignment: align_of::<GBufferedInputStream>(),
330 },
331 ),
332 (
333 "GBufferedInputStreamClass",
334 Layout {
335 size: size_of::<GBufferedInputStreamClass>(),
336 alignment: align_of::<GBufferedInputStreamClass>(),
337 },
338 ),
339 (
340 "GBufferedOutputStream",
341 Layout {
342 size: size_of::<GBufferedOutputStream>(),
343 alignment: align_of::<GBufferedOutputStream>(),
344 },
345 ),
346 (
347 "GBufferedOutputStreamClass",
348 Layout {
349 size: size_of::<GBufferedOutputStreamClass>(),
350 alignment: align_of::<GBufferedOutputStreamClass>(),
351 },
352 ),
353 (
354 "GBusNameOwnerFlags",
355 Layout {
356 size: size_of::<GBusNameOwnerFlags>(),
357 alignment: align_of::<GBusNameOwnerFlags>(),
358 },
359 ),
360 (
361 "GBusNameWatcherFlags",
362 Layout {
363 size: size_of::<GBusNameWatcherFlags>(),
364 alignment: align_of::<GBusNameWatcherFlags>(),
365 },
366 ),
367 (
368 "GBusType",
369 Layout {
370 size: size_of::<GBusType>(),
371 alignment: align_of::<GBusType>(),
372 },
373 ),
374 (
375 "GCancellable",
376 Layout {
377 size: size_of::<GCancellable>(),
378 alignment: align_of::<GCancellable>(),
379 },
380 ),
381 (
382 "GCancellableClass",
383 Layout {
384 size: size_of::<GCancellableClass>(),
385 alignment: align_of::<GCancellableClass>(),
386 },
387 ),
388 (
389 "GCharsetConverterClass",
390 Layout {
391 size: size_of::<GCharsetConverterClass>(),
392 alignment: align_of::<GCharsetConverterClass>(),
393 },
394 ),
395 (
396 "GConverterFlags",
397 Layout {
398 size: size_of::<GConverterFlags>(),
399 alignment: align_of::<GConverterFlags>(),
400 },
401 ),
402 (
403 "GConverterIface",
404 Layout {
405 size: size_of::<GConverterIface>(),
406 alignment: align_of::<GConverterIface>(),
407 },
408 ),
409 (
410 "GConverterInputStream",
411 Layout {
412 size: size_of::<GConverterInputStream>(),
413 alignment: align_of::<GConverterInputStream>(),
414 },
415 ),
416 (
417 "GConverterInputStreamClass",
418 Layout {
419 size: size_of::<GConverterInputStreamClass>(),
420 alignment: align_of::<GConverterInputStreamClass>(),
421 },
422 ),
423 (
424 "GConverterOutputStream",
425 Layout {
426 size: size_of::<GConverterOutputStream>(),
427 alignment: align_of::<GConverterOutputStream>(),
428 },
429 ),
430 (
431 "GConverterOutputStreamClass",
432 Layout {
433 size: size_of::<GConverterOutputStreamClass>(),
434 alignment: align_of::<GConverterOutputStreamClass>(),
435 },
436 ),
437 (
438 "GConverterResult",
439 Layout {
440 size: size_of::<GConverterResult>(),
441 alignment: align_of::<GConverterResult>(),
442 },
443 ),
444 (
445 "GCredentialsType",
446 Layout {
447 size: size_of::<GCredentialsType>(),
448 alignment: align_of::<GCredentialsType>(),
449 },
450 ),
451 (
452 "GDBusAnnotationInfo",
453 Layout {
454 size: size_of::<GDBusAnnotationInfo>(),
455 alignment: align_of::<GDBusAnnotationInfo>(),
456 },
457 ),
458 (
459 "GDBusArgInfo",
460 Layout {
461 size: size_of::<GDBusArgInfo>(),
462 alignment: align_of::<GDBusArgInfo>(),
463 },
464 ),
465 (
466 "GDBusCallFlags",
467 Layout {
468 size: size_of::<GDBusCallFlags>(),
469 alignment: align_of::<GDBusCallFlags>(),
470 },
471 ),
472 (
473 "GDBusCapabilityFlags",
474 Layout {
475 size: size_of::<GDBusCapabilityFlags>(),
476 alignment: align_of::<GDBusCapabilityFlags>(),
477 },
478 ),
479 (
480 "GDBusConnectionFlags",
481 Layout {
482 size: size_of::<GDBusConnectionFlags>(),
483 alignment: align_of::<GDBusConnectionFlags>(),
484 },
485 ),
486 (
487 "GDBusError",
488 Layout {
489 size: size_of::<GDBusError>(),
490 alignment: align_of::<GDBusError>(),
491 },
492 ),
493 (
494 "GDBusErrorEntry",
495 Layout {
496 size: size_of::<GDBusErrorEntry>(),
497 alignment: align_of::<GDBusErrorEntry>(),
498 },
499 ),
500 (
501 "GDBusInterfaceIface",
502 Layout {
503 size: size_of::<GDBusInterfaceIface>(),
504 alignment: align_of::<GDBusInterfaceIface>(),
505 },
506 ),
507 (
508 "GDBusInterfaceInfo",
509 Layout {
510 size: size_of::<GDBusInterfaceInfo>(),
511 alignment: align_of::<GDBusInterfaceInfo>(),
512 },
513 ),
514 (
515 "GDBusInterfaceSkeleton",
516 Layout {
517 size: size_of::<GDBusInterfaceSkeleton>(),
518 alignment: align_of::<GDBusInterfaceSkeleton>(),
519 },
520 ),
521 (
522 "GDBusInterfaceSkeletonClass",
523 Layout {
524 size: size_of::<GDBusInterfaceSkeletonClass>(),
525 alignment: align_of::<GDBusInterfaceSkeletonClass>(),
526 },
527 ),
528 (
529 "GDBusInterfaceSkeletonFlags",
530 Layout {
531 size: size_of::<GDBusInterfaceSkeletonFlags>(),
532 alignment: align_of::<GDBusInterfaceSkeletonFlags>(),
533 },
534 ),
535 (
536 "GDBusInterfaceVTable",
537 Layout {
538 size: size_of::<GDBusInterfaceVTable>(),
539 alignment: align_of::<GDBusInterfaceVTable>(),
540 },
541 ),
542 (
543 "GDBusMessageByteOrder",
544 Layout {
545 size: size_of::<GDBusMessageByteOrder>(),
546 alignment: align_of::<GDBusMessageByteOrder>(),
547 },
548 ),
549 (
550 "GDBusMessageFlags",
551 Layout {
552 size: size_of::<GDBusMessageFlags>(),
553 alignment: align_of::<GDBusMessageFlags>(),
554 },
555 ),
556 (
557 "GDBusMessageHeaderField",
558 Layout {
559 size: size_of::<GDBusMessageHeaderField>(),
560 alignment: align_of::<GDBusMessageHeaderField>(),
561 },
562 ),
563 (
564 "GDBusMessageType",
565 Layout {
566 size: size_of::<GDBusMessageType>(),
567 alignment: align_of::<GDBusMessageType>(),
568 },
569 ),
570 (
571 "GDBusMethodInfo",
572 Layout {
573 size: size_of::<GDBusMethodInfo>(),
574 alignment: align_of::<GDBusMethodInfo>(),
575 },
576 ),
577 (
578 "GDBusNodeInfo",
579 Layout {
580 size: size_of::<GDBusNodeInfo>(),
581 alignment: align_of::<GDBusNodeInfo>(),
582 },
583 ),
584 (
585 "GDBusObjectIface",
586 Layout {
587 size: size_of::<GDBusObjectIface>(),
588 alignment: align_of::<GDBusObjectIface>(),
589 },
590 ),
591 (
592 "GDBusObjectManagerClient",
593 Layout {
594 size: size_of::<GDBusObjectManagerClient>(),
595 alignment: align_of::<GDBusObjectManagerClient>(),
596 },
597 ),
598 (
599 "GDBusObjectManagerClientClass",
600 Layout {
601 size: size_of::<GDBusObjectManagerClientClass>(),
602 alignment: align_of::<GDBusObjectManagerClientClass>(),
603 },
604 ),
605 (
606 "GDBusObjectManagerClientFlags",
607 Layout {
608 size: size_of::<GDBusObjectManagerClientFlags>(),
609 alignment: align_of::<GDBusObjectManagerClientFlags>(),
610 },
611 ),
612 (
613 "GDBusObjectManagerIface",
614 Layout {
615 size: size_of::<GDBusObjectManagerIface>(),
616 alignment: align_of::<GDBusObjectManagerIface>(),
617 },
618 ),
619 (
620 "GDBusObjectManagerServer",
621 Layout {
622 size: size_of::<GDBusObjectManagerServer>(),
623 alignment: align_of::<GDBusObjectManagerServer>(),
624 },
625 ),
626 (
627 "GDBusObjectManagerServerClass",
628 Layout {
629 size: size_of::<GDBusObjectManagerServerClass>(),
630 alignment: align_of::<GDBusObjectManagerServerClass>(),
631 },
632 ),
633 (
634 "GDBusObjectProxy",
635 Layout {
636 size: size_of::<GDBusObjectProxy>(),
637 alignment: align_of::<GDBusObjectProxy>(),
638 },
639 ),
640 (
641 "GDBusObjectProxyClass",
642 Layout {
643 size: size_of::<GDBusObjectProxyClass>(),
644 alignment: align_of::<GDBusObjectProxyClass>(),
645 },
646 ),
647 (
648 "GDBusObjectSkeleton",
649 Layout {
650 size: size_of::<GDBusObjectSkeleton>(),
651 alignment: align_of::<GDBusObjectSkeleton>(),
652 },
653 ),
654 (
655 "GDBusObjectSkeletonClass",
656 Layout {
657 size: size_of::<GDBusObjectSkeletonClass>(),
658 alignment: align_of::<GDBusObjectSkeletonClass>(),
659 },
660 ),
661 (
662 "GDBusPropertyInfo",
663 Layout {
664 size: size_of::<GDBusPropertyInfo>(),
665 alignment: align_of::<GDBusPropertyInfo>(),
666 },
667 ),
668 (
669 "GDBusPropertyInfoFlags",
670 Layout {
671 size: size_of::<GDBusPropertyInfoFlags>(),
672 alignment: align_of::<GDBusPropertyInfoFlags>(),
673 },
674 ),
675 (
676 "GDBusProxy",
677 Layout {
678 size: size_of::<GDBusProxy>(),
679 alignment: align_of::<GDBusProxy>(),
680 },
681 ),
682 (
683 "GDBusProxyClass",
684 Layout {
685 size: size_of::<GDBusProxyClass>(),
686 alignment: align_of::<GDBusProxyClass>(),
687 },
688 ),
689 (
690 "GDBusProxyFlags",
691 Layout {
692 size: size_of::<GDBusProxyFlags>(),
693 alignment: align_of::<GDBusProxyFlags>(),
694 },
695 ),
696 (
697 "GDBusSendMessageFlags",
698 Layout {
699 size: size_of::<GDBusSendMessageFlags>(),
700 alignment: align_of::<GDBusSendMessageFlags>(),
701 },
702 ),
703 (
704 "GDBusServerFlags",
705 Layout {
706 size: size_of::<GDBusServerFlags>(),
707 alignment: align_of::<GDBusServerFlags>(),
708 },
709 ),
710 (
711 "GDBusSignalFlags",
712 Layout {
713 size: size_of::<GDBusSignalFlags>(),
714 alignment: align_of::<GDBusSignalFlags>(),
715 },
716 ),
717 (
718 "GDBusSignalInfo",
719 Layout {
720 size: size_of::<GDBusSignalInfo>(),
721 alignment: align_of::<GDBusSignalInfo>(),
722 },
723 ),
724 (
725 "GDBusSubtreeFlags",
726 Layout {
727 size: size_of::<GDBusSubtreeFlags>(),
728 alignment: align_of::<GDBusSubtreeFlags>(),
729 },
730 ),
731 (
732 "GDBusSubtreeVTable",
733 Layout {
734 size: size_of::<GDBusSubtreeVTable>(),
735 alignment: align_of::<GDBusSubtreeVTable>(),
736 },
737 ),
738 (
739 "GDataInputStream",
740 Layout {
741 size: size_of::<GDataInputStream>(),
742 alignment: align_of::<GDataInputStream>(),
743 },
744 ),
745 (
746 "GDataInputStreamClass",
747 Layout {
748 size: size_of::<GDataInputStreamClass>(),
749 alignment: align_of::<GDataInputStreamClass>(),
750 },
751 ),
752 (
753 "GDataOutputStream",
754 Layout {
755 size: size_of::<GDataOutputStream>(),
756 alignment: align_of::<GDataOutputStream>(),
757 },
758 ),
759 (
760 "GDataOutputStreamClass",
761 Layout {
762 size: size_of::<GDataOutputStreamClass>(),
763 alignment: align_of::<GDataOutputStreamClass>(),
764 },
765 ),
766 (
767 "GDataStreamByteOrder",
768 Layout {
769 size: size_of::<GDataStreamByteOrder>(),
770 alignment: align_of::<GDataStreamByteOrder>(),
771 },
772 ),
773 (
774 "GDataStreamNewlineType",
775 Layout {
776 size: size_of::<GDataStreamNewlineType>(),
777 alignment: align_of::<GDataStreamNewlineType>(),
778 },
779 ),
780 (
781 "GDatagramBasedInterface",
782 Layout {
783 size: size_of::<GDatagramBasedInterface>(),
784 alignment: align_of::<GDatagramBasedInterface>(),
785 },
786 ),
787 (
788 "GDesktopAppInfoClass",
789 Layout {
790 size: size_of::<GDesktopAppInfoClass>(),
791 alignment: align_of::<GDesktopAppInfoClass>(),
792 },
793 ),
794 (
795 "GDesktopAppInfoLookupIface",
796 Layout {
797 size: size_of::<GDesktopAppInfoLookupIface>(),
798 alignment: align_of::<GDesktopAppInfoLookupIface>(),
799 },
800 ),
801 (
802 "GDriveIface",
803 Layout {
804 size: size_of::<GDriveIface>(),
805 alignment: align_of::<GDriveIface>(),
806 },
807 ),
808 (
809 "GDriveStartFlags",
810 Layout {
811 size: size_of::<GDriveStartFlags>(),
812 alignment: align_of::<GDriveStartFlags>(),
813 },
814 ),
815 (
816 "GDriveStartStopType",
817 Layout {
818 size: size_of::<GDriveStartStopType>(),
819 alignment: align_of::<GDriveStartStopType>(),
820 },
821 ),
822 (
823 "GDtlsClientConnectionInterface",
824 Layout {
825 size: size_of::<GDtlsClientConnectionInterface>(),
826 alignment: align_of::<GDtlsClientConnectionInterface>(),
827 },
828 ),
829 (
830 "GDtlsConnectionInterface",
831 Layout {
832 size: size_of::<GDtlsConnectionInterface>(),
833 alignment: align_of::<GDtlsConnectionInterface>(),
834 },
835 ),
836 (
837 "GDtlsServerConnectionInterface",
838 Layout {
839 size: size_of::<GDtlsServerConnectionInterface>(),
840 alignment: align_of::<GDtlsServerConnectionInterface>(),
841 },
842 ),
843 (
844 "GEmblemOrigin",
845 Layout {
846 size: size_of::<GEmblemOrigin>(),
847 alignment: align_of::<GEmblemOrigin>(),
848 },
849 ),
850 (
851 "GEmblemedIcon",
852 Layout {
853 size: size_of::<GEmblemedIcon>(),
854 alignment: align_of::<GEmblemedIcon>(),
855 },
856 ),
857 (
858 "GEmblemedIconClass",
859 Layout {
860 size: size_of::<GEmblemedIconClass>(),
861 alignment: align_of::<GEmblemedIconClass>(),
862 },
863 ),
864 (
865 "GFileAttributeInfo",
866 Layout {
867 size: size_of::<GFileAttributeInfo>(),
868 alignment: align_of::<GFileAttributeInfo>(),
869 },
870 ),
871 (
872 "GFileAttributeInfoFlags",
873 Layout {
874 size: size_of::<GFileAttributeInfoFlags>(),
875 alignment: align_of::<GFileAttributeInfoFlags>(),
876 },
877 ),
878 (
879 "GFileAttributeInfoList",
880 Layout {
881 size: size_of::<GFileAttributeInfoList>(),
882 alignment: align_of::<GFileAttributeInfoList>(),
883 },
884 ),
885 (
886 "GFileAttributeStatus",
887 Layout {
888 size: size_of::<GFileAttributeStatus>(),
889 alignment: align_of::<GFileAttributeStatus>(),
890 },
891 ),
892 (
893 "GFileAttributeType",
894 Layout {
895 size: size_of::<GFileAttributeType>(),
896 alignment: align_of::<GFileAttributeType>(),
897 },
898 ),
899 (
900 "GFileCopyFlags",
901 Layout {
902 size: size_of::<GFileCopyFlags>(),
903 alignment: align_of::<GFileCopyFlags>(),
904 },
905 ),
906 (
907 "GFileCreateFlags",
908 Layout {
909 size: size_of::<GFileCreateFlags>(),
910 alignment: align_of::<GFileCreateFlags>(),
911 },
912 ),
913 (
914 "GFileDescriptorBasedIface",
915 Layout {
916 size: size_of::<GFileDescriptorBasedIface>(),
917 alignment: align_of::<GFileDescriptorBasedIface>(),
918 },
919 ),
920 (
921 "GFileEnumerator",
922 Layout {
923 size: size_of::<GFileEnumerator>(),
924 alignment: align_of::<GFileEnumerator>(),
925 },
926 ),
927 (
928 "GFileEnumeratorClass",
929 Layout {
930 size: size_of::<GFileEnumeratorClass>(),
931 alignment: align_of::<GFileEnumeratorClass>(),
932 },
933 ),
934 (
935 "GFileIOStream",
936 Layout {
937 size: size_of::<GFileIOStream>(),
938 alignment: align_of::<GFileIOStream>(),
939 },
940 ),
941 (
942 "GFileIOStreamClass",
943 Layout {
944 size: size_of::<GFileIOStreamClass>(),
945 alignment: align_of::<GFileIOStreamClass>(),
946 },
947 ),
948 (
949 "GFileIface",
950 Layout {
951 size: size_of::<GFileIface>(),
952 alignment: align_of::<GFileIface>(),
953 },
954 ),
955 (
956 "GFileInputStream",
957 Layout {
958 size: size_of::<GFileInputStream>(),
959 alignment: align_of::<GFileInputStream>(),
960 },
961 ),
962 (
963 "GFileInputStreamClass",
964 Layout {
965 size: size_of::<GFileInputStreamClass>(),
966 alignment: align_of::<GFileInputStreamClass>(),
967 },
968 ),
969 (
970 "GFileMeasureFlags",
971 Layout {
972 size: size_of::<GFileMeasureFlags>(),
973 alignment: align_of::<GFileMeasureFlags>(),
974 },
975 ),
976 (
977 "GFileMonitor",
978 Layout {
979 size: size_of::<GFileMonitor>(),
980 alignment: align_of::<GFileMonitor>(),
981 },
982 ),
983 (
984 "GFileMonitorClass",
985 Layout {
986 size: size_of::<GFileMonitorClass>(),
987 alignment: align_of::<GFileMonitorClass>(),
988 },
989 ),
990 (
991 "GFileMonitorEvent",
992 Layout {
993 size: size_of::<GFileMonitorEvent>(),
994 alignment: align_of::<GFileMonitorEvent>(),
995 },
996 ),
997 (
998 "GFileMonitorFlags",
999 Layout {
1000 size: size_of::<GFileMonitorFlags>(),
1001 alignment: align_of::<GFileMonitorFlags>(),
1002 },
1003 ),
1004 (
1005 "GFileOutputStream",
1006 Layout {
1007 size: size_of::<GFileOutputStream>(),
1008 alignment: align_of::<GFileOutputStream>(),
1009 },
1010 ),
1011 (
1012 "GFileOutputStreamClass",
1013 Layout {
1014 size: size_of::<GFileOutputStreamClass>(),
1015 alignment: align_of::<GFileOutputStreamClass>(),
1016 },
1017 ),
1018 (
1019 "GFileQueryInfoFlags",
1020 Layout {
1021 size: size_of::<GFileQueryInfoFlags>(),
1022 alignment: align_of::<GFileQueryInfoFlags>(),
1023 },
1024 ),
1025 (
1026 "GFileType",
1027 Layout {
1028 size: size_of::<GFileType>(),
1029 alignment: align_of::<GFileType>(),
1030 },
1031 ),
1032 (
1033 "GFilenameCompleterClass",
1034 Layout {
1035 size: size_of::<GFilenameCompleterClass>(),
1036 alignment: align_of::<GFilenameCompleterClass>(),
1037 },
1038 ),
1039 (
1040 "GFilesystemPreviewType",
1041 Layout {
1042 size: size_of::<GFilesystemPreviewType>(),
1043 alignment: align_of::<GFilesystemPreviewType>(),
1044 },
1045 ),
1046 (
1047 "GFilterInputStream",
1048 Layout {
1049 size: size_of::<GFilterInputStream>(),
1050 alignment: align_of::<GFilterInputStream>(),
1051 },
1052 ),
1053 (
1054 "GFilterInputStreamClass",
1055 Layout {
1056 size: size_of::<GFilterInputStreamClass>(),
1057 alignment: align_of::<GFilterInputStreamClass>(),
1058 },
1059 ),
1060 (
1061 "GFilterOutputStream",
1062 Layout {
1063 size: size_of::<GFilterOutputStream>(),
1064 alignment: align_of::<GFilterOutputStream>(),
1065 },
1066 ),
1067 (
1068 "GFilterOutputStreamClass",
1069 Layout {
1070 size: size_of::<GFilterOutputStreamClass>(),
1071 alignment: align_of::<GFilterOutputStreamClass>(),
1072 },
1073 ),
1074 (
1075 "GIOErrorEnum",
1076 Layout {
1077 size: size_of::<GIOErrorEnum>(),
1078 alignment: align_of::<GIOErrorEnum>(),
1079 },
1080 ),
1081 (
1082 "GIOModuleScopeFlags",
1083 Layout {
1084 size: size_of::<GIOModuleScopeFlags>(),
1085 alignment: align_of::<GIOModuleScopeFlags>(),
1086 },
1087 ),
1088 (
1089 "GIOStream",
1090 Layout {
1091 size: size_of::<GIOStream>(),
1092 alignment: align_of::<GIOStream>(),
1093 },
1094 ),
1095 (
1096 "GIOStreamClass",
1097 Layout {
1098 size: size_of::<GIOStreamClass>(),
1099 alignment: align_of::<GIOStreamClass>(),
1100 },
1101 ),
1102 (
1103 "GIOStreamSpliceFlags",
1104 Layout {
1105 size: size_of::<GIOStreamSpliceFlags>(),
1106 alignment: align_of::<GIOStreamSpliceFlags>(),
1107 },
1108 ),
1109 (
1110 "GIconIface",
1111 Layout {
1112 size: size_of::<GIconIface>(),
1113 alignment: align_of::<GIconIface>(),
1114 },
1115 ),
1116 (
1117 "GInetAddress",
1118 Layout {
1119 size: size_of::<GInetAddress>(),
1120 alignment: align_of::<GInetAddress>(),
1121 },
1122 ),
1123 (
1124 "GInetAddressClass",
1125 Layout {
1126 size: size_of::<GInetAddressClass>(),
1127 alignment: align_of::<GInetAddressClass>(),
1128 },
1129 ),
1130 (
1131 "GInetAddressMask",
1132 Layout {
1133 size: size_of::<GInetAddressMask>(),
1134 alignment: align_of::<GInetAddressMask>(),
1135 },
1136 ),
1137 (
1138 "GInetAddressMaskClass",
1139 Layout {
1140 size: size_of::<GInetAddressMaskClass>(),
1141 alignment: align_of::<GInetAddressMaskClass>(),
1142 },
1143 ),
1144 (
1145 "GInetSocketAddress",
1146 Layout {
1147 size: size_of::<GInetSocketAddress>(),
1148 alignment: align_of::<GInetSocketAddress>(),
1149 },
1150 ),
1151 (
1152 "GInetSocketAddressClass",
1153 Layout {
1154 size: size_of::<GInetSocketAddressClass>(),
1155 alignment: align_of::<GInetSocketAddressClass>(),
1156 },
1157 ),
1158 (
1159 "GInitableIface",
1160 Layout {
1161 size: size_of::<GInitableIface>(),
1162 alignment: align_of::<GInitableIface>(),
1163 },
1164 ),
1165 (
1166 "GInputMessage",
1167 Layout {
1168 size: size_of::<GInputMessage>(),
1169 alignment: align_of::<GInputMessage>(),
1170 },
1171 ),
1172 (
1173 "GInputStream",
1174 Layout {
1175 size: size_of::<GInputStream>(),
1176 alignment: align_of::<GInputStream>(),
1177 },
1178 ),
1179 (
1180 "GInputStreamClass",
1181 Layout {
1182 size: size_of::<GInputStreamClass>(),
1183 alignment: align_of::<GInputStreamClass>(),
1184 },
1185 ),
1186 (
1187 "GInputVector",
1188 Layout {
1189 size: size_of::<GInputVector>(),
1190 alignment: align_of::<GInputVector>(),
1191 },
1192 ),
1193 (
1194 "GListModelInterface",
1195 Layout {
1196 size: size_of::<GListModelInterface>(),
1197 alignment: align_of::<GListModelInterface>(),
1198 },
1199 ),
1200 (
1201 "GListStoreClass",
1202 Layout {
1203 size: size_of::<GListStoreClass>(),
1204 alignment: align_of::<GListStoreClass>(),
1205 },
1206 ),
1207 (
1208 "GLoadableIconIface",
1209 Layout {
1210 size: size_of::<GLoadableIconIface>(),
1211 alignment: align_of::<GLoadableIconIface>(),
1212 },
1213 ),
1214 (
1215 "GMemoryInputStream",
1216 Layout {
1217 size: size_of::<GMemoryInputStream>(),
1218 alignment: align_of::<GMemoryInputStream>(),
1219 },
1220 ),
1221 (
1222 "GMemoryInputStreamClass",
1223 Layout {
1224 size: size_of::<GMemoryInputStreamClass>(),
1225 alignment: align_of::<GMemoryInputStreamClass>(),
1226 },
1227 ),
1228 (
1229 "GMemoryMonitorInterface",
1230 Layout {
1231 size: size_of::<GMemoryMonitorInterface>(),
1232 alignment: align_of::<GMemoryMonitorInterface>(),
1233 },
1234 ),
1235 (
1236 "GMemoryMonitorWarningLevel",
1237 Layout {
1238 size: size_of::<GMemoryMonitorWarningLevel>(),
1239 alignment: align_of::<GMemoryMonitorWarningLevel>(),
1240 },
1241 ),
1242 (
1243 "GMemoryOutputStream",
1244 Layout {
1245 size: size_of::<GMemoryOutputStream>(),
1246 alignment: align_of::<GMemoryOutputStream>(),
1247 },
1248 ),
1249 (
1250 "GMemoryOutputStreamClass",
1251 Layout {
1252 size: size_of::<GMemoryOutputStreamClass>(),
1253 alignment: align_of::<GMemoryOutputStreamClass>(),
1254 },
1255 ),
1256 (
1257 "GMenuAttributeIter",
1258 Layout {
1259 size: size_of::<GMenuAttributeIter>(),
1260 alignment: align_of::<GMenuAttributeIter>(),
1261 },
1262 ),
1263 (
1264 "GMenuAttributeIterClass",
1265 Layout {
1266 size: size_of::<GMenuAttributeIterClass>(),
1267 alignment: align_of::<GMenuAttributeIterClass>(),
1268 },
1269 ),
1270 (
1271 "GMenuLinkIter",
1272 Layout {
1273 size: size_of::<GMenuLinkIter>(),
1274 alignment: align_of::<GMenuLinkIter>(),
1275 },
1276 ),
1277 (
1278 "GMenuLinkIterClass",
1279 Layout {
1280 size: size_of::<GMenuLinkIterClass>(),
1281 alignment: align_of::<GMenuLinkIterClass>(),
1282 },
1283 ),
1284 (
1285 "GMenuModel",
1286 Layout {
1287 size: size_of::<GMenuModel>(),
1288 alignment: align_of::<GMenuModel>(),
1289 },
1290 ),
1291 (
1292 "GMenuModelClass",
1293 Layout {
1294 size: size_of::<GMenuModelClass>(),
1295 alignment: align_of::<GMenuModelClass>(),
1296 },
1297 ),
1298 (
1299 "GMountIface",
1300 Layout {
1301 size: size_of::<GMountIface>(),
1302 alignment: align_of::<GMountIface>(),
1303 },
1304 ),
1305 (
1306 "GMountMountFlags",
1307 Layout {
1308 size: size_of::<GMountMountFlags>(),
1309 alignment: align_of::<GMountMountFlags>(),
1310 },
1311 ),
1312 (
1313 "GMountOperation",
1314 Layout {
1315 size: size_of::<GMountOperation>(),
1316 alignment: align_of::<GMountOperation>(),
1317 },
1318 ),
1319 (
1320 "GMountOperationClass",
1321 Layout {
1322 size: size_of::<GMountOperationClass>(),
1323 alignment: align_of::<GMountOperationClass>(),
1324 },
1325 ),
1326 (
1327 "GMountOperationResult",
1328 Layout {
1329 size: size_of::<GMountOperationResult>(),
1330 alignment: align_of::<GMountOperationResult>(),
1331 },
1332 ),
1333 (
1334 "GMountUnmountFlags",
1335 Layout {
1336 size: size_of::<GMountUnmountFlags>(),
1337 alignment: align_of::<GMountUnmountFlags>(),
1338 },
1339 ),
1340 (
1341 "GNativeSocketAddress",
1342 Layout {
1343 size: size_of::<GNativeSocketAddress>(),
1344 alignment: align_of::<GNativeSocketAddress>(),
1345 },
1346 ),
1347 (
1348 "GNativeSocketAddressClass",
1349 Layout {
1350 size: size_of::<GNativeSocketAddressClass>(),
1351 alignment: align_of::<GNativeSocketAddressClass>(),
1352 },
1353 ),
1354 (
1355 "GNativeVolumeMonitor",
1356 Layout {
1357 size: size_of::<GNativeVolumeMonitor>(),
1358 alignment: align_of::<GNativeVolumeMonitor>(),
1359 },
1360 ),
1361 (
1362 "GNativeVolumeMonitorClass",
1363 Layout {
1364 size: size_of::<GNativeVolumeMonitorClass>(),
1365 alignment: align_of::<GNativeVolumeMonitorClass>(),
1366 },
1367 ),
1368 (
1369 "GNetworkAddress",
1370 Layout {
1371 size: size_of::<GNetworkAddress>(),
1372 alignment: align_of::<GNetworkAddress>(),
1373 },
1374 ),
1375 (
1376 "GNetworkAddressClass",
1377 Layout {
1378 size: size_of::<GNetworkAddressClass>(),
1379 alignment: align_of::<GNetworkAddressClass>(),
1380 },
1381 ),
1382 (
1383 "GNetworkConnectivity",
1384 Layout {
1385 size: size_of::<GNetworkConnectivity>(),
1386 alignment: align_of::<GNetworkConnectivity>(),
1387 },
1388 ),
1389 (
1390 "GNetworkMonitorInterface",
1391 Layout {
1392 size: size_of::<GNetworkMonitorInterface>(),
1393 alignment: align_of::<GNetworkMonitorInterface>(),
1394 },
1395 ),
1396 (
1397 "GNetworkService",
1398 Layout {
1399 size: size_of::<GNetworkService>(),
1400 alignment: align_of::<GNetworkService>(),
1401 },
1402 ),
1403 (
1404 "GNetworkServiceClass",
1405 Layout {
1406 size: size_of::<GNetworkServiceClass>(),
1407 alignment: align_of::<GNetworkServiceClass>(),
1408 },
1409 ),
1410 (
1411 "GNotificationPriority",
1412 Layout {
1413 size: size_of::<GNotificationPriority>(),
1414 alignment: align_of::<GNotificationPriority>(),
1415 },
1416 ),
1417 (
1418 "GOutputMessage",
1419 Layout {
1420 size: size_of::<GOutputMessage>(),
1421 alignment: align_of::<GOutputMessage>(),
1422 },
1423 ),
1424 (
1425 "GOutputStream",
1426 Layout {
1427 size: size_of::<GOutputStream>(),
1428 alignment: align_of::<GOutputStream>(),
1429 },
1430 ),
1431 (
1432 "GOutputStreamClass",
1433 Layout {
1434 size: size_of::<GOutputStreamClass>(),
1435 alignment: align_of::<GOutputStreamClass>(),
1436 },
1437 ),
1438 (
1439 "GOutputStreamSpliceFlags",
1440 Layout {
1441 size: size_of::<GOutputStreamSpliceFlags>(),
1442 alignment: align_of::<GOutputStreamSpliceFlags>(),
1443 },
1444 ),
1445 (
1446 "GOutputVector",
1447 Layout {
1448 size: size_of::<GOutputVector>(),
1449 alignment: align_of::<GOutputVector>(),
1450 },
1451 ),
1452 (
1453 "GPasswordSave",
1454 Layout {
1455 size: size_of::<GPasswordSave>(),
1456 alignment: align_of::<GPasswordSave>(),
1457 },
1458 ),
1459 (
1460 "GPermission",
1461 Layout {
1462 size: size_of::<GPermission>(),
1463 alignment: align_of::<GPermission>(),
1464 },
1465 ),
1466 (
1467 "GPermissionClass",
1468 Layout {
1469 size: size_of::<GPermissionClass>(),
1470 alignment: align_of::<GPermissionClass>(),
1471 },
1472 ),
1473 (
1474 "GPollableInputStreamInterface",
1475 Layout {
1476 size: size_of::<GPollableInputStreamInterface>(),
1477 alignment: align_of::<GPollableInputStreamInterface>(),
1478 },
1479 ),
1480 (
1481 "GPollableOutputStreamInterface",
1482 Layout {
1483 size: size_of::<GPollableOutputStreamInterface>(),
1484 alignment: align_of::<GPollableOutputStreamInterface>(),
1485 },
1486 ),
1487 (
1488 "GPollableReturn",
1489 Layout {
1490 size: size_of::<GPollableReturn>(),
1491 alignment: align_of::<GPollableReturn>(),
1492 },
1493 ),
1494 (
1495 "GProxyAddress",
1496 Layout {
1497 size: size_of::<GProxyAddress>(),
1498 alignment: align_of::<GProxyAddress>(),
1499 },
1500 ),
1501 (
1502 "GProxyAddressClass",
1503 Layout {
1504 size: size_of::<GProxyAddressClass>(),
1505 alignment: align_of::<GProxyAddressClass>(),
1506 },
1507 ),
1508 (
1509 "GProxyAddressEnumerator",
1510 Layout {
1511 size: size_of::<GProxyAddressEnumerator>(),
1512 alignment: align_of::<GProxyAddressEnumerator>(),
1513 },
1514 ),
1515 (
1516 "GProxyAddressEnumeratorClass",
1517 Layout {
1518 size: size_of::<GProxyAddressEnumeratorClass>(),
1519 alignment: align_of::<GProxyAddressEnumeratorClass>(),
1520 },
1521 ),
1522 (
1523 "GProxyInterface",
1524 Layout {
1525 size: size_of::<GProxyInterface>(),
1526 alignment: align_of::<GProxyInterface>(),
1527 },
1528 ),
1529 (
1530 "GProxyResolverInterface",
1531 Layout {
1532 size: size_of::<GProxyResolverInterface>(),
1533 alignment: align_of::<GProxyResolverInterface>(),
1534 },
1535 ),
1536 (
1537 "GRemoteActionGroupInterface",
1538 Layout {
1539 size: size_of::<GRemoteActionGroupInterface>(),
1540 alignment: align_of::<GRemoteActionGroupInterface>(),
1541 },
1542 ),
1543 (
1544 "GResolver",
1545 Layout {
1546 size: size_of::<GResolver>(),
1547 alignment: align_of::<GResolver>(),
1548 },
1549 ),
1550 (
1551 "GResolverClass",
1552 Layout {
1553 size: size_of::<GResolverClass>(),
1554 alignment: align_of::<GResolverClass>(),
1555 },
1556 ),
1557 (
1558 "GResolverError",
1559 Layout {
1560 size: size_of::<GResolverError>(),
1561 alignment: align_of::<GResolverError>(),
1562 },
1563 ),
1564 (
1565 "GResolverNameLookupFlags",
1566 Layout {
1567 size: size_of::<GResolverNameLookupFlags>(),
1568 alignment: align_of::<GResolverNameLookupFlags>(),
1569 },
1570 ),
1571 (
1572 "GResolverRecordType",
1573 Layout {
1574 size: size_of::<GResolverRecordType>(),
1575 alignment: align_of::<GResolverRecordType>(),
1576 },
1577 ),
1578 (
1579 "GResourceError",
1580 Layout {
1581 size: size_of::<GResourceError>(),
1582 alignment: align_of::<GResourceError>(),
1583 },
1584 ),
1585 (
1586 "GResourceFlags",
1587 Layout {
1588 size: size_of::<GResourceFlags>(),
1589 alignment: align_of::<GResourceFlags>(),
1590 },
1591 ),
1592 (
1593 "GResourceLookupFlags",
1594 Layout {
1595 size: size_of::<GResourceLookupFlags>(),
1596 alignment: align_of::<GResourceLookupFlags>(),
1597 },
1598 ),
1599 (
1600 "GSeekableIface",
1601 Layout {
1602 size: size_of::<GSeekableIface>(),
1603 alignment: align_of::<GSeekableIface>(),
1604 },
1605 ),
1606 (
1607 "GSettings",
1608 Layout {
1609 size: size_of::<GSettings>(),
1610 alignment: align_of::<GSettings>(),
1611 },
1612 ),
1613 (
1614 "GSettingsBackend",
1615 Layout {
1616 size: size_of::<GSettingsBackend>(),
1617 alignment: align_of::<GSettingsBackend>(),
1618 },
1619 ),
1620 (
1621 "GSettingsBackendClass",
1622 Layout {
1623 size: size_of::<GSettingsBackendClass>(),
1624 alignment: align_of::<GSettingsBackendClass>(),
1625 },
1626 ),
1627 (
1628 "GSettingsBindFlags",
1629 Layout {
1630 size: size_of::<GSettingsBindFlags>(),
1631 alignment: align_of::<GSettingsBindFlags>(),
1632 },
1633 ),
1634 (
1635 "GSettingsClass",
1636 Layout {
1637 size: size_of::<GSettingsClass>(),
1638 alignment: align_of::<GSettingsClass>(),
1639 },
1640 ),
1641 (
1642 "GSimpleActionGroup",
1643 Layout {
1644 size: size_of::<GSimpleActionGroup>(),
1645 alignment: align_of::<GSimpleActionGroup>(),
1646 },
1647 ),
1648 (
1649 "GSimpleActionGroupClass",
1650 Layout {
1651 size: size_of::<GSimpleActionGroupClass>(),
1652 alignment: align_of::<GSimpleActionGroupClass>(),
1653 },
1654 ),
1655 (
1656 "GSimpleProxyResolver",
1657 Layout {
1658 size: size_of::<GSimpleProxyResolver>(),
1659 alignment: align_of::<GSimpleProxyResolver>(),
1660 },
1661 ),
1662 (
1663 "GSimpleProxyResolverClass",
1664 Layout {
1665 size: size_of::<GSimpleProxyResolverClass>(),
1666 alignment: align_of::<GSimpleProxyResolverClass>(),
1667 },
1668 ),
1669 (
1670 "GSocket",
1671 Layout {
1672 size: size_of::<GSocket>(),
1673 alignment: align_of::<GSocket>(),
1674 },
1675 ),
1676 (
1677 "GSocketAddress",
1678 Layout {
1679 size: size_of::<GSocketAddress>(),
1680 alignment: align_of::<GSocketAddress>(),
1681 },
1682 ),
1683 (
1684 "GSocketAddressClass",
1685 Layout {
1686 size: size_of::<GSocketAddressClass>(),
1687 alignment: align_of::<GSocketAddressClass>(),
1688 },
1689 ),
1690 (
1691 "GSocketAddressEnumerator",
1692 Layout {
1693 size: size_of::<GSocketAddressEnumerator>(),
1694 alignment: align_of::<GSocketAddressEnumerator>(),
1695 },
1696 ),
1697 (
1698 "GSocketAddressEnumeratorClass",
1699 Layout {
1700 size: size_of::<GSocketAddressEnumeratorClass>(),
1701 alignment: align_of::<GSocketAddressEnumeratorClass>(),
1702 },
1703 ),
1704 (
1705 "GSocketClass",
1706 Layout {
1707 size: size_of::<GSocketClass>(),
1708 alignment: align_of::<GSocketClass>(),
1709 },
1710 ),
1711 (
1712 "GSocketClient",
1713 Layout {
1714 size: size_of::<GSocketClient>(),
1715 alignment: align_of::<GSocketClient>(),
1716 },
1717 ),
1718 (
1719 "GSocketClientClass",
1720 Layout {
1721 size: size_of::<GSocketClientClass>(),
1722 alignment: align_of::<GSocketClientClass>(),
1723 },
1724 ),
1725 (
1726 "GSocketClientEvent",
1727 Layout {
1728 size: size_of::<GSocketClientEvent>(),
1729 alignment: align_of::<GSocketClientEvent>(),
1730 },
1731 ),
1732 (
1733 "GSocketConnectableIface",
1734 Layout {
1735 size: size_of::<GSocketConnectableIface>(),
1736 alignment: align_of::<GSocketConnectableIface>(),
1737 },
1738 ),
1739 (
1740 "GSocketConnection",
1741 Layout {
1742 size: size_of::<GSocketConnection>(),
1743 alignment: align_of::<GSocketConnection>(),
1744 },
1745 ),
1746 (
1747 "GSocketConnectionClass",
1748 Layout {
1749 size: size_of::<GSocketConnectionClass>(),
1750 alignment: align_of::<GSocketConnectionClass>(),
1751 },
1752 ),
1753 (
1754 "GSocketControlMessage",
1755 Layout {
1756 size: size_of::<GSocketControlMessage>(),
1757 alignment: align_of::<GSocketControlMessage>(),
1758 },
1759 ),
1760 (
1761 "GSocketControlMessageClass",
1762 Layout {
1763 size: size_of::<GSocketControlMessageClass>(),
1764 alignment: align_of::<GSocketControlMessageClass>(),
1765 },
1766 ),
1767 (
1768 "GSocketFamily",
1769 Layout {
1770 size: size_of::<GSocketFamily>(),
1771 alignment: align_of::<GSocketFamily>(),
1772 },
1773 ),
1774 (
1775 "GSocketListener",
1776 Layout {
1777 size: size_of::<GSocketListener>(),
1778 alignment: align_of::<GSocketListener>(),
1779 },
1780 ),
1781 (
1782 "GSocketListenerClass",
1783 Layout {
1784 size: size_of::<GSocketListenerClass>(),
1785 alignment: align_of::<GSocketListenerClass>(),
1786 },
1787 ),
1788 (
1789 "GSocketListenerEvent",
1790 Layout {
1791 size: size_of::<GSocketListenerEvent>(),
1792 alignment: align_of::<GSocketListenerEvent>(),
1793 },
1794 ),
1795 (
1796 "GSocketMsgFlags",
1797 Layout {
1798 size: size_of::<GSocketMsgFlags>(),
1799 alignment: align_of::<GSocketMsgFlags>(),
1800 },
1801 ),
1802 (
1803 "GSocketProtocol",
1804 Layout {
1805 size: size_of::<GSocketProtocol>(),
1806 alignment: align_of::<GSocketProtocol>(),
1807 },
1808 ),
1809 (
1810 "GSocketService",
1811 Layout {
1812 size: size_of::<GSocketService>(),
1813 alignment: align_of::<GSocketService>(),
1814 },
1815 ),
1816 (
1817 "GSocketServiceClass",
1818 Layout {
1819 size: size_of::<GSocketServiceClass>(),
1820 alignment: align_of::<GSocketServiceClass>(),
1821 },
1822 ),
1823 (
1824 "GSocketType",
1825 Layout {
1826 size: size_of::<GSocketType>(),
1827 alignment: align_of::<GSocketType>(),
1828 },
1829 ),
1830 (
1831 "GStaticResource",
1832 Layout {
1833 size: size_of::<GStaticResource>(),
1834 alignment: align_of::<GStaticResource>(),
1835 },
1836 ),
1837 (
1838 "GSubprocessFlags",
1839 Layout {
1840 size: size_of::<GSubprocessFlags>(),
1841 alignment: align_of::<GSubprocessFlags>(),
1842 },
1843 ),
1844 (
1845 "GTcpConnection",
1846 Layout {
1847 size: size_of::<GTcpConnection>(),
1848 alignment: align_of::<GTcpConnection>(),
1849 },
1850 ),
1851 (
1852 "GTcpConnectionClass",
1853 Layout {
1854 size: size_of::<GTcpConnectionClass>(),
1855 alignment: align_of::<GTcpConnectionClass>(),
1856 },
1857 ),
1858 (
1859 "GTcpWrapperConnection",
1860 Layout {
1861 size: size_of::<GTcpWrapperConnection>(),
1862 alignment: align_of::<GTcpWrapperConnection>(),
1863 },
1864 ),
1865 (
1866 "GTcpWrapperConnectionClass",
1867 Layout {
1868 size: size_of::<GTcpWrapperConnectionClass>(),
1869 alignment: align_of::<GTcpWrapperConnectionClass>(),
1870 },
1871 ),
1872 (
1873 "GTestDBusFlags",
1874 Layout {
1875 size: size_of::<GTestDBusFlags>(),
1876 alignment: align_of::<GTestDBusFlags>(),
1877 },
1878 ),
1879 (
1880 "GThreadedSocketService",
1881 Layout {
1882 size: size_of::<GThreadedSocketService>(),
1883 alignment: align_of::<GThreadedSocketService>(),
1884 },
1885 ),
1886 (
1887 "GThreadedSocketServiceClass",
1888 Layout {
1889 size: size_of::<GThreadedSocketServiceClass>(),
1890 alignment: align_of::<GThreadedSocketServiceClass>(),
1891 },
1892 ),
1893 (
1894 "GTlsAuthenticationMode",
1895 Layout {
1896 size: size_of::<GTlsAuthenticationMode>(),
1897 alignment: align_of::<GTlsAuthenticationMode>(),
1898 },
1899 ),
1900 (
1901 "GTlsBackendInterface",
1902 Layout {
1903 size: size_of::<GTlsBackendInterface>(),
1904 alignment: align_of::<GTlsBackendInterface>(),
1905 },
1906 ),
1907 (
1908 "GTlsCertificate",
1909 Layout {
1910 size: size_of::<GTlsCertificate>(),
1911 alignment: align_of::<GTlsCertificate>(),
1912 },
1913 ),
1914 (
1915 "GTlsCertificateClass",
1916 Layout {
1917 size: size_of::<GTlsCertificateClass>(),
1918 alignment: align_of::<GTlsCertificateClass>(),
1919 },
1920 ),
1921 (
1922 "GTlsCertificateFlags",
1923 Layout {
1924 size: size_of::<GTlsCertificateFlags>(),
1925 alignment: align_of::<GTlsCertificateFlags>(),
1926 },
1927 ),
1928 (
1929 "GTlsCertificateRequestFlags",
1930 Layout {
1931 size: size_of::<GTlsCertificateRequestFlags>(),
1932 alignment: align_of::<GTlsCertificateRequestFlags>(),
1933 },
1934 ),
1935 (
1936 "GTlsChannelBindingError",
1937 Layout {
1938 size: size_of::<GTlsChannelBindingError>(),
1939 alignment: align_of::<GTlsChannelBindingError>(),
1940 },
1941 ),
1942 (
1943 "GTlsChannelBindingType",
1944 Layout {
1945 size: size_of::<GTlsChannelBindingType>(),
1946 alignment: align_of::<GTlsChannelBindingType>(),
1947 },
1948 ),
1949 (
1950 "GTlsClientConnectionInterface",
1951 Layout {
1952 size: size_of::<GTlsClientConnectionInterface>(),
1953 alignment: align_of::<GTlsClientConnectionInterface>(),
1954 },
1955 ),
1956 (
1957 "GTlsConnection",
1958 Layout {
1959 size: size_of::<GTlsConnection>(),
1960 alignment: align_of::<GTlsConnection>(),
1961 },
1962 ),
1963 (
1964 "GTlsConnectionClass",
1965 Layout {
1966 size: size_of::<GTlsConnectionClass>(),
1967 alignment: align_of::<GTlsConnectionClass>(),
1968 },
1969 ),
1970 (
1971 "GTlsDatabase",
1972 Layout {
1973 size: size_of::<GTlsDatabase>(),
1974 alignment: align_of::<GTlsDatabase>(),
1975 },
1976 ),
1977 (
1978 "GTlsDatabaseClass",
1979 Layout {
1980 size: size_of::<GTlsDatabaseClass>(),
1981 alignment: align_of::<GTlsDatabaseClass>(),
1982 },
1983 ),
1984 (
1985 "GTlsDatabaseLookupFlags",
1986 Layout {
1987 size: size_of::<GTlsDatabaseLookupFlags>(),
1988 alignment: align_of::<GTlsDatabaseLookupFlags>(),
1989 },
1990 ),
1991 (
1992 "GTlsDatabaseVerifyFlags",
1993 Layout {
1994 size: size_of::<GTlsDatabaseVerifyFlags>(),
1995 alignment: align_of::<GTlsDatabaseVerifyFlags>(),
1996 },
1997 ),
1998 (
1999 "GTlsError",
2000 Layout {
2001 size: size_of::<GTlsError>(),
2002 alignment: align_of::<GTlsError>(),
2003 },
2004 ),
2005 (
2006 "GTlsFileDatabaseInterface",
2007 Layout {
2008 size: size_of::<GTlsFileDatabaseInterface>(),
2009 alignment: align_of::<GTlsFileDatabaseInterface>(),
2010 },
2011 ),
2012 (
2013 "GTlsInteraction",
2014 Layout {
2015 size: size_of::<GTlsInteraction>(),
2016 alignment: align_of::<GTlsInteraction>(),
2017 },
2018 ),
2019 (
2020 "GTlsInteractionClass",
2021 Layout {
2022 size: size_of::<GTlsInteractionClass>(),
2023 alignment: align_of::<GTlsInteractionClass>(),
2024 },
2025 ),
2026 (
2027 "GTlsInteractionResult",
2028 Layout {
2029 size: size_of::<GTlsInteractionResult>(),
2030 alignment: align_of::<GTlsInteractionResult>(),
2031 },
2032 ),
2033 (
2034 "GTlsPassword",
2035 Layout {
2036 size: size_of::<GTlsPassword>(),
2037 alignment: align_of::<GTlsPassword>(),
2038 },
2039 ),
2040 (
2041 "GTlsPasswordClass",
2042 Layout {
2043 size: size_of::<GTlsPasswordClass>(),
2044 alignment: align_of::<GTlsPasswordClass>(),
2045 },
2046 ),
2047 (
2048 "GTlsPasswordFlags",
2049 Layout {
2050 size: size_of::<GTlsPasswordFlags>(),
2051 alignment: align_of::<GTlsPasswordFlags>(),
2052 },
2053 ),
2054 (
2055 "GTlsRehandshakeMode",
2056 Layout {
2057 size: size_of::<GTlsRehandshakeMode>(),
2058 alignment: align_of::<GTlsRehandshakeMode>(),
2059 },
2060 ),
2061 (
2062 "GTlsServerConnectionInterface",
2063 Layout {
2064 size: size_of::<GTlsServerConnectionInterface>(),
2065 alignment: align_of::<GTlsServerConnectionInterface>(),
2066 },
2067 ),
2068 (
2069 "GUnixConnection",
2070 Layout {
2071 size: size_of::<GUnixConnection>(),
2072 alignment: align_of::<GUnixConnection>(),
2073 },
2074 ),
2075 (
2076 "GUnixConnectionClass",
2077 Layout {
2078 size: size_of::<GUnixConnectionClass>(),
2079 alignment: align_of::<GUnixConnectionClass>(),
2080 },
2081 ),
2082 (
2083 "GUnixCredentialsMessage",
2084 Layout {
2085 size: size_of::<GUnixCredentialsMessage>(),
2086 alignment: align_of::<GUnixCredentialsMessage>(),
2087 },
2088 ),
2089 (
2090 "GUnixCredentialsMessageClass",
2091 Layout {
2092 size: size_of::<GUnixCredentialsMessageClass>(),
2093 alignment: align_of::<GUnixCredentialsMessageClass>(),
2094 },
2095 ),
2096 (
2097 "GUnixFDList",
2098 Layout {
2099 size: size_of::<GUnixFDList>(),
2100 alignment: align_of::<GUnixFDList>(),
2101 },
2102 ),
2103 (
2104 "GUnixFDListClass",
2105 Layout {
2106 size: size_of::<GUnixFDListClass>(),
2107 alignment: align_of::<GUnixFDListClass>(),
2108 },
2109 ),
2110 (
2111 "GUnixFDMessage",
2112 Layout {
2113 size: size_of::<GUnixFDMessage>(),
2114 alignment: align_of::<GUnixFDMessage>(),
2115 },
2116 ),
2117 (
2118 "GUnixFDMessageClass",
2119 Layout {
2120 size: size_of::<GUnixFDMessageClass>(),
2121 alignment: align_of::<GUnixFDMessageClass>(),
2122 },
2123 ),
2124 (
2125 "GUnixInputStream",
2126 Layout {
2127 size: size_of::<GUnixInputStream>(),
2128 alignment: align_of::<GUnixInputStream>(),
2129 },
2130 ),
2131 (
2132 "GUnixInputStreamClass",
2133 Layout {
2134 size: size_of::<GUnixInputStreamClass>(),
2135 alignment: align_of::<GUnixInputStreamClass>(),
2136 },
2137 ),
2138 (
2139 "GUnixOutputStream",
2140 Layout {
2141 size: size_of::<GUnixOutputStream>(),
2142 alignment: align_of::<GUnixOutputStream>(),
2143 },
2144 ),
2145 (
2146 "GUnixOutputStreamClass",
2147 Layout {
2148 size: size_of::<GUnixOutputStreamClass>(),
2149 alignment: align_of::<GUnixOutputStreamClass>(),
2150 },
2151 ),
2152 (
2153 "GUnixSocketAddress",
2154 Layout {
2155 size: size_of::<GUnixSocketAddress>(),
2156 alignment: align_of::<GUnixSocketAddress>(),
2157 },
2158 ),
2159 (
2160 "GUnixSocketAddressClass",
2161 Layout {
2162 size: size_of::<GUnixSocketAddressClass>(),
2163 alignment: align_of::<GUnixSocketAddressClass>(),
2164 },
2165 ),
2166 (
2167 "GUnixSocketAddressType",
2168 Layout {
2169 size: size_of::<GUnixSocketAddressType>(),
2170 alignment: align_of::<GUnixSocketAddressType>(),
2171 },
2172 ),
2173 (
2174 "GVfs",
2175 Layout {
2176 size: size_of::<GVfs>(),
2177 alignment: align_of::<GVfs>(),
2178 },
2179 ),
2180 (
2181 "GVfsClass",
2182 Layout {
2183 size: size_of::<GVfsClass>(),
2184 alignment: align_of::<GVfsClass>(),
2185 },
2186 ),
2187 (
2188 "GVolumeIface",
2189 Layout {
2190 size: size_of::<GVolumeIface>(),
2191 alignment: align_of::<GVolumeIface>(),
2192 },
2193 ),
2194 (
2195 "GVolumeMonitor",
2196 Layout {
2197 size: size_of::<GVolumeMonitor>(),
2198 alignment: align_of::<GVolumeMonitor>(),
2199 },
2200 ),
2201 (
2202 "GVolumeMonitorClass",
2203 Layout {
2204 size: size_of::<GVolumeMonitorClass>(),
2205 alignment: align_of::<GVolumeMonitorClass>(),
2206 },
2207 ),
2208 (
2209 "GZlibCompressorClass",
2210 Layout {
2211 size: size_of::<GZlibCompressorClass>(),
2212 alignment: align_of::<GZlibCompressorClass>(),
2213 },
2214 ),
2215 (
2216 "GZlibCompressorFormat",
2217 Layout {
2218 size: size_of::<GZlibCompressorFormat>(),
2219 alignment: align_of::<GZlibCompressorFormat>(),
2220 },
2221 ),
2222 (
2223 "GZlibDecompressorClass",
2224 Layout {
2225 size: size_of::<GZlibDecompressorClass>(),
2226 alignment: align_of::<GZlibDecompressorClass>(),
2227 },
2228 ),
2229 ];
2230
2231 const RUST_CONSTANTS: &[(&str, &str)] = &[
2232 ("(guint) G_APPLICATION_ALLOW_REPLACEMENT", "128"),
2233 ("(guint) G_APPLICATION_CAN_OVERRIDE_APP_ID", "64"),
2234 ("(guint) G_APPLICATION_FLAGS_NONE", "0"),
2235 ("(guint) G_APPLICATION_HANDLES_COMMAND_LINE", "8"),
2236 ("(guint) G_APPLICATION_HANDLES_OPEN", "4"),
2237 ("(guint) G_APPLICATION_IS_LAUNCHER", "2"),
2238 ("(guint) G_APPLICATION_IS_SERVICE", "1"),
2239 ("(guint) G_APPLICATION_NON_UNIQUE", "32"),
2240 ("(guint) G_APPLICATION_REPLACE", "256"),
2241 ("(guint) G_APPLICATION_SEND_ENVIRONMENT", "16"),
2242 ("(guint) G_APP_INFO_CREATE_NEEDS_TERMINAL", "1"),
2243 ("(guint) G_APP_INFO_CREATE_NONE", "0"),
2244 (
2245 "(guint) G_APP_INFO_CREATE_SUPPORTS_STARTUP_NOTIFICATION",
2246 "4",
2247 ),
2248 ("(guint) G_APP_INFO_CREATE_SUPPORTS_URIS", "2"),
2249 ("(guint) G_ASK_PASSWORD_ANONYMOUS_SUPPORTED", "16"),
2250 ("(guint) G_ASK_PASSWORD_NEED_DOMAIN", "4"),
2251 ("(guint) G_ASK_PASSWORD_NEED_PASSWORD", "1"),
2252 ("(guint) G_ASK_PASSWORD_NEED_USERNAME", "2"),
2253 ("(guint) G_ASK_PASSWORD_SAVING_SUPPORTED", "8"),
2254 ("(guint) G_ASK_PASSWORD_TCRYPT", "32"),
2255 ("(guint) G_BUS_NAME_OWNER_FLAGS_ALLOW_REPLACEMENT", "1"),
2256 ("(guint) G_BUS_NAME_OWNER_FLAGS_DO_NOT_QUEUE", "4"),
2257 ("(guint) G_BUS_NAME_OWNER_FLAGS_NONE", "0"),
2258 ("(guint) G_BUS_NAME_OWNER_FLAGS_REPLACE", "2"),
2259 ("(guint) G_BUS_NAME_WATCHER_FLAGS_AUTO_START", "1"),
2260 ("(guint) G_BUS_NAME_WATCHER_FLAGS_NONE", "0"),
2261 ("(gint) G_BUS_TYPE_NONE", "0"),
2262 ("(gint) G_BUS_TYPE_SESSION", "2"),
2263 ("(gint) G_BUS_TYPE_STARTER", "-1"),
2264 ("(gint) G_BUS_TYPE_SYSTEM", "1"),
2265 ("(gint) G_CONVERTER_CONVERTED", "1"),
2266 ("(gint) G_CONVERTER_ERROR", "0"),
2267 ("(gint) G_CONVERTER_FINISHED", "2"),
2268 ("(guint) G_CONVERTER_FLUSH", "2"),
2269 ("(gint) G_CONVERTER_FLUSHED", "3"),
2270 ("(guint) G_CONVERTER_INPUT_AT_END", "1"),
2271 ("(guint) G_CONVERTER_NO_FLAGS", "0"),
2272 ("(gint) G_CREDENTIALS_TYPE_APPLE_XUCRED", "6"),
2273 ("(gint) G_CREDENTIALS_TYPE_FREEBSD_CMSGCRED", "2"),
2274 ("(gint) G_CREDENTIALS_TYPE_INVALID", "0"),
2275 ("(gint) G_CREDENTIALS_TYPE_LINUX_UCRED", "1"),
2276 ("(gint) G_CREDENTIALS_TYPE_NETBSD_UNPCBID", "5"),
2277 ("(gint) G_CREDENTIALS_TYPE_OPENBSD_SOCKPEERCRED", "3"),
2278 ("(gint) G_CREDENTIALS_TYPE_SOLARIS_UCRED", "4"),
2279 ("(gint) G_DATA_STREAM_BYTE_ORDER_BIG_ENDIAN", "0"),
2280 ("(gint) G_DATA_STREAM_BYTE_ORDER_HOST_ENDIAN", "2"),
2281 ("(gint) G_DATA_STREAM_BYTE_ORDER_LITTLE_ENDIAN", "1"),
2282 ("(gint) G_DATA_STREAM_NEWLINE_TYPE_ANY", "3"),
2283 ("(gint) G_DATA_STREAM_NEWLINE_TYPE_CR", "1"),
2284 ("(gint) G_DATA_STREAM_NEWLINE_TYPE_CR_LF", "2"),
2285 ("(gint) G_DATA_STREAM_NEWLINE_TYPE_LF", "0"),
2286 (
2287 "(guint) G_DBUS_CALL_FLAGS_ALLOW_INTERACTIVE_AUTHORIZATION",
2288 "2",
2289 ),
2290 ("(guint) G_DBUS_CALL_FLAGS_NONE", "0"),
2291 ("(guint) G_DBUS_CALL_FLAGS_NO_AUTO_START", "1"),
2292 ("(guint) G_DBUS_CAPABILITY_FLAGS_NONE", "0"),
2293 ("(guint) G_DBUS_CAPABILITY_FLAGS_UNIX_FD_PASSING", "1"),
2294 (
2295 "(guint) G_DBUS_CONNECTION_FLAGS_AUTHENTICATION_ALLOW_ANONYMOUS",
2296 "4",
2297 ),
2298 ("(guint) G_DBUS_CONNECTION_FLAGS_AUTHENTICATION_CLIENT", "1"),
2299 ("(guint) G_DBUS_CONNECTION_FLAGS_AUTHENTICATION_SERVER", "2"),
2300 (
2301 "(guint) G_DBUS_CONNECTION_FLAGS_DELAY_MESSAGE_PROCESSING",
2302 "16",
2303 ),
2304 (
2305 "(guint) G_DBUS_CONNECTION_FLAGS_MESSAGE_BUS_CONNECTION",
2306 "8",
2307 ),
2308 ("(guint) G_DBUS_CONNECTION_FLAGS_NONE", "0"),
2309 ("(gint) G_DBUS_ERROR_ACCESS_DENIED", "9"),
2310 ("(gint) G_DBUS_ERROR_ADDRESS_IN_USE", "14"),
2311 ("(gint) G_DBUS_ERROR_ADT_AUDIT_DATA_UNKNOWN", "39"),
2312 ("(gint) G_DBUS_ERROR_AUTH_FAILED", "10"),
2313 ("(gint) G_DBUS_ERROR_BAD_ADDRESS", "6"),
2314 ("(gint) G_DBUS_ERROR_DISCONNECTED", "15"),
2315 ("(gint) G_DBUS_ERROR_FAILED", "0"),
2316 ("(gint) G_DBUS_ERROR_FILE_EXISTS", "18"),
2317 ("(gint) G_DBUS_ERROR_FILE_NOT_FOUND", "17"),
2318 ("(gint) G_DBUS_ERROR_INVALID_ARGS", "16"),
2319 ("(gint) G_DBUS_ERROR_INVALID_FILE_CONTENT", "37"),
2320 ("(gint) G_DBUS_ERROR_INVALID_SIGNATURE", "36"),
2321 ("(gint) G_DBUS_ERROR_IO_ERROR", "5"),
2322 ("(gint) G_DBUS_ERROR_LIMITS_EXCEEDED", "8"),
2323 ("(gint) G_DBUS_ERROR_MATCH_RULE_INVALID", "22"),
2324 ("(gint) G_DBUS_ERROR_MATCH_RULE_NOT_FOUND", "21"),
2325 ("(gint) G_DBUS_ERROR_NAME_HAS_NO_OWNER", "3"),
2326 ("(gint) G_DBUS_ERROR_NOT_SUPPORTED", "7"),
2327 ("(gint) G_DBUS_ERROR_NO_MEMORY", "1"),
2328 ("(gint) G_DBUS_ERROR_NO_NETWORK", "13"),
2329 ("(gint) G_DBUS_ERROR_NO_REPLY", "4"),
2330 ("(gint) G_DBUS_ERROR_NO_SERVER", "11"),
2331 ("(gint) G_DBUS_ERROR_OBJECT_PATH_IN_USE", "40"),
2332 ("(gint) G_DBUS_ERROR_PROPERTY_READ_ONLY", "44"),
2333 ("(gint) G_DBUS_ERROR_SELINUX_SECURITY_CONTEXT_UNKNOWN", "38"),
2334 ("(gint) G_DBUS_ERROR_SERVICE_UNKNOWN", "2"),
2335 ("(gint) G_DBUS_ERROR_SPAWN_CHILD_EXITED", "25"),
2336 ("(gint) G_DBUS_ERROR_SPAWN_CHILD_SIGNALED", "26"),
2337 ("(gint) G_DBUS_ERROR_SPAWN_CONFIG_INVALID", "29"),
2338 ("(gint) G_DBUS_ERROR_SPAWN_EXEC_FAILED", "23"),
2339 ("(gint) G_DBUS_ERROR_SPAWN_FAILED", "27"),
2340 ("(gint) G_DBUS_ERROR_SPAWN_FILE_INVALID", "33"),
2341 ("(gint) G_DBUS_ERROR_SPAWN_FORK_FAILED", "24"),
2342 ("(gint) G_DBUS_ERROR_SPAWN_NO_MEMORY", "34"),
2343 ("(gint) G_DBUS_ERROR_SPAWN_PERMISSIONS_INVALID", "32"),
2344 ("(gint) G_DBUS_ERROR_SPAWN_SERVICE_INVALID", "30"),
2345 ("(gint) G_DBUS_ERROR_SPAWN_SERVICE_NOT_FOUND", "31"),
2346 ("(gint) G_DBUS_ERROR_SPAWN_SETUP_FAILED", "28"),
2347 ("(gint) G_DBUS_ERROR_TIMED_OUT", "20"),
2348 ("(gint) G_DBUS_ERROR_TIMEOUT", "12"),
2349 ("(gint) G_DBUS_ERROR_UNIX_PROCESS_ID_UNKNOWN", "35"),
2350 ("(gint) G_DBUS_ERROR_UNKNOWN_INTERFACE", "42"),
2351 ("(gint) G_DBUS_ERROR_UNKNOWN_METHOD", "19"),
2352 ("(gint) G_DBUS_ERROR_UNKNOWN_OBJECT", "41"),
2353 ("(gint) G_DBUS_ERROR_UNKNOWN_PROPERTY", "43"),
2354 (
2355 "(guint) G_DBUS_INTERFACE_SKELETON_FLAGS_HANDLE_METHOD_INVOCATIONS_IN_THREAD",
2356 "1",
2357 ),
2358 ("(guint) G_DBUS_INTERFACE_SKELETON_FLAGS_NONE", "0"),
2359 ("(gint) G_DBUS_MESSAGE_BYTE_ORDER_BIG_ENDIAN", "66"),
2360 ("(gint) G_DBUS_MESSAGE_BYTE_ORDER_LITTLE_ENDIAN", "108"),
2361 (
2362 "(guint) G_DBUS_MESSAGE_FLAGS_ALLOW_INTERACTIVE_AUTHORIZATION",
2363 "4",
2364 ),
2365 ("(guint) G_DBUS_MESSAGE_FLAGS_NONE", "0"),
2366 ("(guint) G_DBUS_MESSAGE_FLAGS_NO_AUTO_START", "2"),
2367 ("(guint) G_DBUS_MESSAGE_FLAGS_NO_REPLY_EXPECTED", "1"),
2368 ("(gint) G_DBUS_MESSAGE_HEADER_FIELD_DESTINATION", "6"),
2369 ("(gint) G_DBUS_MESSAGE_HEADER_FIELD_ERROR_NAME", "4"),
2370 ("(gint) G_DBUS_MESSAGE_HEADER_FIELD_INTERFACE", "2"),
2371 ("(gint) G_DBUS_MESSAGE_HEADER_FIELD_INVALID", "0"),
2372 ("(gint) G_DBUS_MESSAGE_HEADER_FIELD_MEMBER", "3"),
2373 ("(gint) G_DBUS_MESSAGE_HEADER_FIELD_NUM_UNIX_FDS", "9"),
2374 ("(gint) G_DBUS_MESSAGE_HEADER_FIELD_PATH", "1"),
2375 ("(gint) G_DBUS_MESSAGE_HEADER_FIELD_REPLY_SERIAL", "5"),
2376 ("(gint) G_DBUS_MESSAGE_HEADER_FIELD_SENDER", "7"),
2377 ("(gint) G_DBUS_MESSAGE_HEADER_FIELD_SIGNATURE", "8"),
2378 ("(gint) G_DBUS_MESSAGE_TYPE_ERROR", "3"),
2379 ("(gint) G_DBUS_MESSAGE_TYPE_INVALID", "0"),
2380 ("(gint) G_DBUS_MESSAGE_TYPE_METHOD_CALL", "1"),
2381 ("(gint) G_DBUS_MESSAGE_TYPE_METHOD_RETURN", "2"),
2382 ("(gint) G_DBUS_MESSAGE_TYPE_SIGNAL", "4"),
2383 (
2384 "(guint) G_DBUS_OBJECT_MANAGER_CLIENT_FLAGS_DO_NOT_AUTO_START",
2385 "1",
2386 ),
2387 ("(guint) G_DBUS_OBJECT_MANAGER_CLIENT_FLAGS_NONE", "0"),
2388 ("(guint) G_DBUS_PROPERTY_INFO_FLAGS_NONE", "0"),
2389 ("(guint) G_DBUS_PROPERTY_INFO_FLAGS_READABLE", "1"),
2390 ("(guint) G_DBUS_PROPERTY_INFO_FLAGS_WRITABLE", "2"),
2391 ("(guint) G_DBUS_PROXY_FLAGS_DO_NOT_AUTO_START", "4"),
2392 (
2393 "(guint) G_DBUS_PROXY_FLAGS_DO_NOT_AUTO_START_AT_CONSTRUCTION",
2394 "16",
2395 ),
2396 ("(guint) G_DBUS_PROXY_FLAGS_DO_NOT_CONNECT_SIGNALS", "2"),
2397 ("(guint) G_DBUS_PROXY_FLAGS_DO_NOT_LOAD_PROPERTIES", "1"),
2398 ("(guint) G_DBUS_PROXY_FLAGS_GET_INVALIDATED_PROPERTIES", "8"),
2399 ("(guint) G_DBUS_PROXY_FLAGS_NONE", "0"),
2400 ("(guint) G_DBUS_SEND_MESSAGE_FLAGS_NONE", "0"),
2401 ("(guint) G_DBUS_SEND_MESSAGE_FLAGS_PRESERVE_SERIAL", "1"),
2402 (
2403 "(guint) G_DBUS_SERVER_FLAGS_AUTHENTICATION_ALLOW_ANONYMOUS",
2404 "2",
2405 ),
2406 ("(guint) G_DBUS_SERVER_FLAGS_NONE", "0"),
2407 ("(guint) G_DBUS_SERVER_FLAGS_RUN_IN_THREAD", "1"),
2408 ("(guint) G_DBUS_SIGNAL_FLAGS_MATCH_ARG0_NAMESPACE", "2"),
2409 ("(guint) G_DBUS_SIGNAL_FLAGS_MATCH_ARG0_PATH", "4"),
2410 ("(guint) G_DBUS_SIGNAL_FLAGS_NONE", "0"),
2411 ("(guint) G_DBUS_SIGNAL_FLAGS_NO_MATCH_RULE", "1"),
2412 (
2413 "(guint) G_DBUS_SUBTREE_FLAGS_DISPATCH_TO_UNENUMERATED_NODES",
2414 "1",
2415 ),
2416 ("(guint) G_DBUS_SUBTREE_FLAGS_NONE", "0"),
2417 (
2418 "G_DESKTOP_APP_INFO_LOOKUP_EXTENSION_POINT_NAME",
2419 "gio-desktop-app-info-lookup",
2420 ),
2421 ("G_DRIVE_IDENTIFIER_KIND_UNIX_DEVICE", "unix-device"),
2422 ("(guint) G_DRIVE_START_NONE", "0"),
2423 ("(gint) G_DRIVE_START_STOP_TYPE_MULTIDISK", "3"),
2424 ("(gint) G_DRIVE_START_STOP_TYPE_NETWORK", "2"),
2425 ("(gint) G_DRIVE_START_STOP_TYPE_PASSWORD", "4"),
2426 ("(gint) G_DRIVE_START_STOP_TYPE_SHUTDOWN", "1"),
2427 ("(gint) G_DRIVE_START_STOP_TYPE_UNKNOWN", "0"),
2428 ("(gint) G_EMBLEM_ORIGIN_DEVICE", "1"),
2429 ("(gint) G_EMBLEM_ORIGIN_LIVEMETADATA", "2"),
2430 ("(gint) G_EMBLEM_ORIGIN_TAG", "3"),
2431 ("(gint) G_EMBLEM_ORIGIN_UNKNOWN", "0"),
2432 ("(gint) G_FILESYSTEM_PREVIEW_TYPE_IF_ALWAYS", "0"),
2433 ("(gint) G_FILESYSTEM_PREVIEW_TYPE_IF_LOCAL", "1"),
2434 ("(gint) G_FILESYSTEM_PREVIEW_TYPE_NEVER", "2"),
2435 ("G_FILE_ATTRIBUTE_ACCESS_CAN_DELETE", "access::can-delete"),
2436 ("G_FILE_ATTRIBUTE_ACCESS_CAN_EXECUTE", "access::can-execute"),
2437 ("G_FILE_ATTRIBUTE_ACCESS_CAN_READ", "access::can-read"),
2438 ("G_FILE_ATTRIBUTE_ACCESS_CAN_RENAME", "access::can-rename"),
2439 ("G_FILE_ATTRIBUTE_ACCESS_CAN_TRASH", "access::can-trash"),
2440 ("G_FILE_ATTRIBUTE_ACCESS_CAN_WRITE", "access::can-write"),
2441 ("G_FILE_ATTRIBUTE_DOS_IS_ARCHIVE", "dos::is-archive"),
2442 ("G_FILE_ATTRIBUTE_DOS_IS_MOUNTPOINT", "dos::is-mountpoint"),
2443 ("G_FILE_ATTRIBUTE_DOS_IS_SYSTEM", "dos::is-system"),
2444 (
2445 "G_FILE_ATTRIBUTE_DOS_REPARSE_POINT_TAG",
2446 "dos::reparse-point-tag",
2447 ),
2448 ("G_FILE_ATTRIBUTE_ETAG_VALUE", "etag::value"),
2449 ("G_FILE_ATTRIBUTE_FILESYSTEM_FREE", "filesystem::free"),
2450 (
2451 "G_FILE_ATTRIBUTE_FILESYSTEM_READONLY",
2452 "filesystem::readonly",
2453 ),
2454 ("G_FILE_ATTRIBUTE_FILESYSTEM_REMOTE", "filesystem::remote"),
2455 ("G_FILE_ATTRIBUTE_FILESYSTEM_SIZE", "filesystem::size"),
2456 ("G_FILE_ATTRIBUTE_FILESYSTEM_TYPE", "filesystem::type"),
2457 ("G_FILE_ATTRIBUTE_FILESYSTEM_USED", "filesystem::used"),
2458 (
2459 "G_FILE_ATTRIBUTE_FILESYSTEM_USE_PREVIEW",
2460 "filesystem::use-preview",
2461 ),
2462 ("G_FILE_ATTRIBUTE_GVFS_BACKEND", "gvfs::backend"),
2463 ("G_FILE_ATTRIBUTE_ID_FILE", "id::file"),
2464 ("G_FILE_ATTRIBUTE_ID_FILESYSTEM", "id::filesystem"),
2465 ("(guint) G_FILE_ATTRIBUTE_INFO_COPY_WHEN_MOVED", "2"),
2466 ("(guint) G_FILE_ATTRIBUTE_INFO_COPY_WITH_FILE", "1"),
2467 ("(guint) G_FILE_ATTRIBUTE_INFO_NONE", "0"),
2468 (
2469 "G_FILE_ATTRIBUTE_MOUNTABLE_CAN_EJECT",
2470 "mountable::can-eject",
2471 ),
2472 (
2473 "G_FILE_ATTRIBUTE_MOUNTABLE_CAN_MOUNT",
2474 "mountable::can-mount",
2475 ),
2476 ("G_FILE_ATTRIBUTE_MOUNTABLE_CAN_POLL", "mountable::can-poll"),
2477 (
2478 "G_FILE_ATTRIBUTE_MOUNTABLE_CAN_START",
2479 "mountable::can-start",
2480 ),
2481 (
2482 "G_FILE_ATTRIBUTE_MOUNTABLE_CAN_START_DEGRADED",
2483 "mountable::can-start-degraded",
2484 ),
2485 ("G_FILE_ATTRIBUTE_MOUNTABLE_CAN_STOP", "mountable::can-stop"),
2486 (
2487 "G_FILE_ATTRIBUTE_MOUNTABLE_CAN_UNMOUNT",
2488 "mountable::can-unmount",
2489 ),
2490 ("G_FILE_ATTRIBUTE_MOUNTABLE_HAL_UDI", "mountable::hal-udi"),
2491 (
2492 "G_FILE_ATTRIBUTE_MOUNTABLE_IS_MEDIA_CHECK_AUTOMATIC",
2493 "mountable::is-media-check-automatic",
2494 ),
2495 (
2496 "G_FILE_ATTRIBUTE_MOUNTABLE_START_STOP_TYPE",
2497 "mountable::start-stop-type",
2498 ),
2499 (
2500 "G_FILE_ATTRIBUTE_MOUNTABLE_UNIX_DEVICE",
2501 "mountable::unix-device",
2502 ),
2503 (
2504 "G_FILE_ATTRIBUTE_MOUNTABLE_UNIX_DEVICE_FILE",
2505 "mountable::unix-device-file",
2506 ),
2507 ("G_FILE_ATTRIBUTE_OWNER_GROUP", "owner::group"),
2508 ("G_FILE_ATTRIBUTE_OWNER_USER", "owner::user"),
2509 ("G_FILE_ATTRIBUTE_OWNER_USER_REAL", "owner::user-real"),
2510 ("G_FILE_ATTRIBUTE_PREVIEW_ICON", "preview::icon"),
2511 ("G_FILE_ATTRIBUTE_RECENT_MODIFIED", "recent::modified"),
2512 ("G_FILE_ATTRIBUTE_SELINUX_CONTEXT", "selinux::context"),
2513 (
2514 "G_FILE_ATTRIBUTE_STANDARD_ALLOCATED_SIZE",
2515 "standard::allocated-size",
2516 ),
2517 (
2518 "G_FILE_ATTRIBUTE_STANDARD_CONTENT_TYPE",
2519 "standard::content-type",
2520 ),
2521 ("G_FILE_ATTRIBUTE_STANDARD_COPY_NAME", "standard::copy-name"),
2522 (
2523 "G_FILE_ATTRIBUTE_STANDARD_DESCRIPTION",
2524 "standard::description",
2525 ),
2526 (
2527 "G_FILE_ATTRIBUTE_STANDARD_DISPLAY_NAME",
2528 "standard::display-name",
2529 ),
2530 ("G_FILE_ATTRIBUTE_STANDARD_EDIT_NAME", "standard::edit-name"),
2531 (
2532 "G_FILE_ATTRIBUTE_STANDARD_FAST_CONTENT_TYPE",
2533 "standard::fast-content-type",
2534 ),
2535 ("G_FILE_ATTRIBUTE_STANDARD_ICON", "standard::icon"),
2536 ("G_FILE_ATTRIBUTE_STANDARD_IS_BACKUP", "standard::is-backup"),
2537 ("G_FILE_ATTRIBUTE_STANDARD_IS_HIDDEN", "standard::is-hidden"),
2538 (
2539 "G_FILE_ATTRIBUTE_STANDARD_IS_SYMLINK",
2540 "standard::is-symlink",
2541 ),
2542 (
2543 "G_FILE_ATTRIBUTE_STANDARD_IS_VIRTUAL",
2544 "standard::is-virtual",
2545 ),
2546 (
2547 "G_FILE_ATTRIBUTE_STANDARD_IS_VOLATILE",
2548 "standard::is-volatile",
2549 ),
2550 ("G_FILE_ATTRIBUTE_STANDARD_NAME", "standard::name"),
2551 ("G_FILE_ATTRIBUTE_STANDARD_SIZE", "standard::size"),
2552 (
2553 "G_FILE_ATTRIBUTE_STANDARD_SORT_ORDER",
2554 "standard::sort-order",
2555 ),
2556 (
2557 "G_FILE_ATTRIBUTE_STANDARD_SYMBOLIC_ICON",
2558 "standard::symbolic-icon",
2559 ),
2560 (
2561 "G_FILE_ATTRIBUTE_STANDARD_SYMLINK_TARGET",
2562 "standard::symlink-target",
2563 ),
2564 (
2565 "G_FILE_ATTRIBUTE_STANDARD_TARGET_URI",
2566 "standard::target-uri",
2567 ),
2568 ("G_FILE_ATTRIBUTE_STANDARD_TYPE", "standard::type"),
2569 ("(gint) G_FILE_ATTRIBUTE_STATUS_ERROR_SETTING", "2"),
2570 ("(gint) G_FILE_ATTRIBUTE_STATUS_SET", "1"),
2571 ("(gint) G_FILE_ATTRIBUTE_STATUS_UNSET", "0"),
2572 ("G_FILE_ATTRIBUTE_THUMBNAILING_FAILED", "thumbnail::failed"),
2573 ("G_FILE_ATTRIBUTE_THUMBNAIL_IS_VALID", "thumbnail::is-valid"),
2574 ("G_FILE_ATTRIBUTE_THUMBNAIL_PATH", "thumbnail::path"),
2575 ("G_FILE_ATTRIBUTE_TIME_ACCESS", "time::access"),
2576 ("G_FILE_ATTRIBUTE_TIME_ACCESS_USEC", "time::access-usec"),
2577 ("G_FILE_ATTRIBUTE_TIME_CHANGED", "time::changed"),
2578 ("G_FILE_ATTRIBUTE_TIME_CHANGED_USEC", "time::changed-usec"),
2579 ("G_FILE_ATTRIBUTE_TIME_CREATED", "time::created"),
2580 ("G_FILE_ATTRIBUTE_TIME_CREATED_USEC", "time::created-usec"),
2581 ("G_FILE_ATTRIBUTE_TIME_MODIFIED", "time::modified"),
2582 ("G_FILE_ATTRIBUTE_TIME_MODIFIED_USEC", "time::modified-usec"),
2583 (
2584 "G_FILE_ATTRIBUTE_TRASH_DELETION_DATE",
2585 "trash::deletion-date",
2586 ),
2587 ("G_FILE_ATTRIBUTE_TRASH_ITEM_COUNT", "trash::item-count"),
2588 ("G_FILE_ATTRIBUTE_TRASH_ORIG_PATH", "trash::orig-path"),
2589 ("(gint) G_FILE_ATTRIBUTE_TYPE_BOOLEAN", "3"),
2590 ("(gint) G_FILE_ATTRIBUTE_TYPE_BYTE_STRING", "2"),
2591 ("(gint) G_FILE_ATTRIBUTE_TYPE_INT32", "5"),
2592 ("(gint) G_FILE_ATTRIBUTE_TYPE_INT64", "7"),
2593 ("(gint) G_FILE_ATTRIBUTE_TYPE_INVALID", "0"),
2594 ("(gint) G_FILE_ATTRIBUTE_TYPE_OBJECT", "8"),
2595 ("(gint) G_FILE_ATTRIBUTE_TYPE_STRING", "1"),
2596 ("(gint) G_FILE_ATTRIBUTE_TYPE_STRINGV", "9"),
2597 ("(gint) G_FILE_ATTRIBUTE_TYPE_UINT32", "4"),
2598 ("(gint) G_FILE_ATTRIBUTE_TYPE_UINT64", "6"),
2599 ("G_FILE_ATTRIBUTE_UNIX_BLOCKS", "unix::blocks"),
2600 ("G_FILE_ATTRIBUTE_UNIX_BLOCK_SIZE", "unix::block-size"),
2601 ("G_FILE_ATTRIBUTE_UNIX_DEVICE", "unix::device"),
2602 ("G_FILE_ATTRIBUTE_UNIX_GID", "unix::gid"),
2603 ("G_FILE_ATTRIBUTE_UNIX_INODE", "unix::inode"),
2604 ("G_FILE_ATTRIBUTE_UNIX_IS_MOUNTPOINT", "unix::is-mountpoint"),
2605 ("G_FILE_ATTRIBUTE_UNIX_MODE", "unix::mode"),
2606 ("G_FILE_ATTRIBUTE_UNIX_NLINK", "unix::nlink"),
2607 ("G_FILE_ATTRIBUTE_UNIX_RDEV", "unix::rdev"),
2608 ("G_FILE_ATTRIBUTE_UNIX_UID", "unix::uid"),
2609 ("(guint) G_FILE_COPY_ALL_METADATA", "8"),
2610 ("(guint) G_FILE_COPY_BACKUP", "2"),
2611 ("(guint) G_FILE_COPY_NOFOLLOW_SYMLINKS", "4"),
2612 ("(guint) G_FILE_COPY_NONE", "0"),
2613 ("(guint) G_FILE_COPY_NO_FALLBACK_FOR_MOVE", "16"),
2614 ("(guint) G_FILE_COPY_OVERWRITE", "1"),
2615 ("(guint) G_FILE_COPY_TARGET_DEFAULT_PERMS", "32"),
2616 ("(guint) G_FILE_CREATE_NONE", "0"),
2617 ("(guint) G_FILE_CREATE_PRIVATE", "1"),
2618 ("(guint) G_FILE_CREATE_REPLACE_DESTINATION", "2"),
2619 ("(guint) G_FILE_MEASURE_APPARENT_SIZE", "4"),
2620 ("(guint) G_FILE_MEASURE_NONE", "0"),
2621 ("(guint) G_FILE_MEASURE_NO_XDEV", "8"),
2622 ("(guint) G_FILE_MEASURE_REPORT_ANY_ERROR", "2"),
2623 ("(gint) G_FILE_MONITOR_EVENT_ATTRIBUTE_CHANGED", "4"),
2624 ("(gint) G_FILE_MONITOR_EVENT_CHANGED", "0"),
2625 ("(gint) G_FILE_MONITOR_EVENT_CHANGES_DONE_HINT", "1"),
2626 ("(gint) G_FILE_MONITOR_EVENT_CREATED", "3"),
2627 ("(gint) G_FILE_MONITOR_EVENT_DELETED", "2"),
2628 ("(gint) G_FILE_MONITOR_EVENT_MOVED", "7"),
2629 ("(gint) G_FILE_MONITOR_EVENT_MOVED_IN", "9"),
2630 ("(gint) G_FILE_MONITOR_EVENT_MOVED_OUT", "10"),
2631 ("(gint) G_FILE_MONITOR_EVENT_PRE_UNMOUNT", "5"),
2632 ("(gint) G_FILE_MONITOR_EVENT_RENAMED", "8"),
2633 ("(gint) G_FILE_MONITOR_EVENT_UNMOUNTED", "6"),
2634 ("(guint) G_FILE_MONITOR_NONE", "0"),
2635 ("(guint) G_FILE_MONITOR_SEND_MOVED", "2"),
2636 ("(guint) G_FILE_MONITOR_WATCH_HARD_LINKS", "4"),
2637 ("(guint) G_FILE_MONITOR_WATCH_MOUNTS", "1"),
2638 ("(guint) G_FILE_MONITOR_WATCH_MOVES", "8"),
2639 ("(guint) G_FILE_QUERY_INFO_NOFOLLOW_SYMLINKS", "1"),
2640 ("(guint) G_FILE_QUERY_INFO_NONE", "0"),
2641 ("(gint) G_FILE_TYPE_DIRECTORY", "2"),
2642 ("(gint) G_FILE_TYPE_MOUNTABLE", "6"),
2643 ("(gint) G_FILE_TYPE_REGULAR", "1"),
2644 ("(gint) G_FILE_TYPE_SHORTCUT", "5"),
2645 ("(gint) G_FILE_TYPE_SPECIAL", "4"),
2646 ("(gint) G_FILE_TYPE_SYMBOLIC_LINK", "3"),
2647 ("(gint) G_FILE_TYPE_UNKNOWN", "0"),
2648 ("(gint) G_IO_ERROR_ADDRESS_IN_USE", "33"),
2649 ("(gint) G_IO_ERROR_ALREADY_MOUNTED", "17"),
2650 ("(gint) G_IO_ERROR_BROKEN_PIPE", "44"),
2651 ("(gint) G_IO_ERROR_BUSY", "26"),
2652 ("(gint) G_IO_ERROR_CANCELLED", "19"),
2653 ("(gint) G_IO_ERROR_CANT_CREATE_BACKUP", "22"),
2654 ("(gint) G_IO_ERROR_CLOSED", "18"),
2655 ("(gint) G_IO_ERROR_CONNECTION_CLOSED", "44"),
2656 ("(gint) G_IO_ERROR_CONNECTION_REFUSED", "39"),
2657 ("(gint) G_IO_ERROR_DBUS_ERROR", "36"),
2658 ("(gint) G_IO_ERROR_EXISTS", "2"),
2659 ("(gint) G_IO_ERROR_FAILED", "0"),
2660 ("(gint) G_IO_ERROR_FAILED_HANDLED", "30"),
2661 ("(gint) G_IO_ERROR_FILENAME_TOO_LONG", "9"),
2662 ("(gint) G_IO_ERROR_HOST_NOT_FOUND", "28"),
2663 ("(gint) G_IO_ERROR_HOST_UNREACHABLE", "37"),
2664 ("(gint) G_IO_ERROR_INVALID_ARGUMENT", "13"),
2665 ("(gint) G_IO_ERROR_INVALID_DATA", "35"),
2666 ("(gint) G_IO_ERROR_INVALID_FILENAME", "10"),
2667 ("(gint) G_IO_ERROR_IS_DIRECTORY", "3"),
2668 ("(gint) G_IO_ERROR_MESSAGE_TOO_LARGE", "46"),
2669 ("(gint) G_IO_ERROR_NETWORK_UNREACHABLE", "38"),
2670 ("(gint) G_IO_ERROR_NOT_CONNECTED", "45"),
2671 ("(gint) G_IO_ERROR_NOT_DIRECTORY", "4"),
2672 ("(gint) G_IO_ERROR_NOT_EMPTY", "5"),
2673 ("(gint) G_IO_ERROR_NOT_FOUND", "1"),
2674 ("(gint) G_IO_ERROR_NOT_INITIALIZED", "32"),
2675 ("(gint) G_IO_ERROR_NOT_MOUNTABLE_FILE", "8"),
2676 ("(gint) G_IO_ERROR_NOT_MOUNTED", "16"),
2677 ("(gint) G_IO_ERROR_NOT_REGULAR_FILE", "6"),
2678 ("(gint) G_IO_ERROR_NOT_SUPPORTED", "15"),
2679 ("(gint) G_IO_ERROR_NOT_SYMBOLIC_LINK", "7"),
2680 ("(gint) G_IO_ERROR_NO_SPACE", "12"),
2681 ("(gint) G_IO_ERROR_PARTIAL_INPUT", "34"),
2682 ("(gint) G_IO_ERROR_PENDING", "20"),
2683 ("(gint) G_IO_ERROR_PERMISSION_DENIED", "14"),
2684 ("(gint) G_IO_ERROR_PROXY_AUTH_FAILED", "41"),
2685 ("(gint) G_IO_ERROR_PROXY_FAILED", "40"),
2686 ("(gint) G_IO_ERROR_PROXY_NEED_AUTH", "42"),
2687 ("(gint) G_IO_ERROR_PROXY_NOT_ALLOWED", "43"),
2688 ("(gint) G_IO_ERROR_READ_ONLY", "21"),
2689 ("(gint) G_IO_ERROR_TIMED_OUT", "24"),
2690 ("(gint) G_IO_ERROR_TOO_MANY_LINKS", "11"),
2691 ("(gint) G_IO_ERROR_TOO_MANY_OPEN_FILES", "31"),
2692 ("(gint) G_IO_ERROR_WOULD_BLOCK", "27"),
2693 ("(gint) G_IO_ERROR_WOULD_MERGE", "29"),
2694 ("(gint) G_IO_ERROR_WOULD_RECURSE", "25"),
2695 ("(gint) G_IO_ERROR_WRONG_ETAG", "23"),
2696 ("(gint) G_IO_MODULE_SCOPE_BLOCK_DUPLICATES", "1"),
2697 ("(gint) G_IO_MODULE_SCOPE_NONE", "0"),
2698 ("(guint) G_IO_STREAM_SPLICE_CLOSE_STREAM1", "1"),
2699 ("(guint) G_IO_STREAM_SPLICE_CLOSE_STREAM2", "2"),
2700 ("(guint) G_IO_STREAM_SPLICE_NONE", "0"),
2701 ("(guint) G_IO_STREAM_SPLICE_WAIT_FOR_BOTH", "4"),
2702 (
2703 "G_MEMORY_MONITOR_EXTENSION_POINT_NAME",
2704 "gio-memory-monitor",
2705 ),
2706 ("(gint) G_MEMORY_MONITOR_WARNING_LEVEL_CRITICAL", "255"),
2707 ("(gint) G_MEMORY_MONITOR_WARNING_LEVEL_LOW", "50"),
2708 ("(gint) G_MEMORY_MONITOR_WARNING_LEVEL_MEDIUM", "100"),
2709 ("G_MENU_ATTRIBUTE_ACTION", "action"),
2710 ("G_MENU_ATTRIBUTE_ACTION_NAMESPACE", "action-namespace"),
2711 ("G_MENU_ATTRIBUTE_ICON", "icon"),
2712 ("G_MENU_ATTRIBUTE_LABEL", "label"),
2713 ("G_MENU_ATTRIBUTE_TARGET", "target"),
2714 ("G_MENU_LINK_SECTION", "section"),
2715 ("G_MENU_LINK_SUBMENU", "submenu"),
2716 ("(guint) G_MOUNT_MOUNT_NONE", "0"),
2717 ("(gint) G_MOUNT_OPERATION_ABORTED", "1"),
2718 ("(gint) G_MOUNT_OPERATION_HANDLED", "0"),
2719 ("(gint) G_MOUNT_OPERATION_UNHANDLED", "2"),
2720 ("(guint) G_MOUNT_UNMOUNT_FORCE", "1"),
2721 ("(guint) G_MOUNT_UNMOUNT_NONE", "0"),
2722 (
2723 "G_NATIVE_VOLUME_MONITOR_EXTENSION_POINT_NAME",
2724 "gio-native-volume-monitor",
2725 ),
2726 ("(gint) G_NETWORK_CONNECTIVITY_FULL", "4"),
2727 ("(gint) G_NETWORK_CONNECTIVITY_LIMITED", "2"),
2728 ("(gint) G_NETWORK_CONNECTIVITY_LOCAL", "1"),
2729 ("(gint) G_NETWORK_CONNECTIVITY_PORTAL", "3"),
2730 (
2731 "G_NETWORK_MONITOR_EXTENSION_POINT_NAME",
2732 "gio-network-monitor",
2733 ),
2734 ("(gint) G_NOTIFICATION_PRIORITY_HIGH", "2"),
2735 ("(gint) G_NOTIFICATION_PRIORITY_LOW", "1"),
2736 ("(gint) G_NOTIFICATION_PRIORITY_NORMAL", "0"),
2737 ("(gint) G_NOTIFICATION_PRIORITY_URGENT", "3"),
2738 ("(guint) G_OUTPUT_STREAM_SPLICE_CLOSE_SOURCE", "1"),
2739 ("(guint) G_OUTPUT_STREAM_SPLICE_CLOSE_TARGET", "2"),
2740 ("(guint) G_OUTPUT_STREAM_SPLICE_NONE", "0"),
2741 ("(gint) G_PASSWORD_SAVE_FOR_SESSION", "1"),
2742 ("(gint) G_PASSWORD_SAVE_NEVER", "0"),
2743 ("(gint) G_PASSWORD_SAVE_PERMANENTLY", "2"),
2744 ("(gint) G_POLLABLE_RETURN_FAILED", "0"),
2745 ("(gint) G_POLLABLE_RETURN_OK", "1"),
2746 ("(gint) G_POLLABLE_RETURN_WOULD_BLOCK", "-27"),
2747 ("G_PROXY_EXTENSION_POINT_NAME", "gio-proxy"),
2748 (
2749 "G_PROXY_RESOLVER_EXTENSION_POINT_NAME",
2750 "gio-proxy-resolver",
2751 ),
2752 ("(gint) G_RESOLVER_ERROR_INTERNAL", "2"),
2753 ("(gint) G_RESOLVER_ERROR_NOT_FOUND", "0"),
2754 ("(gint) G_RESOLVER_ERROR_TEMPORARY_FAILURE", "1"),
2755 ("(guint) G_RESOLVER_NAME_LOOKUP_FLAGS_DEFAULT", "0"),
2756 ("(guint) G_RESOLVER_NAME_LOOKUP_FLAGS_IPV4_ONLY", "1"),
2757 ("(guint) G_RESOLVER_NAME_LOOKUP_FLAGS_IPV6_ONLY", "2"),
2758 ("(gint) G_RESOLVER_RECORD_MX", "2"),
2759 ("(gint) G_RESOLVER_RECORD_NS", "5"),
2760 ("(gint) G_RESOLVER_RECORD_SOA", "4"),
2761 ("(gint) G_RESOLVER_RECORD_SRV", "1"),
2762 ("(gint) G_RESOLVER_RECORD_TXT", "3"),
2763 ("(gint) G_RESOURCE_ERROR_INTERNAL", "1"),
2764 ("(gint) G_RESOURCE_ERROR_NOT_FOUND", "0"),
2765 ("(guint) G_RESOURCE_FLAGS_COMPRESSED", "1"),
2766 ("(guint) G_RESOURCE_FLAGS_NONE", "0"),
2767 ("(guint) G_RESOURCE_LOOKUP_FLAGS_NONE", "0"),
2768 (
2769 "G_SETTINGS_BACKEND_EXTENSION_POINT_NAME",
2770 "gsettings-backend",
2771 ),
2772 ("(guint) G_SETTINGS_BIND_DEFAULT", "0"),
2773 ("(guint) G_SETTINGS_BIND_GET", "1"),
2774 ("(guint) G_SETTINGS_BIND_GET_NO_CHANGES", "8"),
2775 ("(guint) G_SETTINGS_BIND_INVERT_BOOLEAN", "16"),
2776 ("(guint) G_SETTINGS_BIND_NO_SENSITIVITY", "4"),
2777 ("(guint) G_SETTINGS_BIND_SET", "2"),
2778 ("(gint) G_SOCKET_CLIENT_COMPLETE", "8"),
2779 ("(gint) G_SOCKET_CLIENT_CONNECTED", "3"),
2780 ("(gint) G_SOCKET_CLIENT_CONNECTING", "2"),
2781 ("(gint) G_SOCKET_CLIENT_PROXY_NEGOTIATED", "5"),
2782 ("(gint) G_SOCKET_CLIENT_PROXY_NEGOTIATING", "4"),
2783 ("(gint) G_SOCKET_CLIENT_RESOLVED", "1"),
2784 ("(gint) G_SOCKET_CLIENT_RESOLVING", "0"),
2785 ("(gint) G_SOCKET_CLIENT_TLS_HANDSHAKED", "7"),
2786 ("(gint) G_SOCKET_CLIENT_TLS_HANDSHAKING", "6"),
2787 ("(gint) G_SOCKET_FAMILY_INVALID", "0"),
2788 ("(gint) G_SOCKET_FAMILY_IPV4", "2"),
2789 ("(gint) G_SOCKET_FAMILY_IPV6", "10"),
2790 ("(gint) G_SOCKET_FAMILY_UNIX", "1"),
2791 ("(gint) G_SOCKET_LISTENER_BINDING", "0"),
2792 ("(gint) G_SOCKET_LISTENER_BOUND", "1"),
2793 ("(gint) G_SOCKET_LISTENER_LISTENED", "3"),
2794 ("(gint) G_SOCKET_LISTENER_LISTENING", "2"),
2795 ("(guint) G_SOCKET_MSG_DONTROUTE", "4"),
2796 ("(guint) G_SOCKET_MSG_NONE", "0"),
2797 ("(guint) G_SOCKET_MSG_OOB", "1"),
2798 ("(guint) G_SOCKET_MSG_PEEK", "2"),
2799 ("(gint) G_SOCKET_PROTOCOL_DEFAULT", "0"),
2800 ("(gint) G_SOCKET_PROTOCOL_SCTP", "132"),
2801 ("(gint) G_SOCKET_PROTOCOL_TCP", "6"),
2802 ("(gint) G_SOCKET_PROTOCOL_UDP", "17"),
2803 ("(gint) G_SOCKET_PROTOCOL_UNKNOWN", "-1"),
2804 ("(gint) G_SOCKET_TYPE_DATAGRAM", "2"),
2805 ("(gint) G_SOCKET_TYPE_INVALID", "0"),
2806 ("(gint) G_SOCKET_TYPE_SEQPACKET", "3"),
2807 ("(gint) G_SOCKET_TYPE_STREAM", "1"),
2808 ("(guint) G_SUBPROCESS_FLAGS_INHERIT_FDS", "128"),
2809 ("(guint) G_SUBPROCESS_FLAGS_NONE", "0"),
2810 ("(guint) G_SUBPROCESS_FLAGS_STDERR_MERGE", "64"),
2811 ("(guint) G_SUBPROCESS_FLAGS_STDERR_PIPE", "16"),
2812 ("(guint) G_SUBPROCESS_FLAGS_STDERR_SILENCE", "32"),
2813 ("(guint) G_SUBPROCESS_FLAGS_STDIN_INHERIT", "2"),
2814 ("(guint) G_SUBPROCESS_FLAGS_STDIN_PIPE", "1"),
2815 ("(guint) G_SUBPROCESS_FLAGS_STDOUT_PIPE", "4"),
2816 ("(guint) G_SUBPROCESS_FLAGS_STDOUT_SILENCE", "8"),
2817 ("(guint) G_TEST_DBUS_NONE", "0"),
2818 ("(gint) G_TLS_AUTHENTICATION_NONE", "0"),
2819 ("(gint) G_TLS_AUTHENTICATION_REQUESTED", "1"),
2820 ("(gint) G_TLS_AUTHENTICATION_REQUIRED", "2"),
2821 ("G_TLS_BACKEND_EXTENSION_POINT_NAME", "gio-tls-backend"),
2822 ("(guint) G_TLS_CERTIFICATE_BAD_IDENTITY", "2"),
2823 ("(guint) G_TLS_CERTIFICATE_EXPIRED", "8"),
2824 ("(guint) G_TLS_CERTIFICATE_GENERIC_ERROR", "64"),
2825 ("(guint) G_TLS_CERTIFICATE_INSECURE", "32"),
2826 ("(guint) G_TLS_CERTIFICATE_NOT_ACTIVATED", "4"),
2827 ("(gint) G_TLS_CERTIFICATE_REQUEST_NONE", "0"),
2828 ("(guint) G_TLS_CERTIFICATE_REVOKED", "16"),
2829 ("(guint) G_TLS_CERTIFICATE_UNKNOWN_CA", "1"),
2830 ("(guint) G_TLS_CERTIFICATE_VALIDATE_ALL", "127"),
2831 ("(gint) G_TLS_CHANNEL_BINDING_ERROR_GENERAL_ERROR", "4"),
2832 ("(gint) G_TLS_CHANNEL_BINDING_ERROR_INVALID_STATE", "1"),
2833 ("(gint) G_TLS_CHANNEL_BINDING_ERROR_NOT_AVAILABLE", "2"),
2834 ("(gint) G_TLS_CHANNEL_BINDING_ERROR_NOT_IMPLEMENTED", "0"),
2835 ("(gint) G_TLS_CHANNEL_BINDING_ERROR_NOT_SUPPORTED", "3"),
2836 ("(gint) G_TLS_CHANNEL_BINDING_TLS_SERVER_END_POINT", "1"),
2837 ("(gint) G_TLS_CHANNEL_BINDING_TLS_UNIQUE", "0"),
2838 ("(gint) G_TLS_DATABASE_LOOKUP_KEYPAIR", "1"),
2839 ("(gint) G_TLS_DATABASE_LOOKUP_NONE", "0"),
2840 (
2841 "G_TLS_DATABASE_PURPOSE_AUTHENTICATE_CLIENT",
2842 "1.3.6.1.5.5.7.3.2",
2843 ),
2844 (
2845 "G_TLS_DATABASE_PURPOSE_AUTHENTICATE_SERVER",
2846 "1.3.6.1.5.5.7.3.1",
2847 ),
2848 ("(guint) G_TLS_DATABASE_VERIFY_NONE", "0"),
2849 ("(gint) G_TLS_ERROR_BAD_CERTIFICATE", "2"),
2850 ("(gint) G_TLS_ERROR_CERTIFICATE_REQUIRED", "5"),
2851 ("(gint) G_TLS_ERROR_EOF", "6"),
2852 ("(gint) G_TLS_ERROR_HANDSHAKE", "4"),
2853 ("(gint) G_TLS_ERROR_INAPPROPRIATE_FALLBACK", "7"),
2854 ("(gint) G_TLS_ERROR_MISC", "1"),
2855 ("(gint) G_TLS_ERROR_NOT_TLS", "3"),
2856 ("(gint) G_TLS_ERROR_UNAVAILABLE", "0"),
2857 ("(gint) G_TLS_INTERACTION_FAILED", "2"),
2858 ("(gint) G_TLS_INTERACTION_HANDLED", "1"),
2859 ("(gint) G_TLS_INTERACTION_UNHANDLED", "0"),
2860 ("(guint) G_TLS_PASSWORD_FINAL_TRY", "8"),
2861 ("(guint) G_TLS_PASSWORD_MANY_TRIES", "4"),
2862 ("(guint) G_TLS_PASSWORD_NONE", "0"),
2863 ("(guint) G_TLS_PASSWORD_RETRY", "2"),
2864 ("(gint) G_TLS_REHANDSHAKE_NEVER", "0"),
2865 ("(gint) G_TLS_REHANDSHAKE_SAFELY", "1"),
2866 ("(gint) G_TLS_REHANDSHAKE_UNSAFELY", "2"),
2867 ("(gint) G_UNIX_SOCKET_ADDRESS_ABSTRACT", "3"),
2868 ("(gint) G_UNIX_SOCKET_ADDRESS_ABSTRACT_PADDED", "4"),
2869 ("(gint) G_UNIX_SOCKET_ADDRESS_ANONYMOUS", "1"),
2870 ("(gint) G_UNIX_SOCKET_ADDRESS_INVALID", "0"),
2871 ("(gint) G_UNIX_SOCKET_ADDRESS_PATH", "2"),
2872 ("G_VFS_EXTENSION_POINT_NAME", "gio-vfs"),
2873 ("G_VOLUME_IDENTIFIER_KIND_CLASS", "class"),
2874 ("G_VOLUME_IDENTIFIER_KIND_HAL_UDI", "hal-udi"),
2875 ("G_VOLUME_IDENTIFIER_KIND_LABEL", "label"),
2876 ("G_VOLUME_IDENTIFIER_KIND_NFS_MOUNT", "nfs-mount"),
2877 ("G_VOLUME_IDENTIFIER_KIND_UNIX_DEVICE", "unix-device"),
2878 ("G_VOLUME_IDENTIFIER_KIND_UUID", "uuid"),
2879 (
2880 "G_VOLUME_MONITOR_EXTENSION_POINT_NAME",
2881 "gio-volume-monitor",
2882 ),
2883 ("(gint) G_ZLIB_COMPRESSOR_FORMAT_GZIP", "1"),
2884 ("(gint) G_ZLIB_COMPRESSOR_FORMAT_RAW", "2"),
2885 ("(gint) G_ZLIB_COMPRESSOR_FORMAT_ZLIB", "0"),
2886 ];
2887