1#![allow(non_camel_case_types)]
4#![allow(non_upper_case_globals)]
5#![allow(non_snake_case)]
6#![allow(dead_code)]
7#![allow(clippy::all)]
8#![allow(rustdoc::all)]
9
10pub type __uint64_t = ::std::os::raw::c_ulong;
11pub type __off_t = ::std::os::raw::c_long;
12pub type __off64_t = ::std::os::raw::c_long;
13#[repr(u32)]
14#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
15pub enum ucl_error {
16 UCL_EOK = 0,
17 UCL_ESYNTAX = 1,
18 UCL_EIO = 2,
19 UCL_ESTATE = 3,
20 UCL_ENESTED = 4,
21 UCL_EUNPAIRED = 5,
22 UCL_EMACRO = 6,
23 UCL_EINTERNAL = 7,
24 UCL_ESSL = 8,
25 UCL_EMERGE = 9,
26}
27pub use self::ucl_error as ucl_error_t;
28#[repr(u32)]
29#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
30pub enum ucl_type {
31 UCL_OBJECT = 0,
32 UCL_ARRAY = 1,
33 UCL_INT = 2,
34 UCL_FLOAT = 3,
35 UCL_STRING = 4,
36 UCL_BOOLEAN = 5,
37 UCL_TIME = 6,
38 UCL_USERDATA = 7,
39 UCL_NULL = 8,
40}
41pub use self::ucl_type as ucl_type_t;
42#[repr(u32)]
43#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
44pub enum ucl_emitter {
45 UCL_EMIT_JSON = 0,
46 UCL_EMIT_JSON_COMPACT = 1,
47 UCL_EMIT_CONFIG = 2,
48 UCL_EMIT_YAML = 3,
49 UCL_EMIT_MSGPACK = 4,
50 UCL_EMIT_MAX = 5,
51}
52pub use self::ucl_emitter as ucl_emitter_t;
53impl ucl_parser_flags {
54 pub const UCL_PARSER_DEFAULT: ucl_parser_flags = ucl_parser_flags(0);
55 pub const UCL_PARSER_KEY_LOWERCASE: ucl_parser_flags = ucl_parser_flags(1);
56 pub const UCL_PARSER_ZEROCOPY: ucl_parser_flags = ucl_parser_flags(2);
57 pub const UCL_PARSER_NO_TIME: ucl_parser_flags = ucl_parser_flags(4);
58 pub const UCL_PARSER_NO_IMPLICIT_ARRAYS: ucl_parser_flags = ucl_parser_flags(8);
59 pub const UCL_PARSER_SAVE_COMMENTS: ucl_parser_flags = ucl_parser_flags(16);
60 pub const UCL_PARSER_DISABLE_MACRO: ucl_parser_flags = ucl_parser_flags(32);
61 pub const UCL_PARSER_NO_FILEVARS: ucl_parser_flags = ucl_parser_flags(64);
62}
63impl ::std::ops::BitOr<ucl_parser_flags> for ucl_parser_flags {
64 type Output = Self;
65 #[inline]
66 fn bitor(self, other: Self) -> Self {
67 ucl_parser_flags(self.0 | other.0)
68 }
69}
70impl ::std::ops::BitOrAssign for ucl_parser_flags {
71 #[inline]
72 fn bitor_assign(&mut self, rhs: ucl_parser_flags) {
73 self.0 |= rhs.0;
74 }
75}
76impl ::std::ops::BitAnd<ucl_parser_flags> for ucl_parser_flags {
77 type Output = Self;
78 #[inline]
79 fn bitand(self, other: Self) -> Self {
80 ucl_parser_flags(self.0 & other.0)
81 }
82}
83impl ::std::ops::BitAndAssign for ucl_parser_flags {
84 #[inline]
85 fn bitand_assign(&mut self, rhs: ucl_parser_flags) {
86 self.0 &= rhs.0;
87 }
88}
89#[repr(transparent)]
90#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
91pub struct ucl_parser_flags(pub ::std::os::raw::c_uint);
92pub use self::ucl_parser_flags as ucl_parser_flags_t;
93impl ucl_string_flags {
94 pub const UCL_STRING_RAW: ucl_string_flags = ucl_string_flags(0);
95 pub const UCL_STRING_ESCAPE: ucl_string_flags = ucl_string_flags(1);
96 pub const UCL_STRING_TRIM: ucl_string_flags = ucl_string_flags(2);
97 pub const UCL_STRING_PARSE_BOOLEAN: ucl_string_flags = ucl_string_flags(4);
98 pub const UCL_STRING_PARSE_INT: ucl_string_flags = ucl_string_flags(8);
99 pub const UCL_STRING_PARSE_DOUBLE: ucl_string_flags = ucl_string_flags(16);
100 pub const UCL_STRING_PARSE_TIME: ucl_string_flags = ucl_string_flags(32);
101 pub const UCL_STRING_PARSE_NUMBER: ucl_string_flags = ucl_string_flags(56);
102 pub const UCL_STRING_PARSE: ucl_string_flags = ucl_string_flags(60);
103 pub const UCL_STRING_PARSE_BYTES: ucl_string_flags = ucl_string_flags(64);
104}
105impl ::std::ops::BitOr<ucl_string_flags> for ucl_string_flags {
106 type Output = Self;
107 #[inline]
108 fn bitor(self, other: Self) -> Self {
109 ucl_string_flags(self.0 | other.0)
110 }
111}
112impl ::std::ops::BitOrAssign for ucl_string_flags {
113 #[inline]
114 fn bitor_assign(&mut self, rhs: ucl_string_flags) {
115 self.0 |= rhs.0;
116 }
117}
118impl ::std::ops::BitAnd<ucl_string_flags> for ucl_string_flags {
119 type Output = Self;
120 #[inline]
121 fn bitand(self, other: Self) -> Self {
122 ucl_string_flags(self.0 & other.0)
123 }
124}
125impl ::std::ops::BitAndAssign for ucl_string_flags {
126 #[inline]
127 fn bitand_assign(&mut self, rhs: ucl_string_flags) {
128 self.0 &= rhs.0;
129 }
130}
131#[repr(transparent)]
132#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
133pub struct ucl_string_flags(pub ::std::os::raw::c_uint);
134pub use self::ucl_string_flags as ucl_string_flags_t;
135impl ucl_object_flags {
136 pub const UCL_OBJECT_ALLOCATED_KEY: ucl_object_flags = ucl_object_flags(1);
137 pub const UCL_OBJECT_ALLOCATED_VALUE: ucl_object_flags = ucl_object_flags(2);
138 pub const UCL_OBJECT_NEED_KEY_ESCAPE: ucl_object_flags = ucl_object_flags(4);
139 pub const UCL_OBJECT_EPHEMERAL: ucl_object_flags = ucl_object_flags(8);
140 pub const UCL_OBJECT_MULTILINE: ucl_object_flags = ucl_object_flags(16);
141 pub const UCL_OBJECT_MULTIVALUE: ucl_object_flags = ucl_object_flags(32);
142 pub const UCL_OBJECT_INHERITED: ucl_object_flags = ucl_object_flags(64);
143 pub const UCL_OBJECT_BINARY: ucl_object_flags = ucl_object_flags(128);
144 pub const UCL_OBJECT_SQUOTED: ucl_object_flags = ucl_object_flags(256);
145}
146impl ::std::ops::BitOr<ucl_object_flags> for ucl_object_flags {
147 type Output = Self;
148 #[inline]
149 fn bitor(self, other: Self) -> Self {
150 ucl_object_flags(self.0 | other.0)
151 }
152}
153impl ::std::ops::BitOrAssign for ucl_object_flags {
154 #[inline]
155 fn bitor_assign(&mut self, rhs: ucl_object_flags) {
156 self.0 |= rhs.0;
157 }
158}
159impl ::std::ops::BitAnd<ucl_object_flags> for ucl_object_flags {
160 type Output = Self;
161 #[inline]
162 fn bitand(self, other: Self) -> Self {
163 ucl_object_flags(self.0 & other.0)
164 }
165}
166impl ::std::ops::BitAndAssign for ucl_object_flags {
167 #[inline]
168 fn bitand_assign(&mut self, rhs: ucl_object_flags) {
169 self.0 &= rhs.0;
170 }
171}
172#[repr(transparent)]
173#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
174pub struct ucl_object_flags(pub ::std::os::raw::c_uint);
175pub use self::ucl_object_flags as ucl_object_flags_t;
176#[repr(u32)]
177#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
178pub enum ucl_duplicate_strategy {
179 UCL_DUPLICATE_APPEND = 0,
180 UCL_DUPLICATE_MERGE = 1,
181 UCL_DUPLICATE_REWRITE = 2,
182 UCL_DUPLICATE_ERROR = 3,
183}
184#[repr(u32)]
185#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
186pub enum ucl_parse_type {
187 UCL_PARSE_UCL = 0,
188 UCL_PARSE_MSGPACK = 1,
189 UCL_PARSE_CSEXP = 2,
190 UCL_PARSE_AUTO = 3,
191}
192#[repr(C)]
193#[repr(align(8))]
194#[derive(Debug, Copy, Clone)]
195pub struct ucl_object_s {
196 pub _bindgen_opaque_blob: [u64; 8usize],
197}
198#[repr(C)]
199#[derive(Copy, Clone)]
200pub union ucl_object_s__bindgen_ty_1 {
201 pub iv: i64,
202 pub sv: *const ::std::os::raw::c_char,
203 pub dv: f64,
204 pub av: *mut ::std::os::raw::c_void,
205 pub ov: *mut ::std::os::raw::c_void,
206 pub ud: *mut ::std::os::raw::c_void,
207}
208#[allow(clippy::unnecessary_operation, clippy::identity_op)]
209const _: () = {
210 ["Size of ucl_object_s__bindgen_ty_1"]
211 [::std::mem::size_of::<ucl_object_s__bindgen_ty_1>() - 8usize];
212 ["Alignment of ucl_object_s__bindgen_ty_1"]
213 [::std::mem::align_of::<ucl_object_s__bindgen_ty_1>() - 8usize];
214 ["Offset of field: ucl_object_s__bindgen_ty_1::iv"]
215 [::std::mem::offset_of!(ucl_object_s__bindgen_ty_1, iv) - 0usize];
216 ["Offset of field: ucl_object_s__bindgen_ty_1::sv"]
217 [::std::mem::offset_of!(ucl_object_s__bindgen_ty_1, sv) - 0usize];
218 ["Offset of field: ucl_object_s__bindgen_ty_1::dv"]
219 [::std::mem::offset_of!(ucl_object_s__bindgen_ty_1, dv) - 0usize];
220 ["Offset of field: ucl_object_s__bindgen_ty_1::av"]
221 [::std::mem::offset_of!(ucl_object_s__bindgen_ty_1, av) - 0usize];
222 ["Offset of field: ucl_object_s__bindgen_ty_1::ov"]
223 [::std::mem::offset_of!(ucl_object_s__bindgen_ty_1, ov) - 0usize];
224 ["Offset of field: ucl_object_s__bindgen_ty_1::ud"]
225 [::std::mem::offset_of!(ucl_object_s__bindgen_ty_1, ud) - 0usize];
226};
227#[allow(clippy::unnecessary_operation, clippy::identity_op)]
228const _: () = {
229 ["Size of ucl_object_s"][::std::mem::size_of::<ucl_object_s>() - 64usize];
230 ["Alignment of ucl_object_s"][::std::mem::align_of::<ucl_object_s>() - 8usize];
231};
232pub type ucl_object_t = ucl_object_s;
233pub type ucl_userdata_dtor =
234 ::std::option::Option<unsafe extern "C" fn(ud: *mut ::std::os::raw::c_void)>;
235pub type ucl_userdata_emitter = ::std::option::Option<
236 unsafe extern "C" fn(ud: *mut ::std::os::raw::c_void) -> *const ::std::os::raw::c_char,
237>;
238unsafe extern "C" {
239 pub fn ucl_copy_key_trash(obj: *const ucl_object_t) -> *mut ::std::os::raw::c_char;
240}
241unsafe extern "C" {
242 pub fn ucl_copy_value_trash(obj: *const ucl_object_t) -> *mut ::std::os::raw::c_char;
243}
244unsafe extern "C" {
245 pub fn ucl_object_new() -> *mut ucl_object_t;
246}
247unsafe extern "C" {
248 pub fn ucl_object_typed_new(type_: ucl_type_t) -> *mut ucl_object_t;
249}
250unsafe extern "C" {
251 pub fn ucl_object_new_full(
252 type_: ucl_type_t,
253 priority: ::std::os::raw::c_uint,
254 ) -> *mut ucl_object_t;
255}
256unsafe extern "C" {
257 pub fn ucl_object_new_userdata(
258 dtor: ucl_userdata_dtor,
259 emitter: ucl_userdata_emitter,
260 ptr: *mut ::std::os::raw::c_void,
261 ) -> *mut ucl_object_t;
262}
263unsafe extern "C" {
264 pub fn ucl_object_copy(other: *const ucl_object_t) -> *mut ucl_object_t;
265}
266unsafe extern "C" {
267 pub fn ucl_object_type(obj: *const ucl_object_t) -> ucl_type_t;
268}
269unsafe extern "C" {
270 pub fn ucl_object_type_to_string(type_: ucl_type_t) -> *const ::std::os::raw::c_char;
271}
272unsafe extern "C" {
273 pub fn ucl_object_string_to_type(
274 input: *const ::std::os::raw::c_char,
275 res: *mut ucl_type_t,
276 ) -> bool;
277}
278unsafe extern "C" {
279 pub fn ucl_object_fromstring_common(
280 str_: *const ::std::os::raw::c_char,
281 len: usize,
282 flags: ucl_string_flags,
283 ) -> *mut ucl_object_t;
284}
285unsafe extern "C" {
286 pub fn ucl_object_fromstring(str_: *const ::std::os::raw::c_char) -> *mut ucl_object_t;
287}
288unsafe extern "C" {
289 pub fn ucl_object_fromlstring(
290 str_: *const ::std::os::raw::c_char,
291 len: usize,
292 ) -> *mut ucl_object_t;
293}
294unsafe extern "C" {
295 pub fn ucl_object_fromint(iv: i64) -> *mut ucl_object_t;
296}
297unsafe extern "C" {
298 pub fn ucl_object_fromdouble(dv: f64) -> *mut ucl_object_t;
299}
300unsafe extern "C" {
301 pub fn ucl_object_frombool(bv: bool) -> *mut ucl_object_t;
302}
303unsafe extern "C" {
304 pub fn ucl_object_insert_key(
305 top: *mut ucl_object_t,
306 elt: *mut ucl_object_t,
307 key: *const ::std::os::raw::c_char,
308 keylen: usize,
309 copy_key: bool,
310 ) -> bool;
311}
312unsafe extern "C" {
313 pub fn ucl_object_replace_key(
314 top: *mut ucl_object_t,
315 elt: *mut ucl_object_t,
316 key: *const ::std::os::raw::c_char,
317 keylen: usize,
318 copy_key: bool,
319 ) -> bool;
320}
321unsafe extern "C" {
322 pub fn ucl_object_merge(top: *mut ucl_object_t, elt: *mut ucl_object_t, copy: bool) -> bool;
323}
324unsafe extern "C" {
325 pub fn ucl_object_delete_keyl(
326 top: *mut ucl_object_t,
327 key: *const ::std::os::raw::c_char,
328 keylen: usize,
329 ) -> bool;
330}
331unsafe extern "C" {
332 pub fn ucl_object_delete_key(
333 top: *mut ucl_object_t,
334 key: *const ::std::os::raw::c_char,
335 ) -> bool;
336}
337unsafe extern "C" {
338 pub fn ucl_object_pop_keyl(
339 top: *mut ucl_object_t,
340 key: *const ::std::os::raw::c_char,
341 keylen: usize,
342 ) -> *mut ucl_object_t;
343}
344unsafe extern "C" {
345 pub fn ucl_object_pop_key(
346 top: *mut ucl_object_t,
347 key: *const ::std::os::raw::c_char,
348 ) -> *mut ucl_object_t;
349}
350unsafe extern "C" {
351 pub fn ucl_object_insert_key_merged(
352 top: *mut ucl_object_t,
353 elt: *mut ucl_object_t,
354 key: *const ::std::os::raw::c_char,
355 keylen: usize,
356 copy_key: bool,
357 ) -> bool;
358}
359unsafe extern "C" {
360 pub fn ucl_object_reserve(obj: *mut ucl_object_t, reserved: usize) -> bool;
361}
362unsafe extern "C" {
363 pub fn ucl_array_append(top: *mut ucl_object_t, elt: *mut ucl_object_t) -> bool;
364}
365unsafe extern "C" {
366 pub fn ucl_array_prepend(top: *mut ucl_object_t, elt: *mut ucl_object_t) -> bool;
367}
368unsafe extern "C" {
369 pub fn ucl_array_merge(top: *mut ucl_object_t, elt: *mut ucl_object_t, copy: bool) -> bool;
370}
371unsafe extern "C" {
372 pub fn ucl_array_delete(top: *mut ucl_object_t, elt: *mut ucl_object_t) -> *mut ucl_object_t;
373}
374unsafe extern "C" {
375 pub fn ucl_array_head(top: *const ucl_object_t) -> *const ucl_object_t;
376}
377unsafe extern "C" {
378 pub fn ucl_array_tail(top: *const ucl_object_t) -> *const ucl_object_t;
379}
380unsafe extern "C" {
381 pub fn ucl_array_pop_last(top: *mut ucl_object_t) -> *mut ucl_object_t;
382}
383unsafe extern "C" {
384 pub fn ucl_array_pop_first(top: *mut ucl_object_t) -> *mut ucl_object_t;
385}
386unsafe extern "C" {
387 pub fn ucl_array_size(top: *const ucl_object_t) -> ::std::os::raw::c_uint;
388}
389unsafe extern "C" {
390 pub fn ucl_array_find_index(
391 top: *const ucl_object_t,
392 index: ::std::os::raw::c_uint,
393 ) -> *const ucl_object_t;
394}
395unsafe extern "C" {
396 pub fn ucl_array_index_of(
397 top: *mut ucl_object_t,
398 elt: *mut ucl_object_t,
399 ) -> ::std::os::raw::c_uint;
400}
401unsafe extern "C" {
402 pub fn ucl_array_replace_index(
403 top: *mut ucl_object_t,
404 elt: *mut ucl_object_t,
405 index: ::std::os::raw::c_uint,
406 ) -> *mut ucl_object_t;
407}
408unsafe extern "C" {
409 pub fn ucl_elt_append(head: *mut ucl_object_t, elt: *mut ucl_object_t) -> *mut ucl_object_t;
410}
411unsafe extern "C" {
412 pub fn ucl_object_todouble_safe(obj: *const ucl_object_t, target: *mut f64) -> bool;
413}
414unsafe extern "C" {
415 pub fn ucl_object_todouble(obj: *const ucl_object_t) -> f64;
416}
417unsafe extern "C" {
418 pub fn ucl_object_toint_safe(obj: *const ucl_object_t, target: *mut i64) -> bool;
419}
420unsafe extern "C" {
421 pub fn ucl_object_toint(obj: *const ucl_object_t) -> i64;
422}
423unsafe extern "C" {
424 pub fn ucl_object_toboolean_safe(obj: *const ucl_object_t, target: *mut bool) -> bool;
425}
426unsafe extern "C" {
427 pub fn ucl_object_toboolean(obj: *const ucl_object_t) -> bool;
428}
429unsafe extern "C" {
430 pub fn ucl_object_tostring_safe(
431 obj: *const ucl_object_t,
432 target: *mut *const ::std::os::raw::c_char,
433 ) -> bool;
434}
435unsafe extern "C" {
436 pub fn ucl_object_tostring(obj: *const ucl_object_t) -> *const ::std::os::raw::c_char;
437}
438unsafe extern "C" {
439 pub fn ucl_object_tostring_forced(obj: *const ucl_object_t) -> *const ::std::os::raw::c_char;
440}
441unsafe extern "C" {
442 pub fn ucl_object_tolstring_safe(
443 obj: *const ucl_object_t,
444 target: *mut *const ::std::os::raw::c_char,
445 tlen: *mut usize,
446 ) -> bool;
447}
448unsafe extern "C" {
449 pub fn ucl_object_tolstring(
450 obj: *const ucl_object_t,
451 tlen: *mut usize,
452 ) -> *const ::std::os::raw::c_char;
453}
454unsafe extern "C" {
455 pub fn ucl_object_lookup(
456 obj: *const ucl_object_t,
457 key: *const ::std::os::raw::c_char,
458 ) -> *const ucl_object_t;
459}
460unsafe extern "C" {
461 pub fn ucl_object_lookup_any(
462 obj: *const ucl_object_t,
463 key: *const ::std::os::raw::c_char,
464 ...
465 ) -> *const ucl_object_t;
466}
467unsafe extern "C" {
468 pub fn ucl_object_lookup_len(
469 obj: *const ucl_object_t,
470 key: *const ::std::os::raw::c_char,
471 klen: usize,
472 ) -> *const ucl_object_t;
473}
474unsafe extern "C" {
475 pub fn ucl_object_lookup_path(
476 obj: *const ucl_object_t,
477 path: *const ::std::os::raw::c_char,
478 ) -> *const ucl_object_t;
479}
480unsafe extern "C" {
481 pub fn ucl_object_lookup_path_char(
482 obj: *const ucl_object_t,
483 path: *const ::std::os::raw::c_char,
484 sep: ::std::os::raw::c_char,
485 ) -> *const ucl_object_t;
486}
487unsafe extern "C" {
488 pub fn ucl_object_key(obj: *const ucl_object_t) -> *const ::std::os::raw::c_char;
489}
490unsafe extern "C" {
491 pub fn ucl_object_keyl(
492 obj: *const ucl_object_t,
493 len: *mut usize,
494 ) -> *const ::std::os::raw::c_char;
495}
496unsafe extern "C" {
497 pub fn ucl_object_ref(obj: *const ucl_object_t) -> *mut ucl_object_t;
498}
499unsafe extern "C" {
500 pub fn ucl_object_free(obj: *mut ucl_object_t);
501}
502unsafe extern "C" {
503 pub fn ucl_object_unref(obj: *mut ucl_object_t);
504}
505unsafe extern "C" {
506 pub fn ucl_object_compare(
507 o1: *const ucl_object_t,
508 o2: *const ucl_object_t,
509 ) -> ::std::os::raw::c_int;
510}
511unsafe extern "C" {
512 pub fn ucl_object_compare_qsort(
513 o1: *mut *const ucl_object_t,
514 o2: *mut *const ucl_object_t,
515 ) -> ::std::os::raw::c_int;
516}
517unsafe extern "C" {
518 pub fn ucl_object_array_sort(
519 ar: *mut ucl_object_t,
520 cmp: ::std::option::Option<
521 unsafe extern "C" fn(
522 o1: *mut *const ucl_object_t,
523 o2: *mut *const ucl_object_t,
524 ) -> ::std::os::raw::c_int,
525 >,
526 );
527}
528#[repr(u32)]
529#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
530pub enum ucl_object_keys_sort_flags {
531 UCL_SORT_KEYS_DEFAULT = 0,
532 UCL_SORT_KEYS_ICASE = 1,
533 UCL_SORT_KEYS_RECURSIVE = 2,
534}
535unsafe extern "C" {
536 pub fn ucl_object_sort_keys(obj: *mut ucl_object_t, how: ucl_object_keys_sort_flags);
537}
538unsafe extern "C" {
539 pub fn ucl_object_get_priority(obj: *const ucl_object_t) -> ::std::os::raw::c_uint;
540}
541unsafe extern "C" {
542 pub fn ucl_object_set_priority(obj: *mut ucl_object_t, priority: ::std::os::raw::c_uint);
543}
544pub type ucl_object_iter_t = *mut ::std::os::raw::c_void;
545unsafe extern "C" {
546 pub fn ucl_object_iterate_with_error(
547 obj: *const ucl_object_t,
548 iter: *mut ucl_object_iter_t,
549 expand_values: bool,
550 ep: *mut ::std::os::raw::c_int,
551 ) -> *const ucl_object_t;
552}
553unsafe extern "C" {
554 pub fn ucl_object_iterate_end(obj: *const ucl_object_t, iter: *mut ucl_object_iter_t);
555}
556unsafe extern "C" {
557 pub fn ucl_object_iterate_new(obj: *const ucl_object_t) -> ucl_object_iter_t;
558}
559unsafe extern "C" {
560 pub fn ucl_object_iter_chk_excpn(it: *mut ucl_object_iter_t) -> bool;
561}
562unsafe extern "C" {
563 pub fn ucl_object_iterate_reset(
564 it: ucl_object_iter_t,
565 obj: *const ucl_object_t,
566 ) -> ucl_object_iter_t;
567}
568unsafe extern "C" {
569 pub fn ucl_object_iterate_safe(
570 iter: ucl_object_iter_t,
571 expand_values: bool,
572 ) -> *const ucl_object_t;
573}
574#[repr(u32)]
575#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
576pub enum ucl_iterate_type {
577 UCL_ITERATE_EXPLICIT = 1,
578 UCL_ITERATE_IMPLICIT = 2,
579 UCL_ITERATE_BOTH = 3,
580}
581unsafe extern "C" {
582 pub fn ucl_object_iterate_full(
583 iter: ucl_object_iter_t,
584 type_: ucl_iterate_type,
585 ) -> *const ucl_object_t;
586}
587unsafe extern "C" {
588 pub fn ucl_object_iterate_free(it: ucl_object_iter_t);
589}
590pub type ucl_macro_handler = ::std::option::Option<
591 unsafe extern "C" fn(
592 data: *const ::std::os::raw::c_uchar,
593 len: usize,
594 arguments: *const ucl_object_t,
595 ud: *mut ::std::os::raw::c_void,
596 ) -> bool,
597>;
598pub type ucl_context_macro_handler = ::std::option::Option<
599 unsafe extern "C" fn(
600 data: *const ::std::os::raw::c_uchar,
601 len: usize,
602 arguments: *const ucl_object_t,
603 context: *const ucl_object_t,
604 ud: *mut ::std::os::raw::c_void,
605 ) -> bool,
606>;
607#[repr(C)]
608#[derive(Debug, Copy, Clone)]
609pub struct ucl_parser {
610 _unused: [u8; 0],
611}
612unsafe extern "C" {
613 pub fn ucl_parser_new(flags: ::std::os::raw::c_int) -> *mut ucl_parser;
614}
615unsafe extern "C" {
616 pub fn ucl_parser_set_default_priority(
617 parser: *mut ucl_parser,
618 prio: ::std::os::raw::c_uint,
619 ) -> bool;
620}
621unsafe extern "C" {
622 pub fn ucl_parser_get_default_priority(parser: *mut ucl_parser) -> ::std::os::raw::c_int;
623}
624unsafe extern "C" {
625 pub fn ucl_parser_register_macro(
626 parser: *mut ucl_parser,
627 macro_: *const ::std::os::raw::c_char,
628 handler: ucl_macro_handler,
629 ud: *mut ::std::os::raw::c_void,
630 ) -> bool;
631}
632unsafe extern "C" {
633 pub fn ucl_parser_register_context_macro(
634 parser: *mut ucl_parser,
635 macro_: *const ::std::os::raw::c_char,
636 handler: ucl_context_macro_handler,
637 ud: *mut ::std::os::raw::c_void,
638 ) -> bool;
639}
640pub type ucl_variable_handler = ::std::option::Option<
641 unsafe extern "C" fn(
642 data: *const ::std::os::raw::c_uchar,
643 len: usize,
644 replace: *mut *mut ::std::os::raw::c_uchar,
645 replace_len: *mut usize,
646 need_free: *mut bool,
647 ud: *mut ::std::os::raw::c_void,
648 ) -> bool,
649>;
650unsafe extern "C" {
651 pub fn ucl_parser_register_variable(
652 parser: *mut ucl_parser,
653 var: *const ::std::os::raw::c_char,
654 value: *const ::std::os::raw::c_char,
655 );
656}
657unsafe extern "C" {
658 pub fn ucl_parser_set_variables_handler(
659 parser: *mut ucl_parser,
660 handler: ucl_variable_handler,
661 ud: *mut ::std::os::raw::c_void,
662 );
663}
664unsafe extern "C" {
665 pub fn ucl_parser_add_chunk(
666 parser: *mut ucl_parser,
667 data: *const ::std::os::raw::c_uchar,
668 len: usize,
669 ) -> bool;
670}
671unsafe extern "C" {
672 pub fn ucl_parser_add_chunk_priority(
673 parser: *mut ucl_parser,
674 data: *const ::std::os::raw::c_uchar,
675 len: usize,
676 priority: ::std::os::raw::c_uint,
677 ) -> bool;
678}
679unsafe extern "C" {
680 pub fn ucl_parser_insert_chunk(
681 parser: *mut ucl_parser,
682 data: *const ::std::os::raw::c_uchar,
683 len: usize,
684 ) -> bool;
685}
686unsafe extern "C" {
687 pub fn ucl_parser_add_chunk_full(
688 parser: *mut ucl_parser,
689 data: *const ::std::os::raw::c_uchar,
690 len: usize,
691 priority: ::std::os::raw::c_uint,
692 strat: ucl_duplicate_strategy,
693 parse_type: ucl_parse_type,
694 ) -> bool;
695}
696unsafe extern "C" {
697 pub fn ucl_parser_add_string(
698 parser: *mut ucl_parser,
699 data: *const ::std::os::raw::c_char,
700 len: usize,
701 ) -> bool;
702}
703unsafe extern "C" {
704 pub fn ucl_parser_add_string_priority(
705 parser: *mut ucl_parser,
706 data: *const ::std::os::raw::c_char,
707 len: usize,
708 priority: ::std::os::raw::c_uint,
709 ) -> bool;
710}
711unsafe extern "C" {
712 pub fn ucl_parser_add_file(
713 parser: *mut ucl_parser,
714 filename: *const ::std::os::raw::c_char,
715 ) -> bool;
716}
717unsafe extern "C" {
718 pub fn ucl_parser_add_file_priority(
719 parser: *mut ucl_parser,
720 filename: *const ::std::os::raw::c_char,
721 priority: ::std::os::raw::c_uint,
722 ) -> bool;
723}
724unsafe extern "C" {
725 pub fn ucl_parser_add_file_full(
726 parser: *mut ucl_parser,
727 filename: *const ::std::os::raw::c_char,
728 priority: ::std::os::raw::c_uint,
729 strat: ucl_duplicate_strategy,
730 parse_type: ucl_parse_type,
731 ) -> bool;
732}
733unsafe extern "C" {
734 pub fn ucl_parser_add_fd(parser: *mut ucl_parser, fd: ::std::os::raw::c_int) -> bool;
735}
736unsafe extern "C" {
737 pub fn ucl_parser_add_fd_priority(
738 parser: *mut ucl_parser,
739 fd: ::std::os::raw::c_int,
740 priority: ::std::os::raw::c_uint,
741 ) -> bool;
742}
743unsafe extern "C" {
744 pub fn ucl_parser_add_fd_full(
745 parser: *mut ucl_parser,
746 fd: ::std::os::raw::c_int,
747 priority: ::std::os::raw::c_uint,
748 strat: ucl_duplicate_strategy,
749 parse_type: ucl_parse_type,
750 ) -> bool;
751}
752unsafe extern "C" {
753 pub fn ucl_set_include_path(parser: *mut ucl_parser, paths: *mut ucl_object_t) -> bool;
754}
755unsafe extern "C" {
756 pub fn ucl_parser_get_object(parser: *mut ucl_parser) -> *mut ucl_object_t;
757}
758unsafe extern "C" {
759 pub fn ucl_parser_get_current_stack_object(
760 parser: *mut ucl_parser,
761 depth: ::std::os::raw::c_uint,
762 ) -> *mut ucl_object_t;
763}
764unsafe extern "C" {
765 pub fn ucl_parser_chunk_peek(parser: *mut ucl_parser) -> ::std::os::raw::c_uchar;
766}
767unsafe extern "C" {
768 pub fn ucl_parser_chunk_skip(parser: *mut ucl_parser) -> bool;
769}
770unsafe extern "C" {
771 pub fn ucl_parser_get_error(parser: *mut ucl_parser) -> *const ::std::os::raw::c_char;
772}
773unsafe extern "C" {
774 pub fn ucl_parser_get_error_code(parser: *mut ucl_parser) -> ::std::os::raw::c_int;
775}
776unsafe extern "C" {
777 pub fn ucl_parser_get_column(parser: *mut ucl_parser) -> ::std::os::raw::c_uint;
778}
779unsafe extern "C" {
780 pub fn ucl_parser_get_linenum(parser: *mut ucl_parser) -> ::std::os::raw::c_uint;
781}
782unsafe extern "C" {
783 pub fn ucl_parser_clear_error(parser: *mut ucl_parser);
784}
785unsafe extern "C" {
786 pub fn ucl_parser_free(parser: *mut ucl_parser);
787}
788unsafe extern "C" {
789 pub fn ucl_parser_get_comments(parser: *mut ucl_parser) -> *const ucl_object_t;
790}
791unsafe extern "C" {
792 pub fn ucl_comments_find(
793 comments: *const ucl_object_t,
794 srch: *const ucl_object_t,
795 ) -> *const ucl_object_t;
796}
797unsafe extern "C" {
798 pub fn ucl_comments_move(
799 comments: *mut ucl_object_t,
800 from: *const ucl_object_t,
801 to: *const ucl_object_t,
802 ) -> bool;
803}
804unsafe extern "C" {
805 pub fn ucl_comments_add(
806 comments: *mut ucl_object_t,
807 obj: *const ucl_object_t,
808 comment: *const ::std::os::raw::c_char,
809 );
810}
811unsafe extern "C" {
812 pub fn ucl_parser_pubkey_add(
813 parser: *mut ucl_parser,
814 key: *const ::std::os::raw::c_uchar,
815 len: usize,
816 ) -> bool;
817}
818unsafe extern "C" {
819 pub fn ucl_parser_set_filevars(
820 parser: *mut ucl_parser,
821 filename: *const ::std::os::raw::c_char,
822 need_expand: bool,
823 ) -> bool;
824}
825unsafe extern "C" {
826 pub fn ucl_parser_get_cur_file(parser: *mut ucl_parser) -> *const ::std::os::raw::c_char;
827}
828pub type ucl_parser_special_handler_t = ::std::option::Option<
829 unsafe extern "C" fn(
830 parser: *mut ucl_parser,
831 source: *const ::std::os::raw::c_uchar,
832 source_len: usize,
833 destination: *mut *mut ::std::os::raw::c_uchar,
834 dest_len: *mut usize,
835 user_data: *mut ::std::os::raw::c_void,
836 ) -> bool,
837>;
838#[repr(u32)]
839#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
840pub enum ucl_special_handler_flags {
841 UCL_SPECIAL_HANDLER_DEFAULT = 0,
842 UCL_SPECIAL_HANDLER_PREPROCESS_ALL = 1,
843}
844#[repr(C)]
845#[derive(Debug, Copy, Clone)]
846pub struct ucl_parser_special_handler {
847 pub magic: *const ::std::os::raw::c_uchar,
848 pub magic_len: usize,
849 pub flags: ucl_special_handler_flags,
850 pub handler: ucl_parser_special_handler_t,
851 pub free_function: ::std::option::Option<
852 unsafe extern "C" fn(
853 data: *mut ::std::os::raw::c_uchar,
854 len: usize,
855 user_data: *mut ::std::os::raw::c_void,
856 ),
857 >,
858 pub user_data: *mut ::std::os::raw::c_void,
859 pub next: *mut ucl_parser_special_handler,
860}
861#[allow(clippy::unnecessary_operation, clippy::identity_op)]
862const _: () = {
863 ["Size of ucl_parser_special_handler"]
864 [::std::mem::size_of::<ucl_parser_special_handler>() - 56usize];
865 ["Alignment of ucl_parser_special_handler"]
866 [::std::mem::align_of::<ucl_parser_special_handler>() - 8usize];
867 ["Offset of field: ucl_parser_special_handler::magic"]
868 [::std::mem::offset_of!(ucl_parser_special_handler, magic) - 0usize];
869 ["Offset of field: ucl_parser_special_handler::magic_len"]
870 [::std::mem::offset_of!(ucl_parser_special_handler, magic_len) - 8usize];
871 ["Offset of field: ucl_parser_special_handler::flags"]
872 [::std::mem::offset_of!(ucl_parser_special_handler, flags) - 16usize];
873 ["Offset of field: ucl_parser_special_handler::handler"]
874 [::std::mem::offset_of!(ucl_parser_special_handler, handler) - 24usize];
875 ["Offset of field: ucl_parser_special_handler::free_function"]
876 [::std::mem::offset_of!(ucl_parser_special_handler, free_function) - 32usize];
877 ["Offset of field: ucl_parser_special_handler::user_data"]
878 [::std::mem::offset_of!(ucl_parser_special_handler, user_data) - 40usize];
879 ["Offset of field: ucl_parser_special_handler::next"]
880 [::std::mem::offset_of!(ucl_parser_special_handler, next) - 48usize];
881};
882unsafe extern "C" {
883 pub fn ucl_parser_add_special_handler(
884 parser: *mut ucl_parser,
885 handler: *mut ucl_parser_special_handler,
886 );
887}
888pub type ucl_include_trace_func_t = ::std::option::Option<
889 unsafe extern "C" fn(
890 parser: *mut ucl_parser,
891 parent: *const ucl_object_t,
892 args: *const ucl_object_t,
893 path: *const ::std::os::raw::c_char,
894 pathlen: usize,
895 user_data: *mut ::std::os::raw::c_void,
896 ),
897>;
898unsafe extern "C" {
899 pub fn ucl_parser_set_include_tracer(
900 parser: *mut ucl_parser,
901 func: ucl_include_trace_func_t,
902 user_data: *mut ::std::os::raw::c_void,
903 );
904}
905#[repr(C)]
906#[derive(Debug, Copy, Clone)]
907pub struct ucl_emitter_functions {
908 pub ucl_emitter_append_character: ::std::option::Option<
909 unsafe extern "C" fn(
910 c: ::std::os::raw::c_uchar,
911 nchars: usize,
912 ud: *mut ::std::os::raw::c_void,
913 ) -> ::std::os::raw::c_int,
914 >,
915 pub ucl_emitter_append_len: ::std::option::Option<
916 unsafe extern "C" fn(
917 str_: *const ::std::os::raw::c_uchar,
918 len: usize,
919 ud: *mut ::std::os::raw::c_void,
920 ) -> ::std::os::raw::c_int,
921 >,
922 pub ucl_emitter_append_int: ::std::option::Option<
923 unsafe extern "C" fn(elt: i64, ud: *mut ::std::os::raw::c_void) -> ::std::os::raw::c_int,
924 >,
925 pub ucl_emitter_append_double: ::std::option::Option<
926 unsafe extern "C" fn(elt: f64, ud: *mut ::std::os::raw::c_void) -> ::std::os::raw::c_int,
927 >,
928 pub ucl_emitter_free_func:
929 ::std::option::Option<unsafe extern "C" fn(ud: *mut ::std::os::raw::c_void)>,
930 pub ud: *mut ::std::os::raw::c_void,
931}
932#[allow(clippy::unnecessary_operation, clippy::identity_op)]
933const _: () = {
934 ["Size of ucl_emitter_functions"][::std::mem::size_of::<ucl_emitter_functions>() - 48usize];
935 ["Alignment of ucl_emitter_functions"]
936 [::std::mem::align_of::<ucl_emitter_functions>() - 8usize];
937 ["Offset of field: ucl_emitter_functions::ucl_emitter_append_character"]
938 [::std::mem::offset_of!(ucl_emitter_functions, ucl_emitter_append_character) - 0usize];
939 ["Offset of field: ucl_emitter_functions::ucl_emitter_append_len"]
940 [::std::mem::offset_of!(ucl_emitter_functions, ucl_emitter_append_len) - 8usize];
941 ["Offset of field: ucl_emitter_functions::ucl_emitter_append_int"]
942 [::std::mem::offset_of!(ucl_emitter_functions, ucl_emitter_append_int) - 16usize];
943 ["Offset of field: ucl_emitter_functions::ucl_emitter_append_double"]
944 [::std::mem::offset_of!(ucl_emitter_functions, ucl_emitter_append_double) - 24usize];
945 ["Offset of field: ucl_emitter_functions::ucl_emitter_free_func"]
946 [::std::mem::offset_of!(ucl_emitter_functions, ucl_emitter_free_func) - 32usize];
947 ["Offset of field: ucl_emitter_functions::ud"]
948 [::std::mem::offset_of!(ucl_emitter_functions, ud) - 40usize];
949};
950#[repr(C)]
951#[derive(Debug, Copy, Clone)]
952pub struct ucl_emitter_operations {
953 pub ucl_emitter_write_elt: ::std::option::Option<
954 unsafe extern "C" fn(
955 ctx: *mut ucl_emitter_context,
956 obj: *const ucl_object_t,
957 first: bool,
958 print_key: bool,
959 ),
960 >,
961 pub ucl_emitter_start_object: ::std::option::Option<
962 unsafe extern "C" fn(
963 ctx: *mut ucl_emitter_context,
964 obj: *const ucl_object_t,
965 first: bool,
966 print_key: bool,
967 ),
968 >,
969 pub ucl_emitter_end_object: ::std::option::Option<
970 unsafe extern "C" fn(ctx: *mut ucl_emitter_context, obj: *const ucl_object_t),
971 >,
972 pub ucl_emitter_start_array: ::std::option::Option<
973 unsafe extern "C" fn(
974 ctx: *mut ucl_emitter_context,
975 obj: *const ucl_object_t,
976 first: bool,
977 print_key: bool,
978 ),
979 >,
980 pub ucl_emitter_end_array: ::std::option::Option<
981 unsafe extern "C" fn(ctx: *mut ucl_emitter_context, obj: *const ucl_object_t),
982 >,
983}
984#[allow(clippy::unnecessary_operation, clippy::identity_op)]
985const _: () = {
986 ["Size of ucl_emitter_operations"][::std::mem::size_of::<ucl_emitter_operations>() - 40usize];
987 ["Alignment of ucl_emitter_operations"]
988 [::std::mem::align_of::<ucl_emitter_operations>() - 8usize];
989 ["Offset of field: ucl_emitter_operations::ucl_emitter_write_elt"]
990 [::std::mem::offset_of!(ucl_emitter_operations, ucl_emitter_write_elt) - 0usize];
991 ["Offset of field: ucl_emitter_operations::ucl_emitter_start_object"]
992 [::std::mem::offset_of!(ucl_emitter_operations, ucl_emitter_start_object) - 8usize];
993 ["Offset of field: ucl_emitter_operations::ucl_emitter_end_object"]
994 [::std::mem::offset_of!(ucl_emitter_operations, ucl_emitter_end_object) - 16usize];
995 ["Offset of field: ucl_emitter_operations::ucl_emitter_start_array"]
996 [::std::mem::offset_of!(ucl_emitter_operations, ucl_emitter_start_array) - 24usize];
997 ["Offset of field: ucl_emitter_operations::ucl_emitter_end_array"]
998 [::std::mem::offset_of!(ucl_emitter_operations, ucl_emitter_end_array) - 32usize];
999};
1000#[repr(C)]
1001#[derive(Debug, Copy, Clone)]
1002pub struct ucl_emitter_context {
1003 pub name: *const ::std::os::raw::c_char,
1004 pub id: ::std::os::raw::c_int,
1005 pub func: *const ucl_emitter_functions,
1006 pub ops: *const ucl_emitter_operations,
1007 pub indent: ::std::os::raw::c_uint,
1008 pub top: *const ucl_object_t,
1009 pub comments: *const ucl_object_t,
1010}
1011#[allow(clippy::unnecessary_operation, clippy::identity_op)]
1012const _: () = {
1013 ["Size of ucl_emitter_context"][::std::mem::size_of::<ucl_emitter_context>() - 56usize];
1014 ["Alignment of ucl_emitter_context"][::std::mem::align_of::<ucl_emitter_context>() - 8usize];
1015 ["Offset of field: ucl_emitter_context::name"]
1016 [::std::mem::offset_of!(ucl_emitter_context, name) - 0usize];
1017 ["Offset of field: ucl_emitter_context::id"]
1018 [::std::mem::offset_of!(ucl_emitter_context, id) - 8usize];
1019 ["Offset of field: ucl_emitter_context::func"]
1020 [::std::mem::offset_of!(ucl_emitter_context, func) - 16usize];
1021 ["Offset of field: ucl_emitter_context::ops"]
1022 [::std::mem::offset_of!(ucl_emitter_context, ops) - 24usize];
1023 ["Offset of field: ucl_emitter_context::indent"]
1024 [::std::mem::offset_of!(ucl_emitter_context, indent) - 32usize];
1025 ["Offset of field: ucl_emitter_context::top"]
1026 [::std::mem::offset_of!(ucl_emitter_context, top) - 40usize];
1027 ["Offset of field: ucl_emitter_context::comments"]
1028 [::std::mem::offset_of!(ucl_emitter_context, comments) - 48usize];
1029};
1030unsafe extern "C" {
1031 pub fn ucl_object_emit(
1032 obj: *const ucl_object_t,
1033 emit_type: ucl_emitter,
1034 ) -> *mut ::std::os::raw::c_uchar;
1035}
1036unsafe extern "C" {
1037 pub fn ucl_object_emit_len(
1038 obj: *const ucl_object_t,
1039 emit_type: ucl_emitter,
1040 len: *mut usize,
1041 ) -> *mut ::std::os::raw::c_uchar;
1042}
1043unsafe extern "C" {
1044 pub fn ucl_object_emit_full(
1045 obj: *const ucl_object_t,
1046 emit_type: ucl_emitter,
1047 emitter: *mut ucl_emitter_functions,
1048 comments: *const ucl_object_t,
1049 ) -> bool;
1050}
1051unsafe extern "C" {
1052 pub fn ucl_object_emit_streamline_new(
1053 obj: *const ucl_object_t,
1054 emit_type: ucl_emitter,
1055 emitter: *mut ucl_emitter_functions,
1056 ) -> *mut ucl_emitter_context;
1057}
1058unsafe extern "C" {
1059 pub fn ucl_object_emit_streamline_start_container(
1060 ctx: *mut ucl_emitter_context,
1061 obj: *const ucl_object_t,
1062 ) -> bool;
1063}
1064unsafe extern "C" {
1065 pub fn ucl_object_emit_streamline_add_object(
1066 ctx: *mut ucl_emitter_context,
1067 obj: *const ucl_object_t,
1068 );
1069}
1070unsafe extern "C" {
1071 pub fn ucl_object_emit_streamline_end_container(ctx: *mut ucl_emitter_context);
1072}
1073unsafe extern "C" {
1074 pub fn ucl_object_emit_streamline_finish(ctx: *mut ucl_emitter_context);
1075}
1076unsafe extern "C" {
1077 pub fn ucl_object_emit_memory_funcs(
1078 pmem: *mut *mut ::std::os::raw::c_void,
1079 ) -> *mut ucl_emitter_functions;
1080}
1081unsafe extern "C" {
1082 pub fn ucl_object_emit_fd_funcs(fd: ::std::os::raw::c_int) -> *mut ucl_emitter_functions;
1083}
1084unsafe extern "C" {
1085 pub fn ucl_object_emit_funcs_free(f: *mut ucl_emitter_functions);
1086}
1087#[repr(u32)]
1088#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
1089pub enum ucl_schema_error_code {
1090 UCL_SCHEMA_OK = 0,
1091 UCL_SCHEMA_TYPE_MISMATCH = 1,
1092 UCL_SCHEMA_INVALID_SCHEMA = 2,
1093 UCL_SCHEMA_MISSING_PROPERTY = 3,
1094 UCL_SCHEMA_CONSTRAINT = 4,
1095 UCL_SCHEMA_MISSING_DEPENDENCY = 5,
1096 UCL_SCHEMA_EXTERNAL_REF_MISSING = 6,
1097 UCL_SCHEMA_EXTERNAL_REF_INVALID = 7,
1098 UCL_SCHEMA_INTERNAL_ERROR = 8,
1099 UCL_SCHEMA_UNKNOWN = 9,
1100}
1101#[repr(C)]
1102#[derive(Debug, Copy, Clone)]
1103pub struct ucl_schema_error {
1104 pub code: ucl_schema_error_code,
1105 pub msg: [::std::os::raw::c_char; 128usize],
1106 pub obj: *const ucl_object_t,
1107}
1108#[allow(clippy::unnecessary_operation, clippy::identity_op)]
1109const _: () = {
1110 ["Size of ucl_schema_error"][::std::mem::size_of::<ucl_schema_error>() - 144usize];
1111 ["Alignment of ucl_schema_error"][::std::mem::align_of::<ucl_schema_error>() - 8usize];
1112 ["Offset of field: ucl_schema_error::code"]
1113 [::std::mem::offset_of!(ucl_schema_error, code) - 0usize];
1114 ["Offset of field: ucl_schema_error::msg"]
1115 [::std::mem::offset_of!(ucl_schema_error, msg) - 4usize];
1116 ["Offset of field: ucl_schema_error::obj"]
1117 [::std::mem::offset_of!(ucl_schema_error, obj) - 136usize];
1118};
1119unsafe extern "C" {
1120 pub fn ucl_object_validate(
1121 schema: *const ucl_object_t,
1122 obj: *const ucl_object_t,
1123 err: *mut ucl_schema_error,
1124 ) -> bool;
1125}
1126unsafe extern "C" {
1127 pub fn ucl_object_validate_root(
1128 schema: *const ucl_object_t,
1129 obj: *const ucl_object_t,
1130 root: *const ucl_object_t,
1131 err: *mut ucl_schema_error,
1132 ) -> bool;
1133}
1134unsafe extern "C" {
1135 pub fn ucl_object_validate_root_ext(
1136 schema: *const ucl_object_t,
1137 obj: *const ucl_object_t,
1138 root: *const ucl_object_t,
1139 ext_refs: *mut ucl_object_t,
1140 err: *mut ucl_schema_error,
1141 ) -> bool;
1142}