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