pub const _STDINT_H: u32 = 1;
pub const _FEATURES_H: u32 = 1;
pub const _DEFAULT_SOURCE: u32 = 1;
pub const __GLIBC_USE_ISOC2X: u32 = 0;
pub const __USE_ISOC11: u32 = 1;
pub const __USE_ISOC99: u32 = 1;
pub const __USE_ISOC95: u32 = 1;
pub const __USE_POSIX_IMPLICITLY: u32 = 1;
pub const _POSIX_SOURCE: u32 = 1;
pub const _POSIX_C_SOURCE: u32 = 200809;
pub const __USE_POSIX: u32 = 1;
pub const __USE_POSIX2: u32 = 1;
pub const __USE_POSIX199309: u32 = 1;
pub const __USE_POSIX199506: u32 = 1;
pub const __USE_XOPEN2K: u32 = 1;
pub const __USE_XOPEN2K8: u32 = 1;
pub const _ATFILE_SOURCE: u32 = 1;
pub const __USE_MISC: u32 = 1;
pub const __USE_ATFILE: u32 = 1;
pub const __USE_FORTIFY_LEVEL: u32 = 0;
pub const __GLIBC_USE_DEPRECATED_GETS: u32 = 0;
pub const __GLIBC_USE_DEPRECATED_SCANF: u32 = 0;
pub const _STDC_PREDEF_H: u32 = 1;
pub const __STDC_IEC_559__: u32 = 1;
pub const __STDC_IEC_559_COMPLEX__: u32 = 1;
pub const __STDC_ISO_10646__: u32 = 201706;
pub const __GNU_LIBRARY__: u32 = 6;
pub const __GLIBC__: u32 = 2;
pub const __GLIBC_MINOR__: u32 = 31;
pub const _SYS_CDEFS_H: u32 = 1;
pub const __glibc_c99_flexarr_available: u32 = 1;
pub const __WORDSIZE: u32 = 64;
pub const __WORDSIZE_TIME64_COMPAT32: u32 = 1;
pub const __SYSCALL_WORDSIZE: u32 = 64;
pub const __LONG_DOUBLE_USES_FLOAT128: u32 = 0;
pub const __HAVE_GENERIC_SELECTION: u32 = 1;
pub const __GLIBC_USE_LIB_EXT2: u32 = 0;
pub const __GLIBC_USE_IEC_60559_BFP_EXT: u32 = 0;
pub const __GLIBC_USE_IEC_60559_BFP_EXT_C2X: u32 = 0;
pub const __GLIBC_USE_IEC_60559_FUNCS_EXT: u32 = 0;
pub const __GLIBC_USE_IEC_60559_FUNCS_EXT_C2X: u32 = 0;
pub const __GLIBC_USE_IEC_60559_TYPES_EXT: u32 = 0;
pub const _BITS_TYPES_H: u32 = 1;
pub const __TIMESIZE: u32 = 64;
pub const _BITS_TYPESIZES_H: u32 = 1;
pub const __OFF_T_MATCHES_OFF64_T: u32 = 1;
pub const __INO_T_MATCHES_INO64_T: u32 = 1;
pub const __RLIM_T_MATCHES_RLIM64_T: u32 = 1;
pub const __STATFS_MATCHES_STATFS64: u32 = 1;
pub const __FD_SETSIZE: u32 = 1024;
pub const _BITS_TIME64_H: u32 = 1;
pub const _BITS_WCHAR_H: u32 = 1;
pub const _BITS_STDINT_INTN_H: u32 = 1;
pub const _BITS_STDINT_UINTN_H: u32 = 1;
pub const INT8_MIN: i32 = -128;
pub const INT16_MIN: i32 = -32768;
pub const INT32_MIN: i32 = -2147483648;
pub const INT8_MAX: u32 = 127;
pub const INT16_MAX: u32 = 32767;
pub const INT32_MAX: u32 = 2147483647;
pub const UINT8_MAX: u32 = 255;
pub const UINT16_MAX: u32 = 65535;
pub const UINT32_MAX: u32 = 4294967295;
pub const INT_LEAST8_MIN: i32 = -128;
pub const INT_LEAST16_MIN: i32 = -32768;
pub const INT_LEAST32_MIN: i32 = -2147483648;
pub const INT_LEAST8_MAX: u32 = 127;
pub const INT_LEAST16_MAX: u32 = 32767;
pub const INT_LEAST32_MAX: u32 = 2147483647;
pub const UINT_LEAST8_MAX: u32 = 255;
pub const UINT_LEAST16_MAX: u32 = 65535;
pub const UINT_LEAST32_MAX: u32 = 4294967295;
pub const INT_FAST8_MIN: i32 = -128;
pub const INT_FAST16_MIN: i64 = -9223372036854775808;
pub const INT_FAST32_MIN: i64 = -9223372036854775808;
pub const INT_FAST8_MAX: u32 = 127;
pub const INT_FAST16_MAX: u64 = 9223372036854775807;
pub const INT_FAST32_MAX: u64 = 9223372036854775807;
pub const UINT_FAST8_MAX: u32 = 255;
pub const UINT_FAST16_MAX: i32 = -1;
pub const UINT_FAST32_MAX: i32 = -1;
pub const INTPTR_MIN: i64 = -9223372036854775808;
pub const INTPTR_MAX: u64 = 9223372036854775807;
pub const UINTPTR_MAX: i32 = -1;
pub const PTRDIFF_MIN: i64 = -9223372036854775808;
pub const PTRDIFF_MAX: u64 = 9223372036854775807;
pub const SIG_ATOMIC_MIN: i32 = -2147483648;
pub const SIG_ATOMIC_MAX: u32 = 2147483647;
pub const SIZE_MAX: i32 = -1;
pub const WINT_MIN: u32 = 0;
pub const WINT_MAX: u32 = 4294967295;
pub const DECQUADNAME: &'static [u8; 12usize] = b"decimalQuad\0";
pub const DECQUADTITLE: &'static [u8; 22usize] = b"Decimal 128-bit datum\0";
pub const DECQUADAUTHOR: &'static [u8; 15usize] = b"Mike Cowlishaw\0";
pub const DECQUAD_Bytes: u32 = 16;
pub const DECQUAD_Pmax: u32 = 34;
pub const DECQUAD_Emin: i32 = -6143;
pub const DECQUAD_Emax: u32 = 6144;
pub const DECQUAD_EmaxD: u32 = 4;
pub const DECQUAD_Bias: u32 = 6176;
pub const DECQUAD_String: u32 = 43;
pub const DECQUAD_EconL: u32 = 12;
pub const DECQUAD_Declets: u32 = 11;
pub const DECQUAD_Ehigh: u32 = 12287;
pub const DECCNAME: &'static [u8; 11usize] = b"decContext\0";
pub const DECCFULLNAME: &'static [u8; 27usize] = b"Decimal Context Descriptor\0";
pub const DECCAUTHOR: &'static [u8; 15usize] = b"Mike Cowlishaw\0";
pub const _STDIO_H: u32 = 1;
pub const __GNUC_VA_LIST: u32 = 1;
pub const _____fpos_t_defined: u32 = 1;
pub const ____mbstate_t_defined: u32 = 1;
pub const _____fpos64_t_defined: u32 = 1;
pub const ____FILE_defined: u32 = 1;
pub const __FILE_defined: u32 = 1;
pub const __struct_FILE_defined: u32 = 1;
pub const _IO_EOF_SEEN: u32 = 16;
pub const _IO_ERR_SEEN: u32 = 32;
pub const _IO_USER_LOCK: u32 = 32768;
pub const _IOFBF: u32 = 0;
pub const _IOLBF: u32 = 1;
pub const _IONBF: u32 = 2;
pub const BUFSIZ: u32 = 8192;
pub const EOF: i32 = -1;
pub const SEEK_SET: u32 = 0;
pub const SEEK_CUR: u32 = 1;
pub const SEEK_END: u32 = 2;
pub const P_tmpdir: &'static [u8; 5usize] = b"/tmp\0";
pub const _BITS_STDIO_LIM_H: u32 = 1;
pub const L_tmpnam: u32 = 20;
pub const TMP_MAX: u32 = 238328;
pub const FILENAME_MAX: u32 = 4096;
pub const L_ctermid: u32 = 9;
pub const FOPEN_MAX: u32 = 16;
pub const _BITS_SIGNUM_H: u32 = 1;
pub const _BITS_SIGNUM_GENERIC_H: u32 = 1;
pub const SIGINT: u32 = 2;
pub const SIGILL: u32 = 4;
pub const SIGABRT: u32 = 6;
pub const SIGFPE: u32 = 8;
pub const SIGSEGV: u32 = 11;
pub const SIGTERM: u32 = 15;
pub const SIGHUP: u32 = 1;
pub const SIGQUIT: u32 = 3;
pub const SIGTRAP: u32 = 5;
pub const SIGKILL: u32 = 9;
pub const SIGBUS: u32 = 10;
pub const SIGSYS: u32 = 12;
pub const SIGPIPE: u32 = 13;
pub const SIGALRM: u32 = 14;
pub const SIGURG: u32 = 16;
pub const SIGSTOP: u32 = 17;
pub const SIGTSTP: u32 = 18;
pub const SIGCONT: u32 = 19;
pub const SIGCHLD: u32 = 20;
pub const SIGTTIN: u32 = 21;
pub const SIGTTOU: u32 = 22;
pub const SIGPOLL: u32 = 23;
pub const SIGXCPU: u32 = 24;
pub const SIGXFSZ: u32 = 25;
pub const SIGVTALRM: u32 = 26;
pub const SIGPROF: u32 = 27;
pub const SIGUSR1: u32 = 30;
pub const SIGUSR2: u32 = 31;
pub const SIGWINCH: u32 = 28;
pub const SIGIO: u32 = 23;
pub const SIGIOT: u32 = 6;
pub const SIGCLD: u32 = 20;
pub const __SIGRTMIN: u32 = 32;
pub const __SIGRTMAX: u32 = 32;
pub const _NSIG: u32 = 33;
pub const SIGSTKFLT: u32 = 16;
pub const SIGPWR: u32 = 30;
pub const __sig_atomic_t_defined: u32 = 1;
pub const __sigset_t_defined: u32 = 1;
pub const _STRUCT_TIMESPEC: u32 = 1;
pub const _BITS_ENDIAN_H: u32 = 1;
pub const __LITTLE_ENDIAN: u32 = 1234;
pub const __BIG_ENDIAN: u32 = 4321;
pub const __PDP_ENDIAN: u32 = 3412;
pub const _BITS_ENDIANNESS_H: u32 = 1;
pub const __BYTE_ORDER: u32 = 1234;
pub const __FLOAT_WORD_ORDER: u32 = 1234;
pub const __siginfo_t_defined: u32 = 1;
pub const __SI_MAX_SIZE: u32 = 128;
pub const _BITS_SIGINFO_ARCH_H: u32 = 1;
pub const __SI_ERRNO_THEN_CODE: u32 = 1;
pub const __SI_HAVE_SIGSYS: u32 = 1;
pub const _BITS_SIGINFO_CONSTS_H: u32 = 1;
pub const __SI_ASYNCIO_AFTER_SIGIO: u32 = 1;
pub const __sigevent_t_defined: u32 = 1;
pub const __SIGEV_MAX_SIZE: u32 = 64;
pub const __have_pthread_attr_t: u32 = 1;
pub const _BITS_SIGEVENT_CONSTS_H: u32 = 1;
pub const NSIG: u32 = 33;
pub const _BITS_SIGACTION_H: u32 = 1;
pub const SA_NOCLDSTOP: u32 = 1;
pub const SA_NOCLDWAIT: u32 = 2;
pub const SA_SIGINFO: u32 = 4;
pub const SA_ONSTACK: u32 = 134217728;
pub const SA_RESTART: u32 = 268435456;
pub const SA_NODEFER: u32 = 1073741824;
pub const SA_RESETHAND: u32 = 2147483648;
pub const SA_INTERRUPT: u32 = 536870912;
pub const SA_NOMASK: u32 = 1073741824;
pub const SA_ONESHOT: u32 = 2147483648;
pub const SA_STACK: u32 = 134217728;
pub const SIG_BLOCK: u32 = 0;
pub const SIG_UNBLOCK: u32 = 1;
pub const SIG_SETMASK: u32 = 2;
pub const _BITS_SIGCONTEXT_H: u32 = 1;
pub const FP_XSTATE_MAGIC1: u32 = 1179670611;
pub const FP_XSTATE_MAGIC2: u32 = 1179670597;
pub const __stack_t_defined: u32 = 1;
pub const _SYS_UCONTEXT_H: u32 = 1;
pub const __NGREG: u32 = 23;
pub const NGREG: u32 = 23;
pub const _BITS_SIGSTACK_H: u32 = 1;
pub const MINSIGSTKSZ: u32 = 2048;
pub const SIGSTKSZ: u32 = 8192;
pub const _BITS_SS_FLAGS_H: u32 = 1;
pub const __sigstack_defined: u32 = 1;
pub const _BITS_PTHREADTYPES_COMMON_H: u32 = 1;
pub const _THREAD_SHARED_TYPES_H: u32 = 1;
pub const _BITS_PTHREADTYPES_ARCH_H: u32 = 1;
pub const __SIZEOF_PTHREAD_MUTEX_T: u32 = 40;
pub const __SIZEOF_PTHREAD_ATTR_T: u32 = 56;
pub const __SIZEOF_PTHREAD_RWLOCK_T: u32 = 56;
pub const __SIZEOF_PTHREAD_BARRIER_T: u32 = 32;
pub const __SIZEOF_PTHREAD_MUTEXATTR_T: u32 = 4;
pub const __SIZEOF_PTHREAD_COND_T: u32 = 48;
pub const __SIZEOF_PTHREAD_CONDATTR_T: u32 = 4;
pub const __SIZEOF_PTHREAD_RWLOCKATTR_T: u32 = 8;
pub const __SIZEOF_PTHREAD_BARRIERATTR_T: u32 = 4;
pub const _THREAD_MUTEX_INTERNAL_H: u32 = 1;
pub const __PTHREAD_MUTEX_HAVE_PREV: u32 = 1;
pub const _BITS_SIGTHREAD_H: u32 = 1;
pub const DECEXTFLAG: u32 = 1;
pub const DECSUBSET: u32 = 0;
pub const DEC_MAX_DIGITS: u32 = 999999999;
pub const DEC_MIN_DIGITS: u32 = 1;
pub const DEC_MAX_EMAX: u32 = 999999999;
pub const DEC_MIN_EMAX: u32 = 0;
pub const DEC_MAX_EMIN: u32 = 0;
pub const DEC_MIN_EMIN: i32 = -999999999;
pub const DEC_MAX_MATH: u32 = 999999;
pub const DEC_ClassString_SN: &'static [u8; 5usize] = b"sNaN\0";
pub const DEC_ClassString_QN: &'static [u8; 4usize] = b"NaN\0";
pub const DEC_ClassString_NI: &'static [u8; 10usize] = b"-Infinity\0";
pub const DEC_ClassString_NN: &'static [u8; 8usize] = b"-Normal\0";
pub const DEC_ClassString_NS: &'static [u8; 11usize] = b"-Subnormal\0";
pub const DEC_ClassString_NZ: &'static [u8; 6usize] = b"-Zero\0";
pub const DEC_ClassString_PZ: &'static [u8; 6usize] = b"+Zero\0";
pub const DEC_ClassString_PS: &'static [u8; 11usize] = b"+Subnormal\0";
pub const DEC_ClassString_PN: &'static [u8; 8usize] = b"+Normal\0";
pub const DEC_ClassString_PI: &'static [u8; 10usize] = b"+Infinity\0";
pub const DEC_ClassString_UN: &'static [u8; 8usize] = b"Invalid\0";
pub const DEC_Conversion_syntax: u32 = 1;
pub const DEC_Division_by_zero: u32 = 2;
pub const DEC_Division_impossible: u32 = 4;
pub const DEC_Division_undefined: u32 = 8;
pub const DEC_Insufficient_storage: u32 = 16;
pub const DEC_Inexact: u32 = 32;
pub const DEC_Invalid_context: u32 = 64;
pub const DEC_Invalid_operation: u32 = 128;
pub const DEC_Overflow: u32 = 512;
pub const DEC_Clamped: u32 = 1024;
pub const DEC_Rounded: u32 = 2048;
pub const DEC_Subnormal: u32 = 4096;
pub const DEC_Underflow: u32 = 8192;
pub const DEC_IEEE_754_Division_by_zero: u32 = 2;
pub const DEC_IEEE_754_Inexact: u32 = 32;
pub const DEC_IEEE_754_Invalid_operation: u32 = 221;
pub const DEC_IEEE_754_Overflow: u32 = 512;
pub const DEC_IEEE_754_Underflow: u32 = 8192;
pub const DEC_Errors: u32 = 8927;
pub const DEC_NaNs: u32 = 221;
pub const DEC_Information: u32 = 3104;
pub const DEC_IEEE_854_Division_by_zero: u32 = 2;
pub const DEC_IEEE_854_Inexact: u32 = 32;
pub const DEC_IEEE_854_Invalid_operation: u32 = 221;
pub const DEC_IEEE_854_Overflow: u32 = 512;
pub const DEC_IEEE_854_Underflow: u32 = 8192;
pub const DEC_Condition_CS: &'static [u8; 18usize] = b"Conversion syntax\0";
pub const DEC_Condition_DZ: &'static [u8; 17usize] = b"Division by zero\0";
pub const DEC_Condition_DI: &'static [u8; 20usize] = b"Division impossible\0";
pub const DEC_Condition_DU: &'static [u8; 19usize] = b"Division undefined\0";
pub const DEC_Condition_IE: &'static [u8; 8usize] = b"Inexact\0";
pub const DEC_Condition_IS: &'static [u8; 21usize] = b"Insufficient storage\0";
pub const DEC_Condition_IC: &'static [u8; 16usize] = b"Invalid context\0";
pub const DEC_Condition_IO: &'static [u8; 18usize] = b"Invalid operation\0";
pub const DEC_Condition_OV: &'static [u8; 9usize] = b"Overflow\0";
pub const DEC_Condition_PA: &'static [u8; 8usize] = b"Clamped\0";
pub const DEC_Condition_RO: &'static [u8; 8usize] = b"Rounded\0";
pub const DEC_Condition_SU: &'static [u8; 10usize] = b"Subnormal\0";
pub const DEC_Condition_UN: &'static [u8; 10usize] = b"Underflow\0";
pub const DEC_Condition_ZE: &'static [u8; 10usize] = b"No status\0";
pub const DEC_Condition_MU: &'static [u8; 16usize] = b"Multiple status\0";
pub const DEC_Condition_Length: u32 = 21;
pub const DEC_INIT_BASE: u32 = 0;
pub const DEC_INIT_DECIMAL32: u32 = 32;
pub const DEC_INIT_DECIMAL64: u32 = 64;
pub const DEC_INIT_DECIMAL128: u32 = 128;
pub const DEC_INIT_DECSINGLE: u32 = 32;
pub const DEC_INIT_DECDOUBLE: u32 = 64;
pub const DEC_INIT_DECQUAD: u32 = 128;
pub const DECFLOAT_Sign: u32 = 2147483648;
pub const DECFLOAT_NaN: u32 = 2080374784;
pub const DECFLOAT_qNaN: u32 = 2080374784;
pub const DECFLOAT_sNaN: u32 = 2113929216;
pub const DECFLOAT_Inf: u32 = 2013265920;
pub const DECFLOAT_MinSp: u32 = 2013265920;
pub const DECPPLUSALT: u32 = 10;
pub const DECPMINUSALT: u32 = 11;
pub const DECPPLUS: u32 = 12;
pub const DECPMINUS: u32 = 13;
pub const DECPPLUSALT2: u32 = 14;
pub const DECPUNSIGNED: u32 = 15;
pub const DECNAME: &'static [u8; 10usize] = b"decNumber\0";
pub const DECFULLNAME: &'static [u8; 22usize] = b"Decimal Number Module\0";
pub const DECAUTHOR: &'static [u8; 15usize] = b"Mike Cowlishaw\0";
pub const DECNEG: u32 = 128;
pub const DECINF: u32 = 64;
pub const DECNAN: u32 = 32;
pub const DECSNAN: u32 = 16;
pub const DECSPECIAL: u32 = 112;
pub const DECDPUN: u32 = 3;
pub const TRUE: u32 = 1;
pub const FALSE: u32 = 0;
pub const MAX_INT32: u32 = 2147483647;
pub const MIN_INT32: i32 = -2147483648;
pub const MAX_INT64: u64 = 9223372036854775807;
pub const MIN_INT64: i64 = -9223372036854775808;
pub const tid_none_INT: i32 = -512;
pub const tid_EOF_INT: i32 = -256;
pub const tid_NULL_INT: u32 = 0;
pub const tid_BOOL_INT: u32 = 256;
pub const tid_INT_INT: u32 = 512;
pub const tid_FLOAT_INT: u32 = 1024;
pub const tid_DECIMAL_INT: u32 = 1280;
pub const tid_TIMESTAMP_INT: u32 = 1536;
pub const tid_SYMBOL_INT: u32 = 1792;
pub const tid_STRING_INT: u32 = 2048;
pub const tid_CLOB_INT: u32 = 2304;
pub const tid_BLOB_INT: u32 = 2560;
pub const tid_LIST_INT: u32 = 2816;
pub const tid_SEXP_INT: u32 = 3072;
pub const tid_STRUCT_INT: u32 = 3328;
pub const tid_DATAGRAM_INT: u32 = 3840;
pub const MAX_SIZE: u32 = 2147483647;
pub const _STRING_H: u32 = 1;
pub const _BITS_TYPES_LOCALE_T_H: u32 = 1;
pub const _BITS_TYPES___LOCALE_T_H: u32 = 1;
pub const _STRINGS_H: u32 = 1;
pub const DEFAULT_STRING_LENGTH: u32 = 8;
pub const _TIME_H: u32 = 1;
pub const _BITS_TIME_H: u32 = 1;
pub const CLOCK_REALTIME: u32 = 0;
pub const CLOCK_MONOTONIC: u32 = 1;
pub const CLOCK_PROCESS_CPUTIME_ID: u32 = 2;
pub const CLOCK_THREAD_CPUTIME_ID: u32 = 3;
pub const CLOCK_MONOTONIC_RAW: u32 = 4;
pub const CLOCK_REALTIME_COARSE: u32 = 5;
pub const CLOCK_MONOTONIC_COARSE: u32 = 6;
pub const CLOCK_BOOTTIME: u32 = 7;
pub const CLOCK_REALTIME_ALARM: u32 = 8;
pub const CLOCK_BOOTTIME_ALARM: u32 = 9;
pub const CLOCK_TAI: u32 = 11;
pub const TIMER_ABSTIME: u32 = 1;
pub const __clock_t_defined: u32 = 1;
pub const __time_t_defined: u32 = 1;
pub const __struct_tm_defined: u32 = 1;
pub const __clockid_t_defined: u32 = 1;
pub const __timer_t_defined: u32 = 1;
pub const __itimerspec_defined: u32 = 1;
pub const TIME_UTC: u32 = 1;
pub const ION_TT_BIT_YEAR: u32 = 1;
pub const ION_TT_BIT_MONTH: u32 = 2;
pub const ION_TT_BIT_DAY: u32 = 4;
pub const ION_TT_BIT_MIN: u32 = 16;
pub const ION_TT_BIT_SEC: u32 = 32;
pub const ION_TT_BIT_FRAC: u32 = 64;
pub const ION_TS_YEAR: u32 = 1;
pub const ION_TS_MONTH: u32 = 3;
pub const ION_TS_DAY: u32 = 7;
pub const ION_TS_MIN: u32 = 23;
pub const ION_TS_SEC: u32 = 55;
pub const ION_TS_FRAC: u32 = 119;
pub const ION_MAX_TIMESTAMP_STRING: u32 = 69;
pub const II_PLUS: u8 = 43u8;
pub const II_MINUS: u8 = 45u8;
pub const II_STRING_BASE: u32 = 10;
pub const II_BITS_PER_DEC_DIGIT: f64 = 3.35;
pub const II_DEC_DIGIT_PER_BITS: f64 = 3.32191780821918;
pub const II_II_DIGITS_PER_DEC_DIGIT: f64 = 0.108064516;
pub const II_DEC_DIGITS_PER_II_DIGIT: f64 = 9.253731343;
pub const II_BITS_PER_HEX_DIGIT: u32 = 4;
pub const II_HEX_BASE: u32 = 16;
pub const II_HEX_RADIX_CHARS: &'static [u8; 3usize] = b"xX\0";
pub const II_BITS_PER_BINARY_DIGIT: u32 = 1;
pub const II_BINARY_BASE: u32 = 2;
pub const II_BINARY_RADIX_CHARS: &'static [u8; 3usize] = b"bB\0";
pub const II_BITS_PER_BYTE: u32 = 8;
pub const II_BYTE_BASE: u32 = 256;
pub const II_BYTE_MASK: u32 = 255;
pub const II_BYTE_SIGN_BIT: u32 = 128;
pub const II_BYTE_NEG_OVERFLOW_LIMIT: u32 = 254;
pub const UNKNOWN_SID: i32 = -1;
pub const ION_SYS_SYMBOL_SHARED_SYMBOL_TABLE: &'static [u8; 25usize] =
b"$ion_shared_symbol_table\0";
pub const ION_SYS_STRLEN_SHARED_SYMBOL_TABLE: u32 = 24;
pub const ION_SYS_SYMBOL_ION: &'static [u8; 5usize] = b"$ion\0";
pub const ION_SYS_SYMBOL_IVM: &'static [u8; 9usize] = b"$ion_1_0\0";
pub const ION_SYS_SYMBOL_ION_SYMBOL_TABLE: &'static [u8; 18usize] = b"$ion_symbol_table\0";
pub const ION_SYS_SYMBOL_NAME: &'static [u8; 5usize] = b"name\0";
pub const ION_SYS_SYMBOL_VERSION: &'static [u8; 8usize] = b"version\0";
pub const ION_SYS_SYMBOL_IMPORTS: &'static [u8; 8usize] = b"imports\0";
pub const ION_SYS_SYMBOL_SYMBOLS: &'static [u8; 8usize] = b"symbols\0";
pub const ION_SYS_SYMBOL_MAX_ID: &'static [u8; 7usize] = b"max_id\0";
pub const ION_SYS_SYMBOL_MAX_ID_UNDEFINED: i32 = -1;
pub const ION_SYS_SID_ION: u32 = 1;
pub const ION_SYS_SID_IVM: u32 = 2;
pub const ION_SYS_SID_SYMBOL_TABLE: u32 = 3;
pub const ION_SYS_SID_NAME: u32 = 4;
pub const ION_SYS_SID_VERSION: u32 = 5;
pub const ION_SYS_SID_IMPORTS: u32 = 6;
pub const ION_SYS_SID_SYMBOLS: u32 = 7;
pub const ION_SYS_SID_MAX_ID: u32 = 8;
pub const ION_SYS_SID_SHARED_SYMBOL_TABLE: u32 = 9;
pub const ION_SYS_STRLEN_ION: u32 = 4;
pub const ION_SYS_STRLEN_IVM: u32 = 8;
pub const ION_SYS_STRLEN_SYMBOL_TABLE: u32 = 17;
pub const ION_SYS_STRLEN_NAME: u32 = 4;
pub const ION_SYS_STRLEN_VERSION: u32 = 7;
pub const ION_SYS_STRLEN_IMPORTS: u32 = 7;
pub const ION_SYS_STRLEN_SYMBOLS: u32 = 7;
pub const ION_SYS_STRLEN_MAX_ID: u32 = 6;
pub const ION_ERROR_MESSAGE_MAX_LENGTH: u32 = 1024;
pub const ION_TIMESTAMP_STRING_LENGTH: u32 = 55;
pub const ION_VERSION_MARKER_LENGTH: u32 = 4;
pub const ion_error_code_IERR_NOT_IMPL: ion_error_code = -1;
pub const ion_error_code_IERR_OK: ion_error_code = 0;
pub const ion_error_code_IERR_BAD_HANDLE: ion_error_code = 1;
pub const ion_error_code_IERR_INVALID_ARG: ion_error_code = 2;
pub const ion_error_code_IERR_NO_MEMORY: ion_error_code = 3;
pub const ion_error_code_IERR_EOF: ion_error_code = 4;
pub const ion_error_code_IERR_INVALID_STATE: ion_error_code = 5;
pub const ion_error_code_IERR_TOO_MANY_ANNOTATIONS: ion_error_code = 6;
pub const ion_error_code_IERR_UNRECOGNIZED_FLOAT: ion_error_code = 7;
pub const ion_error_code_IERR_NULL_VALUE: ion_error_code = 8;
pub const ion_error_code_IERR_BUFFER_TOO_SMALL: ion_error_code = 9;
pub const ion_error_code_IERR_INVALID_TIMESTAMP: ion_error_code = 10;
pub const ion_error_code_IERR_INVALID_UNICODE_SEQUENCE: ion_error_code = 12;
pub const ion_error_code_IERR_UNREAD_LIMIT_EXCEEDED: ion_error_code = 13;
pub const ion_error_code_IERR_INVALID_TOKEN: ion_error_code = 14;
pub const ion_error_code_IERR_INVALID_UTF8: ion_error_code = 15;
pub const ion_error_code_IERR_LOOKAHEAD_OVERFLOW: ion_error_code = 16;
pub const ion_error_code_IERR_BAD_BASE64_BLOB: ion_error_code = 17;
pub const ion_error_code_IERR_TOKEN_TOO_LONG: ion_error_code = 18;
pub const ion_error_code_IERR_INVALID_UTF8_CHAR: ion_error_code = 19;
pub const ion_error_code_IERR_UNEXPECTED_EOF: ion_error_code = 20;
pub const ion_error_code_IERR_INVALID_ESCAPE_SEQUENCE: ion_error_code = 21;
pub const ion_error_code_IERR_INVALID_SYNTAX: ion_error_code = 22;
pub const ion_error_code_IERR_INVALID_TOKEN_CHAR: ion_error_code = 23;
pub const ion_error_code_IERR_INVALID_SYMBOL: ion_error_code = 24;
pub const ion_error_code_IERR_STACK_UNDERFLOW: ion_error_code = 25;
pub const ion_error_code_IERR_INVALID_SYMBOL_LIST: ion_error_code = 26;
pub const ion_error_code_IERR_PARSER_INTERNAL: ion_error_code = 27;
pub const ion_error_code_IERR_INVALID_SYMBOL_TABLE: ion_error_code = 28;
pub const ion_error_code_IERR_IS_IMMUTABLE: ion_error_code = 29;
pub const ion_error_code_IERR_DUPLICATE_SYMBOL: ion_error_code = 30;
pub const ion_error_code_IERR_DUPLICATE_SYMBOL_ID: ion_error_code = 31;
pub const ion_error_code_IERR_NO_SUCH_ELEMENT: ion_error_code = 32;
pub const ion_error_code_IERR_INVALID_FIELDNAME: ion_error_code = 33;
pub const ion_error_code_IERR_INVALID_BINARY: ion_error_code = 34;
pub const ion_error_code_IERR_IMPORT_NOT_FOUND: ion_error_code = 35;
pub const ion_error_code_IERR_NUMERIC_OVERFLOW: ion_error_code = 36;
pub const ion_error_code_IERR_INVALID_ION_VERSION: ion_error_code = 37;
pub const ion_error_code_IERR_ENTRY_NOT_FOUND: ion_error_code = 38;
pub const ion_error_code_IERR_CANT_FIND_FILE: ion_error_code = 39;
pub const ion_error_code_IERR_STREAM_FAILED: ion_error_code = 40;
pub const ion_error_code_IERR_KEY_ALREADY_EXISTS: ion_error_code = 41;
pub const ion_error_code_IERR_KEY_NOT_FOUND: ion_error_code = 42;
pub const ion_error_code_IERR_KEY_ADDED: ion_error_code = 43;
pub const ion_error_code_IERR_HAS_LOCAL_SYMBOLS: ion_error_code = 44;
pub const ion_error_code_IERR_NOT_A_SYMBOL_TABLE: ion_error_code = 45;
pub const ion_error_code_IERR_MARK_NOT_SET: ion_error_code = 46;
pub const ion_error_code_IERR_WRITE_ERROR: ion_error_code = 47;
pub const ion_error_code_IERR_SEEK_ERROR: ion_error_code = 48;
pub const ion_error_code_IERR_READ_ERROR: ion_error_code = 49;
pub const ion_error_code_IERR_INTERNAL_ERROR: ion_error_code = 50;
pub const ion_error_code_IERR_NEW_LINE_IN_STRING: ion_error_code = 51;
pub const ion_error_code_IERR_INVALID_LEADING_ZEROS: ion_error_code = 52;
pub const ion_error_code_IERR_INVALID_LOB_TERMINATOR: ion_error_code = 53;
pub const ion_error_code_IERR_MAX_ERROR_CODE: ion_error_code = 54;
#[doc = " define the Ion error code enumeration."]
#[doc = ""]
pub type ion_error_code = ::std::os::raw::c_int;
pub use self::ion_error_code as iERR;
extern "C" {
#[doc = " Gets a static string representation of an error code."]
pub fn ion_error_to_str(err: iERR) -> *const ::std::os::raw::c_char;
}
pub type __u_char = ::std::os::raw::c_uchar;
pub type __u_short = ::std::os::raw::c_ushort;
pub type __u_int = ::std::os::raw::c_uint;
pub type __u_long = ::std::os::raw::c_ulong;
pub type __int8_t = ::std::os::raw::c_schar;
pub type __uint8_t = ::std::os::raw::c_uchar;
pub type __int16_t = ::std::os::raw::c_short;
pub type __uint16_t = ::std::os::raw::c_ushort;
pub type __int32_t = ::std::os::raw::c_int;
pub type __uint32_t = ::std::os::raw::c_uint;
pub type __int64_t = ::std::os::raw::c_long;
pub type __uint64_t = ::std::os::raw::c_ulong;
pub type __int_least8_t = __int8_t;
pub type __uint_least8_t = __uint8_t;
pub type __int_least16_t = __int16_t;
pub type __uint_least16_t = __uint16_t;
pub type __int_least32_t = __int32_t;
pub type __uint_least32_t = __uint32_t;
pub type __int_least64_t = __int64_t;
pub type __uint_least64_t = __uint64_t;
pub type __quad_t = ::std::os::raw::c_long;
pub type __u_quad_t = ::std::os::raw::c_ulong;
pub type __intmax_t = ::std::os::raw::c_long;
pub type __uintmax_t = ::std::os::raw::c_ulong;
pub type __dev_t = ::std::os::raw::c_ulong;
pub type __uid_t = ::std::os::raw::c_uint;
pub type __gid_t = ::std::os::raw::c_uint;
pub type __ino_t = ::std::os::raw::c_ulong;
pub type __ino64_t = ::std::os::raw::c_ulong;
pub type __mode_t = ::std::os::raw::c_uint;
pub type __nlink_t = ::std::os::raw::c_ulong;
pub type __off_t = ::std::os::raw::c_long;
pub type __off64_t = ::std::os::raw::c_long;
pub type __pid_t = ::std::os::raw::c_int;
#[repr(C)]
#[derive(Debug, Default, Copy, Clone)]
pub struct __fsid_t {
pub __val: [::std::os::raw::c_int; 2usize],
}
#[test]
fn bindgen_test_layout___fsid_t() {
assert_eq!(
::std::mem::size_of::<__fsid_t>(),
8usize,
concat!("Size of: ", stringify!(__fsid_t))
);
assert_eq!(
::std::mem::align_of::<__fsid_t>(),
4usize,
concat!("Alignment of ", stringify!(__fsid_t))
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<__fsid_t>())).__val as *const _ as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(__fsid_t),
"::",
stringify!(__val)
)
);
}
pub type __clock_t = ::std::os::raw::c_long;
pub type __rlim_t = ::std::os::raw::c_ulong;
pub type __rlim64_t = ::std::os::raw::c_ulong;
pub type __id_t = ::std::os::raw::c_uint;
pub type __time_t = ::std::os::raw::c_long;
pub type __useconds_t = ::std::os::raw::c_uint;
pub type __suseconds_t = ::std::os::raw::c_long;
pub type __daddr_t = ::std::os::raw::c_int;
pub type __key_t = ::std::os::raw::c_int;
pub type __clockid_t = ::std::os::raw::c_int;
pub type __timer_t = *mut ::std::os::raw::c_void;
pub type __blksize_t = ::std::os::raw::c_long;
pub type __blkcnt_t = ::std::os::raw::c_long;
pub type __blkcnt64_t = ::std::os::raw::c_long;
pub type __fsblkcnt_t = ::std::os::raw::c_ulong;
pub type __fsblkcnt64_t = ::std::os::raw::c_ulong;
pub type __fsfilcnt_t = ::std::os::raw::c_ulong;
pub type __fsfilcnt64_t = ::std::os::raw::c_ulong;
pub type __fsword_t = ::std::os::raw::c_long;
pub type __ssize_t = ::std::os::raw::c_long;
pub type __syscall_slong_t = ::std::os::raw::c_long;
pub type __syscall_ulong_t = ::std::os::raw::c_ulong;
pub type __loff_t = __off64_t;
pub type __caddr_t = *mut ::std::os::raw::c_char;
pub type __intptr_t = ::std::os::raw::c_long;
pub type __socklen_t = ::std::os::raw::c_uint;
pub type __sig_atomic_t = ::std::os::raw::c_int;
pub type int_least8_t = __int_least8_t;
pub type int_least16_t = __int_least16_t;
pub type int_least32_t = __int_least32_t;
pub type int_least64_t = __int_least64_t;
pub type uint_least8_t = __uint_least8_t;
pub type uint_least16_t = __uint_least16_t;
pub type uint_least32_t = __uint_least32_t;
pub type uint_least64_t = __uint_least64_t;
pub type int_fast8_t = ::std::os::raw::c_schar;
pub type int_fast16_t = ::std::os::raw::c_long;
pub type int_fast32_t = ::std::os::raw::c_long;
pub type int_fast64_t = ::std::os::raw::c_long;
pub type uint_fast8_t = ::std::os::raw::c_uchar;
pub type uint_fast16_t = ::std::os::raw::c_ulong;
pub type uint_fast32_t = ::std::os::raw::c_ulong;
pub type uint_fast64_t = ::std::os::raw::c_ulong;
pub type intmax_t = __intmax_t;
pub type uintmax_t = __uintmax_t;
pub type size_t = ::std::os::raw::c_ulong;
pub type va_list = __builtin_va_list;
pub type __gnuc_va_list = __builtin_va_list;
#[repr(C)]
#[derive(Copy, Clone)]
pub struct __mbstate_t {
pub __count: ::std::os::raw::c_int,
pub __value: __mbstate_t__bindgen_ty_1,
}
#[repr(C)]
#[derive(Copy, Clone)]
pub union __mbstate_t__bindgen_ty_1 {
pub __wch: ::std::os::raw::c_uint,
pub __wchb: [::std::os::raw::c_char; 4usize],
}
#[test]
fn bindgen_test_layout___mbstate_t__bindgen_ty_1() {
assert_eq!(
::std::mem::size_of::<__mbstate_t__bindgen_ty_1>(),
4usize,
concat!("Size of: ", stringify!(__mbstate_t__bindgen_ty_1))
);
assert_eq!(
::std::mem::align_of::<__mbstate_t__bindgen_ty_1>(),
4usize,
concat!("Alignment of ", stringify!(__mbstate_t__bindgen_ty_1))
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<__mbstate_t__bindgen_ty_1>())).__wch as *const _ as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(__mbstate_t__bindgen_ty_1),
"::",
stringify!(__wch)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<__mbstate_t__bindgen_ty_1>())).__wchb as *const _ as usize
},
0usize,
concat!(
"Offset of field: ",
stringify!(__mbstate_t__bindgen_ty_1),
"::",
stringify!(__wchb)
)
);
}
impl Default for __mbstate_t__bindgen_ty_1 {
fn default() -> Self {
unsafe { ::std::mem::zeroed() }
}
}
#[test]
fn bindgen_test_layout___mbstate_t() {
assert_eq!(
::std::mem::size_of::<__mbstate_t>(),
8usize,
concat!("Size of: ", stringify!(__mbstate_t))
);
assert_eq!(
::std::mem::align_of::<__mbstate_t>(),
4usize,
concat!("Alignment of ", stringify!(__mbstate_t))
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<__mbstate_t>())).__count as *const _ as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(__mbstate_t),
"::",
stringify!(__count)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<__mbstate_t>())).__value as *const _ as usize },
4usize,
concat!(
"Offset of field: ",
stringify!(__mbstate_t),
"::",
stringify!(__value)
)
);
}
impl Default for __mbstate_t {
fn default() -> Self {
unsafe { ::std::mem::zeroed() }
}
}
#[repr(C)]
#[derive(Copy, Clone)]
pub struct _G_fpos_t {
pub __pos: __off_t,
pub __state: __mbstate_t,
}
#[test]
fn bindgen_test_layout__G_fpos_t() {
assert_eq!(
::std::mem::size_of::<_G_fpos_t>(),
16usize,
concat!("Size of: ", stringify!(_G_fpos_t))
);
assert_eq!(
::std::mem::align_of::<_G_fpos_t>(),
8usize,
concat!("Alignment of ", stringify!(_G_fpos_t))
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_G_fpos_t>())).__pos as *const _ as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(_G_fpos_t),
"::",
stringify!(__pos)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_G_fpos_t>())).__state as *const _ as usize },
8usize,
concat!(
"Offset of field: ",
stringify!(_G_fpos_t),
"::",
stringify!(__state)
)
);
}
impl Default for _G_fpos_t {
fn default() -> Self {
unsafe { ::std::mem::zeroed() }
}
}
pub type __fpos_t = _G_fpos_t;
#[repr(C)]
#[derive(Copy, Clone)]
pub struct _G_fpos64_t {
pub __pos: __off64_t,
pub __state: __mbstate_t,
}
#[test]
fn bindgen_test_layout__G_fpos64_t() {
assert_eq!(
::std::mem::size_of::<_G_fpos64_t>(),
16usize,
concat!("Size of: ", stringify!(_G_fpos64_t))
);
assert_eq!(
::std::mem::align_of::<_G_fpos64_t>(),
8usize,
concat!("Alignment of ", stringify!(_G_fpos64_t))
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_G_fpos64_t>())).__pos as *const _ as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(_G_fpos64_t),
"::",
stringify!(__pos)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_G_fpos64_t>())).__state as *const _ as usize },
8usize,
concat!(
"Offset of field: ",
stringify!(_G_fpos64_t),
"::",
stringify!(__state)
)
);
}
impl Default for _G_fpos64_t {
fn default() -> Self {
unsafe { ::std::mem::zeroed() }
}
}
pub type __fpos64_t = _G_fpos64_t;
pub type __FILE = _IO_FILE;
pub type FILE = _IO_FILE;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct _IO_marker {
_unused: [u8; 0],
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct _IO_codecvt {
_unused: [u8; 0],
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct _IO_wide_data {
_unused: [u8; 0],
}
pub type _IO_lock_t = ::std::os::raw::c_void;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct _IO_FILE {
pub _flags: ::std::os::raw::c_int,
pub _IO_read_ptr: *mut ::std::os::raw::c_char,
pub _IO_read_end: *mut ::std::os::raw::c_char,
pub _IO_read_base: *mut ::std::os::raw::c_char,
pub _IO_write_base: *mut ::std::os::raw::c_char,
pub _IO_write_ptr: *mut ::std::os::raw::c_char,
pub _IO_write_end: *mut ::std::os::raw::c_char,
pub _IO_buf_base: *mut ::std::os::raw::c_char,
pub _IO_buf_end: *mut ::std::os::raw::c_char,
pub _IO_save_base: *mut ::std::os::raw::c_char,
pub _IO_backup_base: *mut ::std::os::raw::c_char,
pub _IO_save_end: *mut ::std::os::raw::c_char,
pub _markers: *mut _IO_marker,
pub _chain: *mut _IO_FILE,
pub _fileno: ::std::os::raw::c_int,
pub _flags2: ::std::os::raw::c_int,
pub _old_offset: __off_t,
pub _cur_column: ::std::os::raw::c_ushort,
pub _vtable_offset: ::std::os::raw::c_schar,
pub _shortbuf: [::std::os::raw::c_char; 1usize],
pub _lock: *mut _IO_lock_t,
pub _offset: __off64_t,
pub _codecvt: *mut _IO_codecvt,
pub _wide_data: *mut _IO_wide_data,
pub _freeres_list: *mut _IO_FILE,
pub _freeres_buf: *mut ::std::os::raw::c_void,
pub __pad5: size_t,
pub _mode: ::std::os::raw::c_int,
pub _unused2: [::std::os::raw::c_char; 20usize],
}
#[test]
fn bindgen_test_layout__IO_FILE() {
assert_eq!(
::std::mem::size_of::<_IO_FILE>(),
216usize,
concat!("Size of: ", stringify!(_IO_FILE))
);
assert_eq!(
::std::mem::align_of::<_IO_FILE>(),
8usize,
concat!("Alignment of ", stringify!(_IO_FILE))
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_IO_FILE>()))._flags as *const _ as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(_IO_FILE),
"::",
stringify!(_flags)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_IO_FILE>()))._IO_read_ptr as *const _ as usize },
8usize,
concat!(
"Offset of field: ",
stringify!(_IO_FILE),
"::",
stringify!(_IO_read_ptr)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_IO_FILE>()))._IO_read_end as *const _ as usize },
16usize,
concat!(
"Offset of field: ",
stringify!(_IO_FILE),
"::",
stringify!(_IO_read_end)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_IO_FILE>()))._IO_read_base as *const _ as usize },
24usize,
concat!(
"Offset of field: ",
stringify!(_IO_FILE),
"::",
stringify!(_IO_read_base)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_IO_FILE>()))._IO_write_base as *const _ as usize },
32usize,
concat!(
"Offset of field: ",
stringify!(_IO_FILE),
"::",
stringify!(_IO_write_base)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_IO_FILE>()))._IO_write_ptr as *const _ as usize },
40usize,
concat!(
"Offset of field: ",
stringify!(_IO_FILE),
"::",
stringify!(_IO_write_ptr)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_IO_FILE>()))._IO_write_end as *const _ as usize },
48usize,
concat!(
"Offset of field: ",
stringify!(_IO_FILE),
"::",
stringify!(_IO_write_end)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_IO_FILE>()))._IO_buf_base as *const _ as usize },
56usize,
concat!(
"Offset of field: ",
stringify!(_IO_FILE),
"::",
stringify!(_IO_buf_base)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_IO_FILE>()))._IO_buf_end as *const _ as usize },
64usize,
concat!(
"Offset of field: ",
stringify!(_IO_FILE),
"::",
stringify!(_IO_buf_end)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_IO_FILE>()))._IO_save_base as *const _ as usize },
72usize,
concat!(
"Offset of field: ",
stringify!(_IO_FILE),
"::",
stringify!(_IO_save_base)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_IO_FILE>()))._IO_backup_base as *const _ as usize },
80usize,
concat!(
"Offset of field: ",
stringify!(_IO_FILE),
"::",
stringify!(_IO_backup_base)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_IO_FILE>()))._IO_save_end as *const _ as usize },
88usize,
concat!(
"Offset of field: ",
stringify!(_IO_FILE),
"::",
stringify!(_IO_save_end)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_IO_FILE>()))._markers as *const _ as usize },
96usize,
concat!(
"Offset of field: ",
stringify!(_IO_FILE),
"::",
stringify!(_markers)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_IO_FILE>()))._chain as *const _ as usize },
104usize,
concat!(
"Offset of field: ",
stringify!(_IO_FILE),
"::",
stringify!(_chain)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_IO_FILE>()))._fileno as *const _ as usize },
112usize,
concat!(
"Offset of field: ",
stringify!(_IO_FILE),
"::",
stringify!(_fileno)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_IO_FILE>()))._flags2 as *const _ as usize },
116usize,
concat!(
"Offset of field: ",
stringify!(_IO_FILE),
"::",
stringify!(_flags2)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_IO_FILE>()))._old_offset as *const _ as usize },
120usize,
concat!(
"Offset of field: ",
stringify!(_IO_FILE),
"::",
stringify!(_old_offset)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_IO_FILE>()))._cur_column as *const _ as usize },
128usize,
concat!(
"Offset of field: ",
stringify!(_IO_FILE),
"::",
stringify!(_cur_column)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_IO_FILE>()))._vtable_offset as *const _ as usize },
130usize,
concat!(
"Offset of field: ",
stringify!(_IO_FILE),
"::",
stringify!(_vtable_offset)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_IO_FILE>()))._shortbuf as *const _ as usize },
131usize,
concat!(
"Offset of field: ",
stringify!(_IO_FILE),
"::",
stringify!(_shortbuf)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_IO_FILE>()))._lock as *const _ as usize },
136usize,
concat!(
"Offset of field: ",
stringify!(_IO_FILE),
"::",
stringify!(_lock)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_IO_FILE>()))._offset as *const _ as usize },
144usize,
concat!(
"Offset of field: ",
stringify!(_IO_FILE),
"::",
stringify!(_offset)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_IO_FILE>()))._codecvt as *const _ as usize },
152usize,
concat!(
"Offset of field: ",
stringify!(_IO_FILE),
"::",
stringify!(_codecvt)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_IO_FILE>()))._wide_data as *const _ as usize },
160usize,
concat!(
"Offset of field: ",
stringify!(_IO_FILE),
"::",
stringify!(_wide_data)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_IO_FILE>()))._freeres_list as *const _ as usize },
168usize,
concat!(
"Offset of field: ",
stringify!(_IO_FILE),
"::",
stringify!(_freeres_list)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_IO_FILE>()))._freeres_buf as *const _ as usize },
176usize,
concat!(
"Offset of field: ",
stringify!(_IO_FILE),
"::",
stringify!(_freeres_buf)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_IO_FILE>())).__pad5 as *const _ as usize },
184usize,
concat!(
"Offset of field: ",
stringify!(_IO_FILE),
"::",
stringify!(__pad5)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_IO_FILE>()))._mode as *const _ as usize },
192usize,
concat!(
"Offset of field: ",
stringify!(_IO_FILE),
"::",
stringify!(_mode)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_IO_FILE>()))._unused2 as *const _ as usize },
196usize,
concat!(
"Offset of field: ",
stringify!(_IO_FILE),
"::",
stringify!(_unused2)
)
);
}
impl Default for _IO_FILE {
fn default() -> Self {
unsafe { ::std::mem::zeroed() }
}
}
pub type off_t = __off_t;
pub type ssize_t = __ssize_t;
pub type fpos_t = __fpos_t;
extern "C" {
pub static mut stdin: *mut FILE;
}
extern "C" {
pub static mut stdout: *mut FILE;
}
extern "C" {
pub static mut stderr: *mut FILE;
}
extern "C" {
pub fn remove(__filename: *const ::std::os::raw::c_char) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn rename(
__old: *const ::std::os::raw::c_char,
__new: *const ::std::os::raw::c_char,
) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn renameat(
__oldfd: ::std::os::raw::c_int,
__old: *const ::std::os::raw::c_char,
__newfd: ::std::os::raw::c_int,
__new: *const ::std::os::raw::c_char,
) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn tmpfile() -> *mut FILE;
}
extern "C" {
pub fn tmpnam(__s: *mut ::std::os::raw::c_char) -> *mut ::std::os::raw::c_char;
}
extern "C" {
pub fn tmpnam_r(__s: *mut ::std::os::raw::c_char) -> *mut ::std::os::raw::c_char;
}
extern "C" {
pub fn tempnam(
__dir: *const ::std::os::raw::c_char,
__pfx: *const ::std::os::raw::c_char,
) -> *mut ::std::os::raw::c_char;
}
extern "C" {
pub fn fclose(__stream: *mut FILE) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn fflush(__stream: *mut FILE) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn fflush_unlocked(__stream: *mut FILE) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn fopen(
__filename: *const ::std::os::raw::c_char,
__modes: *const ::std::os::raw::c_char,
) -> *mut FILE;
}
extern "C" {
pub fn freopen(
__filename: *const ::std::os::raw::c_char,
__modes: *const ::std::os::raw::c_char,
__stream: *mut FILE,
) -> *mut FILE;
}
extern "C" {
pub fn fdopen(__fd: ::std::os::raw::c_int, __modes: *const ::std::os::raw::c_char)
-> *mut FILE;
}
extern "C" {
pub fn fmemopen(
__s: *mut ::std::os::raw::c_void,
__len: size_t,
__modes: *const ::std::os::raw::c_char,
) -> *mut FILE;
}
extern "C" {
pub fn open_memstream(
__bufloc: *mut *mut ::std::os::raw::c_char,
__sizeloc: *mut size_t,
) -> *mut FILE;
}
extern "C" {
pub fn setbuf(__stream: *mut FILE, __buf: *mut ::std::os::raw::c_char);
}
extern "C" {
pub fn setvbuf(
__stream: *mut FILE,
__buf: *mut ::std::os::raw::c_char,
__modes: ::std::os::raw::c_int,
__n: size_t,
) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn setbuffer(__stream: *mut FILE, __buf: *mut ::std::os::raw::c_char, __size: size_t);
}
extern "C" {
pub fn setlinebuf(__stream: *mut FILE);
}
extern "C" {
pub fn fprintf(
__stream: *mut FILE,
__format: *const ::std::os::raw::c_char,
...
) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn printf(__format: *const ::std::os::raw::c_char, ...) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn sprintf(
__s: *mut ::std::os::raw::c_char,
__format: *const ::std::os::raw::c_char,
...
) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn vfprintf(
__s: *mut FILE,
__format: *const ::std::os::raw::c_char,
__arg: *mut __va_list_tag,
) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn vprintf(
__format: *const ::std::os::raw::c_char,
__arg: *mut __va_list_tag,
) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn vsprintf(
__s: *mut ::std::os::raw::c_char,
__format: *const ::std::os::raw::c_char,
__arg: *mut __va_list_tag,
) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn snprintf(
__s: *mut ::std::os::raw::c_char,
__maxlen: ::std::os::raw::c_ulong,
__format: *const ::std::os::raw::c_char,
...
) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn vsnprintf(
__s: *mut ::std::os::raw::c_char,
__maxlen: ::std::os::raw::c_ulong,
__format: *const ::std::os::raw::c_char,
__arg: *mut __va_list_tag,
) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn vdprintf(
__fd: ::std::os::raw::c_int,
__fmt: *const ::std::os::raw::c_char,
__arg: *mut __va_list_tag,
) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn dprintf(
__fd: ::std::os::raw::c_int,
__fmt: *const ::std::os::raw::c_char,
...
) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn fscanf(
__stream: *mut FILE,
__format: *const ::std::os::raw::c_char,
...
) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn scanf(__format: *const ::std::os::raw::c_char, ...) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn sscanf(
__s: *const ::std::os::raw::c_char,
__format: *const ::std::os::raw::c_char,
...
) -> ::std::os::raw::c_int;
}
extern "C" {
#[link_name = "\u{1}__isoc99_fscanf"]
pub fn fscanf1(
__stream: *mut FILE,
__format: *const ::std::os::raw::c_char,
...
) -> ::std::os::raw::c_int;
}
extern "C" {
#[link_name = "\u{1}__isoc99_scanf"]
pub fn scanf1(__format: *const ::std::os::raw::c_char, ...) -> ::std::os::raw::c_int;
}
extern "C" {
#[link_name = "\u{1}__isoc99_sscanf"]
pub fn sscanf1(
__s: *const ::std::os::raw::c_char,
__format: *const ::std::os::raw::c_char,
...
) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn vfscanf(
__s: *mut FILE,
__format: *const ::std::os::raw::c_char,
__arg: *mut __va_list_tag,
) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn vscanf(
__format: *const ::std::os::raw::c_char,
__arg: *mut __va_list_tag,
) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn vsscanf(
__s: *const ::std::os::raw::c_char,
__format: *const ::std::os::raw::c_char,
__arg: *mut __va_list_tag,
) -> ::std::os::raw::c_int;
}
extern "C" {
#[link_name = "\u{1}__isoc99_vfscanf"]
pub fn vfscanf1(
__s: *mut FILE,
__format: *const ::std::os::raw::c_char,
__arg: *mut __va_list_tag,
) -> ::std::os::raw::c_int;
}
extern "C" {
#[link_name = "\u{1}__isoc99_vscanf"]
pub fn vscanf1(
__format: *const ::std::os::raw::c_char,
__arg: *mut __va_list_tag,
) -> ::std::os::raw::c_int;
}
extern "C" {
#[link_name = "\u{1}__isoc99_vsscanf"]
pub fn vsscanf1(
__s: *const ::std::os::raw::c_char,
__format: *const ::std::os::raw::c_char,
__arg: *mut __va_list_tag,
) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn fgetc(__stream: *mut FILE) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn getc(__stream: *mut FILE) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn getchar() -> ::std::os::raw::c_int;
}
extern "C" {
pub fn getc_unlocked(__stream: *mut FILE) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn getchar_unlocked() -> ::std::os::raw::c_int;
}
extern "C" {
pub fn fgetc_unlocked(__stream: *mut FILE) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn fputc(__c: ::std::os::raw::c_int, __stream: *mut FILE) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn putc(__c: ::std::os::raw::c_int, __stream: *mut FILE) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn putchar(__c: ::std::os::raw::c_int) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn fputc_unlocked(__c: ::std::os::raw::c_int, __stream: *mut FILE)
-> ::std::os::raw::c_int;
}
extern "C" {
pub fn putc_unlocked(__c: ::std::os::raw::c_int, __stream: *mut FILE) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn putchar_unlocked(__c: ::std::os::raw::c_int) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn getw(__stream: *mut FILE) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn putw(__w: ::std::os::raw::c_int, __stream: *mut FILE) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn fgets(
__s: *mut ::std::os::raw::c_char,
__n: ::std::os::raw::c_int,
__stream: *mut FILE,
) -> *mut ::std::os::raw::c_char;
}
extern "C" {
pub fn __getdelim(
__lineptr: *mut *mut ::std::os::raw::c_char,
__n: *mut size_t,
__delimiter: ::std::os::raw::c_int,
__stream: *mut FILE,
) -> __ssize_t;
}
extern "C" {
pub fn getdelim(
__lineptr: *mut *mut ::std::os::raw::c_char,
__n: *mut size_t,
__delimiter: ::std::os::raw::c_int,
__stream: *mut FILE,
) -> __ssize_t;
}
extern "C" {
pub fn getline(
__lineptr: *mut *mut ::std::os::raw::c_char,
__n: *mut size_t,
__stream: *mut FILE,
) -> __ssize_t;
}
extern "C" {
pub fn fputs(__s: *const ::std::os::raw::c_char, __stream: *mut FILE) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn puts(__s: *const ::std::os::raw::c_char) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn ungetc(__c: ::std::os::raw::c_int, __stream: *mut FILE) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn fread(
__ptr: *mut ::std::os::raw::c_void,
__size: ::std::os::raw::c_ulong,
__n: ::std::os::raw::c_ulong,
__stream: *mut FILE,
) -> ::std::os::raw::c_ulong;
}
extern "C" {
pub fn fwrite(
__ptr: *const ::std::os::raw::c_void,
__size: ::std::os::raw::c_ulong,
__n: ::std::os::raw::c_ulong,
__s: *mut FILE,
) -> ::std::os::raw::c_ulong;
}
extern "C" {
pub fn fread_unlocked(
__ptr: *mut ::std::os::raw::c_void,
__size: size_t,
__n: size_t,
__stream: *mut FILE,
) -> size_t;
}
extern "C" {
pub fn fwrite_unlocked(
__ptr: *const ::std::os::raw::c_void,
__size: size_t,
__n: size_t,
__stream: *mut FILE,
) -> size_t;
}
extern "C" {
pub fn fseek(
__stream: *mut FILE,
__off: ::std::os::raw::c_long,
__whence: ::std::os::raw::c_int,
) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn ftell(__stream: *mut FILE) -> ::std::os::raw::c_long;
}
extern "C" {
pub fn rewind(__stream: *mut FILE);
}
extern "C" {
pub fn fseeko(
__stream: *mut FILE,
__off: __off_t,
__whence: ::std::os::raw::c_int,
) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn ftello(__stream: *mut FILE) -> __off_t;
}
extern "C" {
pub fn fgetpos(__stream: *mut FILE, __pos: *mut fpos_t) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn fsetpos(__stream: *mut FILE, __pos: *const fpos_t) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn clearerr(__stream: *mut FILE);
}
extern "C" {
pub fn feof(__stream: *mut FILE) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn ferror(__stream: *mut FILE) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn clearerr_unlocked(__stream: *mut FILE);
}
extern "C" {
pub fn feof_unlocked(__stream: *mut FILE) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn ferror_unlocked(__stream: *mut FILE) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn perror(__s: *const ::std::os::raw::c_char);
}
extern "C" {
pub static mut sys_nerr: ::std::os::raw::c_int;
}
extern "C" {
pub static mut sys_errlist: [*const ::std::os::raw::c_char; 0usize];
}
extern "C" {
pub fn fileno(__stream: *mut FILE) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn fileno_unlocked(__stream: *mut FILE) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn popen(
__command: *const ::std::os::raw::c_char,
__modes: *const ::std::os::raw::c_char,
) -> *mut FILE;
}
extern "C" {
pub fn pclose(__stream: *mut FILE) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn ctermid(__s: *mut ::std::os::raw::c_char) -> *mut ::std::os::raw::c_char;
}
extern "C" {
pub fn flockfile(__stream: *mut FILE);
}
extern "C" {
pub fn ftrylockfile(__stream: *mut FILE) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn funlockfile(__stream: *mut FILE);
}
extern "C" {
pub fn __uflow(arg1: *mut FILE) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn __overflow(arg1: *mut FILE, arg2: ::std::os::raw::c_int) -> ::std::os::raw::c_int;
}
pub type sig_atomic_t = __sig_atomic_t;
#[repr(C)]
#[derive(Debug, Default, Copy, Clone)]
pub struct __sigset_t {
pub __val: [::std::os::raw::c_ulong; 16usize],
}
#[test]
fn bindgen_test_layout___sigset_t() {
assert_eq!(
::std::mem::size_of::<__sigset_t>(),
128usize,
concat!("Size of: ", stringify!(__sigset_t))
);
assert_eq!(
::std::mem::align_of::<__sigset_t>(),
8usize,
concat!("Alignment of ", stringify!(__sigset_t))
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<__sigset_t>())).__val as *const _ as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(__sigset_t),
"::",
stringify!(__val)
)
);
}
pub type sigset_t = __sigset_t;
pub type pid_t = __pid_t;
pub type uid_t = __uid_t;
#[repr(C)]
#[derive(Debug, Default, Copy, Clone)]
pub struct timespec {
pub tv_sec: __time_t,
pub tv_nsec: __syscall_slong_t,
}
#[test]
fn bindgen_test_layout_timespec() {
assert_eq!(
::std::mem::size_of::<timespec>(),
16usize,
concat!("Size of: ", stringify!(timespec))
);
assert_eq!(
::std::mem::align_of::<timespec>(),
8usize,
concat!("Alignment of ", stringify!(timespec))
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<timespec>())).tv_sec as *const _ as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(timespec),
"::",
stringify!(tv_sec)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<timespec>())).tv_nsec as *const _ as usize },
8usize,
concat!(
"Offset of field: ",
stringify!(timespec),
"::",
stringify!(tv_nsec)
)
);
}
#[repr(C)]
#[derive(Copy, Clone)]
pub union sigval {
pub sival_int: ::std::os::raw::c_int,
pub sival_ptr: *mut ::std::os::raw::c_void,
}
#[test]
fn bindgen_test_layout_sigval() {
assert_eq!(
::std::mem::size_of::<sigval>(),
8usize,
concat!("Size of: ", stringify!(sigval))
);
assert_eq!(
::std::mem::align_of::<sigval>(),
8usize,
concat!("Alignment of ", stringify!(sigval))
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<sigval>())).sival_int as *const _ as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(sigval),
"::",
stringify!(sival_int)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<sigval>())).sival_ptr as *const _ as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(sigval),
"::",
stringify!(sival_ptr)
)
);
}
impl Default for sigval {
fn default() -> Self {
unsafe { ::std::mem::zeroed() }
}
}
pub type __sigval_t = sigval;
#[repr(C)]
#[derive(Copy, Clone)]
pub struct siginfo_t {
pub si_signo: ::std::os::raw::c_int,
pub si_errno: ::std::os::raw::c_int,
pub si_code: ::std::os::raw::c_int,
pub __pad0: ::std::os::raw::c_int,
pub _sifields: siginfo_t__bindgen_ty_1,
}
#[repr(C)]
#[derive(Copy, Clone)]
pub union siginfo_t__bindgen_ty_1 {
pub _pad: [::std::os::raw::c_int; 28usize],
pub _kill: siginfo_t__bindgen_ty_1__bindgen_ty_1,
pub _timer: siginfo_t__bindgen_ty_1__bindgen_ty_2,
pub _rt: siginfo_t__bindgen_ty_1__bindgen_ty_3,
pub _sigchld: siginfo_t__bindgen_ty_1__bindgen_ty_4,
pub _sigfault: siginfo_t__bindgen_ty_1__bindgen_ty_5,
pub _sigpoll: siginfo_t__bindgen_ty_1__bindgen_ty_6,
pub _sigsys: siginfo_t__bindgen_ty_1__bindgen_ty_7,
}
#[repr(C)]
#[derive(Debug, Default, Copy, Clone)]
pub struct siginfo_t__bindgen_ty_1__bindgen_ty_1 {
pub si_pid: __pid_t,
pub si_uid: __uid_t,
}
#[test]
fn bindgen_test_layout_siginfo_t__bindgen_ty_1__bindgen_ty_1() {
assert_eq!(
::std::mem::size_of::<siginfo_t__bindgen_ty_1__bindgen_ty_1>(),
8usize,
concat!(
"Size of: ",
stringify!(siginfo_t__bindgen_ty_1__bindgen_ty_1)
)
);
assert_eq!(
::std::mem::align_of::<siginfo_t__bindgen_ty_1__bindgen_ty_1>(),
4usize,
concat!(
"Alignment of ",
stringify!(siginfo_t__bindgen_ty_1__bindgen_ty_1)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<siginfo_t__bindgen_ty_1__bindgen_ty_1>())).si_pid as *const _
as usize
},
0usize,
concat!(
"Offset of field: ",
stringify!(siginfo_t__bindgen_ty_1__bindgen_ty_1),
"::",
stringify!(si_pid)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<siginfo_t__bindgen_ty_1__bindgen_ty_1>())).si_uid as *const _
as usize
},
4usize,
concat!(
"Offset of field: ",
stringify!(siginfo_t__bindgen_ty_1__bindgen_ty_1),
"::",
stringify!(si_uid)
)
);
}
#[repr(C)]
#[derive(Copy, Clone)]
pub struct siginfo_t__bindgen_ty_1__bindgen_ty_2 {
pub si_tid: ::std::os::raw::c_int,
pub si_overrun: ::std::os::raw::c_int,
pub si_sigval: __sigval_t,
}
#[test]
fn bindgen_test_layout_siginfo_t__bindgen_ty_1__bindgen_ty_2() {
assert_eq!(
::std::mem::size_of::<siginfo_t__bindgen_ty_1__bindgen_ty_2>(),
16usize,
concat!(
"Size of: ",
stringify!(siginfo_t__bindgen_ty_1__bindgen_ty_2)
)
);
assert_eq!(
::std::mem::align_of::<siginfo_t__bindgen_ty_1__bindgen_ty_2>(),
8usize,
concat!(
"Alignment of ",
stringify!(siginfo_t__bindgen_ty_1__bindgen_ty_2)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<siginfo_t__bindgen_ty_1__bindgen_ty_2>())).si_tid as *const _
as usize
},
0usize,
concat!(
"Offset of field: ",
stringify!(siginfo_t__bindgen_ty_1__bindgen_ty_2),
"::",
stringify!(si_tid)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<siginfo_t__bindgen_ty_1__bindgen_ty_2>())).si_overrun as *const _
as usize
},
4usize,
concat!(
"Offset of field: ",
stringify!(siginfo_t__bindgen_ty_1__bindgen_ty_2),
"::",
stringify!(si_overrun)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<siginfo_t__bindgen_ty_1__bindgen_ty_2>())).si_sigval as *const _
as usize
},
8usize,
concat!(
"Offset of field: ",
stringify!(siginfo_t__bindgen_ty_1__bindgen_ty_2),
"::",
stringify!(si_sigval)
)
);
}
impl Default for siginfo_t__bindgen_ty_1__bindgen_ty_2 {
fn default() -> Self {
unsafe { ::std::mem::zeroed() }
}
}
#[repr(C)]
#[derive(Copy, Clone)]
pub struct siginfo_t__bindgen_ty_1__bindgen_ty_3 {
pub si_pid: __pid_t,
pub si_uid: __uid_t,
pub si_sigval: __sigval_t,
}
#[test]
fn bindgen_test_layout_siginfo_t__bindgen_ty_1__bindgen_ty_3() {
assert_eq!(
::std::mem::size_of::<siginfo_t__bindgen_ty_1__bindgen_ty_3>(),
16usize,
concat!(
"Size of: ",
stringify!(siginfo_t__bindgen_ty_1__bindgen_ty_3)
)
);
assert_eq!(
::std::mem::align_of::<siginfo_t__bindgen_ty_1__bindgen_ty_3>(),
8usize,
concat!(
"Alignment of ",
stringify!(siginfo_t__bindgen_ty_1__bindgen_ty_3)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<siginfo_t__bindgen_ty_1__bindgen_ty_3>())).si_pid as *const _
as usize
},
0usize,
concat!(
"Offset of field: ",
stringify!(siginfo_t__bindgen_ty_1__bindgen_ty_3),
"::",
stringify!(si_pid)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<siginfo_t__bindgen_ty_1__bindgen_ty_3>())).si_uid as *const _
as usize
},
4usize,
concat!(
"Offset of field: ",
stringify!(siginfo_t__bindgen_ty_1__bindgen_ty_3),
"::",
stringify!(si_uid)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<siginfo_t__bindgen_ty_1__bindgen_ty_3>())).si_sigval as *const _
as usize
},
8usize,
concat!(
"Offset of field: ",
stringify!(siginfo_t__bindgen_ty_1__bindgen_ty_3),
"::",
stringify!(si_sigval)
)
);
}
impl Default for siginfo_t__bindgen_ty_1__bindgen_ty_3 {
fn default() -> Self {
unsafe { ::std::mem::zeroed() }
}
}
#[repr(C)]
#[derive(Debug, Default, Copy, Clone)]
pub struct siginfo_t__bindgen_ty_1__bindgen_ty_4 {
pub si_pid: __pid_t,
pub si_uid: __uid_t,
pub si_status: ::std::os::raw::c_int,
pub si_utime: __clock_t,
pub si_stime: __clock_t,
}
#[test]
fn bindgen_test_layout_siginfo_t__bindgen_ty_1__bindgen_ty_4() {
assert_eq!(
::std::mem::size_of::<siginfo_t__bindgen_ty_1__bindgen_ty_4>(),
32usize,
concat!(
"Size of: ",
stringify!(siginfo_t__bindgen_ty_1__bindgen_ty_4)
)
);
assert_eq!(
::std::mem::align_of::<siginfo_t__bindgen_ty_1__bindgen_ty_4>(),
8usize,
concat!(
"Alignment of ",
stringify!(siginfo_t__bindgen_ty_1__bindgen_ty_4)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<siginfo_t__bindgen_ty_1__bindgen_ty_4>())).si_pid as *const _
as usize
},
0usize,
concat!(
"Offset of field: ",
stringify!(siginfo_t__bindgen_ty_1__bindgen_ty_4),
"::",
stringify!(si_pid)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<siginfo_t__bindgen_ty_1__bindgen_ty_4>())).si_uid as *const _
as usize
},
4usize,
concat!(
"Offset of field: ",
stringify!(siginfo_t__bindgen_ty_1__bindgen_ty_4),
"::",
stringify!(si_uid)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<siginfo_t__bindgen_ty_1__bindgen_ty_4>())).si_status as *const _
as usize
},
8usize,
concat!(
"Offset of field: ",
stringify!(siginfo_t__bindgen_ty_1__bindgen_ty_4),
"::",
stringify!(si_status)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<siginfo_t__bindgen_ty_1__bindgen_ty_4>())).si_utime as *const _
as usize
},
16usize,
concat!(
"Offset of field: ",
stringify!(siginfo_t__bindgen_ty_1__bindgen_ty_4),
"::",
stringify!(si_utime)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<siginfo_t__bindgen_ty_1__bindgen_ty_4>())).si_stime as *const _
as usize
},
24usize,
concat!(
"Offset of field: ",
stringify!(siginfo_t__bindgen_ty_1__bindgen_ty_4),
"::",
stringify!(si_stime)
)
);
}
#[repr(C)]
#[derive(Copy, Clone)]
pub struct siginfo_t__bindgen_ty_1__bindgen_ty_5 {
pub si_addr: *mut ::std::os::raw::c_void,
pub si_addr_lsb: ::std::os::raw::c_short,
pub _bounds: siginfo_t__bindgen_ty_1__bindgen_ty_5__bindgen_ty_1,
}
#[repr(C)]
#[derive(Copy, Clone)]
pub union siginfo_t__bindgen_ty_1__bindgen_ty_5__bindgen_ty_1 {
pub _addr_bnd: siginfo_t__bindgen_ty_1__bindgen_ty_5__bindgen_ty_1__bindgen_ty_1,
pub _pkey: __uint32_t,
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct siginfo_t__bindgen_ty_1__bindgen_ty_5__bindgen_ty_1__bindgen_ty_1 {
pub _lower: *mut ::std::os::raw::c_void,
pub _upper: *mut ::std::os::raw::c_void,
}
#[test]
fn bindgen_test_layout_siginfo_t__bindgen_ty_1__bindgen_ty_5__bindgen_ty_1__bindgen_ty_1() {
assert_eq!(
::std::mem::size_of::<siginfo_t__bindgen_ty_1__bindgen_ty_5__bindgen_ty_1__bindgen_ty_1>(),
16usize,
concat!(
"Size of: ",
stringify!(siginfo_t__bindgen_ty_1__bindgen_ty_5__bindgen_ty_1__bindgen_ty_1)
)
);
assert_eq!(
::std::mem::align_of::<siginfo_t__bindgen_ty_1__bindgen_ty_5__bindgen_ty_1__bindgen_ty_1>(),
8usize,
concat!(
"Alignment of ",
stringify!(siginfo_t__bindgen_ty_1__bindgen_ty_5__bindgen_ty_1__bindgen_ty_1)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<
siginfo_t__bindgen_ty_1__bindgen_ty_5__bindgen_ty_1__bindgen_ty_1,
>()))
._lower as *const _ as usize
},
0usize,
concat!(
"Offset of field: ",
stringify!(siginfo_t__bindgen_ty_1__bindgen_ty_5__bindgen_ty_1__bindgen_ty_1),
"::",
stringify!(_lower)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<
siginfo_t__bindgen_ty_1__bindgen_ty_5__bindgen_ty_1__bindgen_ty_1,
>()))
._upper as *const _ as usize
},
8usize,
concat!(
"Offset of field: ",
stringify!(siginfo_t__bindgen_ty_1__bindgen_ty_5__bindgen_ty_1__bindgen_ty_1),
"::",
stringify!(_upper)
)
);
}
impl Default for siginfo_t__bindgen_ty_1__bindgen_ty_5__bindgen_ty_1__bindgen_ty_1 {
fn default() -> Self {
unsafe { ::std::mem::zeroed() }
}
}
#[test]
fn bindgen_test_layout_siginfo_t__bindgen_ty_1__bindgen_ty_5__bindgen_ty_1() {
assert_eq!(
::std::mem::size_of::<siginfo_t__bindgen_ty_1__bindgen_ty_5__bindgen_ty_1>(),
16usize,
concat!(
"Size of: ",
stringify!(siginfo_t__bindgen_ty_1__bindgen_ty_5__bindgen_ty_1)
)
);
assert_eq!(
::std::mem::align_of::<siginfo_t__bindgen_ty_1__bindgen_ty_5__bindgen_ty_1>(),
8usize,
concat!(
"Alignment of ",
stringify!(siginfo_t__bindgen_ty_1__bindgen_ty_5__bindgen_ty_1)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<siginfo_t__bindgen_ty_1__bindgen_ty_5__bindgen_ty_1>()))
._addr_bnd as *const _ as usize
},
0usize,
concat!(
"Offset of field: ",
stringify!(siginfo_t__bindgen_ty_1__bindgen_ty_5__bindgen_ty_1),
"::",
stringify!(_addr_bnd)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<siginfo_t__bindgen_ty_1__bindgen_ty_5__bindgen_ty_1>()))._pkey
as *const _ as usize
},
0usize,
concat!(
"Offset of field: ",
stringify!(siginfo_t__bindgen_ty_1__bindgen_ty_5__bindgen_ty_1),
"::",
stringify!(_pkey)
)
);
}
impl Default for siginfo_t__bindgen_ty_1__bindgen_ty_5__bindgen_ty_1 {
fn default() -> Self {
unsafe { ::std::mem::zeroed() }
}
}
#[test]
fn bindgen_test_layout_siginfo_t__bindgen_ty_1__bindgen_ty_5() {
assert_eq!(
::std::mem::size_of::<siginfo_t__bindgen_ty_1__bindgen_ty_5>(),
32usize,
concat!(
"Size of: ",
stringify!(siginfo_t__bindgen_ty_1__bindgen_ty_5)
)
);
assert_eq!(
::std::mem::align_of::<siginfo_t__bindgen_ty_1__bindgen_ty_5>(),
8usize,
concat!(
"Alignment of ",
stringify!(siginfo_t__bindgen_ty_1__bindgen_ty_5)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<siginfo_t__bindgen_ty_1__bindgen_ty_5>())).si_addr as *const _
as usize
},
0usize,
concat!(
"Offset of field: ",
stringify!(siginfo_t__bindgen_ty_1__bindgen_ty_5),
"::",
stringify!(si_addr)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<siginfo_t__bindgen_ty_1__bindgen_ty_5>())).si_addr_lsb
as *const _ as usize
},
8usize,
concat!(
"Offset of field: ",
stringify!(siginfo_t__bindgen_ty_1__bindgen_ty_5),
"::",
stringify!(si_addr_lsb)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<siginfo_t__bindgen_ty_1__bindgen_ty_5>()))._bounds as *const _
as usize
},
16usize,
concat!(
"Offset of field: ",
stringify!(siginfo_t__bindgen_ty_1__bindgen_ty_5),
"::",
stringify!(_bounds)
)
);
}
impl Default for siginfo_t__bindgen_ty_1__bindgen_ty_5 {
fn default() -> Self {
unsafe { ::std::mem::zeroed() }
}
}
#[repr(C)]
#[derive(Debug, Default, Copy, Clone)]
pub struct siginfo_t__bindgen_ty_1__bindgen_ty_6 {
pub si_band: ::std::os::raw::c_long,
pub si_fd: ::std::os::raw::c_int,
}
#[test]
fn bindgen_test_layout_siginfo_t__bindgen_ty_1__bindgen_ty_6() {
assert_eq!(
::std::mem::size_of::<siginfo_t__bindgen_ty_1__bindgen_ty_6>(),
16usize,
concat!(
"Size of: ",
stringify!(siginfo_t__bindgen_ty_1__bindgen_ty_6)
)
);
assert_eq!(
::std::mem::align_of::<siginfo_t__bindgen_ty_1__bindgen_ty_6>(),
8usize,
concat!(
"Alignment of ",
stringify!(siginfo_t__bindgen_ty_1__bindgen_ty_6)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<siginfo_t__bindgen_ty_1__bindgen_ty_6>())).si_band as *const _
as usize
},
0usize,
concat!(
"Offset of field: ",
stringify!(siginfo_t__bindgen_ty_1__bindgen_ty_6),
"::",
stringify!(si_band)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<siginfo_t__bindgen_ty_1__bindgen_ty_6>())).si_fd as *const _
as usize
},
8usize,
concat!(
"Offset of field: ",
stringify!(siginfo_t__bindgen_ty_1__bindgen_ty_6),
"::",
stringify!(si_fd)
)
);
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct siginfo_t__bindgen_ty_1__bindgen_ty_7 {
pub _call_addr: *mut ::std::os::raw::c_void,
pub _syscall: ::std::os::raw::c_int,
pub _arch: ::std::os::raw::c_uint,
}
#[test]
fn bindgen_test_layout_siginfo_t__bindgen_ty_1__bindgen_ty_7() {
assert_eq!(
::std::mem::size_of::<siginfo_t__bindgen_ty_1__bindgen_ty_7>(),
16usize,
concat!(
"Size of: ",
stringify!(siginfo_t__bindgen_ty_1__bindgen_ty_7)
)
);
assert_eq!(
::std::mem::align_of::<siginfo_t__bindgen_ty_1__bindgen_ty_7>(),
8usize,
concat!(
"Alignment of ",
stringify!(siginfo_t__bindgen_ty_1__bindgen_ty_7)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<siginfo_t__bindgen_ty_1__bindgen_ty_7>()))._call_addr as *const _
as usize
},
0usize,
concat!(
"Offset of field: ",
stringify!(siginfo_t__bindgen_ty_1__bindgen_ty_7),
"::",
stringify!(_call_addr)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<siginfo_t__bindgen_ty_1__bindgen_ty_7>()))._syscall as *const _
as usize
},
8usize,
concat!(
"Offset of field: ",
stringify!(siginfo_t__bindgen_ty_1__bindgen_ty_7),
"::",
stringify!(_syscall)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<siginfo_t__bindgen_ty_1__bindgen_ty_7>()))._arch as *const _
as usize
},
12usize,
concat!(
"Offset of field: ",
stringify!(siginfo_t__bindgen_ty_1__bindgen_ty_7),
"::",
stringify!(_arch)
)
);
}
impl Default for siginfo_t__bindgen_ty_1__bindgen_ty_7 {
fn default() -> Self {
unsafe { ::std::mem::zeroed() }
}
}
#[test]
fn bindgen_test_layout_siginfo_t__bindgen_ty_1() {
assert_eq!(
::std::mem::size_of::<siginfo_t__bindgen_ty_1>(),
112usize,
concat!("Size of: ", stringify!(siginfo_t__bindgen_ty_1))
);
assert_eq!(
::std::mem::align_of::<siginfo_t__bindgen_ty_1>(),
8usize,
concat!("Alignment of ", stringify!(siginfo_t__bindgen_ty_1))
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<siginfo_t__bindgen_ty_1>()))._pad as *const _ as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(siginfo_t__bindgen_ty_1),
"::",
stringify!(_pad)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<siginfo_t__bindgen_ty_1>()))._kill as *const _ as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(siginfo_t__bindgen_ty_1),
"::",
stringify!(_kill)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<siginfo_t__bindgen_ty_1>()))._timer as *const _ as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(siginfo_t__bindgen_ty_1),
"::",
stringify!(_timer)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<siginfo_t__bindgen_ty_1>()))._rt as *const _ as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(siginfo_t__bindgen_ty_1),
"::",
stringify!(_rt)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<siginfo_t__bindgen_ty_1>()))._sigchld as *const _ as usize
},
0usize,
concat!(
"Offset of field: ",
stringify!(siginfo_t__bindgen_ty_1),
"::",
stringify!(_sigchld)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<siginfo_t__bindgen_ty_1>()))._sigfault as *const _ as usize
},
0usize,
concat!(
"Offset of field: ",
stringify!(siginfo_t__bindgen_ty_1),
"::",
stringify!(_sigfault)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<siginfo_t__bindgen_ty_1>()))._sigpoll as *const _ as usize
},
0usize,
concat!(
"Offset of field: ",
stringify!(siginfo_t__bindgen_ty_1),
"::",
stringify!(_sigpoll)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<siginfo_t__bindgen_ty_1>()))._sigsys as *const _ as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(siginfo_t__bindgen_ty_1),
"::",
stringify!(_sigsys)
)
);
}
impl Default for siginfo_t__bindgen_ty_1 {
fn default() -> Self {
unsafe { ::std::mem::zeroed() }
}
}
#[test]
fn bindgen_test_layout_siginfo_t() {
assert_eq!(
::std::mem::size_of::<siginfo_t>(),
128usize,
concat!("Size of: ", stringify!(siginfo_t))
);
assert_eq!(
::std::mem::align_of::<siginfo_t>(),
8usize,
concat!("Alignment of ", stringify!(siginfo_t))
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<siginfo_t>())).si_signo as *const _ as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(siginfo_t),
"::",
stringify!(si_signo)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<siginfo_t>())).si_errno as *const _ as usize },
4usize,
concat!(
"Offset of field: ",
stringify!(siginfo_t),
"::",
stringify!(si_errno)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<siginfo_t>())).si_code as *const _ as usize },
8usize,
concat!(
"Offset of field: ",
stringify!(siginfo_t),
"::",
stringify!(si_code)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<siginfo_t>())).__pad0 as *const _ as usize },
12usize,
concat!(
"Offset of field: ",
stringify!(siginfo_t),
"::",
stringify!(__pad0)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<siginfo_t>()))._sifields as *const _ as usize },
16usize,
concat!(
"Offset of field: ",
stringify!(siginfo_t),
"::",
stringify!(_sifields)
)
);
}
impl Default for siginfo_t {
fn default() -> Self {
unsafe { ::std::mem::zeroed() }
}
}
pub const SI_ASYNCNL: ::std::os::raw::c_int = -60;
pub const SI_DETHREAD: ::std::os::raw::c_int = -7;
pub const SI_TKILL: ::std::os::raw::c_int = -6;
pub const SI_SIGIO: ::std::os::raw::c_int = -5;
pub const SI_ASYNCIO: ::std::os::raw::c_int = -4;
pub const SI_MESGQ: ::std::os::raw::c_int = -3;
pub const SI_TIMER: ::std::os::raw::c_int = -2;
pub const SI_QUEUE: ::std::os::raw::c_int = -1;
pub const SI_USER: ::std::os::raw::c_int = 0;
pub const SI_KERNEL: ::std::os::raw::c_int = 128;
pub type _bindgen_ty_1 = ::std::os::raw::c_int;
pub const ILL_ILLOPC: ::std::os::raw::c_uint = 1;
pub const ILL_ILLOPN: ::std::os::raw::c_uint = 2;
pub const ILL_ILLADR: ::std::os::raw::c_uint = 3;
pub const ILL_ILLTRP: ::std::os::raw::c_uint = 4;
pub const ILL_PRVOPC: ::std::os::raw::c_uint = 5;
pub const ILL_PRVREG: ::std::os::raw::c_uint = 6;
pub const ILL_COPROC: ::std::os::raw::c_uint = 7;
pub const ILL_BADSTK: ::std::os::raw::c_uint = 8;
pub const ILL_BADIADDR: ::std::os::raw::c_uint = 9;
pub type _bindgen_ty_2 = ::std::os::raw::c_uint;
pub const FPE_INTDIV: ::std::os::raw::c_uint = 1;
pub const FPE_INTOVF: ::std::os::raw::c_uint = 2;
pub const FPE_FLTDIV: ::std::os::raw::c_uint = 3;
pub const FPE_FLTOVF: ::std::os::raw::c_uint = 4;
pub const FPE_FLTUND: ::std::os::raw::c_uint = 5;
pub const FPE_FLTRES: ::std::os::raw::c_uint = 6;
pub const FPE_FLTINV: ::std::os::raw::c_uint = 7;
pub const FPE_FLTSUB: ::std::os::raw::c_uint = 8;
pub const FPE_FLTUNK: ::std::os::raw::c_uint = 14;
pub const FPE_CONDTRAP: ::std::os::raw::c_uint = 15;
pub type _bindgen_ty_3 = ::std::os::raw::c_uint;
pub const SEGV_MAPERR: ::std::os::raw::c_uint = 1;
pub const SEGV_ACCERR: ::std::os::raw::c_uint = 2;
pub const SEGV_BNDERR: ::std::os::raw::c_uint = 3;
pub const SEGV_PKUERR: ::std::os::raw::c_uint = 4;
pub const SEGV_ACCADI: ::std::os::raw::c_uint = 5;
pub const SEGV_ADIDERR: ::std::os::raw::c_uint = 6;
pub const SEGV_ADIPERR: ::std::os::raw::c_uint = 7;
pub type _bindgen_ty_4 = ::std::os::raw::c_uint;
pub const BUS_ADRALN: ::std::os::raw::c_uint = 1;
pub const BUS_ADRERR: ::std::os::raw::c_uint = 2;
pub const BUS_OBJERR: ::std::os::raw::c_uint = 3;
pub const BUS_MCEERR_AR: ::std::os::raw::c_uint = 4;
pub const BUS_MCEERR_AO: ::std::os::raw::c_uint = 5;
pub type _bindgen_ty_5 = ::std::os::raw::c_uint;
pub const CLD_EXITED: ::std::os::raw::c_uint = 1;
pub const CLD_KILLED: ::std::os::raw::c_uint = 2;
pub const CLD_DUMPED: ::std::os::raw::c_uint = 3;
pub const CLD_TRAPPED: ::std::os::raw::c_uint = 4;
pub const CLD_STOPPED: ::std::os::raw::c_uint = 5;
pub const CLD_CONTINUED: ::std::os::raw::c_uint = 6;
pub type _bindgen_ty_6 = ::std::os::raw::c_uint;
pub const POLL_IN: ::std::os::raw::c_uint = 1;
pub const POLL_OUT: ::std::os::raw::c_uint = 2;
pub const POLL_MSG: ::std::os::raw::c_uint = 3;
pub const POLL_ERR: ::std::os::raw::c_uint = 4;
pub const POLL_PRI: ::std::os::raw::c_uint = 5;
pub const POLL_HUP: ::std::os::raw::c_uint = 6;
pub type _bindgen_ty_7 = ::std::os::raw::c_uint;
pub type sigval_t = __sigval_t;
#[repr(C)]
#[derive(Copy, Clone)]
pub struct sigevent {
pub sigev_value: __sigval_t,
pub sigev_signo: ::std::os::raw::c_int,
pub sigev_notify: ::std::os::raw::c_int,
pub _sigev_un: sigevent__bindgen_ty_1,
}
#[repr(C)]
#[derive(Copy, Clone)]
pub union sigevent__bindgen_ty_1 {
pub _pad: [::std::os::raw::c_int; 12usize],
pub _tid: __pid_t,
pub _sigev_thread: sigevent__bindgen_ty_1__bindgen_ty_1,
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct sigevent__bindgen_ty_1__bindgen_ty_1 {
pub _function: ::std::option::Option<unsafe extern "C" fn(arg1: __sigval_t)>,
pub _attribute: *mut pthread_attr_t,
}
#[test]
fn bindgen_test_layout_sigevent__bindgen_ty_1__bindgen_ty_1() {
assert_eq!(
::std::mem::size_of::<sigevent__bindgen_ty_1__bindgen_ty_1>(),
16usize,
concat!(
"Size of: ",
stringify!(sigevent__bindgen_ty_1__bindgen_ty_1)
)
);
assert_eq!(
::std::mem::align_of::<sigevent__bindgen_ty_1__bindgen_ty_1>(),
8usize,
concat!(
"Alignment of ",
stringify!(sigevent__bindgen_ty_1__bindgen_ty_1)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<sigevent__bindgen_ty_1__bindgen_ty_1>()))._function as *const _
as usize
},
0usize,
concat!(
"Offset of field: ",
stringify!(sigevent__bindgen_ty_1__bindgen_ty_1),
"::",
stringify!(_function)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<sigevent__bindgen_ty_1__bindgen_ty_1>()))._attribute as *const _
as usize
},
8usize,
concat!(
"Offset of field: ",
stringify!(sigevent__bindgen_ty_1__bindgen_ty_1),
"::",
stringify!(_attribute)
)
);
}
impl Default for sigevent__bindgen_ty_1__bindgen_ty_1 {
fn default() -> Self {
unsafe { ::std::mem::zeroed() }
}
}
#[test]
fn bindgen_test_layout_sigevent__bindgen_ty_1() {
assert_eq!(
::std::mem::size_of::<sigevent__bindgen_ty_1>(),
48usize,
concat!("Size of: ", stringify!(sigevent__bindgen_ty_1))
);
assert_eq!(
::std::mem::align_of::<sigevent__bindgen_ty_1>(),
8usize,
concat!("Alignment of ", stringify!(sigevent__bindgen_ty_1))
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<sigevent__bindgen_ty_1>()))._pad as *const _ as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(sigevent__bindgen_ty_1),
"::",
stringify!(_pad)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<sigevent__bindgen_ty_1>()))._tid as *const _ as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(sigevent__bindgen_ty_1),
"::",
stringify!(_tid)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<sigevent__bindgen_ty_1>()))._sigev_thread as *const _ as usize
},
0usize,
concat!(
"Offset of field: ",
stringify!(sigevent__bindgen_ty_1),
"::",
stringify!(_sigev_thread)
)
);
}
impl Default for sigevent__bindgen_ty_1 {
fn default() -> Self {
unsafe { ::std::mem::zeroed() }
}
}
#[test]
fn bindgen_test_layout_sigevent() {
assert_eq!(
::std::mem::size_of::<sigevent>(),
64usize,
concat!("Size of: ", stringify!(sigevent))
);
assert_eq!(
::std::mem::align_of::<sigevent>(),
8usize,
concat!("Alignment of ", stringify!(sigevent))
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<sigevent>())).sigev_value as *const _ as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(sigevent),
"::",
stringify!(sigev_value)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<sigevent>())).sigev_signo as *const _ as usize },
8usize,
concat!(
"Offset of field: ",
stringify!(sigevent),
"::",
stringify!(sigev_signo)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<sigevent>())).sigev_notify as *const _ as usize },
12usize,
concat!(
"Offset of field: ",
stringify!(sigevent),
"::",
stringify!(sigev_notify)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<sigevent>()))._sigev_un as *const _ as usize },
16usize,
concat!(
"Offset of field: ",
stringify!(sigevent),
"::",
stringify!(_sigev_un)
)
);
}
impl Default for sigevent {
fn default() -> Self {
unsafe { ::std::mem::zeroed() }
}
}
pub type sigevent_t = sigevent;
pub const SIGEV_SIGNAL: ::std::os::raw::c_uint = 0;
pub const SIGEV_NONE: ::std::os::raw::c_uint = 1;
pub const SIGEV_THREAD: ::std::os::raw::c_uint = 2;
pub const SIGEV_THREAD_ID: ::std::os::raw::c_uint = 4;
pub type _bindgen_ty_8 = ::std::os::raw::c_uint;
pub type __sighandler_t = ::std::option::Option<unsafe extern "C" fn(arg1: ::std::os::raw::c_int)>;
extern "C" {
pub fn __sysv_signal(__sig: ::std::os::raw::c_int, __handler: __sighandler_t)
-> __sighandler_t;
}
extern "C" {
pub fn signal(__sig: ::std::os::raw::c_int, __handler: __sighandler_t) -> __sighandler_t;
}
extern "C" {
pub fn kill(__pid: __pid_t, __sig: ::std::os::raw::c_int) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn killpg(__pgrp: __pid_t, __sig: ::std::os::raw::c_int) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn raise(__sig: ::std::os::raw::c_int) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn ssignal(__sig: ::std::os::raw::c_int, __handler: __sighandler_t) -> __sighandler_t;
}
extern "C" {
pub fn gsignal(__sig: ::std::os::raw::c_int) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn psignal(__sig: ::std::os::raw::c_int, __s: *const ::std::os::raw::c_char);
}
extern "C" {
pub fn psiginfo(__pinfo: *const siginfo_t, __s: *const ::std::os::raw::c_char);
}
extern "C" {
pub fn sigblock(__mask: ::std::os::raw::c_int) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn sigsetmask(__mask: ::std::os::raw::c_int) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn siggetmask() -> ::std::os::raw::c_int;
}
pub type sig_t = __sighandler_t;
extern "C" {
pub fn sigemptyset(__set: *mut sigset_t) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn sigfillset(__set: *mut sigset_t) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn sigaddset(__set: *mut sigset_t, __signo: ::std::os::raw::c_int)
-> ::std::os::raw::c_int;
}
extern "C" {
pub fn sigdelset(__set: *mut sigset_t, __signo: ::std::os::raw::c_int)
-> ::std::os::raw::c_int;
}
extern "C" {
pub fn sigismember(
__set: *const sigset_t,
__signo: ::std::os::raw::c_int,
) -> ::std::os::raw::c_int;
}
#[repr(C)]
#[derive(Copy, Clone)]
pub struct sigaction {
pub __sigaction_handler: sigaction__bindgen_ty_1,
pub sa_mask: __sigset_t,
pub sa_flags: ::std::os::raw::c_int,
pub sa_restorer: ::std::option::Option<unsafe extern "C" fn()>,
}
#[repr(C)]
#[derive(Copy, Clone)]
pub union sigaction__bindgen_ty_1 {
pub sa_handler: __sighandler_t,
pub sa_sigaction: ::std::option::Option<
unsafe extern "C" fn(
arg1: ::std::os::raw::c_int,
arg2: *mut siginfo_t,
arg3: *mut ::std::os::raw::c_void,
),
>,
}
#[test]
fn bindgen_test_layout_sigaction__bindgen_ty_1() {
assert_eq!(
::std::mem::size_of::<sigaction__bindgen_ty_1>(),
8usize,
concat!("Size of: ", stringify!(sigaction__bindgen_ty_1))
);
assert_eq!(
::std::mem::align_of::<sigaction__bindgen_ty_1>(),
8usize,
concat!("Alignment of ", stringify!(sigaction__bindgen_ty_1))
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<sigaction__bindgen_ty_1>())).sa_handler as *const _ as usize
},
0usize,
concat!(
"Offset of field: ",
stringify!(sigaction__bindgen_ty_1),
"::",
stringify!(sa_handler)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<sigaction__bindgen_ty_1>())).sa_sigaction as *const _ as usize
},
0usize,
concat!(
"Offset of field: ",
stringify!(sigaction__bindgen_ty_1),
"::",
stringify!(sa_sigaction)
)
);
}
impl Default for sigaction__bindgen_ty_1 {
fn default() -> Self {
unsafe { ::std::mem::zeroed() }
}
}
#[test]
fn bindgen_test_layout_sigaction() {
assert_eq!(
::std::mem::size_of::<sigaction>(),
152usize,
concat!("Size of: ", stringify!(sigaction))
);
assert_eq!(
::std::mem::align_of::<sigaction>(),
8usize,
concat!("Alignment of ", stringify!(sigaction))
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<sigaction>())).__sigaction_handler as *const _ as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(sigaction),
"::",
stringify!(__sigaction_handler)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<sigaction>())).sa_mask as *const _ as usize },
8usize,
concat!(
"Offset of field: ",
stringify!(sigaction),
"::",
stringify!(sa_mask)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<sigaction>())).sa_flags as *const _ as usize },
136usize,
concat!(
"Offset of field: ",
stringify!(sigaction),
"::",
stringify!(sa_flags)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<sigaction>())).sa_restorer as *const _ as usize },
144usize,
concat!(
"Offset of field: ",
stringify!(sigaction),
"::",
stringify!(sa_restorer)
)
);
}
impl Default for sigaction {
fn default() -> Self {
unsafe { ::std::mem::zeroed() }
}
}
extern "C" {
pub fn sigprocmask(
__how: ::std::os::raw::c_int,
__set: *const sigset_t,
__oset: *mut sigset_t,
) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn sigsuspend(__set: *const sigset_t) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn sigaction(
__sig: ::std::os::raw::c_int,
__act: *const sigaction,
__oact: *mut sigaction,
) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn sigpending(__set: *mut sigset_t) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn sigwait(
__set: *const sigset_t,
__sig: *mut ::std::os::raw::c_int,
) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn sigwaitinfo(__set: *const sigset_t, __info: *mut siginfo_t) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn sigtimedwait(
__set: *const sigset_t,
__info: *mut siginfo_t,
__timeout: *const timespec,
) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn sigqueue(
__pid: __pid_t,
__sig: ::std::os::raw::c_int,
__val: sigval,
) -> ::std::os::raw::c_int;
}
extern "C" {
pub static _sys_siglist: [*const ::std::os::raw::c_char; 65usize];
}
extern "C" {
pub static sys_siglist: [*const ::std::os::raw::c_char; 65usize];
}
#[repr(C)]
#[derive(Debug, Default, Copy, Clone)]
pub struct _fpx_sw_bytes {
pub magic1: __uint32_t,
pub extended_size: __uint32_t,
pub xstate_bv: __uint64_t,
pub xstate_size: __uint32_t,
pub __glibc_reserved1: [__uint32_t; 7usize],
}
#[test]
fn bindgen_test_layout__fpx_sw_bytes() {
assert_eq!(
::std::mem::size_of::<_fpx_sw_bytes>(),
48usize,
concat!("Size of: ", stringify!(_fpx_sw_bytes))
);
assert_eq!(
::std::mem::align_of::<_fpx_sw_bytes>(),
8usize,
concat!("Alignment of ", stringify!(_fpx_sw_bytes))
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_fpx_sw_bytes>())).magic1 as *const _ as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(_fpx_sw_bytes),
"::",
stringify!(magic1)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_fpx_sw_bytes>())).extended_size as *const _ as usize },
4usize,
concat!(
"Offset of field: ",
stringify!(_fpx_sw_bytes),
"::",
stringify!(extended_size)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_fpx_sw_bytes>())).xstate_bv as *const _ as usize },
8usize,
concat!(
"Offset of field: ",
stringify!(_fpx_sw_bytes),
"::",
stringify!(xstate_bv)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_fpx_sw_bytes>())).xstate_size as *const _ as usize },
16usize,
concat!(
"Offset of field: ",
stringify!(_fpx_sw_bytes),
"::",
stringify!(xstate_size)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_fpx_sw_bytes>())).__glibc_reserved1 as *const _ as usize },
20usize,
concat!(
"Offset of field: ",
stringify!(_fpx_sw_bytes),
"::",
stringify!(__glibc_reserved1)
)
);
}
#[repr(C)]
#[derive(Debug, Default, Copy, Clone)]
pub struct _fpreg {
pub significand: [::std::os::raw::c_ushort; 4usize],
pub exponent: ::std::os::raw::c_ushort,
}
#[test]
fn bindgen_test_layout__fpreg() {
assert_eq!(
::std::mem::size_of::<_fpreg>(),
10usize,
concat!("Size of: ", stringify!(_fpreg))
);
assert_eq!(
::std::mem::align_of::<_fpreg>(),
2usize,
concat!("Alignment of ", stringify!(_fpreg))
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_fpreg>())).significand as *const _ as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(_fpreg),
"::",
stringify!(significand)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_fpreg>())).exponent as *const _ as usize },
8usize,
concat!(
"Offset of field: ",
stringify!(_fpreg),
"::",
stringify!(exponent)
)
);
}
#[repr(C)]
#[derive(Debug, Default, Copy, Clone)]
pub struct _fpxreg {
pub significand: [::std::os::raw::c_ushort; 4usize],
pub exponent: ::std::os::raw::c_ushort,
pub __glibc_reserved1: [::std::os::raw::c_ushort; 3usize],
}
#[test]
fn bindgen_test_layout__fpxreg() {
assert_eq!(
::std::mem::size_of::<_fpxreg>(),
16usize,
concat!("Size of: ", stringify!(_fpxreg))
);
assert_eq!(
::std::mem::align_of::<_fpxreg>(),
2usize,
concat!("Alignment of ", stringify!(_fpxreg))
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_fpxreg>())).significand as *const _ as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(_fpxreg),
"::",
stringify!(significand)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_fpxreg>())).exponent as *const _ as usize },
8usize,
concat!(
"Offset of field: ",
stringify!(_fpxreg),
"::",
stringify!(exponent)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_fpxreg>())).__glibc_reserved1 as *const _ as usize },
10usize,
concat!(
"Offset of field: ",
stringify!(_fpxreg),
"::",
stringify!(__glibc_reserved1)
)
);
}
#[repr(C)]
#[derive(Debug, Default, Copy, Clone)]
pub struct _xmmreg {
pub element: [__uint32_t; 4usize],
}
#[test]
fn bindgen_test_layout__xmmreg() {
assert_eq!(
::std::mem::size_of::<_xmmreg>(),
16usize,
concat!("Size of: ", stringify!(_xmmreg))
);
assert_eq!(
::std::mem::align_of::<_xmmreg>(),
4usize,
concat!("Alignment of ", stringify!(_xmmreg))
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_xmmreg>())).element as *const _ as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(_xmmreg),
"::",
stringify!(element)
)
);
}
#[repr(C)]
#[derive(Debug, Default, Copy, Clone)]
pub struct _fpstate {
pub cwd: __uint16_t,
pub swd: __uint16_t,
pub ftw: __uint16_t,
pub fop: __uint16_t,
pub rip: __uint64_t,
pub rdp: __uint64_t,
pub mxcsr: __uint32_t,
pub mxcr_mask: __uint32_t,
pub _st: [_fpxreg; 8usize],
pub _xmm: [_xmmreg; 16usize],
pub __glibc_reserved1: [__uint32_t; 24usize],
}
#[test]
fn bindgen_test_layout__fpstate() {
assert_eq!(
::std::mem::size_of::<_fpstate>(),
512usize,
concat!("Size of: ", stringify!(_fpstate))
);
assert_eq!(
::std::mem::align_of::<_fpstate>(),
8usize,
concat!("Alignment of ", stringify!(_fpstate))
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_fpstate>())).cwd as *const _ as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(_fpstate),
"::",
stringify!(cwd)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_fpstate>())).swd as *const _ as usize },
2usize,
concat!(
"Offset of field: ",
stringify!(_fpstate),
"::",
stringify!(swd)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_fpstate>())).ftw as *const _ as usize },
4usize,
concat!(
"Offset of field: ",
stringify!(_fpstate),
"::",
stringify!(ftw)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_fpstate>())).fop as *const _ as usize },
6usize,
concat!(
"Offset of field: ",
stringify!(_fpstate),
"::",
stringify!(fop)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_fpstate>())).rip as *const _ as usize },
8usize,
concat!(
"Offset of field: ",
stringify!(_fpstate),
"::",
stringify!(rip)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_fpstate>())).rdp as *const _ as usize },
16usize,
concat!(
"Offset of field: ",
stringify!(_fpstate),
"::",
stringify!(rdp)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_fpstate>())).mxcsr as *const _ as usize },
24usize,
concat!(
"Offset of field: ",
stringify!(_fpstate),
"::",
stringify!(mxcsr)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_fpstate>())).mxcr_mask as *const _ as usize },
28usize,
concat!(
"Offset of field: ",
stringify!(_fpstate),
"::",
stringify!(mxcr_mask)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_fpstate>()))._st as *const _ as usize },
32usize,
concat!(
"Offset of field: ",
stringify!(_fpstate),
"::",
stringify!(_st)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_fpstate>()))._xmm as *const _ as usize },
160usize,
concat!(
"Offset of field: ",
stringify!(_fpstate),
"::",
stringify!(_xmm)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_fpstate>())).__glibc_reserved1 as *const _ as usize },
416usize,
concat!(
"Offset of field: ",
stringify!(_fpstate),
"::",
stringify!(__glibc_reserved1)
)
);
}
#[repr(C)]
#[derive(Copy, Clone)]
pub struct sigcontext {
pub r8: __uint64_t,
pub r9: __uint64_t,
pub r10: __uint64_t,
pub r11: __uint64_t,
pub r12: __uint64_t,
pub r13: __uint64_t,
pub r14: __uint64_t,
pub r15: __uint64_t,
pub rdi: __uint64_t,
pub rsi: __uint64_t,
pub rbp: __uint64_t,
pub rbx: __uint64_t,
pub rdx: __uint64_t,
pub rax: __uint64_t,
pub rcx: __uint64_t,
pub rsp: __uint64_t,
pub rip: __uint64_t,
pub eflags: __uint64_t,
pub cs: ::std::os::raw::c_ushort,
pub gs: ::std::os::raw::c_ushort,
pub fs: ::std::os::raw::c_ushort,
pub __pad0: ::std::os::raw::c_ushort,
pub err: __uint64_t,
pub trapno: __uint64_t,
pub oldmask: __uint64_t,
pub cr2: __uint64_t,
pub __bindgen_anon_1: sigcontext__bindgen_ty_1,
pub __reserved1: [__uint64_t; 8usize],
}
#[repr(C)]
#[derive(Copy, Clone)]
pub union sigcontext__bindgen_ty_1 {
pub fpstate: *mut _fpstate,
pub __fpstate_word: __uint64_t,
}
#[test]
fn bindgen_test_layout_sigcontext__bindgen_ty_1() {
assert_eq!(
::std::mem::size_of::<sigcontext__bindgen_ty_1>(),
8usize,
concat!("Size of: ", stringify!(sigcontext__bindgen_ty_1))
);
assert_eq!(
::std::mem::align_of::<sigcontext__bindgen_ty_1>(),
8usize,
concat!("Alignment of ", stringify!(sigcontext__bindgen_ty_1))
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<sigcontext__bindgen_ty_1>())).fpstate as *const _ as usize
},
0usize,
concat!(
"Offset of field: ",
stringify!(sigcontext__bindgen_ty_1),
"::",
stringify!(fpstate)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<sigcontext__bindgen_ty_1>())).__fpstate_word as *const _ as usize
},
0usize,
concat!(
"Offset of field: ",
stringify!(sigcontext__bindgen_ty_1),
"::",
stringify!(__fpstate_word)
)
);
}
impl Default for sigcontext__bindgen_ty_1 {
fn default() -> Self {
unsafe { ::std::mem::zeroed() }
}
}
#[test]
fn bindgen_test_layout_sigcontext() {
assert_eq!(
::std::mem::size_of::<sigcontext>(),
256usize,
concat!("Size of: ", stringify!(sigcontext))
);
assert_eq!(
::std::mem::align_of::<sigcontext>(),
8usize,
concat!("Alignment of ", stringify!(sigcontext))
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<sigcontext>())).r8 as *const _ as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(sigcontext),
"::",
stringify!(r8)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<sigcontext>())).r9 as *const _ as usize },
8usize,
concat!(
"Offset of field: ",
stringify!(sigcontext),
"::",
stringify!(r9)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<sigcontext>())).r10 as *const _ as usize },
16usize,
concat!(
"Offset of field: ",
stringify!(sigcontext),
"::",
stringify!(r10)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<sigcontext>())).r11 as *const _ as usize },
24usize,
concat!(
"Offset of field: ",
stringify!(sigcontext),
"::",
stringify!(r11)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<sigcontext>())).r12 as *const _ as usize },
32usize,
concat!(
"Offset of field: ",
stringify!(sigcontext),
"::",
stringify!(r12)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<sigcontext>())).r13 as *const _ as usize },
40usize,
concat!(
"Offset of field: ",
stringify!(sigcontext),
"::",
stringify!(r13)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<sigcontext>())).r14 as *const _ as usize },
48usize,
concat!(
"Offset of field: ",
stringify!(sigcontext),
"::",
stringify!(r14)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<sigcontext>())).r15 as *const _ as usize },
56usize,
concat!(
"Offset of field: ",
stringify!(sigcontext),
"::",
stringify!(r15)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<sigcontext>())).rdi as *const _ as usize },
64usize,
concat!(
"Offset of field: ",
stringify!(sigcontext),
"::",
stringify!(rdi)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<sigcontext>())).rsi as *const _ as usize },
72usize,
concat!(
"Offset of field: ",
stringify!(sigcontext),
"::",
stringify!(rsi)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<sigcontext>())).rbp as *const _ as usize },
80usize,
concat!(
"Offset of field: ",
stringify!(sigcontext),
"::",
stringify!(rbp)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<sigcontext>())).rbx as *const _ as usize },
88usize,
concat!(
"Offset of field: ",
stringify!(sigcontext),
"::",
stringify!(rbx)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<sigcontext>())).rdx as *const _ as usize },
96usize,
concat!(
"Offset of field: ",
stringify!(sigcontext),
"::",
stringify!(rdx)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<sigcontext>())).rax as *const _ as usize },
104usize,
concat!(
"Offset of field: ",
stringify!(sigcontext),
"::",
stringify!(rax)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<sigcontext>())).rcx as *const _ as usize },
112usize,
concat!(
"Offset of field: ",
stringify!(sigcontext),
"::",
stringify!(rcx)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<sigcontext>())).rsp as *const _ as usize },
120usize,
concat!(
"Offset of field: ",
stringify!(sigcontext),
"::",
stringify!(rsp)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<sigcontext>())).rip as *const _ as usize },
128usize,
concat!(
"Offset of field: ",
stringify!(sigcontext),
"::",
stringify!(rip)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<sigcontext>())).eflags as *const _ as usize },
136usize,
concat!(
"Offset of field: ",
stringify!(sigcontext),
"::",
stringify!(eflags)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<sigcontext>())).cs as *const _ as usize },
144usize,
concat!(
"Offset of field: ",
stringify!(sigcontext),
"::",
stringify!(cs)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<sigcontext>())).gs as *const _ as usize },
146usize,
concat!(
"Offset of field: ",
stringify!(sigcontext),
"::",
stringify!(gs)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<sigcontext>())).fs as *const _ as usize },
148usize,
concat!(
"Offset of field: ",
stringify!(sigcontext),
"::",
stringify!(fs)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<sigcontext>())).__pad0 as *const _ as usize },
150usize,
concat!(
"Offset of field: ",
stringify!(sigcontext),
"::",
stringify!(__pad0)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<sigcontext>())).err as *const _ as usize },
152usize,
concat!(
"Offset of field: ",
stringify!(sigcontext),
"::",
stringify!(err)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<sigcontext>())).trapno as *const _ as usize },
160usize,
concat!(
"Offset of field: ",
stringify!(sigcontext),
"::",
stringify!(trapno)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<sigcontext>())).oldmask as *const _ as usize },
168usize,
concat!(
"Offset of field: ",
stringify!(sigcontext),
"::",
stringify!(oldmask)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<sigcontext>())).cr2 as *const _ as usize },
176usize,
concat!(
"Offset of field: ",
stringify!(sigcontext),
"::",
stringify!(cr2)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<sigcontext>())).__reserved1 as *const _ as usize },
192usize,
concat!(
"Offset of field: ",
stringify!(sigcontext),
"::",
stringify!(__reserved1)
)
);
}
impl Default for sigcontext {
fn default() -> Self {
unsafe { ::std::mem::zeroed() }
}
}
#[repr(C)]
#[derive(Debug, Default, Copy, Clone)]
pub struct _xsave_hdr {
pub xstate_bv: __uint64_t,
pub __glibc_reserved1: [__uint64_t; 2usize],
pub __glibc_reserved2: [__uint64_t; 5usize],
}
#[test]
fn bindgen_test_layout__xsave_hdr() {
assert_eq!(
::std::mem::size_of::<_xsave_hdr>(),
64usize,
concat!("Size of: ", stringify!(_xsave_hdr))
);
assert_eq!(
::std::mem::align_of::<_xsave_hdr>(),
8usize,
concat!("Alignment of ", stringify!(_xsave_hdr))
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_xsave_hdr>())).xstate_bv as *const _ as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(_xsave_hdr),
"::",
stringify!(xstate_bv)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_xsave_hdr>())).__glibc_reserved1 as *const _ as usize },
8usize,
concat!(
"Offset of field: ",
stringify!(_xsave_hdr),
"::",
stringify!(__glibc_reserved1)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_xsave_hdr>())).__glibc_reserved2 as *const _ as usize },
24usize,
concat!(
"Offset of field: ",
stringify!(_xsave_hdr),
"::",
stringify!(__glibc_reserved2)
)
);
}
#[repr(C)]
#[derive(Copy, Clone)]
pub struct _ymmh_state {
pub ymmh_space: [__uint32_t; 64usize],
}
#[test]
fn bindgen_test_layout__ymmh_state() {
assert_eq!(
::std::mem::size_of::<_ymmh_state>(),
256usize,
concat!("Size of: ", stringify!(_ymmh_state))
);
assert_eq!(
::std::mem::align_of::<_ymmh_state>(),
4usize,
concat!("Alignment of ", stringify!(_ymmh_state))
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_ymmh_state>())).ymmh_space as *const _ as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(_ymmh_state),
"::",
stringify!(ymmh_space)
)
);
}
impl Default for _ymmh_state {
fn default() -> Self {
unsafe { ::std::mem::zeroed() }
}
}
#[repr(C)]
#[derive(Copy, Clone)]
pub struct _xstate {
pub fpstate: _fpstate,
pub xstate_hdr: _xsave_hdr,
pub ymmh: _ymmh_state,
}
#[test]
fn bindgen_test_layout__xstate() {
assert_eq!(
::std::mem::size_of::<_xstate>(),
832usize,
concat!("Size of: ", stringify!(_xstate))
);
assert_eq!(
::std::mem::align_of::<_xstate>(),
8usize,
concat!("Alignment of ", stringify!(_xstate))
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_xstate>())).fpstate as *const _ as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(_xstate),
"::",
stringify!(fpstate)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_xstate>())).xstate_hdr as *const _ as usize },
512usize,
concat!(
"Offset of field: ",
stringify!(_xstate),
"::",
stringify!(xstate_hdr)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_xstate>())).ymmh as *const _ as usize },
576usize,
concat!(
"Offset of field: ",
stringify!(_xstate),
"::",
stringify!(ymmh)
)
);
}
impl Default for _xstate {
fn default() -> Self {
unsafe { ::std::mem::zeroed() }
}
}
extern "C" {
pub fn sigreturn(__scp: *mut sigcontext) -> ::std::os::raw::c_int;
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct stack_t {
pub ss_sp: *mut ::std::os::raw::c_void,
pub ss_flags: ::std::os::raw::c_int,
pub ss_size: size_t,
}
#[test]
fn bindgen_test_layout_stack_t() {
assert_eq!(
::std::mem::size_of::<stack_t>(),
24usize,
concat!("Size of: ", stringify!(stack_t))
);
assert_eq!(
::std::mem::align_of::<stack_t>(),
8usize,
concat!("Alignment of ", stringify!(stack_t))
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<stack_t>())).ss_sp as *const _ as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(stack_t),
"::",
stringify!(ss_sp)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<stack_t>())).ss_flags as *const _ as usize },
8usize,
concat!(
"Offset of field: ",
stringify!(stack_t),
"::",
stringify!(ss_flags)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<stack_t>())).ss_size as *const _ as usize },
16usize,
concat!(
"Offset of field: ",
stringify!(stack_t),
"::",
stringify!(ss_size)
)
);
}
impl Default for stack_t {
fn default() -> Self {
unsafe { ::std::mem::zeroed() }
}
}
pub type greg_t = ::std::os::raw::c_longlong;
pub type gregset_t = [greg_t; 23usize];
#[repr(C)]
#[derive(Debug, Default, Copy, Clone)]
pub struct _libc_fpxreg {
pub significand: [::std::os::raw::c_ushort; 4usize],
pub exponent: ::std::os::raw::c_ushort,
pub __glibc_reserved1: [::std::os::raw::c_ushort; 3usize],
}
#[test]
fn bindgen_test_layout__libc_fpxreg() {
assert_eq!(
::std::mem::size_of::<_libc_fpxreg>(),
16usize,
concat!("Size of: ", stringify!(_libc_fpxreg))
);
assert_eq!(
::std::mem::align_of::<_libc_fpxreg>(),
2usize,
concat!("Alignment of ", stringify!(_libc_fpxreg))
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_libc_fpxreg>())).significand as *const _ as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(_libc_fpxreg),
"::",
stringify!(significand)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_libc_fpxreg>())).exponent as *const _ as usize },
8usize,
concat!(
"Offset of field: ",
stringify!(_libc_fpxreg),
"::",
stringify!(exponent)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_libc_fpxreg>())).__glibc_reserved1 as *const _ as usize },
10usize,
concat!(
"Offset of field: ",
stringify!(_libc_fpxreg),
"::",
stringify!(__glibc_reserved1)
)
);
}
#[repr(C)]
#[derive(Debug, Default, Copy, Clone)]
pub struct _libc_xmmreg {
pub element: [__uint32_t; 4usize],
}
#[test]
fn bindgen_test_layout__libc_xmmreg() {
assert_eq!(
::std::mem::size_of::<_libc_xmmreg>(),
16usize,
concat!("Size of: ", stringify!(_libc_xmmreg))
);
assert_eq!(
::std::mem::align_of::<_libc_xmmreg>(),
4usize,
concat!("Alignment of ", stringify!(_libc_xmmreg))
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_libc_xmmreg>())).element as *const _ as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(_libc_xmmreg),
"::",
stringify!(element)
)
);
}
#[repr(C)]
#[derive(Debug, Default, Copy, Clone)]
pub struct _libc_fpstate {
pub cwd: __uint16_t,
pub swd: __uint16_t,
pub ftw: __uint16_t,
pub fop: __uint16_t,
pub rip: __uint64_t,
pub rdp: __uint64_t,
pub mxcsr: __uint32_t,
pub mxcr_mask: __uint32_t,
pub _st: [_libc_fpxreg; 8usize],
pub _xmm: [_libc_xmmreg; 16usize],
pub __glibc_reserved1: [__uint32_t; 24usize],
}
#[test]
fn bindgen_test_layout__libc_fpstate() {
assert_eq!(
::std::mem::size_of::<_libc_fpstate>(),
512usize,
concat!("Size of: ", stringify!(_libc_fpstate))
);
assert_eq!(
::std::mem::align_of::<_libc_fpstate>(),
8usize,
concat!("Alignment of ", stringify!(_libc_fpstate))
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_libc_fpstate>())).cwd as *const _ as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(_libc_fpstate),
"::",
stringify!(cwd)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_libc_fpstate>())).swd as *const _ as usize },
2usize,
concat!(
"Offset of field: ",
stringify!(_libc_fpstate),
"::",
stringify!(swd)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_libc_fpstate>())).ftw as *const _ as usize },
4usize,
concat!(
"Offset of field: ",
stringify!(_libc_fpstate),
"::",
stringify!(ftw)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_libc_fpstate>())).fop as *const _ as usize },
6usize,
concat!(
"Offset of field: ",
stringify!(_libc_fpstate),
"::",
stringify!(fop)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_libc_fpstate>())).rip as *const _ as usize },
8usize,
concat!(
"Offset of field: ",
stringify!(_libc_fpstate),
"::",
stringify!(rip)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_libc_fpstate>())).rdp as *const _ as usize },
16usize,
concat!(
"Offset of field: ",
stringify!(_libc_fpstate),
"::",
stringify!(rdp)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_libc_fpstate>())).mxcsr as *const _ as usize },
24usize,
concat!(
"Offset of field: ",
stringify!(_libc_fpstate),
"::",
stringify!(mxcsr)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_libc_fpstate>())).mxcr_mask as *const _ as usize },
28usize,
concat!(
"Offset of field: ",
stringify!(_libc_fpstate),
"::",
stringify!(mxcr_mask)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_libc_fpstate>()))._st as *const _ as usize },
32usize,
concat!(
"Offset of field: ",
stringify!(_libc_fpstate),
"::",
stringify!(_st)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_libc_fpstate>()))._xmm as *const _ as usize },
160usize,
concat!(
"Offset of field: ",
stringify!(_libc_fpstate),
"::",
stringify!(_xmm)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_libc_fpstate>())).__glibc_reserved1 as *const _ as usize },
416usize,
concat!(
"Offset of field: ",
stringify!(_libc_fpstate),
"::",
stringify!(__glibc_reserved1)
)
);
}
pub type fpregset_t = *mut _libc_fpstate;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct mcontext_t {
pub gregs: gregset_t,
pub fpregs: fpregset_t,
pub __reserved1: [::std::os::raw::c_ulonglong; 8usize],
}
#[test]
fn bindgen_test_layout_mcontext_t() {
assert_eq!(
::std::mem::size_of::<mcontext_t>(),
256usize,
concat!("Size of: ", stringify!(mcontext_t))
);
assert_eq!(
::std::mem::align_of::<mcontext_t>(),
8usize,
concat!("Alignment of ", stringify!(mcontext_t))
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<mcontext_t>())).gregs as *const _ as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(mcontext_t),
"::",
stringify!(gregs)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<mcontext_t>())).fpregs as *const _ as usize },
184usize,
concat!(
"Offset of field: ",
stringify!(mcontext_t),
"::",
stringify!(fpregs)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<mcontext_t>())).__reserved1 as *const _ as usize },
192usize,
concat!(
"Offset of field: ",
stringify!(mcontext_t),
"::",
stringify!(__reserved1)
)
);
}
impl Default for mcontext_t {
fn default() -> Self {
unsafe { ::std::mem::zeroed() }
}
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct ucontext_t {
pub uc_flags: ::std::os::raw::c_ulong,
pub uc_link: *mut ucontext_t,
pub uc_stack: stack_t,
pub uc_mcontext: mcontext_t,
pub uc_sigmask: sigset_t,
pub __fpregs_mem: _libc_fpstate,
pub __ssp: [::std::os::raw::c_ulonglong; 4usize],
}
#[test]
fn bindgen_test_layout_ucontext_t() {
assert_eq!(
::std::mem::size_of::<ucontext_t>(),
968usize,
concat!("Size of: ", stringify!(ucontext_t))
);
assert_eq!(
::std::mem::align_of::<ucontext_t>(),
8usize,
concat!("Alignment of ", stringify!(ucontext_t))
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<ucontext_t>())).uc_flags as *const _ as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(ucontext_t),
"::",
stringify!(uc_flags)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<ucontext_t>())).uc_link as *const _ as usize },
8usize,
concat!(
"Offset of field: ",
stringify!(ucontext_t),
"::",
stringify!(uc_link)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<ucontext_t>())).uc_stack as *const _ as usize },
16usize,
concat!(
"Offset of field: ",
stringify!(ucontext_t),
"::",
stringify!(uc_stack)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<ucontext_t>())).uc_mcontext as *const _ as usize },
40usize,
concat!(
"Offset of field: ",
stringify!(ucontext_t),
"::",
stringify!(uc_mcontext)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<ucontext_t>())).uc_sigmask as *const _ as usize },
296usize,
concat!(
"Offset of field: ",
stringify!(ucontext_t),
"::",
stringify!(uc_sigmask)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<ucontext_t>())).__fpregs_mem as *const _ as usize },
424usize,
concat!(
"Offset of field: ",
stringify!(ucontext_t),
"::",
stringify!(__fpregs_mem)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<ucontext_t>())).__ssp as *const _ as usize },
936usize,
concat!(
"Offset of field: ",
stringify!(ucontext_t),
"::",
stringify!(__ssp)
)
);
}
impl Default for ucontext_t {
fn default() -> Self {
unsafe { ::std::mem::zeroed() }
}
}
extern "C" {
pub fn siginterrupt(
__sig: ::std::os::raw::c_int,
__interrupt: ::std::os::raw::c_int,
) -> ::std::os::raw::c_int;
}
pub const SS_ONSTACK: ::std::os::raw::c_uint = 1;
pub const SS_DISABLE: ::std::os::raw::c_uint = 2;
pub type _bindgen_ty_9 = ::std::os::raw::c_uint;
extern "C" {
pub fn sigaltstack(__ss: *const stack_t, __oss: *mut stack_t) -> ::std::os::raw::c_int;
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct sigstack {
pub ss_sp: *mut ::std::os::raw::c_void,
pub ss_onstack: ::std::os::raw::c_int,
}
#[test]
fn bindgen_test_layout_sigstack() {
assert_eq!(
::std::mem::size_of::<sigstack>(),
16usize,
concat!("Size of: ", stringify!(sigstack))
);
assert_eq!(
::std::mem::align_of::<sigstack>(),
8usize,
concat!("Alignment of ", stringify!(sigstack))
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<sigstack>())).ss_sp as *const _ as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(sigstack),
"::",
stringify!(ss_sp)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<sigstack>())).ss_onstack as *const _ as usize },
8usize,
concat!(
"Offset of field: ",
stringify!(sigstack),
"::",
stringify!(ss_onstack)
)
);
}
impl Default for sigstack {
fn default() -> Self {
unsafe { ::std::mem::zeroed() }
}
}
extern "C" {
pub fn sigstack(__ss: *mut sigstack, __oss: *mut sigstack) -> ::std::os::raw::c_int;
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct __pthread_internal_list {
pub __prev: *mut __pthread_internal_list,
pub __next: *mut __pthread_internal_list,
}
#[test]
fn bindgen_test_layout___pthread_internal_list() {
assert_eq!(
::std::mem::size_of::<__pthread_internal_list>(),
16usize,
concat!("Size of: ", stringify!(__pthread_internal_list))
);
assert_eq!(
::std::mem::align_of::<__pthread_internal_list>(),
8usize,
concat!("Alignment of ", stringify!(__pthread_internal_list))
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<__pthread_internal_list>())).__prev as *const _ as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(__pthread_internal_list),
"::",
stringify!(__prev)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<__pthread_internal_list>())).__next as *const _ as usize },
8usize,
concat!(
"Offset of field: ",
stringify!(__pthread_internal_list),
"::",
stringify!(__next)
)
);
}
impl Default for __pthread_internal_list {
fn default() -> Self {
unsafe { ::std::mem::zeroed() }
}
}
pub type __pthread_list_t = __pthread_internal_list;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct __pthread_internal_slist {
pub __next: *mut __pthread_internal_slist,
}
#[test]
fn bindgen_test_layout___pthread_internal_slist() {
assert_eq!(
::std::mem::size_of::<__pthread_internal_slist>(),
8usize,
concat!("Size of: ", stringify!(__pthread_internal_slist))
);
assert_eq!(
::std::mem::align_of::<__pthread_internal_slist>(),
8usize,
concat!("Alignment of ", stringify!(__pthread_internal_slist))
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<__pthread_internal_slist>())).__next as *const _ as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(__pthread_internal_slist),
"::",
stringify!(__next)
)
);
}
impl Default for __pthread_internal_slist {
fn default() -> Self {
unsafe { ::std::mem::zeroed() }
}
}
pub type __pthread_slist_t = __pthread_internal_slist;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct __pthread_mutex_s {
pub __lock: ::std::os::raw::c_int,
pub __count: ::std::os::raw::c_uint,
pub __owner: ::std::os::raw::c_int,
pub __nusers: ::std::os::raw::c_uint,
pub __kind: ::std::os::raw::c_int,
pub __spins: ::std::os::raw::c_short,
pub __elision: ::std::os::raw::c_short,
pub __list: __pthread_list_t,
}
#[test]
fn bindgen_test_layout___pthread_mutex_s() {
assert_eq!(
::std::mem::size_of::<__pthread_mutex_s>(),
40usize,
concat!("Size of: ", stringify!(__pthread_mutex_s))
);
assert_eq!(
::std::mem::align_of::<__pthread_mutex_s>(),
8usize,
concat!("Alignment of ", stringify!(__pthread_mutex_s))
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<__pthread_mutex_s>())).__lock as *const _ as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(__pthread_mutex_s),
"::",
stringify!(__lock)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<__pthread_mutex_s>())).__count as *const _ as usize },
4usize,
concat!(
"Offset of field: ",
stringify!(__pthread_mutex_s),
"::",
stringify!(__count)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<__pthread_mutex_s>())).__owner as *const _ as usize },
8usize,
concat!(
"Offset of field: ",
stringify!(__pthread_mutex_s),
"::",
stringify!(__owner)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<__pthread_mutex_s>())).__nusers as *const _ as usize },
12usize,
concat!(
"Offset of field: ",
stringify!(__pthread_mutex_s),
"::",
stringify!(__nusers)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<__pthread_mutex_s>())).__kind as *const _ as usize },
16usize,
concat!(
"Offset of field: ",
stringify!(__pthread_mutex_s),
"::",
stringify!(__kind)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<__pthread_mutex_s>())).__spins as *const _ as usize },
20usize,
concat!(
"Offset of field: ",
stringify!(__pthread_mutex_s),
"::",
stringify!(__spins)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<__pthread_mutex_s>())).__elision as *const _ as usize },
22usize,
concat!(
"Offset of field: ",
stringify!(__pthread_mutex_s),
"::",
stringify!(__elision)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<__pthread_mutex_s>())).__list as *const _ as usize },
24usize,
concat!(
"Offset of field: ",
stringify!(__pthread_mutex_s),
"::",
stringify!(__list)
)
);
}
impl Default for __pthread_mutex_s {
fn default() -> Self {
unsafe { ::std::mem::zeroed() }
}
}
#[repr(C)]
#[derive(Debug, Default, Copy, Clone)]
pub struct __pthread_rwlock_arch_t {
pub __readers: ::std::os::raw::c_uint,
pub __writers: ::std::os::raw::c_uint,
pub __wrphase_futex: ::std::os::raw::c_uint,
pub __writers_futex: ::std::os::raw::c_uint,
pub __pad3: ::std::os::raw::c_uint,
pub __pad4: ::std::os::raw::c_uint,
pub __cur_writer: ::std::os::raw::c_int,
pub __shared: ::std::os::raw::c_int,
pub __rwelision: ::std::os::raw::c_schar,
pub __pad1: [::std::os::raw::c_uchar; 7usize],
pub __pad2: ::std::os::raw::c_ulong,
pub __flags: ::std::os::raw::c_uint,
}
#[test]
fn bindgen_test_layout___pthread_rwlock_arch_t() {
assert_eq!(
::std::mem::size_of::<__pthread_rwlock_arch_t>(),
56usize,
concat!("Size of: ", stringify!(__pthread_rwlock_arch_t))
);
assert_eq!(
::std::mem::align_of::<__pthread_rwlock_arch_t>(),
8usize,
concat!("Alignment of ", stringify!(__pthread_rwlock_arch_t))
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<__pthread_rwlock_arch_t>())).__readers as *const _ as usize
},
0usize,
concat!(
"Offset of field: ",
stringify!(__pthread_rwlock_arch_t),
"::",
stringify!(__readers)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<__pthread_rwlock_arch_t>())).__writers as *const _ as usize
},
4usize,
concat!(
"Offset of field: ",
stringify!(__pthread_rwlock_arch_t),
"::",
stringify!(__writers)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<__pthread_rwlock_arch_t>())).__wrphase_futex as *const _ as usize
},
8usize,
concat!(
"Offset of field: ",
stringify!(__pthread_rwlock_arch_t),
"::",
stringify!(__wrphase_futex)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<__pthread_rwlock_arch_t>())).__writers_futex as *const _ as usize
},
12usize,
concat!(
"Offset of field: ",
stringify!(__pthread_rwlock_arch_t),
"::",
stringify!(__writers_futex)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<__pthread_rwlock_arch_t>())).__pad3 as *const _ as usize },
16usize,
concat!(
"Offset of field: ",
stringify!(__pthread_rwlock_arch_t),
"::",
stringify!(__pad3)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<__pthread_rwlock_arch_t>())).__pad4 as *const _ as usize },
20usize,
concat!(
"Offset of field: ",
stringify!(__pthread_rwlock_arch_t),
"::",
stringify!(__pad4)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<__pthread_rwlock_arch_t>())).__cur_writer as *const _ as usize
},
24usize,
concat!(
"Offset of field: ",
stringify!(__pthread_rwlock_arch_t),
"::",
stringify!(__cur_writer)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<__pthread_rwlock_arch_t>())).__shared as *const _ as usize
},
28usize,
concat!(
"Offset of field: ",
stringify!(__pthread_rwlock_arch_t),
"::",
stringify!(__shared)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<__pthread_rwlock_arch_t>())).__rwelision as *const _ as usize
},
32usize,
concat!(
"Offset of field: ",
stringify!(__pthread_rwlock_arch_t),
"::",
stringify!(__rwelision)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<__pthread_rwlock_arch_t>())).__pad1 as *const _ as usize },
33usize,
concat!(
"Offset of field: ",
stringify!(__pthread_rwlock_arch_t),
"::",
stringify!(__pad1)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<__pthread_rwlock_arch_t>())).__pad2 as *const _ as usize },
40usize,
concat!(
"Offset of field: ",
stringify!(__pthread_rwlock_arch_t),
"::",
stringify!(__pad2)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<__pthread_rwlock_arch_t>())).__flags as *const _ as usize },
48usize,
concat!(
"Offset of field: ",
stringify!(__pthread_rwlock_arch_t),
"::",
stringify!(__flags)
)
);
}
#[repr(C)]
#[derive(Copy, Clone)]
pub struct __pthread_cond_s {
pub __bindgen_anon_1: __pthread_cond_s__bindgen_ty_1,
pub __bindgen_anon_2: __pthread_cond_s__bindgen_ty_2,
pub __g_refs: [::std::os::raw::c_uint; 2usize],
pub __g_size: [::std::os::raw::c_uint; 2usize],
pub __g1_orig_size: ::std::os::raw::c_uint,
pub __wrefs: ::std::os::raw::c_uint,
pub __g_signals: [::std::os::raw::c_uint; 2usize],
}
#[repr(C)]
#[derive(Copy, Clone)]
pub union __pthread_cond_s__bindgen_ty_1 {
pub __wseq: ::std::os::raw::c_ulonglong,
pub __wseq32: __pthread_cond_s__bindgen_ty_1__bindgen_ty_1,
}
#[repr(C)]
#[derive(Debug, Default, Copy, Clone)]
pub struct __pthread_cond_s__bindgen_ty_1__bindgen_ty_1 {
pub __low: ::std::os::raw::c_uint,
pub __high: ::std::os::raw::c_uint,
}
#[test]
fn bindgen_test_layout___pthread_cond_s__bindgen_ty_1__bindgen_ty_1() {
assert_eq!(
::std::mem::size_of::<__pthread_cond_s__bindgen_ty_1__bindgen_ty_1>(),
8usize,
concat!(
"Size of: ",
stringify!(__pthread_cond_s__bindgen_ty_1__bindgen_ty_1)
)
);
assert_eq!(
::std::mem::align_of::<__pthread_cond_s__bindgen_ty_1__bindgen_ty_1>(),
4usize,
concat!(
"Alignment of ",
stringify!(__pthread_cond_s__bindgen_ty_1__bindgen_ty_1)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<__pthread_cond_s__bindgen_ty_1__bindgen_ty_1>())).__low
as *const _ as usize
},
0usize,
concat!(
"Offset of field: ",
stringify!(__pthread_cond_s__bindgen_ty_1__bindgen_ty_1),
"::",
stringify!(__low)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<__pthread_cond_s__bindgen_ty_1__bindgen_ty_1>())).__high
as *const _ as usize
},
4usize,
concat!(
"Offset of field: ",
stringify!(__pthread_cond_s__bindgen_ty_1__bindgen_ty_1),
"::",
stringify!(__high)
)
);
}
#[test]
fn bindgen_test_layout___pthread_cond_s__bindgen_ty_1() {
assert_eq!(
::std::mem::size_of::<__pthread_cond_s__bindgen_ty_1>(),
8usize,
concat!("Size of: ", stringify!(__pthread_cond_s__bindgen_ty_1))
);
assert_eq!(
::std::mem::align_of::<__pthread_cond_s__bindgen_ty_1>(),
8usize,
concat!("Alignment of ", stringify!(__pthread_cond_s__bindgen_ty_1))
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<__pthread_cond_s__bindgen_ty_1>())).__wseq as *const _ as usize
},
0usize,
concat!(
"Offset of field: ",
stringify!(__pthread_cond_s__bindgen_ty_1),
"::",
stringify!(__wseq)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<__pthread_cond_s__bindgen_ty_1>())).__wseq32 as *const _ as usize
},
0usize,
concat!(
"Offset of field: ",
stringify!(__pthread_cond_s__bindgen_ty_1),
"::",
stringify!(__wseq32)
)
);
}
impl Default for __pthread_cond_s__bindgen_ty_1 {
fn default() -> Self {
unsafe { ::std::mem::zeroed() }
}
}
#[repr(C)]
#[derive(Copy, Clone)]
pub union __pthread_cond_s__bindgen_ty_2 {
pub __g1_start: ::std::os::raw::c_ulonglong,
pub __g1_start32: __pthread_cond_s__bindgen_ty_2__bindgen_ty_1,
}
#[repr(C)]
#[derive(Debug, Default, Copy, Clone)]
pub struct __pthread_cond_s__bindgen_ty_2__bindgen_ty_1 {
pub __low: ::std::os::raw::c_uint,
pub __high: ::std::os::raw::c_uint,
}
#[test]
fn bindgen_test_layout___pthread_cond_s__bindgen_ty_2__bindgen_ty_1() {
assert_eq!(
::std::mem::size_of::<__pthread_cond_s__bindgen_ty_2__bindgen_ty_1>(),
8usize,
concat!(
"Size of: ",
stringify!(__pthread_cond_s__bindgen_ty_2__bindgen_ty_1)
)
);
assert_eq!(
::std::mem::align_of::<__pthread_cond_s__bindgen_ty_2__bindgen_ty_1>(),
4usize,
concat!(
"Alignment of ",
stringify!(__pthread_cond_s__bindgen_ty_2__bindgen_ty_1)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<__pthread_cond_s__bindgen_ty_2__bindgen_ty_1>())).__low
as *const _ as usize
},
0usize,
concat!(
"Offset of field: ",
stringify!(__pthread_cond_s__bindgen_ty_2__bindgen_ty_1),
"::",
stringify!(__low)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<__pthread_cond_s__bindgen_ty_2__bindgen_ty_1>())).__high
as *const _ as usize
},
4usize,
concat!(
"Offset of field: ",
stringify!(__pthread_cond_s__bindgen_ty_2__bindgen_ty_1),
"::",
stringify!(__high)
)
);
}
#[test]
fn bindgen_test_layout___pthread_cond_s__bindgen_ty_2() {
assert_eq!(
::std::mem::size_of::<__pthread_cond_s__bindgen_ty_2>(),
8usize,
concat!("Size of: ", stringify!(__pthread_cond_s__bindgen_ty_2))
);
assert_eq!(
::std::mem::align_of::<__pthread_cond_s__bindgen_ty_2>(),
8usize,
concat!("Alignment of ", stringify!(__pthread_cond_s__bindgen_ty_2))
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<__pthread_cond_s__bindgen_ty_2>())).__g1_start as *const _
as usize
},
0usize,
concat!(
"Offset of field: ",
stringify!(__pthread_cond_s__bindgen_ty_2),
"::",
stringify!(__g1_start)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<__pthread_cond_s__bindgen_ty_2>())).__g1_start32 as *const _
as usize
},
0usize,
concat!(
"Offset of field: ",
stringify!(__pthread_cond_s__bindgen_ty_2),
"::",
stringify!(__g1_start32)
)
);
}
impl Default for __pthread_cond_s__bindgen_ty_2 {
fn default() -> Self {
unsafe { ::std::mem::zeroed() }
}
}
#[test]
fn bindgen_test_layout___pthread_cond_s() {
assert_eq!(
::std::mem::size_of::<__pthread_cond_s>(),
48usize,
concat!("Size of: ", stringify!(__pthread_cond_s))
);
assert_eq!(
::std::mem::align_of::<__pthread_cond_s>(),
8usize,
concat!("Alignment of ", stringify!(__pthread_cond_s))
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<__pthread_cond_s>())).__g_refs as *const _ as usize },
16usize,
concat!(
"Offset of field: ",
stringify!(__pthread_cond_s),
"::",
stringify!(__g_refs)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<__pthread_cond_s>())).__g_size as *const _ as usize },
24usize,
concat!(
"Offset of field: ",
stringify!(__pthread_cond_s),
"::",
stringify!(__g_size)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<__pthread_cond_s>())).__g1_orig_size as *const _ as usize },
32usize,
concat!(
"Offset of field: ",
stringify!(__pthread_cond_s),
"::",
stringify!(__g1_orig_size)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<__pthread_cond_s>())).__wrefs as *const _ as usize },
36usize,
concat!(
"Offset of field: ",
stringify!(__pthread_cond_s),
"::",
stringify!(__wrefs)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<__pthread_cond_s>())).__g_signals as *const _ as usize },
40usize,
concat!(
"Offset of field: ",
stringify!(__pthread_cond_s),
"::",
stringify!(__g_signals)
)
);
}
impl Default for __pthread_cond_s {
fn default() -> Self {
unsafe { ::std::mem::zeroed() }
}
}
pub type pthread_t = ::std::os::raw::c_ulong;
#[repr(C)]
#[derive(Copy, Clone)]
pub union pthread_mutexattr_t {
pub __size: [::std::os::raw::c_char; 4usize],
pub __align: ::std::os::raw::c_int,
}
#[test]
fn bindgen_test_layout_pthread_mutexattr_t() {
assert_eq!(
::std::mem::size_of::<pthread_mutexattr_t>(),
4usize,
concat!("Size of: ", stringify!(pthread_mutexattr_t))
);
assert_eq!(
::std::mem::align_of::<pthread_mutexattr_t>(),
4usize,
concat!("Alignment of ", stringify!(pthread_mutexattr_t))
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<pthread_mutexattr_t>())).__size as *const _ as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(pthread_mutexattr_t),
"::",
stringify!(__size)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<pthread_mutexattr_t>())).__align as *const _ as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(pthread_mutexattr_t),
"::",
stringify!(__align)
)
);
}
impl Default for pthread_mutexattr_t {
fn default() -> Self {
unsafe { ::std::mem::zeroed() }
}
}
#[repr(C)]
#[derive(Copy, Clone)]
pub union pthread_condattr_t {
pub __size: [::std::os::raw::c_char; 4usize],
pub __align: ::std::os::raw::c_int,
}
#[test]
fn bindgen_test_layout_pthread_condattr_t() {
assert_eq!(
::std::mem::size_of::<pthread_condattr_t>(),
4usize,
concat!("Size of: ", stringify!(pthread_condattr_t))
);
assert_eq!(
::std::mem::align_of::<pthread_condattr_t>(),
4usize,
concat!("Alignment of ", stringify!(pthread_condattr_t))
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<pthread_condattr_t>())).__size as *const _ as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(pthread_condattr_t),
"::",
stringify!(__size)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<pthread_condattr_t>())).__align as *const _ as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(pthread_condattr_t),
"::",
stringify!(__align)
)
);
}
impl Default for pthread_condattr_t {
fn default() -> Self {
unsafe { ::std::mem::zeroed() }
}
}
pub type pthread_key_t = ::std::os::raw::c_uint;
pub type pthread_once_t = ::std::os::raw::c_int;
#[repr(C)]
#[derive(Copy, Clone)]
pub union pthread_attr_t {
pub __size: [::std::os::raw::c_char; 56usize],
pub __align: ::std::os::raw::c_long,
}
#[test]
fn bindgen_test_layout_pthread_attr_t() {
assert_eq!(
::std::mem::size_of::<pthread_attr_t>(),
56usize,
concat!("Size of: ", stringify!(pthread_attr_t))
);
assert_eq!(
::std::mem::align_of::<pthread_attr_t>(),
8usize,
concat!("Alignment of ", stringify!(pthread_attr_t))
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<pthread_attr_t>())).__size as *const _ as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(pthread_attr_t),
"::",
stringify!(__size)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<pthread_attr_t>())).__align as *const _ as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(pthread_attr_t),
"::",
stringify!(__align)
)
);
}
impl Default for pthread_attr_t {
fn default() -> Self {
unsafe { ::std::mem::zeroed() }
}
}
#[repr(C)]
#[derive(Copy, Clone)]
pub union pthread_mutex_t {
pub __data: __pthread_mutex_s,
pub __size: [::std::os::raw::c_char; 40usize],
pub __align: ::std::os::raw::c_long,
}
#[test]
fn bindgen_test_layout_pthread_mutex_t() {
assert_eq!(
::std::mem::size_of::<pthread_mutex_t>(),
40usize,
concat!("Size of: ", stringify!(pthread_mutex_t))
);
assert_eq!(
::std::mem::align_of::<pthread_mutex_t>(),
8usize,
concat!("Alignment of ", stringify!(pthread_mutex_t))
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<pthread_mutex_t>())).__data as *const _ as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(pthread_mutex_t),
"::",
stringify!(__data)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<pthread_mutex_t>())).__size as *const _ as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(pthread_mutex_t),
"::",
stringify!(__size)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<pthread_mutex_t>())).__align as *const _ as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(pthread_mutex_t),
"::",
stringify!(__align)
)
);
}
impl Default for pthread_mutex_t {
fn default() -> Self {
unsafe { ::std::mem::zeroed() }
}
}
#[repr(C)]
#[derive(Copy, Clone)]
pub union pthread_cond_t {
pub __data: __pthread_cond_s,
pub __size: [::std::os::raw::c_char; 48usize],
pub __align: ::std::os::raw::c_longlong,
}
#[test]
fn bindgen_test_layout_pthread_cond_t() {
assert_eq!(
::std::mem::size_of::<pthread_cond_t>(),
48usize,
concat!("Size of: ", stringify!(pthread_cond_t))
);
assert_eq!(
::std::mem::align_of::<pthread_cond_t>(),
8usize,
concat!("Alignment of ", stringify!(pthread_cond_t))
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<pthread_cond_t>())).__data as *const _ as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(pthread_cond_t),
"::",
stringify!(__data)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<pthread_cond_t>())).__size as *const _ as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(pthread_cond_t),
"::",
stringify!(__size)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<pthread_cond_t>())).__align as *const _ as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(pthread_cond_t),
"::",
stringify!(__align)
)
);
}
impl Default for pthread_cond_t {
fn default() -> Self {
unsafe { ::std::mem::zeroed() }
}
}
#[repr(C)]
#[derive(Copy, Clone)]
pub union pthread_rwlock_t {
pub __data: __pthread_rwlock_arch_t,
pub __size: [::std::os::raw::c_char; 56usize],
pub __align: ::std::os::raw::c_long,
}
#[test]
fn bindgen_test_layout_pthread_rwlock_t() {
assert_eq!(
::std::mem::size_of::<pthread_rwlock_t>(),
56usize,
concat!("Size of: ", stringify!(pthread_rwlock_t))
);
assert_eq!(
::std::mem::align_of::<pthread_rwlock_t>(),
8usize,
concat!("Alignment of ", stringify!(pthread_rwlock_t))
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<pthread_rwlock_t>())).__data as *const _ as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(pthread_rwlock_t),
"::",
stringify!(__data)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<pthread_rwlock_t>())).__size as *const _ as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(pthread_rwlock_t),
"::",
stringify!(__size)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<pthread_rwlock_t>())).__align as *const _ as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(pthread_rwlock_t),
"::",
stringify!(__align)
)
);
}
impl Default for pthread_rwlock_t {
fn default() -> Self {
unsafe { ::std::mem::zeroed() }
}
}
#[repr(C)]
#[derive(Copy, Clone)]
pub union pthread_rwlockattr_t {
pub __size: [::std::os::raw::c_char; 8usize],
pub __align: ::std::os::raw::c_long,
}
#[test]
fn bindgen_test_layout_pthread_rwlockattr_t() {
assert_eq!(
::std::mem::size_of::<pthread_rwlockattr_t>(),
8usize,
concat!("Size of: ", stringify!(pthread_rwlockattr_t))
);
assert_eq!(
::std::mem::align_of::<pthread_rwlockattr_t>(),
8usize,
concat!("Alignment of ", stringify!(pthread_rwlockattr_t))
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<pthread_rwlockattr_t>())).__size as *const _ as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(pthread_rwlockattr_t),
"::",
stringify!(__size)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<pthread_rwlockattr_t>())).__align as *const _ as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(pthread_rwlockattr_t),
"::",
stringify!(__align)
)
);
}
impl Default for pthread_rwlockattr_t {
fn default() -> Self {
unsafe { ::std::mem::zeroed() }
}
}
pub type pthread_spinlock_t = ::std::os::raw::c_int;
#[repr(C)]
#[derive(Copy, Clone)]
pub union pthread_barrier_t {
pub __size: [::std::os::raw::c_char; 32usize],
pub __align: ::std::os::raw::c_long,
}
#[test]
fn bindgen_test_layout_pthread_barrier_t() {
assert_eq!(
::std::mem::size_of::<pthread_barrier_t>(),
32usize,
concat!("Size of: ", stringify!(pthread_barrier_t))
);
assert_eq!(
::std::mem::align_of::<pthread_barrier_t>(),
8usize,
concat!("Alignment of ", stringify!(pthread_barrier_t))
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<pthread_barrier_t>())).__size as *const _ as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(pthread_barrier_t),
"::",
stringify!(__size)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<pthread_barrier_t>())).__align as *const _ as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(pthread_barrier_t),
"::",
stringify!(__align)
)
);
}
impl Default for pthread_barrier_t {
fn default() -> Self {
unsafe { ::std::mem::zeroed() }
}
}
#[repr(C)]
#[derive(Copy, Clone)]
pub union pthread_barrierattr_t {
pub __size: [::std::os::raw::c_char; 4usize],
pub __align: ::std::os::raw::c_int,
}
#[test]
fn bindgen_test_layout_pthread_barrierattr_t() {
assert_eq!(
::std::mem::size_of::<pthread_barrierattr_t>(),
4usize,
concat!("Size of: ", stringify!(pthread_barrierattr_t))
);
assert_eq!(
::std::mem::align_of::<pthread_barrierattr_t>(),
4usize,
concat!("Alignment of ", stringify!(pthread_barrierattr_t))
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<pthread_barrierattr_t>())).__size as *const _ as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(pthread_barrierattr_t),
"::",
stringify!(__size)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<pthread_barrierattr_t>())).__align as *const _ as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(pthread_barrierattr_t),
"::",
stringify!(__align)
)
);
}
impl Default for pthread_barrierattr_t {
fn default() -> Self {
unsafe { ::std::mem::zeroed() }
}
}
extern "C" {
pub fn pthread_sigmask(
__how: ::std::os::raw::c_int,
__newmask: *const __sigset_t,
__oldmask: *mut __sigset_t,
) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn pthread_kill(
__threadid: pthread_t,
__signo: ::std::os::raw::c_int,
) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn __libc_current_sigrtmin() -> ::std::os::raw::c_int;
}
extern "C" {
pub fn __libc_current_sigrtmax() -> ::std::os::raw::c_int;
}
pub const rounding_DEC_ROUND_CEILING: rounding = 0;
pub const rounding_DEC_ROUND_UP: rounding = 1;
pub const rounding_DEC_ROUND_HALF_UP: rounding = 2;
pub const rounding_DEC_ROUND_HALF_EVEN: rounding = 3;
pub const rounding_DEC_ROUND_HALF_DOWN: rounding = 4;
pub const rounding_DEC_ROUND_DOWN: rounding = 5;
pub const rounding_DEC_ROUND_FLOOR: rounding = 6;
pub const rounding_DEC_ROUND_05UP: rounding = 7;
pub const rounding_DEC_ROUND_MAX: rounding = 8;
pub type rounding = ::std::os::raw::c_uint;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct decContext {
pub digits: i32,
pub emax: i32,
pub emin: i32,
pub round: rounding,
pub traps: u32,
pub status: u32,
pub clamp: u8,
}
#[test]
fn bindgen_test_layout_decContext() {
assert_eq!(
::std::mem::size_of::<decContext>(),
28usize,
concat!("Size of: ", stringify!(decContext))
);
assert_eq!(
::std::mem::align_of::<decContext>(),
4usize,
concat!("Alignment of ", stringify!(decContext))
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<decContext>())).digits as *const _ as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(decContext),
"::",
stringify!(digits)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<decContext>())).emax as *const _ as usize },
4usize,
concat!(
"Offset of field: ",
stringify!(decContext),
"::",
stringify!(emax)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<decContext>())).emin as *const _ as usize },
8usize,
concat!(
"Offset of field: ",
stringify!(decContext),
"::",
stringify!(emin)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<decContext>())).round as *const _ as usize },
12usize,
concat!(
"Offset of field: ",
stringify!(decContext),
"::",
stringify!(round)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<decContext>())).traps as *const _ as usize },
16usize,
concat!(
"Offset of field: ",
stringify!(decContext),
"::",
stringify!(traps)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<decContext>())).status as *const _ as usize },
20usize,
concat!(
"Offset of field: ",
stringify!(decContext),
"::",
stringify!(status)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<decContext>())).clamp as *const _ as usize },
24usize,
concat!(
"Offset of field: ",
stringify!(decContext),
"::",
stringify!(clamp)
)
);
}
impl Default for decContext {
fn default() -> Self {
unsafe { ::std::mem::zeroed() }
}
}
pub const decClass_DEC_CLASS_SNAN: decClass = 0;
pub const decClass_DEC_CLASS_QNAN: decClass = 1;
pub const decClass_DEC_CLASS_NEG_INF: decClass = 2;
pub const decClass_DEC_CLASS_NEG_NORMAL: decClass = 3;
pub const decClass_DEC_CLASS_NEG_SUBNORMAL: decClass = 4;
pub const decClass_DEC_CLASS_NEG_ZERO: decClass = 5;
pub const decClass_DEC_CLASS_POS_ZERO: decClass = 6;
pub const decClass_DEC_CLASS_POS_SUBNORMAL: decClass = 7;
pub const decClass_DEC_CLASS_POS_NORMAL: decClass = 8;
pub const decClass_DEC_CLASS_POS_INF: decClass = 9;
pub type decClass = ::std::os::raw::c_uint;
extern "C" {
pub fn decContextClearStatus(arg1: *mut decContext, arg2: u32) -> *mut decContext;
}
extern "C" {
pub fn decContextDefault(arg1: *mut decContext, arg2: i32) -> *mut decContext;
}
extern "C" {
pub fn decContextGetRounding(arg1: *mut decContext) -> rounding;
}
extern "C" {
pub fn decContextGetStatus(arg1: *mut decContext) -> u32;
}
extern "C" {
pub fn decContextRestoreStatus(arg1: *mut decContext, arg2: u32, arg3: u32) -> *mut decContext;
}
extern "C" {
pub fn decContextSaveStatus(arg1: *mut decContext, arg2: u32) -> u32;
}
extern "C" {
pub fn decContextSetRounding(arg1: *mut decContext, arg2: rounding) -> *mut decContext;
}
extern "C" {
pub fn decContextSetStatus(arg1: *mut decContext, arg2: u32) -> *mut decContext;
}
extern "C" {
pub fn decContextSetStatusFromString(
arg1: *mut decContext,
arg2: *const ::std::os::raw::c_char,
) -> *mut decContext;
}
extern "C" {
pub fn decContextSetStatusFromStringQuiet(
arg1: *mut decContext,
arg2: *const ::std::os::raw::c_char,
) -> *mut decContext;
}
extern "C" {
pub fn decContextSetStatusQuiet(arg1: *mut decContext, arg2: u32) -> *mut decContext;
}
extern "C" {
pub fn decContextStatusToString(arg1: *const decContext) -> *const ::std::os::raw::c_char;
}
extern "C" {
pub fn decContextTestEndian(arg1: u8) -> i32;
}
extern "C" {
pub fn decContextTestSavedStatus(arg1: u32, arg2: u32) -> u32;
}
extern "C" {
pub fn decContextTestStatus(arg1: *mut decContext, arg2: u32) -> u32;
}
extern "C" {
pub fn decContextZeroStatus(arg1: *mut decContext) -> *mut decContext;
}
#[repr(C)]
#[derive(Copy, Clone)]
pub union decQuad {
pub bytes: [u8; 16usize],
pub shorts: [u16; 8usize],
pub words: [u32; 4usize],
}
#[test]
fn bindgen_test_layout_decQuad() {
assert_eq!(
::std::mem::size_of::<decQuad>(),
16usize,
concat!("Size of: ", stringify!(decQuad))
);
assert_eq!(
::std::mem::align_of::<decQuad>(),
4usize,
concat!("Alignment of ", stringify!(decQuad))
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<decQuad>())).bytes as *const _ as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(decQuad),
"::",
stringify!(bytes)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<decQuad>())).shorts as *const _ as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(decQuad),
"::",
stringify!(shorts)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<decQuad>())).words as *const _ as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(decQuad),
"::",
stringify!(words)
)
);
}
impl Default for decQuad {
fn default() -> Self {
unsafe { ::std::mem::zeroed() }
}
}
extern "C" {
pub fn decQuadFromBCD(
arg1: *mut decQuad,
arg2: i32,
arg3: *const u8,
arg4: i32,
) -> *mut decQuad;
}
extern "C" {
pub fn decQuadFromInt32(arg1: *mut decQuad, arg2: i32) -> *mut decQuad;
}
extern "C" {
pub fn decQuadFromPacked(arg1: *mut decQuad, arg2: i32, arg3: *const u8) -> *mut decQuad;
}
extern "C" {
pub fn decQuadFromPackedChecked(arg1: *mut decQuad, arg2: i32, arg3: *const u8)
-> *mut decQuad;
}
extern "C" {
pub fn decQuadFromString(
arg1: *mut decQuad,
arg2: *const ::std::os::raw::c_char,
arg3: *mut decContext,
) -> *mut decQuad;
}
extern "C" {
pub fn decQuadFromUInt32(arg1: *mut decQuad, arg2: u32) -> *mut decQuad;
}
extern "C" {
pub fn decQuadGetCoefficient(arg1: *const decQuad, arg2: *mut u8) -> i32;
}
extern "C" {
pub fn decQuadGetExponent(arg1: *const decQuad) -> i32;
}
extern "C" {
pub fn decQuadSetCoefficient(arg1: *mut decQuad, arg2: *const u8, arg3: i32) -> *mut decQuad;
}
extern "C" {
pub fn decQuadSetExponent(arg1: *mut decQuad, arg2: *mut decContext, arg3: i32)
-> *mut decQuad;
}
extern "C" {
pub fn decQuadShow(arg1: *const decQuad, arg2: *const ::std::os::raw::c_char);
}
extern "C" {
pub fn decQuadToBCD(arg1: *const decQuad, arg2: *mut i32, arg3: *mut u8) -> i32;
}
extern "C" {
pub fn decQuadToEngString(
arg1: *const decQuad,
arg2: *mut ::std::os::raw::c_char,
) -> *mut ::std::os::raw::c_char;
}
extern "C" {
pub fn decQuadToInt32(arg1: *const decQuad, arg2: *mut decContext, arg3: rounding) -> i32;
}
extern "C" {
pub fn decQuadToInt32Exact(arg1: *const decQuad, arg2: *mut decContext, arg3: rounding) -> i32;
}
extern "C" {
pub fn decQuadToPacked(arg1: *const decQuad, arg2: *mut i32, arg3: *mut u8) -> i32;
}
extern "C" {
pub fn decQuadToString(
arg1: *const decQuad,
arg2: *mut ::std::os::raw::c_char,
) -> *mut ::std::os::raw::c_char;
}
extern "C" {
pub fn decQuadToUInt32(arg1: *const decQuad, arg2: *mut decContext, arg3: rounding) -> u32;
}
extern "C" {
pub fn decQuadToUInt32Exact(arg1: *const decQuad, arg2: *mut decContext, arg3: rounding)
-> u32;
}
extern "C" {
pub fn decQuadZero(arg1: *mut decQuad) -> *mut decQuad;
}
extern "C" {
pub fn decQuadAbs(
arg1: *mut decQuad,
arg2: *const decQuad,
arg3: *mut decContext,
) -> *mut decQuad;
}
extern "C" {
pub fn decQuadAdd(
arg1: *mut decQuad,
arg2: *const decQuad,
arg3: *const decQuad,
arg4: *mut decContext,
) -> *mut decQuad;
}
extern "C" {
pub fn decQuadAnd(
arg1: *mut decQuad,
arg2: *const decQuad,
arg3: *const decQuad,
arg4: *mut decContext,
) -> *mut decQuad;
}
extern "C" {
pub fn decQuadDivide(
arg1: *mut decQuad,
arg2: *const decQuad,
arg3: *const decQuad,
arg4: *mut decContext,
) -> *mut decQuad;
}
extern "C" {
pub fn decQuadDivideInteger(
arg1: *mut decQuad,
arg2: *const decQuad,
arg3: *const decQuad,
arg4: *mut decContext,
) -> *mut decQuad;
}
extern "C" {
pub fn decQuadFMA(
arg1: *mut decQuad,
arg2: *const decQuad,
arg3: *const decQuad,
arg4: *const decQuad,
arg5: *mut decContext,
) -> *mut decQuad;
}
extern "C" {
pub fn decQuadInvert(
arg1: *mut decQuad,
arg2: *const decQuad,
arg3: *mut decContext,
) -> *mut decQuad;
}
extern "C" {
pub fn decQuadLogB(
arg1: *mut decQuad,
arg2: *const decQuad,
arg3: *mut decContext,
) -> *mut decQuad;
}
extern "C" {
pub fn decQuadMax(
arg1: *mut decQuad,
arg2: *const decQuad,
arg3: *const decQuad,
arg4: *mut decContext,
) -> *mut decQuad;
}
extern "C" {
pub fn decQuadMaxMag(
arg1: *mut decQuad,
arg2: *const decQuad,
arg3: *const decQuad,
arg4: *mut decContext,
) -> *mut decQuad;
}
extern "C" {
pub fn decQuadMin(
arg1: *mut decQuad,
arg2: *const decQuad,
arg3: *const decQuad,
arg4: *mut decContext,
) -> *mut decQuad;
}
extern "C" {
pub fn decQuadMinMag(
arg1: *mut decQuad,
arg2: *const decQuad,
arg3: *const decQuad,
arg4: *mut decContext,
) -> *mut decQuad;
}
extern "C" {
pub fn decQuadMinus(
arg1: *mut decQuad,
arg2: *const decQuad,
arg3: *mut decContext,
) -> *mut decQuad;
}
extern "C" {
pub fn decQuadMultiply(
arg1: *mut decQuad,
arg2: *const decQuad,
arg3: *const decQuad,
arg4: *mut decContext,
) -> *mut decQuad;
}
extern "C" {
pub fn decQuadNextMinus(
arg1: *mut decQuad,
arg2: *const decQuad,
arg3: *mut decContext,
) -> *mut decQuad;
}
extern "C" {
pub fn decQuadNextPlus(
arg1: *mut decQuad,
arg2: *const decQuad,
arg3: *mut decContext,
) -> *mut decQuad;
}
extern "C" {
pub fn decQuadNextToward(
arg1: *mut decQuad,
arg2: *const decQuad,
arg3: *const decQuad,
arg4: *mut decContext,
) -> *mut decQuad;
}
extern "C" {
pub fn decQuadOr(
arg1: *mut decQuad,
arg2: *const decQuad,
arg3: *const decQuad,
arg4: *mut decContext,
) -> *mut decQuad;
}
extern "C" {
pub fn decQuadPlus(
arg1: *mut decQuad,
arg2: *const decQuad,
arg3: *mut decContext,
) -> *mut decQuad;
}
extern "C" {
pub fn decQuadQuantize(
arg1: *mut decQuad,
arg2: *const decQuad,
arg3: *const decQuad,
arg4: *mut decContext,
) -> *mut decQuad;
}
extern "C" {
pub fn decQuadReduce(
arg1: *mut decQuad,
arg2: *const decQuad,
arg3: *mut decContext,
) -> *mut decQuad;
}
extern "C" {
pub fn decQuadRemainder(
arg1: *mut decQuad,
arg2: *const decQuad,
arg3: *const decQuad,
arg4: *mut decContext,
) -> *mut decQuad;
}
extern "C" {
pub fn decQuadRemainderNear(
arg1: *mut decQuad,
arg2: *const decQuad,
arg3: *const decQuad,
arg4: *mut decContext,
) -> *mut decQuad;
}
extern "C" {
pub fn decQuadRotate(
arg1: *mut decQuad,
arg2: *const decQuad,
arg3: *const decQuad,
arg4: *mut decContext,
) -> *mut decQuad;
}
extern "C" {
pub fn decQuadScaleB(
arg1: *mut decQuad,
arg2: *const decQuad,
arg3: *const decQuad,
arg4: *mut decContext,
) -> *mut decQuad;
}
extern "C" {
pub fn decQuadShift(
arg1: *mut decQuad,
arg2: *const decQuad,
arg3: *const decQuad,
arg4: *mut decContext,
) -> *mut decQuad;
}
extern "C" {
pub fn decQuadSubtract(
arg1: *mut decQuad,
arg2: *const decQuad,
arg3: *const decQuad,
arg4: *mut decContext,
) -> *mut decQuad;
}
extern "C" {
pub fn decQuadToIntegralValue(
arg1: *mut decQuad,
arg2: *const decQuad,
arg3: *mut decContext,
arg4: rounding,
) -> *mut decQuad;
}
extern "C" {
pub fn decQuadToIntegralExact(
arg1: *mut decQuad,
arg2: *const decQuad,
arg3: *mut decContext,
) -> *mut decQuad;
}
extern "C" {
pub fn decQuadXor(
arg1: *mut decQuad,
arg2: *const decQuad,
arg3: *const decQuad,
arg4: *mut decContext,
) -> *mut decQuad;
}
extern "C" {
pub fn decQuadCompare(
arg1: *mut decQuad,
arg2: *const decQuad,
arg3: *const decQuad,
arg4: *mut decContext,
) -> *mut decQuad;
}
extern "C" {
pub fn decQuadCompareSignal(
arg1: *mut decQuad,
arg2: *const decQuad,
arg3: *const decQuad,
arg4: *mut decContext,
) -> *mut decQuad;
}
extern "C" {
pub fn decQuadCompareTotal(
arg1: *mut decQuad,
arg2: *const decQuad,
arg3: *const decQuad,
) -> *mut decQuad;
}
extern "C" {
pub fn decQuadCompareTotalMag(
arg1: *mut decQuad,
arg2: *const decQuad,
arg3: *const decQuad,
) -> *mut decQuad;
}
extern "C" {
pub fn decQuadCanonical(arg1: *mut decQuad, arg2: *const decQuad) -> *mut decQuad;
}
extern "C" {
pub fn decQuadCopy(arg1: *mut decQuad, arg2: *const decQuad) -> *mut decQuad;
}
extern "C" {
pub fn decQuadCopyAbs(arg1: *mut decQuad, arg2: *const decQuad) -> *mut decQuad;
}
extern "C" {
pub fn decQuadCopyNegate(arg1: *mut decQuad, arg2: *const decQuad) -> *mut decQuad;
}
extern "C" {
pub fn decQuadCopySign(
arg1: *mut decQuad,
arg2: *const decQuad,
arg3: *const decQuad,
) -> *mut decQuad;
}
extern "C" {
pub fn decQuadClass(arg1: *const decQuad) -> decClass;
}
extern "C" {
pub fn decQuadClassString(arg1: *const decQuad) -> *const ::std::os::raw::c_char;
}
extern "C" {
pub fn decQuadDigits(arg1: *const decQuad) -> u32;
}
extern "C" {
pub fn decQuadIsCanonical(arg1: *const decQuad) -> u32;
}
extern "C" {
pub fn decQuadIsFinite(arg1: *const decQuad) -> u32;
}
extern "C" {
pub fn decQuadIsInteger(arg1: *const decQuad) -> u32;
}
extern "C" {
pub fn decQuadIsLogical(arg1: *const decQuad) -> u32;
}
extern "C" {
pub fn decQuadIsInfinite(arg1: *const decQuad) -> u32;
}
extern "C" {
pub fn decQuadIsNaN(arg1: *const decQuad) -> u32;
}
extern "C" {
pub fn decQuadIsNegative(arg1: *const decQuad) -> u32;
}
extern "C" {
pub fn decQuadIsNormal(arg1: *const decQuad) -> u32;
}
extern "C" {
pub fn decQuadIsPositive(arg1: *const decQuad) -> u32;
}
extern "C" {
pub fn decQuadIsSignaling(arg1: *const decQuad) -> u32;
}
extern "C" {
pub fn decQuadIsSignalling(arg1: *const decQuad) -> u32;
}
extern "C" {
pub fn decQuadIsSigned(arg1: *const decQuad) -> u32;
}
extern "C" {
pub fn decQuadIsSubnormal(arg1: *const decQuad) -> u32;
}
extern "C" {
pub fn decQuadIsZero(arg1: *const decQuad) -> u32;
}
extern "C" {
pub fn decQuadRadix(arg1: *const decQuad) -> u32;
}
extern "C" {
pub fn decQuadSameQuantum(arg1: *const decQuad, arg2: *const decQuad) -> u32;
}
extern "C" {
pub fn decQuadVersion() -> *const ::std::os::raw::c_char;
}
#[repr(C)]
#[derive(Debug, Default, Copy, Clone)]
pub struct decNumber {
pub digits: i32,
pub exponent: i32,
pub bits: u8,
pub lsu: [u16; 12usize],
}
#[test]
fn bindgen_test_layout_decNumber() {
assert_eq!(
::std::mem::size_of::<decNumber>(),
36usize,
concat!("Size of: ", stringify!(decNumber))
);
assert_eq!(
::std::mem::align_of::<decNumber>(),
4usize,
concat!("Alignment of ", stringify!(decNumber))
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<decNumber>())).digits as *const _ as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(decNumber),
"::",
stringify!(digits)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<decNumber>())).exponent as *const _ as usize },
4usize,
concat!(
"Offset of field: ",
stringify!(decNumber),
"::",
stringify!(exponent)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<decNumber>())).bits as *const _ as usize },
8usize,
concat!(
"Offset of field: ",
stringify!(decNumber),
"::",
stringify!(bits)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<decNumber>())).lsu as *const _ as usize },
10usize,
concat!(
"Offset of field: ",
stringify!(decNumber),
"::",
stringify!(lsu)
)
);
}
extern "C" {
pub fn decNumberFromInt32(arg1: *mut decNumber, arg2: i32) -> *mut decNumber;
}
extern "C" {
pub fn decNumberFromUInt32(arg1: *mut decNumber, arg2: u32) -> *mut decNumber;
}
extern "C" {
pub fn decNumberFromString(
arg1: *mut decNumber,
arg2: *const ::std::os::raw::c_char,
arg3: *mut decContext,
) -> *mut decNumber;
}
extern "C" {
pub fn decNumberToString(
arg1: *const decNumber,
arg2: *mut ::std::os::raw::c_char,
) -> *mut ::std::os::raw::c_char;
}
extern "C" {
pub fn decNumberToEngString(
arg1: *const decNumber,
arg2: *mut ::std::os::raw::c_char,
) -> *mut ::std::os::raw::c_char;
}
extern "C" {
pub fn decNumberToUInt32(arg1: *const decNumber, arg2: *mut decContext) -> u32;
}
extern "C" {
pub fn decNumberToInt32(arg1: *const decNumber, arg2: *mut decContext) -> i32;
}
extern "C" {
pub fn decNumberGetBCD(arg1: *const decNumber, arg2: *mut u8) -> *mut u8;
}
extern "C" {
pub fn decNumberSetBCD(arg1: *mut decNumber, arg2: *const u8, arg3: u32) -> *mut decNumber;
}
extern "C" {
pub fn decNumberAbs(
arg1: *mut decNumber,
arg2: *const decNumber,
arg3: *mut decContext,
) -> *mut decNumber;
}
extern "C" {
pub fn decNumberAdd(
arg1: *mut decNumber,
arg2: *const decNumber,
arg3: *const decNumber,
arg4: *mut decContext,
) -> *mut decNumber;
}
extern "C" {
pub fn decNumberAnd(
arg1: *mut decNumber,
arg2: *const decNumber,
arg3: *const decNumber,
arg4: *mut decContext,
) -> *mut decNumber;
}
extern "C" {
pub fn decNumberCompare(
arg1: *mut decNumber,
arg2: *const decNumber,
arg3: *const decNumber,
arg4: *mut decContext,
) -> *mut decNumber;
}
extern "C" {
pub fn decNumberCompareSignal(
arg1: *mut decNumber,
arg2: *const decNumber,
arg3: *const decNumber,
arg4: *mut decContext,
) -> *mut decNumber;
}
extern "C" {
pub fn decNumberCompareTotal(
arg1: *mut decNumber,
arg2: *const decNumber,
arg3: *const decNumber,
arg4: *mut decContext,
) -> *mut decNumber;
}
extern "C" {
pub fn decNumberCompareTotalMag(
arg1: *mut decNumber,
arg2: *const decNumber,
arg3: *const decNumber,
arg4: *mut decContext,
) -> *mut decNumber;
}
extern "C" {
pub fn decNumberDivide(
arg1: *mut decNumber,
arg2: *const decNumber,
arg3: *const decNumber,
arg4: *mut decContext,
) -> *mut decNumber;
}
extern "C" {
pub fn decNumberDivideInteger(
arg1: *mut decNumber,
arg2: *const decNumber,
arg3: *const decNumber,
arg4: *mut decContext,
) -> *mut decNumber;
}
extern "C" {
pub fn decNumberExp(
arg1: *mut decNumber,
arg2: *const decNumber,
arg3: *mut decContext,
) -> *mut decNumber;
}
extern "C" {
pub fn decNumberFMA(
arg1: *mut decNumber,
arg2: *const decNumber,
arg3: *const decNumber,
arg4: *const decNumber,
arg5: *mut decContext,
) -> *mut decNumber;
}
extern "C" {
pub fn decNumberInvert(
arg1: *mut decNumber,
arg2: *const decNumber,
arg3: *mut decContext,
) -> *mut decNumber;
}
extern "C" {
pub fn decNumberLn(
arg1: *mut decNumber,
arg2: *const decNumber,
arg3: *mut decContext,
) -> *mut decNumber;
}
extern "C" {
pub fn decNumberLogB(
arg1: *mut decNumber,
arg2: *const decNumber,
arg3: *mut decContext,
) -> *mut decNumber;
}
extern "C" {
pub fn decNumberLog10(
arg1: *mut decNumber,
arg2: *const decNumber,
arg3: *mut decContext,
) -> *mut decNumber;
}
extern "C" {
pub fn decNumberMax(
arg1: *mut decNumber,
arg2: *const decNumber,
arg3: *const decNumber,
arg4: *mut decContext,
) -> *mut decNumber;
}
extern "C" {
pub fn decNumberMaxMag(
arg1: *mut decNumber,
arg2: *const decNumber,
arg3: *const decNumber,
arg4: *mut decContext,
) -> *mut decNumber;
}
extern "C" {
pub fn decNumberMin(
arg1: *mut decNumber,
arg2: *const decNumber,
arg3: *const decNumber,
arg4: *mut decContext,
) -> *mut decNumber;
}
extern "C" {
pub fn decNumberMinMag(
arg1: *mut decNumber,
arg2: *const decNumber,
arg3: *const decNumber,
arg4: *mut decContext,
) -> *mut decNumber;
}
extern "C" {
pub fn decNumberMinus(
arg1: *mut decNumber,
arg2: *const decNumber,
arg3: *mut decContext,
) -> *mut decNumber;
}
extern "C" {
pub fn decNumberMultiply(
arg1: *mut decNumber,
arg2: *const decNumber,
arg3: *const decNumber,
arg4: *mut decContext,
) -> *mut decNumber;
}
extern "C" {
pub fn decNumberNormalize(
arg1: *mut decNumber,
arg2: *const decNumber,
arg3: *mut decContext,
) -> *mut decNumber;
}
extern "C" {
pub fn decNumberOr(
arg1: *mut decNumber,
arg2: *const decNumber,
arg3: *const decNumber,
arg4: *mut decContext,
) -> *mut decNumber;
}
extern "C" {
pub fn decNumberPlus(
arg1: *mut decNumber,
arg2: *const decNumber,
arg3: *mut decContext,
) -> *mut decNumber;
}
extern "C" {
pub fn decNumberPower(
arg1: *mut decNumber,
arg2: *const decNumber,
arg3: *const decNumber,
arg4: *mut decContext,
) -> *mut decNumber;
}
extern "C" {
pub fn decNumberQuantize(
arg1: *mut decNumber,
arg2: *const decNumber,
arg3: *const decNumber,
arg4: *mut decContext,
) -> *mut decNumber;
}
extern "C" {
pub fn decNumberReduce(
arg1: *mut decNumber,
arg2: *const decNumber,
arg3: *mut decContext,
) -> *mut decNumber;
}
extern "C" {
pub fn decNumberRemainder(
arg1: *mut decNumber,
arg2: *const decNumber,
arg3: *const decNumber,
arg4: *mut decContext,
) -> *mut decNumber;
}
extern "C" {
pub fn decNumberRemainderNear(
arg1: *mut decNumber,
arg2: *const decNumber,
arg3: *const decNumber,
arg4: *mut decContext,
) -> *mut decNumber;
}
extern "C" {
pub fn decNumberRescale(
arg1: *mut decNumber,
arg2: *const decNumber,
arg3: *const decNumber,
arg4: *mut decContext,
) -> *mut decNumber;
}
extern "C" {
pub fn decNumberRotate(
arg1: *mut decNumber,
arg2: *const decNumber,
arg3: *const decNumber,
arg4: *mut decContext,
) -> *mut decNumber;
}
extern "C" {
pub fn decNumberSameQuantum(
arg1: *mut decNumber,
arg2: *const decNumber,
arg3: *const decNumber,
) -> *mut decNumber;
}
extern "C" {
pub fn decNumberScaleB(
arg1: *mut decNumber,
arg2: *const decNumber,
arg3: *const decNumber,
arg4: *mut decContext,
) -> *mut decNumber;
}
extern "C" {
pub fn decNumberShift(
arg1: *mut decNumber,
arg2: *const decNumber,
arg3: *const decNumber,
arg4: *mut decContext,
) -> *mut decNumber;
}
extern "C" {
pub fn decNumberSquareRoot(
arg1: *mut decNumber,
arg2: *const decNumber,
arg3: *mut decContext,
) -> *mut decNumber;
}
extern "C" {
pub fn decNumberSubtract(
arg1: *mut decNumber,
arg2: *const decNumber,
arg3: *const decNumber,
arg4: *mut decContext,
) -> *mut decNumber;
}
extern "C" {
pub fn decNumberToIntegralExact(
arg1: *mut decNumber,
arg2: *const decNumber,
arg3: *mut decContext,
) -> *mut decNumber;
}
extern "C" {
pub fn decNumberToIntegralValue(
arg1: *mut decNumber,
arg2: *const decNumber,
arg3: *mut decContext,
) -> *mut decNumber;
}
extern "C" {
pub fn decNumberXor(
arg1: *mut decNumber,
arg2: *const decNumber,
arg3: *const decNumber,
arg4: *mut decContext,
) -> *mut decNumber;
}
extern "C" {
pub fn decNumberClass(arg1: *const decNumber, arg2: *mut decContext) -> decClass;
}
extern "C" {
pub fn decNumberClassToString(arg1: decClass) -> *const ::std::os::raw::c_char;
}
extern "C" {
pub fn decNumberCopy(arg1: *mut decNumber, arg2: *const decNumber) -> *mut decNumber;
}
extern "C" {
pub fn decNumberCopyAbs(arg1: *mut decNumber, arg2: *const decNumber) -> *mut decNumber;
}
extern "C" {
pub fn decNumberCopyNegate(arg1: *mut decNumber, arg2: *const decNumber) -> *mut decNumber;
}
extern "C" {
pub fn decNumberCopySign(
arg1: *mut decNumber,
arg2: *const decNumber,
arg3: *const decNumber,
) -> *mut decNumber;
}
extern "C" {
pub fn decNumberNextMinus(
arg1: *mut decNumber,
arg2: *const decNumber,
arg3: *mut decContext,
) -> *mut decNumber;
}
extern "C" {
pub fn decNumberNextPlus(
arg1: *mut decNumber,
arg2: *const decNumber,
arg3: *mut decContext,
) -> *mut decNumber;
}
extern "C" {
pub fn decNumberNextToward(
arg1: *mut decNumber,
arg2: *const decNumber,
arg3: *const decNumber,
arg4: *mut decContext,
) -> *mut decNumber;
}
extern "C" {
pub fn decNumberTrim(arg1: *mut decNumber) -> *mut decNumber;
}
extern "C" {
pub fn decNumberVersion() -> *const ::std::os::raw::c_char;
}
extern "C" {
pub fn decNumberZero(arg1: *mut decNumber) -> *mut decNumber;
}
extern "C" {
pub fn decNumberIsNormal(arg1: *const decNumber, arg2: *mut decContext) -> i32;
}
extern "C" {
pub fn decNumberIsSubnormal(arg1: *const decNumber, arg2: *mut decContext) -> i32;
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct ion_type {
_unused: [u8; 0],
}
#[doc = " Strong typed enum over pointer type."]
pub type ION_TYPE = *mut ion_type;
pub type SID = i32;
pub type SIZE = i32;
pub type BYTE = u8;
pub type BOOL = ::std::os::raw::c_int;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct _ion_symbol_table {
_unused: [u8; 0],
}
pub type ION_SYMBOL_TABLE = _ion_symbol_table;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct _ion_catalog {
_unused: [u8; 0],
}
pub type ION_CATALOG = _ion_catalog;
#[doc = " An Ion String."]
#[doc = ""]
#[doc = " @see _ion_string"]
pub type ION_STRING = _ion_string;
pub type ION_SYMBOL = _ion_symbol;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct _ion_symbol_table_import_descriptor {
_unused: [u8; 0],
}
pub type ION_SYMBOL_TABLE_IMPORT_DESCRIPTOR = _ion_symbol_table_import_descriptor;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct _ion_symbol_table_import {
_unused: [u8; 0],
}
pub type ION_SYMBOL_TABLE_IMPORT = _ion_symbol_table_import;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct _ion_reader {
_unused: [u8; 0],
}
pub type ION_READER = _ion_reader;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct _ion_writer {
_unused: [u8; 0],
}
pub type ION_WRITER = _ion_writer;
pub type ION_INT = _ion_int;
pub type ION_DECIMAL = _ion_decimal;
pub type ION_TIMESTAMP = _ion_timestamp;
pub type ION_COLLECTION = _ion_collection;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct _ion_stream {
_unused: [u8; 0],
}
pub type ION_STREAM = _ion_stream;
pub type ION_STREAM_HANDLER =
::std::option::Option<unsafe extern "C" fn(pstream: *mut _ion_user_stream) -> iERR>;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct _ion_user_stream {
pub curr: *mut BYTE,
pub limit: *mut BYTE,
pub handler_state: *mut ::std::os::raw::c_void,
pub handler: ION_STREAM_HANDLER,
}
#[test]
fn bindgen_test_layout__ion_user_stream() {
assert_eq!(
::std::mem::size_of::<_ion_user_stream>(),
32usize,
concat!("Size of: ", stringify!(_ion_user_stream))
);
assert_eq!(
::std::mem::align_of::<_ion_user_stream>(),
8usize,
concat!("Alignment of ", stringify!(_ion_user_stream))
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_ion_user_stream>())).curr as *const _ as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(_ion_user_stream),
"::",
stringify!(curr)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_ion_user_stream>())).limit as *const _ as usize },
8usize,
concat!(
"Offset of field: ",
stringify!(_ion_user_stream),
"::",
stringify!(limit)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_ion_user_stream>())).handler_state as *const _ as usize },
16usize,
concat!(
"Offset of field: ",
stringify!(_ion_user_stream),
"::",
stringify!(handler_state)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_ion_user_stream>())).handler as *const _ as usize },
24usize,
concat!(
"Offset of field: ",
stringify!(_ion_user_stream),
"::",
stringify!(handler)
)
);
}
impl Default for _ion_user_stream {
fn default() -> Self {
unsafe { ::std::mem::zeroed() }
}
}
pub type iSTRING = *mut ION_STRING;
pub type iSYMBOL = *mut ION_SYMBOL;
pub type iIMPORT = *mut ION_SYMBOL_TABLE_IMPORT;
pub type iSYMTAB = *mut ION_SYMBOL_TABLE;
pub type iCATALOG = *mut ION_CATALOG;
pub type iSTREAM = *mut ION_STREAM;
pub type iTIMESTAMP = *mut ION_TIMESTAMP;
pub type hOWNER = *mut ::std::os::raw::c_void;
pub type hREADER = *mut ION_READER;
pub type hWRITER = *mut ION_WRITER;
pub type hSYMTAB = *mut ION_SYMBOL_TABLE;
pub type hCATALOG = *mut ION_CATALOG;
extern "C" {
pub fn memcpy(
__dest: *mut ::std::os::raw::c_void,
__src: *const ::std::os::raw::c_void,
__n: ::std::os::raw::c_ulong,
) -> *mut ::std::os::raw::c_void;
}
extern "C" {
pub fn memmove(
__dest: *mut ::std::os::raw::c_void,
__src: *const ::std::os::raw::c_void,
__n: ::std::os::raw::c_ulong,
) -> *mut ::std::os::raw::c_void;
}
extern "C" {
pub fn memccpy(
__dest: *mut ::std::os::raw::c_void,
__src: *const ::std::os::raw::c_void,
__c: ::std::os::raw::c_int,
__n: ::std::os::raw::c_ulong,
) -> *mut ::std::os::raw::c_void;
}
extern "C" {
pub fn memset(
__s: *mut ::std::os::raw::c_void,
__c: ::std::os::raw::c_int,
__n: ::std::os::raw::c_ulong,
) -> *mut ::std::os::raw::c_void;
}
extern "C" {
pub fn memcmp(
__s1: *const ::std::os::raw::c_void,
__s2: *const ::std::os::raw::c_void,
__n: ::std::os::raw::c_ulong,
) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn memchr(
__s: *const ::std::os::raw::c_void,
__c: ::std::os::raw::c_int,
__n: ::std::os::raw::c_ulong,
) -> *mut ::std::os::raw::c_void;
}
extern "C" {
pub fn strcpy(
__dest: *mut ::std::os::raw::c_char,
__src: *const ::std::os::raw::c_char,
) -> *mut ::std::os::raw::c_char;
}
extern "C" {
pub fn strncpy(
__dest: *mut ::std::os::raw::c_char,
__src: *const ::std::os::raw::c_char,
__n: ::std::os::raw::c_ulong,
) -> *mut ::std::os::raw::c_char;
}
extern "C" {
pub fn strcat(
__dest: *mut ::std::os::raw::c_char,
__src: *const ::std::os::raw::c_char,
) -> *mut ::std::os::raw::c_char;
}
extern "C" {
pub fn strncat(
__dest: *mut ::std::os::raw::c_char,
__src: *const ::std::os::raw::c_char,
__n: ::std::os::raw::c_ulong,
) -> *mut ::std::os::raw::c_char;
}
extern "C" {
pub fn strcmp(
__s1: *const ::std::os::raw::c_char,
__s2: *const ::std::os::raw::c_char,
) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn strncmp(
__s1: *const ::std::os::raw::c_char,
__s2: *const ::std::os::raw::c_char,
__n: ::std::os::raw::c_ulong,
) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn strcoll(
__s1: *const ::std::os::raw::c_char,
__s2: *const ::std::os::raw::c_char,
) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn strxfrm(
__dest: *mut ::std::os::raw::c_char,
__src: *const ::std::os::raw::c_char,
__n: ::std::os::raw::c_ulong,
) -> ::std::os::raw::c_ulong;
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct __locale_struct {
pub __locales: [*mut __locale_data; 13usize],
pub __ctype_b: *const ::std::os::raw::c_ushort,
pub __ctype_tolower: *const ::std::os::raw::c_int,
pub __ctype_toupper: *const ::std::os::raw::c_int,
pub __names: [*const ::std::os::raw::c_char; 13usize],
}
#[test]
fn bindgen_test_layout___locale_struct() {
assert_eq!(
::std::mem::size_of::<__locale_struct>(),
232usize,
concat!("Size of: ", stringify!(__locale_struct))
);
assert_eq!(
::std::mem::align_of::<__locale_struct>(),
8usize,
concat!("Alignment of ", stringify!(__locale_struct))
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<__locale_struct>())).__locales as *const _ as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(__locale_struct),
"::",
stringify!(__locales)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<__locale_struct>())).__ctype_b as *const _ as usize },
104usize,
concat!(
"Offset of field: ",
stringify!(__locale_struct),
"::",
stringify!(__ctype_b)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<__locale_struct>())).__ctype_tolower as *const _ as usize },
112usize,
concat!(
"Offset of field: ",
stringify!(__locale_struct),
"::",
stringify!(__ctype_tolower)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<__locale_struct>())).__ctype_toupper as *const _ as usize },
120usize,
concat!(
"Offset of field: ",
stringify!(__locale_struct),
"::",
stringify!(__ctype_toupper)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<__locale_struct>())).__names as *const _ as usize },
128usize,
concat!(
"Offset of field: ",
stringify!(__locale_struct),
"::",
stringify!(__names)
)
);
}
impl Default for __locale_struct {
fn default() -> Self {
unsafe { ::std::mem::zeroed() }
}
}
pub type __locale_t = *mut __locale_struct;
pub type locale_t = __locale_t;
extern "C" {
pub fn strcoll_l(
__s1: *const ::std::os::raw::c_char,
__s2: *const ::std::os::raw::c_char,
__l: locale_t,
) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn strxfrm_l(
__dest: *mut ::std::os::raw::c_char,
__src: *const ::std::os::raw::c_char,
__n: size_t,
__l: locale_t,
) -> size_t;
}
extern "C" {
pub fn strdup(__s: *const ::std::os::raw::c_char) -> *mut ::std::os::raw::c_char;
}
extern "C" {
pub fn strndup(
__string: *const ::std::os::raw::c_char,
__n: ::std::os::raw::c_ulong,
) -> *mut ::std::os::raw::c_char;
}
extern "C" {
pub fn strchr(
__s: *const ::std::os::raw::c_char,
__c: ::std::os::raw::c_int,
) -> *mut ::std::os::raw::c_char;
}
extern "C" {
pub fn strrchr(
__s: *const ::std::os::raw::c_char,
__c: ::std::os::raw::c_int,
) -> *mut ::std::os::raw::c_char;
}
extern "C" {
pub fn strcspn(
__s: *const ::std::os::raw::c_char,
__reject: *const ::std::os::raw::c_char,
) -> ::std::os::raw::c_ulong;
}
extern "C" {
pub fn strspn(
__s: *const ::std::os::raw::c_char,
__accept: *const ::std::os::raw::c_char,
) -> ::std::os::raw::c_ulong;
}
extern "C" {
pub fn strpbrk(
__s: *const ::std::os::raw::c_char,
__accept: *const ::std::os::raw::c_char,
) -> *mut ::std::os::raw::c_char;
}
extern "C" {
pub fn strstr(
__haystack: *const ::std::os::raw::c_char,
__needle: *const ::std::os::raw::c_char,
) -> *mut ::std::os::raw::c_char;
}
extern "C" {
pub fn strtok(
__s: *mut ::std::os::raw::c_char,
__delim: *const ::std::os::raw::c_char,
) -> *mut ::std::os::raw::c_char;
}
extern "C" {
pub fn __strtok_r(
__s: *mut ::std::os::raw::c_char,
__delim: *const ::std::os::raw::c_char,
__save_ptr: *mut *mut ::std::os::raw::c_char,
) -> *mut ::std::os::raw::c_char;
}
extern "C" {
pub fn strtok_r(
__s: *mut ::std::os::raw::c_char,
__delim: *const ::std::os::raw::c_char,
__save_ptr: *mut *mut ::std::os::raw::c_char,
) -> *mut ::std::os::raw::c_char;
}
extern "C" {
pub fn strlen(__s: *const ::std::os::raw::c_char) -> ::std::os::raw::c_ulong;
}
extern "C" {
pub fn strnlen(__string: *const ::std::os::raw::c_char, __maxlen: size_t) -> size_t;
}
extern "C" {
pub fn strerror(__errnum: ::std::os::raw::c_int) -> *mut ::std::os::raw::c_char;
}
extern "C" {
#[link_name = "\u{1}__xpg_strerror_r"]
pub fn strerror_r(
__errnum: ::std::os::raw::c_int,
__buf: *mut ::std::os::raw::c_char,
__buflen: size_t,
) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn strerror_l(
__errnum: ::std::os::raw::c_int,
__l: locale_t,
) -> *mut ::std::os::raw::c_char;
}
extern "C" {
pub fn bcmp(
__s1: *const ::std::os::raw::c_void,
__s2: *const ::std::os::raw::c_void,
__n: ::std::os::raw::c_ulong,
) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn bcopy(
__src: *const ::std::os::raw::c_void,
__dest: *mut ::std::os::raw::c_void,
__n: size_t,
);
}
extern "C" {
pub fn bzero(__s: *mut ::std::os::raw::c_void, __n: ::std::os::raw::c_ulong);
}
extern "C" {
pub fn index(
__s: *const ::std::os::raw::c_char,
__c: ::std::os::raw::c_int,
) -> *mut ::std::os::raw::c_char;
}
extern "C" {
pub fn rindex(
__s: *const ::std::os::raw::c_char,
__c: ::std::os::raw::c_int,
) -> *mut ::std::os::raw::c_char;
}
extern "C" {
pub fn ffs(__i: ::std::os::raw::c_int) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn ffsl(__l: ::std::os::raw::c_long) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn ffsll(__ll: ::std::os::raw::c_longlong) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn strcasecmp(
__s1: *const ::std::os::raw::c_char,
__s2: *const ::std::os::raw::c_char,
) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn strncasecmp(
__s1: *const ::std::os::raw::c_char,
__s2: *const ::std::os::raw::c_char,
__n: ::std::os::raw::c_ulong,
) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn strcasecmp_l(
__s1: *const ::std::os::raw::c_char,
__s2: *const ::std::os::raw::c_char,
__loc: locale_t,
) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn strncasecmp_l(
__s1: *const ::std::os::raw::c_char,
__s2: *const ::std::os::raw::c_char,
__n: size_t,
__loc: locale_t,
) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn explicit_bzero(__s: *mut ::std::os::raw::c_void, __n: size_t);
}
extern "C" {
pub fn strsep(
__stringp: *mut *mut ::std::os::raw::c_char,
__delim: *const ::std::os::raw::c_char,
) -> *mut ::std::os::raw::c_char;
}
extern "C" {
pub fn strsignal(__sig: ::std::os::raw::c_int) -> *mut ::std::os::raw::c_char;
}
extern "C" {
pub fn __stpcpy(
__dest: *mut ::std::os::raw::c_char,
__src: *const ::std::os::raw::c_char,
) -> *mut ::std::os::raw::c_char;
}
extern "C" {
pub fn stpcpy(
__dest: *mut ::std::os::raw::c_char,
__src: *const ::std::os::raw::c_char,
) -> *mut ::std::os::raw::c_char;
}
extern "C" {
pub fn __stpncpy(
__dest: *mut ::std::os::raw::c_char,
__src: *const ::std::os::raw::c_char,
__n: size_t,
) -> *mut ::std::os::raw::c_char;
}
extern "C" {
pub fn stpncpy(
__dest: *mut ::std::os::raw::c_char,
__src: *const ::std::os::raw::c_char,
__n: ::std::os::raw::c_ulong,
) -> *mut ::std::os::raw::c_char;
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct _ion_string {
#[doc = "< The number of bytes in the value array."]
pub length: i32,
#[doc = "< UTF-8 encoded text, not null-terminated."]
pub value: *mut BYTE,
}
#[test]
fn bindgen_test_layout__ion_string() {
assert_eq!(
::std::mem::size_of::<_ion_string>(),
16usize,
concat!("Size of: ", stringify!(_ion_string))
);
assert_eq!(
::std::mem::align_of::<_ion_string>(),
8usize,
concat!("Alignment of ", stringify!(_ion_string))
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_ion_string>())).length as *const _ as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(_ion_string),
"::",
stringify!(length)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_ion_string>())).value as *const _ as usize },
8usize,
concat!(
"Offset of field: ",
stringify!(_ion_string),
"::",
stringify!(value)
)
);
}
impl Default for _ion_string {
fn default() -> Self {
unsafe { ::std::mem::zeroed() }
}
}
extern "C" {
pub fn ion_string_init(str_: *mut ION_STRING);
}
extern "C" {
pub fn ion_string_assign(dst: *mut ION_STRING, src: *mut ION_STRING);
}
extern "C" {
pub fn ion_string_assign_cstr(
str_: *mut ION_STRING,
val: *mut ::std::os::raw::c_char,
len: SIZE,
) -> *mut ION_STRING;
}
extern "C" {
pub fn ion_string_strdup(p_ionstring: *mut ION_STRING) -> *mut ::std::os::raw::c_char;
}
extern "C" {
pub fn ion_string_copy_to_owner(
owner: hOWNER,
dst: *mut ION_STRING,
src: *mut ION_STRING,
) -> iERR;
}
extern "C" {
#[doc = " Gets the number of UTF-8 bytes held by the string."]
#[doc = ""]
#[doc = " @param str must not be null."]
#[doc = ""]
#[doc = " @return may be zero."]
pub fn ion_string_get_length(str_: *mut ION_STRING) -> ::std::os::raw::c_int;
}
extern "C" {
#[doc = " Returns -1 is idx is out of range or str is null"]
pub fn ion_string_get_byte(str_: *mut ION_STRING, idx: ::std::os::raw::c_int) -> BYTE;
}
extern "C" {
#[doc = " Gets a pointer to the UTF-8 bytes held by the string."]
#[doc = " The number of bytes in the string is determined via ion_string_get_length()."]
#[doc = ""]
#[doc = " @param str must not be null."]
#[doc = ""]
#[doc = " @return a pointer to the first UTF-8 byte in the string; may be null."]
#[doc = " The byte sequence is not null-terminated."]
pub fn ion_string_get_bytes(str_: *mut ION_STRING) -> *mut BYTE;
}
extern "C" {
pub fn ion_string_is_null(str_: *mut ION_STRING) -> BOOL;
}
extern "C" {
pub fn ion_string_is_equal(str1: *mut ION_STRING, str2: *mut ION_STRING) -> BOOL;
}
pub type clock_t = __clock_t;
pub type time_t = __time_t;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct tm {
pub tm_sec: ::std::os::raw::c_int,
pub tm_min: ::std::os::raw::c_int,
pub tm_hour: ::std::os::raw::c_int,
pub tm_mday: ::std::os::raw::c_int,
pub tm_mon: ::std::os::raw::c_int,
pub tm_year: ::std::os::raw::c_int,
pub tm_wday: ::std::os::raw::c_int,
pub tm_yday: ::std::os::raw::c_int,
pub tm_isdst: ::std::os::raw::c_int,
pub tm_gmtoff: ::std::os::raw::c_long,
pub tm_zone: *const ::std::os::raw::c_char,
}
#[test]
fn bindgen_test_layout_tm() {
assert_eq!(
::std::mem::size_of::<tm>(),
56usize,
concat!("Size of: ", stringify!(tm))
);
assert_eq!(
::std::mem::align_of::<tm>(),
8usize,
concat!("Alignment of ", stringify!(tm))
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<tm>())).tm_sec as *const _ as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(tm),
"::",
stringify!(tm_sec)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<tm>())).tm_min as *const _ as usize },
4usize,
concat!(
"Offset of field: ",
stringify!(tm),
"::",
stringify!(tm_min)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<tm>())).tm_hour as *const _ as usize },
8usize,
concat!(
"Offset of field: ",
stringify!(tm),
"::",
stringify!(tm_hour)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<tm>())).tm_mday as *const _ as usize },
12usize,
concat!(
"Offset of field: ",
stringify!(tm),
"::",
stringify!(tm_mday)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<tm>())).tm_mon as *const _ as usize },
16usize,
concat!(
"Offset of field: ",
stringify!(tm),
"::",
stringify!(tm_mon)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<tm>())).tm_year as *const _ as usize },
20usize,
concat!(
"Offset of field: ",
stringify!(tm),
"::",
stringify!(tm_year)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<tm>())).tm_wday as *const _ as usize },
24usize,
concat!(
"Offset of field: ",
stringify!(tm),
"::",
stringify!(tm_wday)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<tm>())).tm_yday as *const _ as usize },
28usize,
concat!(
"Offset of field: ",
stringify!(tm),
"::",
stringify!(tm_yday)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<tm>())).tm_isdst as *const _ as usize },
32usize,
concat!(
"Offset of field: ",
stringify!(tm),
"::",
stringify!(tm_isdst)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<tm>())).tm_gmtoff as *const _ as usize },
40usize,
concat!(
"Offset of field: ",
stringify!(tm),
"::",
stringify!(tm_gmtoff)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<tm>())).tm_zone as *const _ as usize },
48usize,
concat!(
"Offset of field: ",
stringify!(tm),
"::",
stringify!(tm_zone)
)
);
}
impl Default for tm {
fn default() -> Self {
unsafe { ::std::mem::zeroed() }
}
}
pub type clockid_t = __clockid_t;
pub type timer_t = __timer_t;
#[repr(C)]
#[derive(Debug, Default, Copy, Clone)]
pub struct itimerspec {
pub it_interval: timespec,
pub it_value: timespec,
}
#[test]
fn bindgen_test_layout_itimerspec() {
assert_eq!(
::std::mem::size_of::<itimerspec>(),
32usize,
concat!("Size of: ", stringify!(itimerspec))
);
assert_eq!(
::std::mem::align_of::<itimerspec>(),
8usize,
concat!("Alignment of ", stringify!(itimerspec))
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<itimerspec>())).it_interval as *const _ as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(itimerspec),
"::",
stringify!(it_interval)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<itimerspec>())).it_value as *const _ as usize },
16usize,
concat!(
"Offset of field: ",
stringify!(itimerspec),
"::",
stringify!(it_value)
)
);
}
extern "C" {
pub fn clock() -> clock_t;
}
extern "C" {
pub fn time(__timer: *mut time_t) -> time_t;
}
extern "C" {
pub fn difftime(__time1: time_t, __time0: time_t) -> f64;
}
extern "C" {
pub fn mktime(__tp: *mut tm) -> time_t;
}
extern "C" {
pub fn strftime(
__s: *mut ::std::os::raw::c_char,
__maxsize: size_t,
__format: *const ::std::os::raw::c_char,
__tp: *const tm,
) -> size_t;
}
extern "C" {
pub fn strftime_l(
__s: *mut ::std::os::raw::c_char,
__maxsize: size_t,
__format: *const ::std::os::raw::c_char,
__tp: *const tm,
__loc: locale_t,
) -> size_t;
}
extern "C" {
pub fn gmtime(__timer: *const time_t) -> *mut tm;
}
extern "C" {
pub fn localtime(__timer: *const time_t) -> *mut tm;
}
extern "C" {
pub fn gmtime_r(__timer: *const time_t, __tp: *mut tm) -> *mut tm;
}
extern "C" {
pub fn localtime_r(__timer: *const time_t, __tp: *mut tm) -> *mut tm;
}
extern "C" {
pub fn asctime(__tp: *const tm) -> *mut ::std::os::raw::c_char;
}
extern "C" {
pub fn ctime(__timer: *const time_t) -> *mut ::std::os::raw::c_char;
}
extern "C" {
pub fn asctime_r(
__tp: *const tm,
__buf: *mut ::std::os::raw::c_char,
) -> *mut ::std::os::raw::c_char;
}
extern "C" {
pub fn ctime_r(
__timer: *const time_t,
__buf: *mut ::std::os::raw::c_char,
) -> *mut ::std::os::raw::c_char;
}
extern "C" {
pub static mut __tzname: [*mut ::std::os::raw::c_char; 2usize];
}
extern "C" {
pub static mut __daylight: ::std::os::raw::c_int;
}
extern "C" {
pub static mut __timezone: ::std::os::raw::c_long;
}
extern "C" {
pub static mut tzname: [*mut ::std::os::raw::c_char; 2usize];
}
extern "C" {
pub fn tzset();
}
extern "C" {
pub static mut daylight: ::std::os::raw::c_int;
}
extern "C" {
pub static mut timezone: ::std::os::raw::c_long;
}
extern "C" {
pub fn timegm(__tp: *mut tm) -> time_t;
}
extern "C" {
pub fn timelocal(__tp: *mut tm) -> time_t;
}
extern "C" {
pub fn dysize(__year: ::std::os::raw::c_int) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn nanosleep(
__requested_time: *const timespec,
__remaining: *mut timespec,
) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn clock_getres(__clock_id: clockid_t, __res: *mut timespec) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn clock_gettime(__clock_id: clockid_t, __tp: *mut timespec) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn clock_settime(__clock_id: clockid_t, __tp: *const timespec) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn clock_nanosleep(
__clock_id: clockid_t,
__flags: ::std::os::raw::c_int,
__req: *const timespec,
__rem: *mut timespec,
) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn clock_getcpuclockid(__pid: pid_t, __clock_id: *mut clockid_t) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn timer_create(
__clock_id: clockid_t,
__evp: *mut sigevent,
__timerid: *mut timer_t,
) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn timer_delete(__timerid: timer_t) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn timer_settime(
__timerid: timer_t,
__flags: ::std::os::raw::c_int,
__value: *const itimerspec,
__ovalue: *mut itimerspec,
) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn timer_gettime(__timerid: timer_t, __value: *mut itimerspec) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn timer_getoverrun(__timerid: timer_t) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn timespec_get(
__ts: *mut timespec,
__base: ::std::os::raw::c_int,
) -> ::std::os::raw::c_int;
}
#[doc = " Structure to store time information."]
#[doc = " time_t only has up to second precision, and time zone support is OS dependent."]
#[doc = " _ion_timestamp uses decimal to store fraction of a second"]
#[repr(C)]
#[derive(Copy, Clone)]
pub struct _ion_timestamp {
#[doc = " Defined as ION_TS_YEAR, ION_TS_MONTH, ION_TS_DAY, ION_TS_MIN, ION_TS_SEC, ION_TS_FRAC"]
#[doc = ""]
pub precision: u8,
#[doc = " Time zone offset (+/- 24 hours), in term of minutes."]
#[doc = ""]
pub tz_offset: i16,
pub year: u16,
pub month: u16,
pub day: u16,
pub hours: u16,
pub minutes: u16,
pub seconds: u16,
#[doc = " Fraction of a second, e.g: 0.5, 0.01, etc"]
#[doc = ""]
pub fraction: decQuad,
}
#[test]
fn bindgen_test_layout__ion_timestamp() {
assert_eq!(
::std::mem::size_of::<_ion_timestamp>(),
32usize,
concat!("Size of: ", stringify!(_ion_timestamp))
);
assert_eq!(
::std::mem::align_of::<_ion_timestamp>(),
4usize,
concat!("Alignment of ", stringify!(_ion_timestamp))
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_ion_timestamp>())).precision as *const _ as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(_ion_timestamp),
"::",
stringify!(precision)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_ion_timestamp>())).tz_offset as *const _ as usize },
2usize,
concat!(
"Offset of field: ",
stringify!(_ion_timestamp),
"::",
stringify!(tz_offset)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_ion_timestamp>())).year as *const _ as usize },
4usize,
concat!(
"Offset of field: ",
stringify!(_ion_timestamp),
"::",
stringify!(year)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_ion_timestamp>())).month as *const _ as usize },
6usize,
concat!(
"Offset of field: ",
stringify!(_ion_timestamp),
"::",
stringify!(month)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_ion_timestamp>())).day as *const _ as usize },
8usize,
concat!(
"Offset of field: ",
stringify!(_ion_timestamp),
"::",
stringify!(day)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_ion_timestamp>())).hours as *const _ as usize },
10usize,
concat!(
"Offset of field: ",
stringify!(_ion_timestamp),
"::",
stringify!(hours)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_ion_timestamp>())).minutes as *const _ as usize },
12usize,
concat!(
"Offset of field: ",
stringify!(_ion_timestamp),
"::",
stringify!(minutes)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_ion_timestamp>())).seconds as *const _ as usize },
14usize,
concat!(
"Offset of field: ",
stringify!(_ion_timestamp),
"::",
stringify!(seconds)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_ion_timestamp>())).fraction as *const _ as usize },
16usize,
concat!(
"Offset of field: ",
stringify!(_ion_timestamp),
"::",
stringify!(fraction)
)
);
}
impl Default for _ion_timestamp {
fn default() -> Self {
unsafe { ::std::mem::zeroed() }
}
}
extern "C" {
#[doc = " Get the time precision for the given timestamp object."]
#[doc = " The precision values are defined as ION_TS_YEAR, ION_TS_MONTH, ION_TS_DAY,"]
#[doc = " ION_TS_MIN, ION_TS_SEC and ION_TS_FRAC"]
#[doc = ""]
pub fn ion_timestamp_get_precision(
ptime: *const ION_TIMESTAMP,
precision: *mut ::std::os::raw::c_int,
) -> iERR;
}
extern "C" {
#[doc = " Get the string format of timestamp."]
#[doc = ""]
pub fn ion_timestamp_to_string(
ptime: *mut ION_TIMESTAMP,
buffer: *mut ::std::os::raw::c_char,
buf_length: SIZE,
output_length: *mut SIZE,
pcontext: *mut decContext,
) -> iERR;
}
extern "C" {
#[doc = " Parse timestamp string and construct timestamp object in ptime."]
#[doc = " This expects a null terminated string."]
#[doc = ""]
pub fn ion_timestamp_parse(
ptime: *mut ION_TIMESTAMP,
buffer: *mut ::std::os::raw::c_char,
length: SIZE,
p_characters_used: *mut SIZE,
pcontext: *mut decContext,
) -> iERR;
}
extern "C" {
#[doc = " Initialize ION_TIMESTAMP object with value specified in time_t"]
#[doc = " time_t can be constructed using time() or mktime(), timegm,"]
#[doc = " and it contains ION_TS_SEC precision."]
#[doc = ""]
#[doc = " Higher precision fields (fraction) will be set to 0."]
#[doc = " Local time zone will be cleared. ion_timestamp_has_local_offset will be false, and"]
#[doc = " ion_timestamp_get_local_offset will be zero."]
#[doc = ""]
pub fn ion_timestamp_for_time_t(ptime: *mut ION_TIMESTAMP, time: *const time_t) -> iERR;
}
extern "C" {
#[doc = " Fill time_t with value in ION_TIMESTAMP"]
#[doc = ""]
pub fn ion_timestamp_to_time_t(ptime: *const ION_TIMESTAMP, time: *mut time_t) -> iERR;
}
extern "C" {
#[doc = " Comparing two timestamps to see whether they represent the same point in time."]
#[doc = " Two timestamp of different precision will return false"]
pub fn ion_timestamp_equals(
ptime1: *const ION_TIMESTAMP,
ptime2: *const ION_TIMESTAMP,
is_equal: *mut BOOL,
pcontext: *mut decContext,
) -> iERR;
}
extern "C" {
#[doc = " Compare timestamps for instant equality only (i.e. precision and local offsets need not be equivalent)."]
#[doc = " NOTE: if this has any use externally, it could be exposed. If not, it should be removed."]
pub fn ion_timestamp_instant_equals(
ptime1: *const ION_TIMESTAMP,
ptime2: *const ION_TIMESTAMP,
is_equal: *mut BOOL,
pcontext: *mut decContext,
) -> iERR;
}
extern "C" {
#[doc = " Initialize ION_TIMESTAMP object with value specified."]
#[doc = " It will have ION_TS_YEAR precision"]
#[doc = ""]
#[doc = " Higher precision fields (month, day, min, sec, fraction) will be set to 0."]
#[doc = " Local time zone will be cleared. ion_timestamp_has_local_offset will be false, and"]
#[doc = " ion_timestamp_get_local_offset will be zero."]
#[doc = ""]
pub fn ion_timestamp_for_year(ptime: *mut ION_TIMESTAMP, year: ::std::os::raw::c_int) -> iERR;
}
extern "C" {
#[doc = " Initialize ION_TIMESTAMP object with value specified."]
#[doc = " It will have ION_TS_MONTH precision"]
#[doc = ""]
#[doc = " Higher precision fields (day, min, sec, fraction) will be set to 0."]
#[doc = " Local time zone will be cleared. ion_timestamp_has_local_offset will be false, and"]
#[doc = " ion_timestamp_get_local_offset will be zero."]
#[doc = ""]
pub fn ion_timestamp_for_month(
ptime: *mut ION_TIMESTAMP,
year: ::std::os::raw::c_int,
month: ::std::os::raw::c_int,
) -> iERR;
}
extern "C" {
#[doc = " Initialize ION_TIMESTAMP object with value specified."]
#[doc = " It will have ION_TS_DAY precision"]
#[doc = ""]
#[doc = " Higher precision fields (min, sec, fraction) will be set to 0."]
#[doc = " Local time zone will be cleared. ion_timestamp_has_local_offset will be false, and"]
#[doc = " ion_timestamp_get_local_offset will be zero."]
#[doc = ""]
pub fn ion_timestamp_for_day(
ptime: *mut ION_TIMESTAMP,
year: ::std::os::raw::c_int,
month: ::std::os::raw::c_int,
day: ::std::os::raw::c_int,
) -> iERR;
}
extern "C" {
#[doc = " Initialize ION_TIMESTAMP object with value specified."]
#[doc = " It will have ION_TS_MIN precision"]
#[doc = ""]
#[doc = " Higher precision fields (sec, fraction) will be set to 0."]
#[doc = " Local time zone will be cleared. ion_timestamp_has_local_offset will be false, and"]
#[doc = " ion_timestamp_get_local_offset will be zero."]
#[doc = ""]
pub fn ion_timestamp_for_minute(
ptime: *mut ION_TIMESTAMP,
year: ::std::os::raw::c_int,
month: ::std::os::raw::c_int,
day: ::std::os::raw::c_int,
hours: ::std::os::raw::c_int,
minutes: ::std::os::raw::c_int,
) -> iERR;
}
extern "C" {
#[doc = " Initialize ION_TIMESTAMP object with value specified."]
#[doc = " It will have ION_TS_SEC precision"]
#[doc = ""]
#[doc = " Higher precision field (fraction) will be set to 0."]
#[doc = " Local time zone will be cleared. ion_timestamp_has_local_offset will be false, and"]
#[doc = " ion_timestamp_get_local_offset will be zero."]
#[doc = ""]
pub fn ion_timestamp_for_second(
ptime: *mut ION_TIMESTAMP,
year: ::std::os::raw::c_int,
month: ::std::os::raw::c_int,
day: ::std::os::raw::c_int,
hours: ::std::os::raw::c_int,
minutes: ::std::os::raw::c_int,
seconds: ::std::os::raw::c_int,
) -> iERR;
}
extern "C" {
#[doc = " Initialize ION_TIMESTAMP object with value specified."]
#[doc = " *p_fraction have a range of (0, 1), not including 0 (without significant digit) and 1."]
#[doc = " 0.0 (0d-1), 0.00(0d-2) is valid, while 0 or 0. is not."]
#[doc = ""]
#[doc = " It will have ION_TS_FRAC precision"]
#[doc = ""]
#[doc = " Local time zone will be cleared. ion_timestamp_has_local_offset will be false, and"]
#[doc = " ion_timestamp_get_local_offset will be zero."]
#[doc = ""]
pub fn ion_timestamp_for_fraction(
ptime: *mut ION_TIMESTAMP,
year: ::std::os::raw::c_int,
month: ::std::os::raw::c_int,
day: ::std::os::raw::c_int,
hours: ::std::os::raw::c_int,
minutes: ::std::os::raw::c_int,
seconds: ::std::os::raw::c_int,
p_fraction: *mut decQuad,
pcontext: *mut decContext,
) -> iERR;
}
extern "C" {
#[doc = " Get year"]
pub fn ion_timestamp_get_thru_year(
ptime: *mut ION_TIMESTAMP,
p_year: *mut ::std::os::raw::c_int,
) -> iERR;
}
extern "C" {
#[doc = " Get year, month"]
#[doc = " If precision is not up to month, 0 will be returned as month value."]
pub fn ion_timestamp_get_thru_month(
ptime: *mut ION_TIMESTAMP,
p_year: *mut ::std::os::raw::c_int,
p_month: *mut ::std::os::raw::c_int,
) -> iERR;
}
extern "C" {
#[doc = " Get year, month, day"]
#[doc = " If precision is not up to month/day, 0 will be returned as month/day value."]
pub fn ion_timestamp_get_thru_day(
ptime: *mut ION_TIMESTAMP,
p_year: *mut ::std::os::raw::c_int,
p_month: *mut ::std::os::raw::c_int,
p_day: *mut ::std::os::raw::c_int,
) -> iERR;
}
extern "C" {
#[doc = " Get time up to minute precision."]
#[doc = " If precision is not up to hour/minute, 0 will be returned as hour/minute value."]
pub fn ion_timestamp_get_thru_minute(
ptime: *mut ION_TIMESTAMP,
p_year: *mut ::std::os::raw::c_int,
p_month: *mut ::std::os::raw::c_int,
p_day: *mut ::std::os::raw::c_int,
p_hour: *mut ::std::os::raw::c_int,
p_minute: *mut ::std::os::raw::c_int,
) -> iERR;
}
extern "C" {
#[doc = " Get time up to second precision."]
#[doc = " If precision is not up to hour/minute/second, 0 will be returned as hour/minute/second value."]
pub fn ion_timestamp_get_thru_second(
ptime: *mut ION_TIMESTAMP,
p_year: *mut ::std::os::raw::c_int,
p_month: *mut ::std::os::raw::c_int,
p_day: *mut ::std::os::raw::c_int,
p_hour: *mut ::std::os::raw::c_int,
p_minute: *mut ::std::os::raw::c_int,
p_second: *mut ::std::os::raw::c_int,
) -> iERR;
}
extern "C" {
#[doc = " Get time up to fraction of second precision."]
#[doc = " If precision is not up to fraction, 0 will be returned."]
pub fn ion_timestamp_get_thru_fraction(
ptime: *mut ION_TIMESTAMP,
p_year: *mut ::std::os::raw::c_int,
p_month: *mut ::std::os::raw::c_int,
p_day: *mut ::std::os::raw::c_int,
p_hour: *mut ::std::os::raw::c_int,
p_minute: *mut ::std::os::raw::c_int,
p_second: *mut ::std::os::raw::c_int,
p_fraction: *mut decQuad,
) -> iERR;
}
extern "C" {
#[doc = " Determines whether a timestamp has a defined local offset (for example,"]
#[doc = " \"+08:00\" or \"Z\". Otherwise, it's local offest is unknown (\"-00:00\"), and"]
#[doc = " effectively zero."]
#[doc = ""]
#[doc = " @param ptime the timestamp to inspect."]
#[doc = " @param p_has_local_offset the return value; false when the local offset is"]
#[doc = " unknown."]
#[doc = ""]
#[doc = " @return IERR_INVALID_ARG if any parameter is null."]
pub fn ion_timestamp_has_local_offset(
ptime: *mut ION_TIMESTAMP,
p_has_local_offset: *mut BOOL,
) -> iERR;
}
extern "C" {
#[doc = " Gets the effective local offset of a timestamp. The result is zero for"]
#[doc = " timestamps with offsets \"Z\", \"+00:00\", or \"-00:00\". In other words, if"]
#[doc = " ion_timestamp_has_local_offset returns false, this returns zero."]
#[doc = ""]
#[doc = " @param ptime the timestamp to inspect."]
#[doc = " @param p_local_offset the return value, in minutes from GMT;"]
#[doc = " zero when the local offset is unknown."]
#[doc = ""]
#[doc = " @return IERR_INVALID_ARG if any parameter is null;"]
#[doc = " IERR_NULL_VALUE if the timestamp is null.timestamp."]
pub fn ion_timestamp_get_local_offset(
ptime: *mut ION_TIMESTAMP,
p_offset_minutes: *mut ::std::os::raw::c_int,
) -> iERR;
}
extern "C" {
#[doc = " Removes any local offset from a timestamp."]
#[doc = " Afterwards, ion_timestamp_has_local_offset will be false, and"]
#[doc = " ion_timestamp_get_local_offset will be zero."]
#[doc = ""]
#[doc = " @param ptime the timestamp to alter."]
#[doc = ""]
#[doc = " @return IERR_INVALID_ARG if any parameter is null."]
pub fn ion_timestamp_unset_local_offset(ptime: *mut ION_TIMESTAMP) -> iERR;
}
extern "C" {
#[doc = " Changes the local offset of a timestamp. If the timestamp has less than minute precision,"]
#[doc = " the given offset is ignored and the timestamp is unchanged."]
#[doc = " If the timestamp is changed, ion_timestamp_has_local_offset will be true, and"]
#[doc = " ion_timestamp_get_local_offset will be the given offset."]
#[doc = ""]
#[doc = " @param ptime the timestamp to alter."]
#[doc = " @param offset_minutes the new local offset, in (positive or negative)"]
#[doc = " minutes from GMT."]
#[doc = ""]
#[doc = " @return IERR_INVALID_ARG if ptime is null, or if offset_minutes is outside"]
#[doc = " the range -23:59 to +23:59."]
pub fn ion_timestamp_set_local_offset(
ptime: *mut ION_TIMESTAMP,
offset_minutes: ::std::os::raw::c_int,
) -> iERR;
}
pub const ION_DECIMAL_TYPE_ION_DECIMAL_TYPE_UNKNOWN: ION_DECIMAL_TYPE = 0;
#[doc = " The _ion_decimal holds a decQuad."]
pub const ION_DECIMAL_TYPE_ION_DECIMAL_TYPE_QUAD: ION_DECIMAL_TYPE = 1;
#[doc = " The _ion_decimal holds an unowned decNumber."]
pub const ION_DECIMAL_TYPE_ION_DECIMAL_TYPE_NUMBER: ION_DECIMAL_TYPE = 2;
#[doc = " The _ion_decimal holds a decNumber whose memory is managed by an owner."]
pub const ION_DECIMAL_TYPE_ION_DECIMAL_TYPE_NUMBER_OWNED: ION_DECIMAL_TYPE = 3;
#[doc = " Determines which value of the _ion_decimal's `value` field is active."]
pub type ION_DECIMAL_TYPE = ::std::os::raw::c_uint;
#[repr(C)]
#[derive(Copy, Clone)]
pub struct _ion_decimal {
pub type_: ION_DECIMAL_TYPE,
pub value: _ion_decimal__bindgen_ty_1,
}
#[repr(C)]
#[derive(Copy, Clone)]
pub union _ion_decimal__bindgen_ty_1 {
pub quad_value: decQuad,
pub num_value: *mut decNumber,
}
#[test]
fn bindgen_test_layout__ion_decimal__bindgen_ty_1() {
assert_eq!(
::std::mem::size_of::<_ion_decimal__bindgen_ty_1>(),
16usize,
concat!("Size of: ", stringify!(_ion_decimal__bindgen_ty_1))
);
assert_eq!(
::std::mem::align_of::<_ion_decimal__bindgen_ty_1>(),
8usize,
concat!("Alignment of ", stringify!(_ion_decimal__bindgen_ty_1))
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<_ion_decimal__bindgen_ty_1>())).quad_value as *const _ as usize
},
0usize,
concat!(
"Offset of field: ",
stringify!(_ion_decimal__bindgen_ty_1),
"::",
stringify!(quad_value)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<_ion_decimal__bindgen_ty_1>())).num_value as *const _ as usize
},
0usize,
concat!(
"Offset of field: ",
stringify!(_ion_decimal__bindgen_ty_1),
"::",
stringify!(num_value)
)
);
}
impl Default for _ion_decimal__bindgen_ty_1 {
fn default() -> Self {
unsafe { ::std::mem::zeroed() }
}
}
#[test]
fn bindgen_test_layout__ion_decimal() {
assert_eq!(
::std::mem::size_of::<_ion_decimal>(),
24usize,
concat!("Size of: ", stringify!(_ion_decimal))
);
assert_eq!(
::std::mem::align_of::<_ion_decimal>(),
8usize,
concat!("Alignment of ", stringify!(_ion_decimal))
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_ion_decimal>())).type_ as *const _ as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(_ion_decimal),
"::",
stringify!(type_)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_ion_decimal>())).value as *const _ as usize },
8usize,
concat!(
"Offset of field: ",
stringify!(_ion_decimal),
"::",
stringify!(value)
)
);
}
impl Default for _ion_decimal {
fn default() -> Self {
unsafe { ::std::mem::zeroed() }
}
}
extern "C" {
#[doc = " Zeroes the given ION_DECIMAL in-place. NOTE: this has better performance than memset in certain environments."]
#[doc = ""]
#[doc = " @param value - the value to zero."]
#[doc = " @return IERR_OK (no errors are possible)."]
pub fn ion_decimal_zero(value: *mut ION_DECIMAL) -> iERR;
}
extern "C" {
#[doc = " If necessary, copies the given decimal's internal data so that owner of that data may safely go out of scope. This is"]
#[doc = " useful, for example, when it is necessary to keep the value in scope after the reader that produced it is closed."]
#[doc = " Values produced through calls to `ion_decimal_*` APIs (with the possible exception of `ion_decimal_from_number`) do"]
#[doc = " NOT need to be claimed."]
#[doc = ""]
#[doc = " @param value - The value to claim."]
pub fn ion_decimal_claim(value: *mut ION_DECIMAL) -> iERR;
}
extern "C" {
#[doc = " Frees any memory that was allocated when constructing this value. This should be called to clean up all ION_DECIMALs."]
#[doc = ""]
#[doc = " @param value - The value to free."]
pub fn ion_decimal_free(value: *mut ION_DECIMAL) -> iERR;
}
extern "C" {
#[doc = " Converts the given ION_DECIMAL to a string. `ION_DECIMAL_STRLEN` may be used to determine the amount of space"]
#[doc = " required to hold the string representation."]
#[doc = ""]
#[doc = " @return IERR_OK (no errors are possible)."]
pub fn ion_decimal_to_string(
value: *const ION_DECIMAL,
p_string: *mut ::std::os::raw::c_char,
) -> iERR;
}
extern "C" {
#[doc = " Converts the given string to its ION_DECIMAL representation."]
#[doc = ""]
#[doc = " @param value - a non-null pointer to the resulting decimal."]
#[doc = " @param str - a null-terminated string representing a decimal. Exponents (if any) may be indicated using either 'd'"]
#[doc = " or 'e'."]
#[doc = " @param context - the context to use for the conversion. If the decimal lies outside of the context's limits, an error"]
#[doc = " is raised."]
#[doc = " @return IERR_NUMERIC_OVERFLOW if the decimal lies outside of the context's limits, otherwise IERR_OK."]
pub fn ion_decimal_from_string(
value: *mut ION_DECIMAL,
str_: *const ::std::os::raw::c_char,
context: *mut decContext,
) -> iERR;
}
extern "C" {
#[doc = " Represents the given uint32 as an ION_DECIMAL."]
#[doc = ""]
#[doc = " @return IERR_OK (no errors are possible)."]
pub fn ion_decimal_from_uint32(value: *mut ION_DECIMAL, num: u32) -> iERR;
}
extern "C" {
#[doc = " Represents the given int32 as an ION_DECIMAL."]
#[doc = ""]
#[doc = " @return IERR_OK (no errors are possible)."]
pub fn ion_decimal_from_int32(value: *mut ION_DECIMAL, num: i32) -> iERR;
}
extern "C" {
#[doc = " Represents the given decQuad as an ION_DECIMAL. The caller IS NOT required to keep the given decQuad in scope for the"]
#[doc = " lifetime of the resulting ION_DECIMAL."]
#[doc = ""]
#[doc = " @return IERR_OK (no errors are possible)."]
pub fn ion_decimal_from_quad(value: *mut ION_DECIMAL, quad: *mut decQuad) -> iERR;
}
extern "C" {
#[doc = " Represents the given decNumber as an ION_DECIMAL. This function does not allocate or copy any memory, so the caller"]
#[doc = " IS required to keep the given decNumber in scope for the lifetime of the resulting ION_DECIMAL. If desired, the"]
#[doc = " caller can alleviate this requirement by calling `ion_decimal_claim` on the resulting ION_DECIMAL (note that this"]
#[doc = " forces a copy). It is the caller's responsibility to eventually free any dynamically allocated memory used by the"]
#[doc = " given decNumber (calling `ion_decimal_free` will not free this memory)."]
#[doc = ""]
#[doc = " @return IERR_OK (no errors are possible)."]
pub fn ion_decimal_from_number(value: *mut ION_DECIMAL, number: *mut decNumber) -> iERR;
}
extern "C" {
#[doc = " Converts the given ION_INT to its ION_DECIMAL representation."]
pub fn ion_decimal_from_ion_int(
value: *mut ION_DECIMAL,
context: *mut decContext,
p_int: *mut ION_INT,
) -> iERR;
}
extern "C" {
#[doc = " Converts the given ION_DECIMAL to its ION_INT representation. If the given ION_DECIMAL is not an integer,"]
#[doc = " IERR_INVALID_ARG will be returned; rounding will never occur. If rounding is desired, use"]
#[doc = " `ion_decimal_to_integral_exact` or `ion_decimal_to_integral_value` first."]
pub fn ion_decimal_to_ion_int(
value: *const ION_DECIMAL,
context: *mut decContext,
p_int: *mut ION_INT,
) -> iERR;
}
extern "C" {
pub fn ion_decimal_to_int32(
value: *const ION_DECIMAL,
context: *mut decContext,
p_int: *mut i32,
) -> iERR;
}
extern "C" {
pub fn ion_decimal_to_uint32(
value: *const ION_DECIMAL,
context: *mut decContext,
p_int: *mut u32,
) -> iERR;
}
extern "C" {
pub fn ion_decimal_fma(
value: *mut ION_DECIMAL,
lhs: *const ION_DECIMAL,
rhs: *const ION_DECIMAL,
fhs: *const ION_DECIMAL,
context: *mut decContext,
) -> iERR;
}
extern "C" {
pub fn ion_decimal_add(
value: *mut ION_DECIMAL,
lhs: *const ION_DECIMAL,
rhs: *const ION_DECIMAL,
context: *mut decContext,
) -> iERR;
}
extern "C" {
pub fn ion_decimal_and(
value: *mut ION_DECIMAL,
lhs: *const ION_DECIMAL,
rhs: *const ION_DECIMAL,
context: *mut decContext,
) -> iERR;
}
extern "C" {
pub fn ion_decimal_divide(
value: *mut ION_DECIMAL,
lhs: *const ION_DECIMAL,
rhs: *const ION_DECIMAL,
context: *mut decContext,
) -> iERR;
}
extern "C" {
pub fn ion_decimal_divide_integer(
value: *mut ION_DECIMAL,
lhs: *const ION_DECIMAL,
rhs: *const ION_DECIMAL,
context: *mut decContext,
) -> iERR;
}
extern "C" {
pub fn ion_decimal_max(
value: *mut ION_DECIMAL,
lhs: *const ION_DECIMAL,
rhs: *const ION_DECIMAL,
context: *mut decContext,
) -> iERR;
}
extern "C" {
pub fn ion_decimal_max_mag(
value: *mut ION_DECIMAL,
lhs: *const ION_DECIMAL,
rhs: *const ION_DECIMAL,
context: *mut decContext,
) -> iERR;
}
extern "C" {
pub fn ion_decimal_min(
value: *mut ION_DECIMAL,
lhs: *const ION_DECIMAL,
rhs: *const ION_DECIMAL,
context: *mut decContext,
) -> iERR;
}
extern "C" {
pub fn ion_decimal_min_mag(
value: *mut ION_DECIMAL,
lhs: *const ION_DECIMAL,
rhs: *const ION_DECIMAL,
context: *mut decContext,
) -> iERR;
}
extern "C" {
pub fn ion_decimal_multiply(
value: *mut ION_DECIMAL,
lhs: *const ION_DECIMAL,
rhs: *const ION_DECIMAL,
context: *mut decContext,
) -> iERR;
}
extern "C" {
pub fn ion_decimal_or(
value: *mut ION_DECIMAL,
lhs: *const ION_DECIMAL,
rhs: *const ION_DECIMAL,
context: *mut decContext,
) -> iERR;
}
extern "C" {
pub fn ion_decimal_quantize(
value: *mut ION_DECIMAL,
lhs: *const ION_DECIMAL,
rhs: *const ION_DECIMAL,
context: *mut decContext,
) -> iERR;
}
extern "C" {
pub fn ion_decimal_remainder(
value: *mut ION_DECIMAL,
lhs: *const ION_DECIMAL,
rhs: *const ION_DECIMAL,
context: *mut decContext,
) -> iERR;
}
extern "C" {
pub fn ion_decimal_remainder_near(
value: *mut ION_DECIMAL,
lhs: *const ION_DECIMAL,
rhs: *const ION_DECIMAL,
context: *mut decContext,
) -> iERR;
}
extern "C" {
pub fn ion_decimal_rotate(
value: *mut ION_DECIMAL,
lhs: *const ION_DECIMAL,
rhs: *const ION_DECIMAL,
context: *mut decContext,
) -> iERR;
}
extern "C" {
pub fn ion_decimal_scaleb(
value: *mut ION_DECIMAL,
lhs: *const ION_DECIMAL,
rhs: *const ION_DECIMAL,
context: *mut decContext,
) -> iERR;
}
extern "C" {
pub fn ion_decimal_shift(
value: *mut ION_DECIMAL,
lhs: *const ION_DECIMAL,
rhs: *const ION_DECIMAL,
context: *mut decContext,
) -> iERR;
}
extern "C" {
pub fn ion_decimal_subtract(
value: *mut ION_DECIMAL,
lhs: *const ION_DECIMAL,
rhs: *const ION_DECIMAL,
context: *mut decContext,
) -> iERR;
}
extern "C" {
pub fn ion_decimal_xor(
value: *mut ION_DECIMAL,
lhs: *const ION_DECIMAL,
rhs: *const ION_DECIMAL,
context: *mut decContext,
) -> iERR;
}
extern "C" {
pub fn ion_decimal_abs(
value: *mut ION_DECIMAL,
rhs: *const ION_DECIMAL,
context: *mut decContext,
) -> iERR;
}
extern "C" {
pub fn ion_decimal_invert(
value: *mut ION_DECIMAL,
rhs: *const ION_DECIMAL,
context: *mut decContext,
) -> iERR;
}
extern "C" {
pub fn ion_decimal_logb(
value: *mut ION_DECIMAL,
rhs: *const ION_DECIMAL,
context: *mut decContext,
) -> iERR;
}
extern "C" {
pub fn ion_decimal_minus(
value: *mut ION_DECIMAL,
rhs: *const ION_DECIMAL,
context: *mut decContext,
) -> iERR;
}
extern "C" {
pub fn ion_decimal_plus(
value: *mut ION_DECIMAL,
rhs: *const ION_DECIMAL,
context: *mut decContext,
) -> iERR;
}
extern "C" {
pub fn ion_decimal_reduce(
value: *mut ION_DECIMAL,
rhs: *const ION_DECIMAL,
context: *mut decContext,
) -> iERR;
}
extern "C" {
pub fn ion_decimal_to_integral_exact(
value: *mut ION_DECIMAL,
rhs: *const ION_DECIMAL,
context: *mut decContext,
) -> iERR;
}
extern "C" {
pub fn ion_decimal_to_integral_value(
value: *mut ION_DECIMAL,
rhs: *const ION_DECIMAL,
context: *mut decContext,
) -> iERR;
}
extern "C" {
pub fn ion_decimal_digits(value: *const ION_DECIMAL) -> u32;
}
extern "C" {
pub fn ion_decimal_get_exponent(value: *const ION_DECIMAL) -> i32;
}
extern "C" {
pub fn ion_decimal_radix(value: *const ION_DECIMAL) -> u32;
}
extern "C" {
pub fn ion_decimal_same_quantum(lhs: *const ION_DECIMAL, rhs: *const ION_DECIMAL) -> u32;
}
extern "C" {
pub fn ion_decimal_is_integer(value: *const ION_DECIMAL) -> u32;
}
extern "C" {
pub fn ion_decimal_is_subnormal(value: *const ION_DECIMAL, context: *mut decContext) -> u32;
}
extern "C" {
pub fn ion_decimal_is_normal(value: *const ION_DECIMAL, context: *mut decContext) -> u32;
}
extern "C" {
pub fn ion_decimal_is_finite(value: *const ION_DECIMAL) -> u32;
}
extern "C" {
pub fn ion_decimal_is_infinite(value: *const ION_DECIMAL) -> u32;
}
extern "C" {
pub fn ion_decimal_is_nan(value: *const ION_DECIMAL) -> u32;
}
extern "C" {
pub fn ion_decimal_is_negative(value: *const ION_DECIMAL) -> u32;
}
extern "C" {
pub fn ion_decimal_is_zero(value: *const ION_DECIMAL) -> u32;
}
extern "C" {
pub fn ion_decimal_is_canonical(value: *const ION_DECIMAL) -> u32;
}
extern "C" {
#[doc = " Compares ION_DECIMALs for ordering and equivalence under the Ion data model. A negative result indicates that `left`"]
#[doc = " is less than `right`. A positive result indicates that `left` is greater than `right`. A result of zero indicates"]
#[doc = " that `left` and `right` are equivalent under the Ion data model. Non-equivalent values are ordered according to the"]
#[doc = " IEEE 754 total ordering."]
pub fn ion_decimal_compare(
left: *const ION_DECIMAL,
right: *const ION_DECIMAL,
context: *mut decContext,
result: *mut i32,
) -> iERR;
}
extern "C" {
#[doc = " Compares decQuads for equivalence under the Ion data model. That is, the sign, coefficient, and exponent must be"]
#[doc = " equivalent for the normalized values (even for zero)."]
#[doc = ""]
#[doc = " @deprecated - use of decQuads directly is deprecated. ION_DECIMAL should be used. See `ion_decimal_equals`."]
pub fn ion_decimal_equals_quad(
left: *const decQuad,
right: *const decQuad,
context: *mut decContext,
is_equal: *mut BOOL,
) -> iERR;
}
extern "C" {
#[doc = " Compares ION_DECIMALs for equivalence under the Ion data model. That is, the sign, coefficient, and exponent must be"]
#[doc = " equivalent for the normalized values (even for zero)."]
pub fn ion_decimal_equals(
left: *const ION_DECIMAL,
right: *const ION_DECIMAL,
context: *mut decContext,
is_equal: *mut BOOL,
) -> iERR;
}
extern "C" {
pub fn ion_decimal_canonical(value: *mut ION_DECIMAL, rhs: *const ION_DECIMAL) -> iERR;
}
extern "C" {
pub fn ion_decimal_copy(value: *mut ION_DECIMAL, rhs: *const ION_DECIMAL) -> iERR;
}
extern "C" {
pub fn ion_decimal_copy_abs(value: *mut ION_DECIMAL, rhs: *const ION_DECIMAL) -> iERR;
}
extern "C" {
pub fn ion_decimal_copy_negate(value: *mut ION_DECIMAL, rhs: *const ION_DECIMAL) -> iERR;
}
extern "C" {
pub fn ion_decimal_copy_sign(
value: *mut ION_DECIMAL,
rhs: *const ION_DECIMAL,
lhs: *const ION_DECIMAL,
context: *mut decContext,
) -> iERR;
}
extern "C" {
pub fn ion_float_is_negative_zero(value: f64) -> BOOL;
}
pub type II_DIGIT = u32;
pub type II_LONG_DIGIT = u64;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct _ion_int {
pub _owner: *mut ::std::os::raw::c_void,
pub _signum: ::std::os::raw::c_int,
pub _len: SIZE,
pub _digits: *mut II_DIGIT,
}
#[test]
fn bindgen_test_layout__ion_int() {
assert_eq!(
::std::mem::size_of::<_ion_int>(),
24usize,
concat!("Size of: ", stringify!(_ion_int))
);
assert_eq!(
::std::mem::align_of::<_ion_int>(),
8usize,
concat!("Alignment of ", stringify!(_ion_int))
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_ion_int>()))._owner as *const _ as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(_ion_int),
"::",
stringify!(_owner)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_ion_int>()))._signum as *const _ as usize },
8usize,
concat!(
"Offset of field: ",
stringify!(_ion_int),
"::",
stringify!(_signum)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_ion_int>()))._len as *const _ as usize },
12usize,
concat!(
"Offset of field: ",
stringify!(_ion_int),
"::",
stringify!(_len)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_ion_int>()))._digits as *const _ as usize },
16usize,
concat!(
"Offset of field: ",
stringify!(_ion_int),
"::",
stringify!(_digits)
)
);
}
impl Default for _ion_int {
fn default() -> Self {
unsafe { ::std::mem::zeroed() }
}
}
extern "C" {
pub static mut g_int_zero_bytes: [II_DIGIT; 0usize];
}
extern "C" {
pub static mut g_Int_Zero: ION_INT;
}
extern "C" {
pub static mut g_Int_Null: ION_INT;
}
extern "C" {
pub static mut g_ion_int_globals_initialized: BOOL;
}
extern "C" {
pub static mut g_digit_base_quad: decQuad;
}
extern "C" {
pub static mut g_digit_base_number: decNumber;
}
extern "C" {
#[doc = ""]
pub fn ion_int_alloc(owner: *mut ::std::os::raw::c_void, piint: *mut *mut ION_INT) -> iERR;
}
extern "C" {
pub fn ion_int_free(iint: *mut ION_INT);
}
extern "C" {
pub fn ion_int_init(iint: *mut ION_INT, owner: *mut ::std::os::raw::c_void) -> iERR;
}
extern "C" {
pub fn ion_int_copy(
dst: *mut ION_INT,
src: *mut ION_INT,
owner: *mut ::std::os::raw::c_void,
) -> iERR;
}
extern "C" {
pub fn ion_int_is_null(iint: *mut ION_INT, p_is_null: *mut BOOL) -> iERR;
}
extern "C" {
pub fn ion_int_is_zero(iint: *mut ION_INT, p_bool: *mut BOOL) -> iERR;
}
extern "C" {
pub fn ion_int_compare(
left: *mut ION_INT,
right: *mut ION_INT,
p_result: *mut ::std::os::raw::c_int,
) -> iERR;
}
extern "C" {
pub fn ion_int_signum(iint: *mut ION_INT, p_signum: *mut i32) -> iERR;
}
extern "C" {
pub fn ion_int_highest_bit_set(iint: *mut ION_INT, p_pos: *mut SIZE) -> iERR;
}
extern "C" {
pub fn ion_int_from_string(iint: *mut ION_INT, p_str: iSTRING) -> iERR;
}
extern "C" {
pub fn ion_int_from_hex_string(iint: *mut ION_INT, p_str: iSTRING) -> iERR;
}
extern "C" {
pub fn ion_int_from_binary_string(iint: *mut ION_INT, p_str: iSTRING) -> iERR;
}
extern "C" {
pub fn ion_int_from_chars(
iint: *mut ION_INT,
p_chars: *const ::std::os::raw::c_char,
char_limit: SIZE,
) -> iERR;
}
extern "C" {
pub fn ion_int_from_hex_chars(
iint: *mut ION_INT,
p_chars: *const ::std::os::raw::c_char,
char_limit: SIZE,
) -> iERR;
}
extern "C" {
pub fn ion_int_from_binary_chars(
iint: *mut ION_INT,
p_chars: *const ::std::os::raw::c_char,
char_limit: SIZE,
) -> iERR;
}
extern "C" {
pub fn ion_int_from_bytes(iint: *mut ION_INT, buf: *mut BYTE, limit: SIZE) -> iERR;
}
extern "C" {
pub fn ion_int_from_abs_bytes(
iint: *mut ION_INT,
buf: *mut BYTE,
limit: SIZE,
is_negative: BOOL,
) -> iERR;
}
extern "C" {
pub fn ion_int_from_long(iint: *mut ION_INT, value: i64) -> iERR;
}
extern "C" {
#[doc = " @deprecated use of decQuads directly is deprecated. ION_DECIMAL should be used. See `ion_decimal_to_ion_int`."]
pub fn ion_int_from_decimal(
iint: *mut ION_INT,
p_value: *const decQuad,
context: *mut decContext,
) -> iERR;
}
extern "C" {
pub fn ion_int_char_length(iint: *mut ION_INT, p_len: *mut SIZE) -> iERR;
}
extern "C" {
pub fn ion_int_to_char(
iint: *mut ION_INT,
p_str: *mut BYTE,
len: SIZE,
p_written: *mut SIZE,
) -> iERR;
}
extern "C" {
pub fn ion_int_to_string(iint: *mut ION_INT, owner: hOWNER, p_str: iSTRING) -> iERR;
}
extern "C" {
pub fn ion_int_byte_length(iint: *mut ION_INT, p_byte_length: *mut SIZE) -> iERR;
}
extern "C" {
pub fn ion_int_to_bytes(
iint: *mut ION_INT,
starting_int_byte_offset: SIZE,
buffer: *mut BYTE,
buffer_length: SIZE,
bytes_written: *mut SIZE,
) -> iERR;
}
extern "C" {
pub fn ion_int_abs_bytes_length(iint: *mut ION_INT, p_byte_length: *mut SIZE) -> iERR;
}
extern "C" {
pub fn ion_int_to_abs_bytes(
iint: *mut ION_INT,
starting_int_byte_offset: SIZE,
buffer: *mut BYTE,
buffer_length: SIZE,
bytes_written: *mut SIZE,
) -> iERR;
}
extern "C" {
pub fn ion_int_to_int64(iint: *mut ION_INT, p_int64: *mut i64) -> iERR;
}
extern "C" {
pub fn ion_int_to_int32(iint: *mut ION_INT, p_int32: *mut i32) -> iERR;
}
extern "C" {
#[doc = " @deprecated use of decQuads directly is deprecated. ION_DECIMAL should be used. See `ion_decimal_from_ion_int`."]
pub fn ion_int_to_decimal(
iint: *mut ION_INT,
p_quad: *mut decQuad,
context: *mut decContext,
) -> iERR;
}
extern "C" {
#[doc = ""]
pub fn _ion_int_dump_quad(quad: *mut decQuad, expected: i64);
}
extern "C" {
pub fn _ion_int_init_globals() -> ::std::os::raw::c_int;
}
extern "C" {
pub fn _ion_int_from_decimal_number(
iint: *mut ION_INT,
p_value: *const decNumber,
context: *mut decContext,
) -> iERR;
}
extern "C" {
pub fn _ion_int_to_decimal_number(
iint: *mut ION_INT,
p_value: *mut decNumber,
context: *mut decContext,
) -> iERR;
}
extern "C" {
pub fn _ion_int_validate_arg(iint: *const ION_INT) -> iERR;
}
extern "C" {
pub fn _ion_int_validate_arg_with_ptr(
iint: *const ION_INT,
ptr: *const ::std::os::raw::c_void,
) -> iERR;
}
extern "C" {
pub fn _ion_int_validate_non_null_arg_with_ptr(
iint: *const ION_INT,
ptr: *const ::std::os::raw::c_void,
) -> iERR;
}
extern "C" {
pub fn _ion_int_init(iint: *mut ION_INT, owner: *mut ::std::os::raw::c_void);
}
extern "C" {
pub fn _ion_int_zero(iint: *mut ION_INT) -> iERR;
}
extern "C" {
pub fn _ion_int_realloc_helper(
value: *mut ::std::os::raw::c_void,
old_len: SIZE,
owner: *mut ::std::os::raw::c_void,
new_len: SIZE,
) -> *mut ::std::os::raw::c_void;
}
extern "C" {
pub fn _ion_int_extend_digits(iint: *mut ION_INT, digits_needed: SIZE, zero_fill: BOOL)
-> iERR;
}
extern "C" {
pub fn _ion_int_buffer_temp_copy(
orig_digits: *mut II_DIGIT,
len: SIZE,
cache_buffer: *mut II_DIGIT,
cache_len: SIZE,
) -> *mut II_DIGIT;
}
extern "C" {
pub fn _ion_int_free_temp(temp_buffer: *mut II_DIGIT, cache_buffer: *mut II_DIGIT);
}
extern "C" {
pub fn _ion_int_from_bytes_helper(
iint: *mut ION_INT,
buf: *mut BYTE,
byte_idx: SIZE,
limit: SIZE,
invert: BOOL,
includes_sign_byte: BOOL,
) -> BOOL;
}
extern "C" {
pub fn _ion_int_from_chars_helper(
iint: *mut ION_INT,
str_: *const ::std::os::raw::c_char,
len: SIZE,
) -> iERR;
}
extern "C" {
pub fn _ion_int_from_radix_chars_helper(
iint: *mut ION_INT,
str_: *const ::std::os::raw::c_char,
len: SIZE,
digit_values: *mut ::std::os::raw::c_uint,
base: ::std::os::raw::c_uint,
bits_per_digit: ::std::os::raw::c_uint,
radix_chars: *const ::std::os::raw::c_char,
) -> iERR;
}
extern "C" {
pub fn _ion_int_from_hex_chars_helper(
iint: *mut ION_INT,
str_: *const ::std::os::raw::c_char,
len: SIZE,
) -> iERR;
}
extern "C" {
pub fn _ion_int_from_binary_chars_helper(
iint: *mut ION_INT,
str_: *const ::std::os::raw::c_char,
len: SIZE,
) -> iERR;
}
extern "C" {
pub fn _ion_int_is_null_helper(iint: *const ION_INT) -> BOOL;
}
extern "C" {
pub fn _ion_int_is_zero(iint: *const ION_INT) -> BOOL;
}
extern "C" {
pub fn _ion_int_is_zero_bytes(digits: *const II_DIGIT, len: SIZE) -> BOOL;
}
extern "C" {
pub fn _ion_int_highest_bit_set_helper(iint: *const ION_INT) -> SIZE;
}
extern "C" {
pub fn _ion_int_get_char_len_helper(iint: *const ION_INT) -> SIZE;
}
extern "C" {
pub fn _ion_int_to_string_helper(
iint: *mut ION_INT,
strbuf: *mut ::std::os::raw::c_char,
buflen: SIZE,
p_written: *mut SIZE,
) -> iERR;
}
extern "C" {
pub fn _ion_int_is_high_bytes_high_bit_set_helper(
iint: *const ION_INT,
abs_byte_count: SIZE,
) -> BOOL;
}
extern "C" {
pub fn _ion_int_bytes_length_helper(iint: *const ION_INT) -> SIZE;
}
extern "C" {
pub fn _ion_int_to_bytes_helper(
iint: *mut ION_INT,
bytes_in_int: SIZE,
starting_int_byte_offset: SIZE,
is_neg: BOOL,
buffer: *mut BYTE,
buffer_length: SIZE,
bytes_written: *mut SIZE,
) -> iERR;
}
extern "C" {
pub fn _ion_int_abs_bytes_length_helper(iint: *const ION_INT) -> SIZE;
}
extern "C" {
pub fn _ion_int_abs_bytes_signed_length_helper(iint: *const ION_INT) -> SIZE;
}
extern "C" {
pub fn _ion_int_to_int64_helper(iint: *mut ION_INT, p_int64: *mut i64) -> iERR;
}
extern "C" {
pub fn _ion_int_add_digit(digits: *mut II_DIGIT, digit_count: SIZE, value: II_DIGIT) -> iERR;
}
extern "C" {
pub fn _ion_int_sub_digit(digits: *mut II_DIGIT, digit_count: SIZE, value: II_DIGIT) -> iERR;
}
extern "C" {
pub fn _ion_int_multiply_and_add(
digits: *mut II_DIGIT,
digit_count: SIZE,
mult_value: II_DIGIT,
add_value: II_DIGIT,
) -> iERR;
}
extern "C" {
pub fn _ion_int_divide_by_digit(
digits: *mut II_DIGIT,
digit_count: SIZE,
value: II_DIGIT,
p_remainder: *mut II_DIGIT,
) -> iERR;
}
pub type ION_COLLECTION_NODE = _ion_collection_node;
pub type ION_COLLECTION_CURSOR = *mut _ion_collection_node;
#[doc = " The node allocation scheme depends on this layout !"]
#[doc = " currently that there are only 2 members so it uses"]
#[doc = " the size of the ptr as the base to allocate"]
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct _ion_collection_node {
pub _next: *mut ION_COLLECTION_NODE,
pub _prev: *mut ION_COLLECTION_NODE,
pub _data: [u8; 8usize],
}
#[test]
fn bindgen_test_layout__ion_collection_node() {
assert_eq!(
::std::mem::size_of::<_ion_collection_node>(),
24usize,
concat!("Size of: ", stringify!(_ion_collection_node))
);
assert_eq!(
::std::mem::align_of::<_ion_collection_node>(),
8usize,
concat!("Alignment of ", stringify!(_ion_collection_node))
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_ion_collection_node>()))._next as *const _ as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(_ion_collection_node),
"::",
stringify!(_next)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_ion_collection_node>()))._prev as *const _ as usize },
8usize,
concat!(
"Offset of field: ",
stringify!(_ion_collection_node),
"::",
stringify!(_prev)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_ion_collection_node>()))._data as *const _ as usize },
16usize,
concat!(
"Offset of field: ",
stringify!(_ion_collection_node),
"::",
stringify!(_data)
)
);
}
impl Default for _ion_collection_node {
fn default() -> Self {
unsafe { ::std::mem::zeroed() }
}
}
#[doc = " The collections used by the parser are linked lists which are"]
#[doc = " managed by the collection header."]
#[doc = " the memory used for the nodes is allocated on the parent, which"]
#[doc = " is passed in when the user initializes the collection"]
#[doc = ""]
#[doc = " the nodes in the list have a user sized data buffer, which is"]
#[doc = " expected to a small struct (like ion string) or a scaler (like an"]
#[doc = " int or pointer)."]
#[doc = ""]
#[doc = " the push, pop, and append routines return the address of this"]
#[doc = " data buffer - for push and append it is the buffer of the new node"]
#[doc = " for pop it is the buffer of the released node - which is still"]
#[doc = " allocated and is, therefore, good UNTIL ANOTHER push or append"]
#[doc = " or copy is executed against the containing collection."]
#[doc = ""]
#[doc = " each collections holds a high water mark free list of nodes that"]
#[doc = " were previously used but aren't currently being used"]
#[doc = ""]
#[doc = " to use this as a:"]
#[doc = " queue you'll want to \"append\" and \"pop head\""]
#[doc = " stack you'll want to \"push\" and \"pop head\""]
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct _ion_collection {
pub _owner: *mut ::std::os::raw::c_void,
pub _node_size: i32,
pub _count: i32,
pub _head: *mut ION_COLLECTION_NODE,
pub _tail: *mut ION_COLLECTION_NODE,
pub _freelist: *mut ION_COLLECTION_NODE,
}
#[test]
fn bindgen_test_layout__ion_collection() {
assert_eq!(
::std::mem::size_of::<_ion_collection>(),
40usize,
concat!("Size of: ", stringify!(_ion_collection))
);
assert_eq!(
::std::mem::align_of::<_ion_collection>(),
8usize,
concat!("Alignment of ", stringify!(_ion_collection))
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_ion_collection>()))._owner as *const _ as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(_ion_collection),
"::",
stringify!(_owner)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_ion_collection>()))._node_size as *const _ as usize },
8usize,
concat!(
"Offset of field: ",
stringify!(_ion_collection),
"::",
stringify!(_node_size)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_ion_collection>()))._count as *const _ as usize },
12usize,
concat!(
"Offset of field: ",
stringify!(_ion_collection),
"::",
stringify!(_count)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_ion_collection>()))._head as *const _ as usize },
16usize,
concat!(
"Offset of field: ",
stringify!(_ion_collection),
"::",
stringify!(_head)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_ion_collection>()))._tail as *const _ as usize },
24usize,
concat!(
"Offset of field: ",
stringify!(_ion_collection),
"::",
stringify!(_tail)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_ion_collection>()))._freelist as *const _ as usize },
32usize,
concat!(
"Offset of field: ",
stringify!(_ion_collection),
"::",
stringify!(_freelist)
)
);
}
impl Default for _ion_collection {
fn default() -> Self {
unsafe { ::std::mem::zeroed() }
}
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct _ion_symbol_import_location {
pub name: ION_STRING,
pub location: SID,
}
#[test]
fn bindgen_test_layout__ion_symbol_import_location() {
assert_eq!(
::std::mem::size_of::<_ion_symbol_import_location>(),
24usize,
concat!("Size of: ", stringify!(_ion_symbol_import_location))
);
assert_eq!(
::std::mem::align_of::<_ion_symbol_import_location>(),
8usize,
concat!("Alignment of ", stringify!(_ion_symbol_import_location))
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<_ion_symbol_import_location>())).name as *const _ as usize
},
0usize,
concat!(
"Offset of field: ",
stringify!(_ion_symbol_import_location),
"::",
stringify!(name)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<_ion_symbol_import_location>())).location as *const _ as usize
},
16usize,
concat!(
"Offset of field: ",
stringify!(_ion_symbol_import_location),
"::",
stringify!(location)
)
);
}
impl Default for _ion_symbol_import_location {
fn default() -> Self {
unsafe { ::std::mem::zeroed() }
}
}
pub type ION_SYMBOL_IMPORT_LOCATION = _ion_symbol_import_location;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct _ion_symbol {
pub sid: SID,
pub value: ION_STRING,
pub import_location: ION_SYMBOL_IMPORT_LOCATION,
pub add_count: i32,
}
#[test]
fn bindgen_test_layout__ion_symbol() {
assert_eq!(
::std::mem::size_of::<_ion_symbol>(),
56usize,
concat!("Size of: ", stringify!(_ion_symbol))
);
assert_eq!(
::std::mem::align_of::<_ion_symbol>(),
8usize,
concat!("Alignment of ", stringify!(_ion_symbol))
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_ion_symbol>())).sid as *const _ as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(_ion_symbol),
"::",
stringify!(sid)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_ion_symbol>())).value as *const _ as usize },
8usize,
concat!(
"Offset of field: ",
stringify!(_ion_symbol),
"::",
stringify!(value)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_ion_symbol>())).import_location as *const _ as usize },
24usize,
concat!(
"Offset of field: ",
stringify!(_ion_symbol),
"::",
stringify!(import_location)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_ion_symbol>())).add_count as *const _ as usize },
48usize,
concat!(
"Offset of field: ",
stringify!(_ion_symbol),
"::",
stringify!(add_count)
)
);
}
impl Default for _ion_symbol {
fn default() -> Self {
unsafe { ::std::mem::zeroed() }
}
}
pub const _ION_SYMBOL_TABLE_TYPE_ist_EMPTY: _ION_SYMBOL_TABLE_TYPE = 0;
pub const _ION_SYMBOL_TABLE_TYPE_ist_LOCAL: _ION_SYMBOL_TABLE_TYPE = 1;
pub const _ION_SYMBOL_TABLE_TYPE_ist_SHARED: _ION_SYMBOL_TABLE_TYPE = 2;
pub const _ION_SYMBOL_TABLE_TYPE_ist_SYSTEM: _ION_SYMBOL_TABLE_TYPE = 3;
pub type _ION_SYMBOL_TABLE_TYPE = ::std::os::raw::c_uint;
pub use self::_ION_SYMBOL_TABLE_TYPE as ION_SYMBOL_TABLE_TYPE;
extern "C" {
pub static mut ION_SYMBOL_ION_BYTES: [BYTE; 0usize];
}
extern "C" {
pub static mut ION_SYMBOL_VTM_BYTES: [BYTE; 0usize];
}
extern "C" {
pub static mut ION_SYMBOL_SYMBOL_TABLE_BYTES: [BYTE; 0usize];
}
extern "C" {
pub static mut ION_SYMBOL_NAME_BYTES: [BYTE; 0usize];
}
extern "C" {
pub static mut ION_SYMBOL_VERSION_BYTES: [BYTE; 0usize];
}
extern "C" {
pub static mut ION_SYMBOL_IMPORTS_BYTES: [BYTE; 0usize];
}
extern "C" {
pub static mut ION_SYMBOL_SYMBOLS_BYTES: [BYTE; 0usize];
}
extern "C" {
pub static mut ION_SYMBOL_MAX_ID_BYTES: [BYTE; 0usize];
}
extern "C" {
pub static mut ION_SYMBOL_SHARED_SYMBOL_TABLE_BYTES: [BYTE; 0usize];
}
extern "C" {
pub static mut ION_SYMBOL_ION_STRING: ION_STRING;
}
extern "C" {
pub static mut ION_SYMBOL_VTM_STRING: ION_STRING;
}
extern "C" {
pub static mut ION_SYMBOL_SYMBOL_TABLE_STRING: ION_STRING;
}
extern "C" {
pub static mut ION_SYMBOL_NAME_STRING: ION_STRING;
}
extern "C" {
pub static mut ION_SYMBOL_VERSION_STRING: ION_STRING;
}
extern "C" {
pub static mut ION_SYMBOL_IMPORTS_STRING: ION_STRING;
}
extern "C" {
pub static mut ION_SYMBOL_SYMBOLS_STRING: ION_STRING;
}
extern "C" {
pub static mut ION_SYMBOL_MAX_ID_STRING: ION_STRING;
}
extern "C" {
pub static mut ION_SYMBOL_SHARED_SYMBOL_TABLE_STRING: ION_STRING;
}
extern "C" {
pub static mut SYSTEM_SYMBOLS: [*mut ::std::os::raw::c_char; 0usize];
}
extern "C" {
#[doc = " Allocates a new local symbol table."]
#[doc = " @param p_hsymtab - Pointer to a handle to the newly-allocated symbol table."]
#[doc = " @param owner - Handle to the new symbol table's memory owner. If NULL, the resulting symbol table is its own memory"]
#[doc = " owner and must be freed using `ion_symbol_table_close`."]
pub fn ion_symbol_table_open(p_hsymtab: *mut hSYMTAB, owner: hOWNER) -> iERR;
}
extern "C" {
#[doc = " Allocates a new local symbol table of the given type (i.e. shared or local)."]
#[doc = " @param p_hsymtab - Pointer to a handle to the newly-allocated symbol table."]
#[doc = " @param owner - Handle to the new symbol table's memory owner. If NULL, the resulting symbol table is its own memory"]
#[doc = " owner and must be freed using `ion_symbol_table_close`."]
pub fn ion_symbol_table_open_with_type(
p_hsymtab: *mut hSYMTAB,
owner: hOWNER,
type_: ION_SYMBOL_TABLE_TYPE,
) -> iERR;
}
extern "C" {
#[doc = " Clones the given symbol table, using that symbol table's memory owner as the owner of the newly allocated symbol"]
#[doc = " table."]
#[doc = " @param hsymtab - They symbol table to clone."]
#[doc = " @param p_hclone - Pointer to a handle to the newly-allocated symbol table clone."]
pub fn ion_symbol_table_clone(hsymtab: hSYMTAB, p_hclone: *mut hSYMTAB) -> iERR;
}
extern "C" {
#[doc = " Clones the given symbol table, using the given owner as the newly-allocated symbol table's memory owner."]
#[doc = " @param hsymtab - They symbol table to clone."]
#[doc = " @param p_hclone - Pointer to a handle to the newly-allocated symbol table clone."]
#[doc = " @param owner - Handle to the new symbol table's memory owner. If NULL, the resulting symbol table is its own memory"]
#[doc = " owner and must be freed using `ion_symbol_table_close`."]
pub fn ion_symbol_table_clone_with_owner(
hsymtab: hSYMTAB,
p_hclone: *mut hSYMTAB,
owner: hOWNER,
) -> iERR;
}
extern "C" {
#[doc = " Gets the global system symbol table for the given Ion version. This global system symbol table must never be closed."]
#[doc = " @param p_hsystem_table - Pointer to a handle to the global system symbol table."]
#[doc = " @param version - The Ion version. Currently, must be 1."]
pub fn ion_symbol_table_get_system_table(p_hsystem_table: *mut hSYMTAB, version: i32) -> iERR;
}
extern "C" {
#[doc = " Deserializes a symbol table (shared or local) from the given reader."]
#[doc = " @param hreader - The reader, positioned at the start of the symbol table struct."]
#[doc = " @param owner - Handle to the new symbol table's memory owner. If NULL, the resulting symbol table is its own memory"]
#[doc = " owner and must be freed using `ion_symbol_table_close`."]
#[doc = " @param p_hsymtab - Pointer to a handle to the newly-allocated symbol table."]
pub fn ion_symbol_table_load(hreader: hREADER, owner: hOWNER, p_hsymtab: *mut hSYMTAB) -> iERR;
}
extern "C" {
#[doc = " Serializes a symbol table (shared or local) using the given writer."]
#[doc = " @param hsymtab - The symbol table to serialize."]
#[doc = " @param hwriter - The writer (text or binary)."]
pub fn ion_symbol_table_unload(hsymtab: hSYMTAB, hwriter: hWRITER) -> iERR;
}
extern "C" {
pub fn ion_symbol_table_lock(hsymtab: hSYMTAB) -> iERR;
}
extern "C" {
pub fn ion_symbol_table_is_locked(hsymtab: hSYMTAB, p_is_locked: *mut BOOL) -> iERR;
}
extern "C" {
pub fn ion_symbol_table_get_type(hsymtab: hSYMTAB, p_type: *mut ION_SYMBOL_TABLE_TYPE) -> iERR;
}
extern "C" {
pub fn ion_symbol_table_get_name(hsymtab: hSYMTAB, p_name: iSTRING) -> iERR;
}
extern "C" {
pub fn ion_symbol_table_get_version(hsymtab: hSYMTAB, p_version: *mut i32) -> iERR;
}
extern "C" {
pub fn ion_symbol_table_get_max_sid(hsymtab: hSYMTAB, p_max_id: *mut SID) -> iERR;
}
extern "C" {
pub fn ion_symbol_table_set_name(hsymtab: hSYMTAB, name: iSTRING) -> iERR;
}
extern "C" {
pub fn ion_symbol_table_set_version(hsymtab: hSYMTAB, version: i32) -> iERR;
}
extern "C" {
pub fn ion_symbol_table_set_max_sid(hsymtab: hSYMTAB, max_id: SID) -> iERR;
}
extern "C" {
pub fn ion_symbol_table_get_imports(
hsymtab: hSYMTAB,
p_imports: *mut *mut ION_COLLECTION,
) -> iERR;
}
extern "C" {
#[doc = " Imports a shared symbol table into a local symbol table, given a description of the import and the catalog in which"]
#[doc = " it can be found."]
#[doc = " NOTE: the best match for the described shared symbol table import that is available in the catalog will be used. If"]
#[doc = " no match is found, all of the import's symbols will be considered to have unknown text."]
#[doc = " @param hsymtab - The local symbol table into which the imported symbol table will be incorporated."]
#[doc = " @param pimport - The description of the shared symbol table to be imported."]
#[doc = " @param catalog - The catalog to query for the matching shared symbol table."]
pub fn ion_symbol_table_add_import(
hsymtab: hSYMTAB,
pimport: *mut ION_SYMBOL_TABLE_IMPORT_DESCRIPTOR,
catalog: hCATALOG,
) -> iERR;
}
extern "C" {
#[doc = " Imports a shared symbol table into a local symbol table."]
#[doc = " @param hsymtab - The local symbol table into which the imported symbol table will be incorporated."]
#[doc = " @param hsymtab_import - The shared symbol table to import."]
pub fn ion_symbol_table_import_symbol_table(hsymtab: hSYMTAB, hsymtab_import: hSYMTAB) -> iERR;
}
extern "C" {
pub fn ion_symbol_table_find_by_name(hsymtab: hSYMTAB, name: iSTRING, p_sid: *mut SID) -> iERR;
}
extern "C" {
pub fn ion_symbol_table_find_by_sid(hsymtab: hSYMTAB, sid: SID, p_name: *mut iSTRING) -> iERR;
}
extern "C" {
pub fn ion_symbol_table_is_symbol_known(
hsymtab: hSYMTAB,
sid: SID,
p_is_known: *mut BOOL,
) -> iERR;
}
extern "C" {
pub fn ion_symbol_table_get_symbol(
hsymtab: hSYMTAB,
sid: SID,
p_sym: *mut *mut ION_SYMBOL,
) -> iERR;
}
extern "C" {
pub fn ion_symbol_table_get_local_symbol(
hsymtab: hSYMTAB,
sid: SID,
p_sym: *mut *mut ION_SYMBOL,
) -> iERR;
}
extern "C" {
pub fn ion_symbol_table_add_symbol(hsymtab: hSYMTAB, name: iSTRING, p_sid: *mut SID) -> iERR;
}
extern "C" {
#[doc = " If the given symbol table is its own memory owner, its memory and everything it owns is freed. If the given symbol"]
#[doc = " table has an external owner and that owner has not been freed, this does nothing; this symbol table will be freed"]
#[doc = " when its memory owner is freed. If the given symbol table has an external owner which has been freed, the behavior of"]
#[doc = " this function is undefined."]
#[doc = " NOTE: Symbol tables constructed and returned by readers and writers are owned by those readers and writers."]
pub fn ion_symbol_table_close(hsymtab: hSYMTAB) -> iERR;
}
extern "C" {
#[doc = " Copies an ION_SYMBOL to a new memory owner."]
pub fn ion_symbol_copy_to_owner(
owner: hOWNER,
dst: *mut ION_SYMBOL,
src: *mut ION_SYMBOL,
) -> iERR;
}
extern "C" {
#[doc = " Compares the two given ION_SYMBOLs for equality under the Ion data model."]
pub fn ion_symbol_is_equal(
lhs: *mut ION_SYMBOL,
rhs: *mut ION_SYMBOL,
is_equal: *mut BOOL,
) -> iERR;
}
extern "C" {
pub fn ion_symbol_table_type_to_str(t: ION_SYMBOL_TABLE_TYPE) -> *const ::std::os::raw::c_char;
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct _ion_stream_user_paged {
_unused: [u8; 0],
}
pub type ION_STREAM_USER_PAGED = _ion_stream_user_paged;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct _ion_stream_paged {
_unused: [u8; 0],
}
pub type ION_STREAM_PAGED = _ion_stream_paged;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct _ion_page {
_unused: [u8; 0],
}
pub type ION_PAGE = _ion_page;
pub type PAGE_ID = i32;
pub type POSITION = i64;
extern "C" {
#[doc = ""]
pub fn ion_stream_open_buffer(
buffer: *mut BYTE,
buf_length: SIZE,
buf_filled: SIZE,
read_only: BOOL,
pp_stream: *mut *mut ION_STREAM,
) -> iERR;
}
extern "C" {
pub fn ion_stream_open_memory_only(pp_stream: *mut *mut ION_STREAM) -> iERR;
}
extern "C" {
pub fn ion_stream_open_stdin(pp_stream: *mut *mut ION_STREAM) -> iERR;
}
extern "C" {
pub fn ion_stream_open_stdout(pp_stream: *mut *mut ION_STREAM) -> iERR;
}
extern "C" {
pub fn ion_stream_open_stderr(pp_stream: *mut *mut ION_STREAM) -> iERR;
}
extern "C" {
pub fn ion_stream_open_file_in(in_: *mut FILE, pp_stream: *mut *mut ION_STREAM) -> iERR;
}
extern "C" {
pub fn ion_stream_open_file_out(out: *mut FILE, pp_stream: *mut *mut ION_STREAM) -> iERR;
}
extern "C" {
pub fn ion_stream_open_file_rw(
fp: *mut FILE,
cache_all: BOOL,
pp_stream: *mut *mut ION_STREAM,
) -> iERR;
}
extern "C" {
pub fn ion_stream_open_handler_in(
fn_input_handler: ION_STREAM_HANDLER,
handler_state: *mut ::std::os::raw::c_void,
pp_stream: *mut *mut ION_STREAM,
) -> iERR;
}
extern "C" {
pub fn ion_stream_open_handler_out(
fn_output_handler: ION_STREAM_HANDLER,
handler_state: *mut ::std::os::raw::c_void,
pp_stream: *mut *mut ION_STREAM,
) -> iERR;
}
extern "C" {
pub fn ion_stream_open_fd_in(
fd_in: ::std::os::raw::c_int,
pp_stream: *mut *mut ION_STREAM,
) -> iERR;
}
extern "C" {
pub fn ion_stream_open_fd_out(
fd_out: ::std::os::raw::c_int,
pp_stream: *mut *mut ION_STREAM,
) -> iERR;
}
extern "C" {
pub fn ion_stream_open_fd_rw(
fd: ::std::os::raw::c_int,
cache_all: BOOL,
pp_stream: *mut *mut ION_STREAM,
) -> iERR;
}
extern "C" {
pub fn ion_stream_flush(stream: *mut ION_STREAM) -> iERR;
}
extern "C" {
pub fn ion_stream_close(stream: *mut ION_STREAM) -> iERR;
}
extern "C" {
#[doc = ""]
pub fn ion_stream_can_read(stream: *mut ION_STREAM) -> BOOL;
}
extern "C" {
pub fn ion_stream_can_write(stream: *mut ION_STREAM) -> BOOL;
}
extern "C" {
pub fn ion_stream_can_seek(stream: *mut ION_STREAM) -> BOOL;
}
extern "C" {
pub fn ion_stream_can_mark(stream: *mut ION_STREAM) -> BOOL;
}
extern "C" {
pub fn ion_stream_is_dirty(stream: *mut ION_STREAM) -> BOOL;
}
extern "C" {
pub fn ion_stream_is_mark_open(stream: *mut ION_STREAM) -> BOOL;
}
extern "C" {
pub fn ion_stream_get_position(stream: *mut ION_STREAM) -> POSITION;
}
extern "C" {
pub fn ion_stream_get_file_stream(stream: *mut ION_STREAM) -> *mut FILE;
}
extern "C" {
pub fn ion_stream_get_mark_start(stream: *mut ION_STREAM) -> POSITION;
}
extern "C" {
pub fn ion_stream_get_marked_length(stream: *mut ION_STREAM) -> POSITION;
}
extern "C" {
#[doc = ""]
pub fn ion_stream_read_byte(stream: *mut ION_STREAM, p_c: *mut ::std::os::raw::c_int) -> iERR;
}
extern "C" {
pub fn ion_stream_read(
stream: *mut ION_STREAM,
buf: *mut BYTE,
len: SIZE,
p_bytes_read: *mut SIZE,
) -> iERR;
}
extern "C" {
pub fn ion_stream_unread_byte(stream: *mut ION_STREAM, c: ::std::os::raw::c_int) -> iERR;
}
extern "C" {
pub fn ion_stream_write(
stream: *mut ION_STREAM,
buf: *mut BYTE,
len: SIZE,
p_bytes_written: *mut SIZE,
) -> iERR;
}
extern "C" {
pub fn ion_stream_write_byte(stream: *mut ION_STREAM, byte: ::std::os::raw::c_int) -> iERR;
}
extern "C" {
pub fn ion_stream_write_byte_no_checks(
stream: *mut ION_STREAM,
byte: ::std::os::raw::c_int,
) -> iERR;
}
extern "C" {
pub fn ion_stream_write_stream(
stream: *mut ION_STREAM,
stream_input: *mut ION_STREAM,
len: SIZE,
p_written: *mut SIZE,
) -> iERR;
}
extern "C" {
pub fn ion_stream_seek(stream: *mut ION_STREAM, position: POSITION) -> iERR;
}
extern "C" {
pub fn ion_stream_truncate(stream: *mut ION_STREAM) -> iERR;
}
extern "C" {
pub fn ion_stream_skip(stream: *mut ION_STREAM, distance: SIZE, p_skipped: *mut SIZE) -> iERR;
}
extern "C" {
pub fn ion_stream_mark(stream: *mut ION_STREAM) -> iERR;
}
extern "C" {
pub fn ion_stream_mark_remark(stream: *mut ION_STREAM, position: POSITION) -> iERR;
}
extern "C" {
pub fn ion_stream_mark_rewind(stream: *mut ION_STREAM) -> iERR;
}
extern "C" {
pub fn ion_stream_mark_clear(stream: *mut ION_STREAM) -> iERR;
}
#[doc = " A function that may be called by the reader upon a change to the stream's symbol table context."]
#[doc = ""]
#[doc = " For example, an ION_READER_CONTEXT_CALLBACK function may be used to wrap `ion_writer_add_imported_tables`, with the"]
#[doc = " user context pointing to a writer instance, in order to update the writer's symbol table context in lockstep with"]
#[doc = " the reader."]
#[doc = ""]
#[doc = " @param context - User-provided context, e.g., a hWRITER."]
#[doc = " @param imports - A collection of ION_SYMBOL_TABLE_IMPORT, representing the shared symbol tables in the new symbol"]
#[doc = " table context."]
pub type ION_READER_CONTEXT_CALLBACK = ::std::option::Option<
unsafe extern "C" fn(
context: *mut ::std::os::raw::c_void,
imports: *mut ION_COLLECTION,
) -> iERR,
>;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct _ion_reader_context_change_notifier {
#[doc = " The function to call upon a change to the reader's symbol table context."]
pub notify: ION_READER_CONTEXT_CALLBACK,
#[doc = " The user context to provide as the first argument to `notify`. May be NULL."]
pub context: *mut ::std::os::raw::c_void,
}
#[test]
fn bindgen_test_layout__ion_reader_context_change_notifier() {
assert_eq!(
::std::mem::size_of::<_ion_reader_context_change_notifier>(),
16usize,
concat!("Size of: ", stringify!(_ion_reader_context_change_notifier))
);
assert_eq!(
::std::mem::align_of::<_ion_reader_context_change_notifier>(),
8usize,
concat!(
"Alignment of ",
stringify!(_ion_reader_context_change_notifier)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<_ion_reader_context_change_notifier>())).notify as *const _
as usize
},
0usize,
concat!(
"Offset of field: ",
stringify!(_ion_reader_context_change_notifier),
"::",
stringify!(notify)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<_ion_reader_context_change_notifier>())).context as *const _
as usize
},
8usize,
concat!(
"Offset of field: ",
stringify!(_ion_reader_context_change_notifier),
"::",
stringify!(context)
)
);
}
impl Default for _ion_reader_context_change_notifier {
fn default() -> Self {
unsafe { ::std::mem::zeroed() }
}
}
pub type ION_READER_CONTEXT_CHANGE_NOTIFIER = _ion_reader_context_change_notifier;
#[doc = " Reader configuration data, could be supplied by user during reader creation time."]
#[doc = " All fields in the structure are defaulted to 0, except for the following:"]
#[doc = ""]
#[doc = " #define DEFAULT_ANNOTATION_LIMIT 10"]
#[doc = " #define DEFAULT_WRITER_STACK_DEPTH 10"]
#[doc = " #define DEFAULT_CHUNK_THRESHOLD DEFAULT_BLOCK_SIZE"]
#[doc = " #define DEFAULT_SYMBOL_THRESHOLD 512"]
#[doc = ""]
#[doc = " Some field also has a range limit:"]
#[doc = " #define MIN_ANNOTATION_LIMIT 1"]
#[doc = " #define MIN_WRITER_STACK_DEPTH 2"]
#[doc = " #define MIN_SYMBOL_THRESHOLD 32"]
#[doc = " #define MIN_CHUNK_THRESHOLD 32"]
#[doc = " #define MIN_ION_ALLOCATION_BLOCK_SIZE 32"]
#[doc = ""]
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct _ion_reader_options {
#[doc = " If true the reader will return otherwise hidden system values"]
#[doc = ""]
pub return_system_values: BOOL,
#[doc = " Character to be treated as new line for line counting, defaults to '\\n'"]
#[doc = ""]
pub new_line_char: ::std::os::raw::c_int,
#[doc = " The max container depth defaults to 10"]
#[doc = ""]
pub max_container_depth: SIZE,
#[doc = " The max number of annotations on 1 value, defaults to 10"]
#[doc = ""]
pub max_annotation_count: SIZE,
#[doc = " The max number number of bytes the annotations on a single value. This"]
#[doc = " is an total. How the bytes are divided among the annotations is irrelevant"]
#[doc = " (i.e. 1 large, or 100 small may have the same total space requirements)."]
#[doc = " defaults to user_value_threshold (or 4096)."]
#[doc = ""]
pub max_annotation_buffered: SIZE,
#[doc = " The size maximum size allowed for symbols, 512 bytes is the default"]
#[doc = ""]
pub symbol_threshold: SIZE,
#[doc = " user value allocation threshold, max size of allocation made to process"]
#[doc = " any value returned to the user, default is 4096. Includes symbol, int,"]
#[doc = " decimal, timestamp, blob values in all cases. This includes string, clob,"]
#[doc = " and blob values if they are to be returned to the caller in a contiguous"]
#[doc = " buffer."]
#[doc = ""]
pub user_value_threshold: SIZE,
#[doc = " The size over which long values are returned as chunks. This is only"]
#[doc = " valid for string, clob and blob values as all others must be buffered"]
#[doc = " up to the limit of user_value_threshold. The default is 4096."]
#[doc = ""]
pub chunk_threshold: SIZE,
#[doc = " Memory is allocated in pages owned by the primary entities it's default size is 4096"]
#[doc = ""]
pub allocation_page_size: SIZE,
#[doc = " If true this will disable validation of string content which verifies the"]
#[doc = " string returned is in fact a valid UTF-8 sequence. This defaults to false."]
pub skip_character_validation: BOOL,
#[doc = " Handle to catalog of shared symbol tables for the reader to use. If NULL, will be treated as empty."]
#[doc = ""]
pub pcatalog: *mut ION_CATALOG,
#[doc = " Handle to the decNumber context for the reader to use. This allows configuration of the maximum number of"]
#[doc = " decimal digits, decimal exponent range, etc. See decContextDefault in decContext.h for simple initialization."]
#[doc = ""]
#[doc = " If NULL, the reader will initialize its decimal context by calling decContextDefault with the DEC_INIT_DECQUAD"]
#[doc = " option, which results in a maximum of 34 decimal digits and an exponent range of [-6143, 6144]."]
#[doc = ""]
#[doc = " Note that up to 34 digits of precision will always be supported, even if configured to be less than 34."]
pub decimal_context: *mut decContext,
#[doc = " Notification callback data to be used upon symbol table context change. Ignored if"]
#[doc = " `context_change_notifier.notify` is NULL."]
pub context_change_notifier: ION_READER_CONTEXT_CHANGE_NOTIFIER,
}
#[test]
fn bindgen_test_layout__ion_reader_options() {
assert_eq!(
::std::mem::size_of::<_ion_reader_options>(),
72usize,
concat!("Size of: ", stringify!(_ion_reader_options))
);
assert_eq!(
::std::mem::align_of::<_ion_reader_options>(),
8usize,
concat!("Alignment of ", stringify!(_ion_reader_options))
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<_ion_reader_options>())).return_system_values as *const _
as usize
},
0usize,
concat!(
"Offset of field: ",
stringify!(_ion_reader_options),
"::",
stringify!(return_system_values)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<_ion_reader_options>())).new_line_char as *const _ as usize
},
4usize,
concat!(
"Offset of field: ",
stringify!(_ion_reader_options),
"::",
stringify!(new_line_char)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<_ion_reader_options>())).max_container_depth as *const _ as usize
},
8usize,
concat!(
"Offset of field: ",
stringify!(_ion_reader_options),
"::",
stringify!(max_container_depth)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<_ion_reader_options>())).max_annotation_count as *const _
as usize
},
12usize,
concat!(
"Offset of field: ",
stringify!(_ion_reader_options),
"::",
stringify!(max_annotation_count)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<_ion_reader_options>())).max_annotation_buffered as *const _
as usize
},
16usize,
concat!(
"Offset of field: ",
stringify!(_ion_reader_options),
"::",
stringify!(max_annotation_buffered)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<_ion_reader_options>())).symbol_threshold as *const _ as usize
},
20usize,
concat!(
"Offset of field: ",
stringify!(_ion_reader_options),
"::",
stringify!(symbol_threshold)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<_ion_reader_options>())).user_value_threshold as *const _
as usize
},
24usize,
concat!(
"Offset of field: ",
stringify!(_ion_reader_options),
"::",
stringify!(user_value_threshold)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<_ion_reader_options>())).chunk_threshold as *const _ as usize
},
28usize,
concat!(
"Offset of field: ",
stringify!(_ion_reader_options),
"::",
stringify!(chunk_threshold)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<_ion_reader_options>())).allocation_page_size as *const _
as usize
},
32usize,
concat!(
"Offset of field: ",
stringify!(_ion_reader_options),
"::",
stringify!(allocation_page_size)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<_ion_reader_options>())).skip_character_validation as *const _
as usize
},
36usize,
concat!(
"Offset of field: ",
stringify!(_ion_reader_options),
"::",
stringify!(skip_character_validation)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_ion_reader_options>())).pcatalog as *const _ as usize },
40usize,
concat!(
"Offset of field: ",
stringify!(_ion_reader_options),
"::",
stringify!(pcatalog)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<_ion_reader_options>())).decimal_context as *const _ as usize
},
48usize,
concat!(
"Offset of field: ",
stringify!(_ion_reader_options),
"::",
stringify!(decimal_context)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<_ion_reader_options>())).context_change_notifier as *const _
as usize
},
56usize,
concat!(
"Offset of field: ",
stringify!(_ion_reader_options),
"::",
stringify!(context_change_notifier)
)
);
}
impl Default for _ion_reader_options {
fn default() -> Self {
unsafe { ::std::mem::zeroed() }
}
}
#[doc = " Reader configuration data, could be supplied by user during reader creation time."]
#[doc = " All fields in the structure are defaulted to 0, except for the following:"]
#[doc = ""]
#[doc = " #define DEFAULT_ANNOTATION_LIMIT 10"]
#[doc = " #define DEFAULT_WRITER_STACK_DEPTH 10"]
#[doc = " #define DEFAULT_CHUNK_THRESHOLD DEFAULT_BLOCK_SIZE"]
#[doc = " #define DEFAULT_SYMBOL_THRESHOLD 512"]
#[doc = ""]
#[doc = " Some field also has a range limit:"]
#[doc = " #define MIN_ANNOTATION_LIMIT 1"]
#[doc = " #define MIN_WRITER_STACK_DEPTH 2"]
#[doc = " #define MIN_SYMBOL_THRESHOLD 32"]
#[doc = " #define MIN_CHUNK_THRESHOLD 32"]
#[doc = " #define MIN_ION_ALLOCATION_BLOCK_SIZE 32"]
#[doc = ""]
pub type ION_READER_OPTIONS = _ion_reader_options;
extern "C" {
#[doc = " Allocates a new reader consuming a given buffer of data."]
#[doc = ""]
#[doc = " @param p_hreader will receive a pointer to the new reader."]
#[doc = " It must be freed via ion_reader_close()."]
#[doc = " @param buffer the Ion data to read, either UTF-8 text or binary."]
#[doc = " Must be a valid handle. The caller retains ownership of the buffer and"]
#[doc = " must ensure that its data is unmodified until the reader is closed."]
#[doc = " @param buf_length the length of the buffer"]
#[doc = " @param p_options may be null, in that case, default value will be used."]
pub fn ion_reader_open_buffer(
p_hreader: *mut hREADER,
buffer: *mut BYTE,
buf_length: SIZE,
p_options: *mut ION_READER_OPTIONS,
) -> iERR;
}
extern "C" {
#[doc = " Create hREADER object, and associate it with the stream for reading."]
#[doc = ""]
#[doc = " The hREADER object itself does not have a read data buffer, it's using the buffer from handler_state, which"]
#[doc = " usually contains a BYTE[]."]
#[doc = ""]
#[doc = " hREADER object will invoke fn_input_handler to read from input data source (File, for example) and fill"]
#[doc = " the BYTE[] in handler_state."]
#[doc = ""]
#[doc = "<pre>"]
#[doc = "typedef struct _test_file {"]
#[doc = "FILE *in;"]
#[doc = "int block_size;"]
#[doc = "BYTE *buffer;"]
#[doc = "} TEST_FILE;"]
#[doc = "BYTE g_buffer[1024];"]
#[doc = "TEST_FILE g_test_file ="]
#[doc = "{"]
#[doc = "NULL,"]
#[doc = "TEST_FILE_BUF_MAX,"]
#[doc = "g_buffer"]
#[doc = "};"]
#[doc = "iERR test_stream_handler(struct _ion_stream *pstream)"]
#[doc = "{"]
#[doc = "iENTER;"]
#[doc = "TEST_FILE *tfile;"]
#[doc = "SIZE len;"]
#[doc = "tfile = (TEST_FILE *)pstream->handler_state;"]
#[doc = "pstream->curr = tfile->buffer;"]
#[doc = "len = fread( tfile->buffer, sizeof(*tfile->buffer), tfile->block_size, g_test_file.in );"]
#[doc = "if (len < 1) {"]
#[doc = "pstream->limit = NULL;"]
#[doc = "DONTFAILWITH(IERR_EOF);"]
#[doc = "}"]
#[doc = "pstream->limit = pstream->curr + len;"]
#[doc = "iRETURN;"]
#[doc = "}"]
#[doc = "fstream = fopen(pathname, \"r\");"]
#[doc = "g_test_file.in = fstream;"]
#[doc = "ion_reader_open_stream(&reader, &g_test_file, test_stream_handler, NULL);"]
#[doc = "</pre>"]
#[doc = ""]
#[doc = " @param p_hreader Newly created reader object will be stored here."]
#[doc = " @param p_stream stream opened with ion_stream functions"]
#[doc = " @param p_options const, Reader configuration data object, used while creating reader object."]
#[doc = " @return IERR_OK if succeeded"]
pub fn ion_reader_open_stream(
p_hreader: *mut hREADER,
handler_state: *mut ::std::os::raw::c_void,
fn_input_handler: ION_STREAM_HANDLER,
p_options: *mut ION_READER_OPTIONS,
) -> iERR;
}
extern "C" {
#[doc = " Resets input stream for given reader."]
#[doc = ""]
#[doc = " readers' current stream would be closed and would be initialized with given stream."]
#[doc = " catalog, symbol table, dec_context & other reader defaults would be reused [ @see _ion_reader_initialize impl.]"]
#[doc = ""]
#[doc = " @param p_hreader Reader object for which input stream is to be reset"]
#[doc = " @param handler_state Object that contains a buffer to store the read-in data from input stream."]
#[doc = " @param fn_input_handler Function used to read from input stream and refill the buffer."]
#[doc = " the handler is responsible for settting start, curr and limit of reader object"]
#[doc = " it may opt to change the handler_state if it wants to."]
#[doc = " on this first call it is actually handling whatever initialization"]
#[doc = " it might need as well"]
#[doc = " @return IERR_OK if succeeded"]
pub fn ion_reader_reset_stream(
p_hreader: *mut hREADER,
handler_state: *mut ::std::os::raw::c_void,
fn_input_handler: ION_STREAM_HANDLER,
) -> iERR;
}
extern "C" {
#[doc = " Resets input user-managed stream for given reader."]
#[doc = ""]
#[doc = " Readers' current stream would be closed and would be initialized with given stream."]
#[doc = " Resets the state of the reader to be at the top level. Symbol table and other reader state such as"]
#[doc = " whether its a binary or a text reader is retained."]
#[doc = " A common pattern when using this interface would be to open the reader with a user-managed-stream,"]
#[doc = " Then call ion_reader_next which will read the"]
#[doc = " ion version marker and the initial local symbol table (if one"]
#[doc = " is present). At that point the symbol table will be current."]
#[doc = " A later user-managed-stream seek is immediately followed by calling this API."]
#[doc = " This ensures symbol table is retained and reader/parser state is valid following the random jump;"]
#[doc = " and parsing continues unhindered from thereon."]
#[doc = " @param p_hreader Reader object for which input stream is to be reset"]
#[doc = " @param handler_state Object that contains a buffer to store the read-in data from input stream."]
#[doc = " @param fn_input_handler Function used to read from input stream and refill the buffer."]
#[doc = " the handler is responsible for setting start, curr and limit of reader"]
#[doc = " object."]
#[doc = " @param length Length of the user-managed-stream. An EOF by the reader when this length"]
#[doc = " is reached."]
#[doc = " @return IERR_OK if succeeded"]
pub fn ion_reader_reset_stream_with_length(
p_hreader: *mut hREADER,
handler_state: *mut ::std::os::raw::c_void,
fn_input_handler: ION_STREAM_HANDLER,
length: POSITION,
) -> iERR;
}
extern "C" {
pub fn ion_reader_open(
p_hreader: *mut hREADER,
p_stream: *mut ION_STREAM,
p_options: *mut ION_READER_OPTIONS,
) -> iERR;
}
extern "C" {
pub fn ion_reader_get_catalog(hreader: hREADER, p_hcatalog: *mut hCATALOG) -> iERR;
}
extern "C" {
#[doc = " moves the stream position to the specified offset. Resets the"]
#[doc = " the state of the reader to be at the top level. As long as the"]
#[doc = " specified position is at the first byte of a top-level value"]
#[doc = " (just before the type description byte) this will work neatly."]
#[doc = " Do not attempt to seek to a value below the top level, as the"]
#[doc = " view of the data is likely to be invalid."]
#[doc = ""]
#[doc = " If a length is specified (default is -1 or no limit) eof will"]
#[doc = " be returned when length bytes are consumed."]
#[doc = ""]
#[doc = " A common pattern when using this interface would be to open"]
#[doc = " the reader from an in memory buffer stream or a seek-able"]
#[doc = " file handle. Then call ion_reader_next which will read the"]
#[doc = " ion version marker and the initial local symbol table (if one"]
#[doc = " is present). At that point the symbol table will be current"]
#[doc = " and later seek's will have an appropriate symbol table to use."]
pub fn ion_reader_seek(hreader: hREADER, offset: POSITION, length: SIZE) -> iERR;
}
extern "C" {
#[doc = " set the current symbol table to the table passed in. This"]
#[doc = " can be used to reset the readers symbol"]
#[doc = " table is you wish to seek in a stream which contains multiple"]
#[doc = " symbol tables. This symbol table handle should be a handle"]
#[doc = " returned by ion_reader_get_symbol_table."]
pub fn ion_reader_set_symbol_table(hreader: hREADER, hsymtab: hSYMTAB) -> iERR;
}
extern "C" {
#[doc = " returns the offset of the value the reader is currently"]
#[doc = " positioned on. This offset is appropriate to use later"]
#[doc = " to seek to."]
pub fn ion_reader_get_value_offset(hreader: hREADER, p_offset: *mut POSITION) -> iERR;
}
extern "C" {
#[doc = " returns the length of the value the reader is currently"]
#[doc = " positioned on. This length is appropriate to use later"]
#[doc = " when calling ion_reader_seek to limit \"over-reading\" in"]
#[doc = " the underlying stream which could result in errors that"]
#[doc = " are not really of interest. NOTE: readers of text data"]
#[doc = " will always set *p_length to -1 because text Ion data is"]
#[doc = " not length-prefixed. When the reader may be reading text"]
#[doc = " Ion data, the correct way to calculate a value's length"]
#[doc = " is by subtracting the current value's offset (see"]
#[doc = " `ion_reader_get_value_offset`) from the next value's"]
#[doc = " offset. This technique will work for both binary and text"]
#[doc = " Ion data."]
pub fn ion_reader_get_value_length(hreader: hREADER, p_length: *mut SIZE) -> iERR;
}
extern "C" {
#[doc = " returns the current symbol table the value the reader is currently"]
#[doc = " positioned on. This can be used to reset the readers symbol"]
#[doc = " table is you wish to seek in a stream which contains multiple"]
#[doc = " symbol tables. This symbol table handle can be used to call"]
#[doc = " ion_reader_set_symbol_table."]
pub fn ion_reader_get_symbol_table(hreader: hREADER, p_hsymtab: *mut hSYMTAB) -> iERR;
}
extern "C" {
#[doc = " Returns the next ION_TYPE in the stream. In case of EOF, IERR_OK will be returned. p_value_type = tid_EOF."]
#[doc = " @param hreader"]
#[doc = " @param p_value_type ION_TYPE (tid_EOF, tid_BOOL, etc, defined in ion_const.h). tid_EOF if EOF."]
pub fn ion_reader_next(hreader: hREADER, p_value_type: *mut ION_TYPE) -> iERR;
}
extern "C" {
pub fn ion_reader_step_in(hreader: hREADER) -> iERR;
}
extern "C" {
pub fn ion_reader_step_out(hreader: hREADER) -> iERR;
}
extern "C" {
pub fn ion_reader_get_depth(hreader: hREADER, p_depth: *mut SIZE) -> iERR;
}
extern "C" {
#[doc = " Returns the type of the current value, or tid_none if no value has been assigned. (before next() is called)"]
pub fn ion_reader_get_type(hreader: hREADER, p_value_type: *mut ION_TYPE) -> iERR;
}
extern "C" {
pub fn ion_reader_has_any_annotations(
hreader: hREADER,
p_has_any_annotations: *mut BOOL,
) -> iERR;
}
extern "C" {
pub fn ion_reader_has_annotation(
hreader: hREADER,
annotation: iSTRING,
p_annotation_found: *mut BOOL,
) -> iERR;
}
extern "C" {
pub fn ion_reader_is_null(hreader: hREADER, p_is_null: *mut BOOL) -> iERR;
}
extern "C" {
pub fn ion_reader_is_in_struct(preader: hREADER, p_is_in_struct: *mut BOOL) -> iERR;
}
extern "C" {
pub fn ion_reader_get_field_name(hreader: hREADER, p_str: iSTRING) -> iERR;
}
extern "C" {
pub fn ion_reader_get_field_name_symbol(
hreader: hREADER,
p_psymbol: *mut *mut ION_SYMBOL,
) -> iERR;
}
extern "C" {
pub fn ion_reader_get_annotations(
hreader: hREADER,
p_strs: iSTRING,
max_count: SIZE,
p_count: *mut SIZE,
) -> iERR;
}
extern "C" {
pub fn ion_reader_get_annotation_symbols(
hreader: hREADER,
p_symbols: *mut ION_SYMBOL,
max_count: SIZE,
p_count: *mut SIZE,
) -> iERR;
}
extern "C" {
pub fn ion_reader_get_annotation_count(hreader: hREADER, p_count: *mut SIZE) -> iERR;
}
extern "C" {
pub fn ion_reader_get_an_annotation(
hreader: hREADER,
idx: ::std::os::raw::c_int,
p_strs: iSTRING,
) -> iERR;
}
extern "C" {
pub fn ion_reader_get_an_annotation_symbol(
hreader: hREADER,
idx: ::std::os::raw::c_int,
p_symbol: *mut ION_SYMBOL,
) -> iERR;
}
extern "C" {
pub fn ion_reader_read_null(hreader: hREADER, p_value: *mut ION_TYPE) -> iERR;
}
extern "C" {
pub fn ion_reader_read_bool(hreader: hREADER, p_value: *mut BOOL) -> iERR;
}
extern "C" {
#[doc = " Read integer value from Ion stream."]
#[doc = " The size of the integer is sizeof(int)"]
#[doc = " If the value in the Ion stream does not fit into the variable, it will return with IERR_NUMERIC_OVERFLOW."]
pub fn ion_reader_read_int(hreader: hREADER, p_value: *mut ::std::os::raw::c_int) -> iERR;
}
extern "C" {
#[doc = " Read integer value from Ion stream."]
#[doc = " The size of the integer is sizeof(int32_t)"]
#[doc = " If the value in the Ion stream does not fit into the variable, it will return with IERR_NUMERIC_OVERFLOW."]
pub fn ion_reader_read_int32(hreader: hREADER, p_value: *mut i32) -> iERR;
}
extern "C" {
#[doc = " Read integer value from Ion stream."]
#[doc = " The size of the integer is sizeof(int64_t)"]
#[doc = " If the value in the Ion stream does not fit into the variable, it will return with IERR_NUMERIC_OVERFLOW."]
pub fn ion_reader_read_int64(hreader: hREADER, p_value: *mut i64) -> iERR;
}
extern "C" {
#[doc = " Read integer value from Ion stream."]
#[doc = " This supports arbitary length integers defined by ion_int."]
pub fn ion_reader_read_ion_int(hreader: hREADER, p_value: *mut ION_INT) -> iERR;
}
extern "C" {
#[doc = " Read integer value from Ion stream."]
#[doc = " The size of the integer is sizeof(long), which is 4 or 8 bytes depends on the OS"]
#[doc = " If the value in the Ion stream does not fit into the variable, it will return with IERR_NUMERIC_OVERFLOW."]
pub fn ion_reader_read_long(hreader: hREADER, p_value: *mut ::std::os::raw::c_long) -> iERR;
}
extern "C" {
pub fn ion_reader_read_double(hreader: hREADER, p_value: *mut f64) -> iERR;
}
extern "C" {
#[doc = " @deprecated use of decQuads directly is deprecated. ION_DECIMAL should be used. See `ion_reader_read_ion_decimal`."]
pub fn ion_reader_read_decimal(hreader: hREADER, p_value: *mut decQuad) -> iERR;
}
extern "C" {
pub fn ion_reader_read_ion_decimal(hreader: hREADER, p_value: *mut ION_DECIMAL) -> iERR;
}
extern "C" {
#[doc = " @return IERR_NULL_VALUE if the current value is null.timestamp."]
pub fn ion_reader_read_timestamp(hreader: hREADER, p_value: iTIMESTAMP) -> iERR;
}
extern "C" {
#[doc = " Read the current symbol value as an ION_SYMBOL."]
pub fn ion_reader_read_ion_symbol(hreader: hREADER, p_symbol: *mut ION_SYMBOL) -> iERR;
}
extern "C" {
#[doc = " Determines the content of the current text value, which must be an"]
#[doc = " Ion string or symbol. The reader retains ownership of the returned byte"]
#[doc = " array, and the caller must copy the data out (if necessary) before moving"]
#[doc = " the cursor."]
#[doc = ""]
#[doc = " @param hreader must be a valid handle."]
#[doc = ""]
#[doc = " @param p_value receives the string information."]
pub fn ion_reader_get_string_length(hreader: hREADER, p_length: *mut SIZE) -> iERR;
}
extern "C" {
pub fn ion_reader_read_string(hreader: hREADER, p_value: iSTRING) -> iERR;
}
extern "C" {
pub fn ion_reader_read_partial_string(
hreader: hREADER,
p_buf: *mut BYTE,
buf_max: SIZE,
p_length: *mut SIZE,
) -> iERR;
}
extern "C" {
pub fn ion_reader_get_lob_size(hreader: hREADER, p_length: *mut SIZE) -> iERR;
}
extern "C" {
pub fn ion_reader_read_lob_bytes(
hreader: hREADER,
p_buf: *mut BYTE,
buf_max: SIZE,
p_length: *mut SIZE,
) -> iERR;
}
extern "C" {
pub fn ion_reader_read_lob_partial_bytes(
hreader: hREADER,
p_buf: *mut BYTE,
buf_max: SIZE,
p_length: *mut SIZE,
) -> iERR;
}
extern "C" {
pub fn ion_reader_get_position(
hreader: hREADER,
p_bytes: *mut i64,
p_line: *mut i32,
p_offset: *mut i32,
) -> iERR;
}
extern "C" {
#[doc = " Closes a reader and releases associated memory. The caller is responsible"]
#[doc = " for releasing the underlying buffer (if any). After calling this method"]
#[doc = " the given handle will no longer be value."]
#[doc = ""]
#[doc = " @param hreader must be a valid handle."]
pub fn ion_reader_close(hreader: hREADER) -> iERR;
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct _ion_writer_options {
pub output_as_binary: BOOL,
#[doc = " On text output, this escapes non-ascii characters. So the output file is pure ascii, only valid for text output"]
#[doc = ""]
pub escape_all_non_ascii: BOOL,
#[doc = " Turns on pretty printing, only valid for text output"]
#[doc = ""]
pub pretty_print: BOOL,
#[doc = " Uses tabs for indenting instead of spaces"]
#[doc = ""]
pub indent_with_tabs: BOOL,
#[doc = " Sets the default indent amount (default is 2)"]
#[doc = ""]
pub indent_size: SIZE,
#[doc = " Puts \"small\" containers on a single line instead of putting all values on separate lines"]
#[doc = ""]
pub small_containers_in_line: BOOL,
#[doc = " Turns off the otherwise automatic insertion of system values (like symbol tables)"]
#[doc = ""]
pub supress_system_values: BOOL,
#[doc = " Turns on very active flushing of the internal streams (text only)"]
#[doc = ""]
pub flush_every_value: BOOL,
#[doc = " The max container depth defaults to 10"]
#[doc = ""]
pub max_container_depth: SIZE,
#[doc = " The max number of annotations on 1 value, defaults to 10"]
pub max_annotation_count: SIZE,
#[doc = " The temp buffer is used to hold temp strings (etc) default is 1024"]
#[doc = ""]
pub temp_buffer_size: SIZE,
#[doc = " memory is allocated in pages owned by the primary entities it's default size is 4096"]
#[doc = ""]
pub allocation_page_size: SIZE,
#[doc = " Handle to catalog of shared symbol tables for the writer to use"]
#[doc = ""]
pub pcatalog: *mut ION_CATALOG,
#[doc = " An ordered list of ION_SYMBOL_TABLE_IMPORT that the writer will import into each new local"]
#[doc = " symbol table context. Should be initialized by calling `ion_writer_options_initialize_shared_imports`,"]
#[doc = " populated by calling `ion_writer_options_add_shared_imports` and/or"]
#[doc = " `ion_writer_options_add_shared_imports_symbol_tables`, and freed by calling"]
#[doc = " `ion_writer_options_close_shared_imports`."]
#[doc = " NOTE: the system symbol table is always used as the first import; it need not be provided here."]
pub encoding_psymbol_table: ION_COLLECTION,
#[doc = " Handle to the decNumber context for the writer to use. This allows configuration of the maximum number of"]
#[doc = " decimal digits, decimal exponent range, etc. See decContextDefault in decContext.h for simple initialization."]
#[doc = ""]
#[doc = " If NULL, the writer will initialize its decimal context by calling decContextDefault with the DEC_INIT_DECQUAD"]
#[doc = " option, which results in a maximum of 34 decimal digits and an exponent range of [-6143, 6144]."]
#[doc = ""]
#[doc = " Note that up to 34 digits of precision will always be supported, even if configured to be less than 34."]
pub decimal_context: *mut decContext,
}
#[test]
fn bindgen_test_layout__ion_writer_options() {
assert_eq!(
::std::mem::size_of::<_ion_writer_options>(),
104usize,
concat!("Size of: ", stringify!(_ion_writer_options))
);
assert_eq!(
::std::mem::align_of::<_ion_writer_options>(),
8usize,
concat!("Alignment of ", stringify!(_ion_writer_options))
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<_ion_writer_options>())).output_as_binary as *const _ as usize
},
0usize,
concat!(
"Offset of field: ",
stringify!(_ion_writer_options),
"::",
stringify!(output_as_binary)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<_ion_writer_options>())).escape_all_non_ascii as *const _
as usize
},
4usize,
concat!(
"Offset of field: ",
stringify!(_ion_writer_options),
"::",
stringify!(escape_all_non_ascii)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<_ion_writer_options>())).pretty_print as *const _ as usize
},
8usize,
concat!(
"Offset of field: ",
stringify!(_ion_writer_options),
"::",
stringify!(pretty_print)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<_ion_writer_options>())).indent_with_tabs as *const _ as usize
},
12usize,
concat!(
"Offset of field: ",
stringify!(_ion_writer_options),
"::",
stringify!(indent_with_tabs)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_ion_writer_options>())).indent_size as *const _ as usize },
16usize,
concat!(
"Offset of field: ",
stringify!(_ion_writer_options),
"::",
stringify!(indent_size)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<_ion_writer_options>())).small_containers_in_line as *const _
as usize
},
20usize,
concat!(
"Offset of field: ",
stringify!(_ion_writer_options),
"::",
stringify!(small_containers_in_line)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<_ion_writer_options>())).supress_system_values as *const _
as usize
},
24usize,
concat!(
"Offset of field: ",
stringify!(_ion_writer_options),
"::",
stringify!(supress_system_values)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<_ion_writer_options>())).flush_every_value as *const _ as usize
},
28usize,
concat!(
"Offset of field: ",
stringify!(_ion_writer_options),
"::",
stringify!(flush_every_value)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<_ion_writer_options>())).max_container_depth as *const _ as usize
},
32usize,
concat!(
"Offset of field: ",
stringify!(_ion_writer_options),
"::",
stringify!(max_container_depth)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<_ion_writer_options>())).max_annotation_count as *const _
as usize
},
36usize,
concat!(
"Offset of field: ",
stringify!(_ion_writer_options),
"::",
stringify!(max_annotation_count)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<_ion_writer_options>())).temp_buffer_size as *const _ as usize
},
40usize,
concat!(
"Offset of field: ",
stringify!(_ion_writer_options),
"::",
stringify!(temp_buffer_size)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<_ion_writer_options>())).allocation_page_size as *const _
as usize
},
44usize,
concat!(
"Offset of field: ",
stringify!(_ion_writer_options),
"::",
stringify!(allocation_page_size)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_ion_writer_options>())).pcatalog as *const _ as usize },
48usize,
concat!(
"Offset of field: ",
stringify!(_ion_writer_options),
"::",
stringify!(pcatalog)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<_ion_writer_options>())).encoding_psymbol_table as *const _
as usize
},
56usize,
concat!(
"Offset of field: ",
stringify!(_ion_writer_options),
"::",
stringify!(encoding_psymbol_table)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<_ion_writer_options>())).decimal_context as *const _ as usize
},
96usize,
concat!(
"Offset of field: ",
stringify!(_ion_writer_options),
"::",
stringify!(decimal_context)
)
);
}
impl Default for _ion_writer_options {
fn default() -> Self {
unsafe { ::std::mem::zeroed() }
}
}
pub type ION_WRITER_OPTIONS = _ion_writer_options;
extern "C" {
#[doc = " Initializes the options' imports list. This must be done before calling `ion_writer_options_add_*`."]
#[doc = " NOTE: This does NOT need to be called if the writer does not need to use shared imports."]
#[doc = " @param options - The writer options containing the imports list to initialize."]
pub fn ion_writer_options_initialize_shared_imports(options: *mut ION_WRITER_OPTIONS) -> iERR;
}
extern "C" {
#[doc = " Adds the imports from the given collection of ION_SYMBOL_TABLE_IMPORT to the options' imports list."]
#[doc = " `ion_writer_options_initialize_shared_imports` must have been called first. The given collection must not contain"]
#[doc = " a system symbol table."]
pub fn ion_writer_options_add_shared_imports(
options: *mut ION_WRITER_OPTIONS,
imports: *mut ION_COLLECTION,
) -> iERR;
}
extern "C" {
#[doc = " Adds the given array of ION_SYMBOL_TABLE (which must be shared symbol tables) to the options' imports list."]
#[doc = " `ion_writer_options_initialize_shared_imports` must have been called first. The given array must not contain"]
#[doc = " a system symbol table."]
pub fn ion_writer_options_add_shared_imports_symbol_tables(
options: *mut ION_WRITER_OPTIONS,
imports: *mut *mut ION_SYMBOL_TABLE,
imports_count: SIZE,
) -> iERR;
}
extern "C" {
#[doc = " Frees the options' imports list. This must be done once the options are no longer needed, and only if"]
#[doc = " `ion_writer_options_initialize_shared_imports` was called."]
pub fn ion_writer_options_close_shared_imports(options: *mut ION_WRITER_OPTIONS) -> iERR;
}
extern "C" {
#[doc = " Ion Writer interfaces. Takes a byte buffer and length which"]
#[doc = " will contain the text or binary content, returns handle to a writer."]
#[doc = " @param p_hwriter"]
#[doc = " @param buffer Byte buffer, allocated and provided by caller."]
#[doc = " @param buf_length size of the buffer (0 or greater). If the buffer is not big enough, ion_write"]
#[doc = " operation will return IERR_EOF rather than IERR_OK."]
#[doc = " @param p_option writer configuration object."]
pub fn ion_writer_open_buffer(
p_hwriter: *mut hWRITER,
buffer: *mut BYTE,
buf_length: SIZE,
p_options: *mut ION_WRITER_OPTIONS,
) -> iERR;
}
extern "C" {
#[doc = " Open stream to write ion data."]
#[doc = " @param p_hwriter"]
#[doc = " @param fn_block_handler User provided function to write from handler_state buffer to file,"]
#[doc = " @param handler_state Related to write buffer. ion_writer will write to the buffer provided by the handler_state,"]
#[doc = " fn_block_handler will write the buffer to file."]
#[doc = " @param p_options writer configuration object."]
#[doc = " @see ion_reader_open_stream"]
#[doc = " @see ion_writer_open_buffer"]
pub fn ion_writer_open_stream(
p_hwriter: *mut hWRITER,
fn_output_handler: ION_STREAM_HANDLER,
handler_state: *mut ::std::os::raw::c_void,
p_options: *mut ION_WRITER_OPTIONS,
) -> iERR;
}
extern "C" {
pub fn ion_writer_open(
p_hwriter: *mut hWRITER,
p_stream: *mut ION_STREAM,
p_options: *mut ION_WRITER_OPTIONS,
) -> iERR;
}
extern "C" {
pub fn ion_writer_get_depth(hwriter: hWRITER, p_depth: *mut SIZE) -> iERR;
}
extern "C" {
pub fn ion_writer_set_catalog(hwriter: hWRITER, hcatalog: hCATALOG) -> iERR;
}
extern "C" {
pub fn ion_writer_get_catalog(hwriter: hWRITER, p_hcatalog: *mut hCATALOG) -> iERR;
}
extern "C" {
#[doc = " Sets the writer's symbol table."]
#[doc = ""]
#[doc = " If the writer's current symbol table context must be serialized, forces the writer to finish and flush its current"]
#[doc = " symbol table context (with the same side-effects as `ion_writer_finish`) first. If the given symbol table is a shared"]
#[doc = " symbol table, a new local symbol table that imports that shared symbol table is created. Raises an error if a"]
#[doc = " manually-written symbol table is in progress or if the writer is not at the top level."]
pub fn ion_writer_set_symbol_table(hwriter: hWRITER, hsymtab: hSYMTAB) -> iERR;
}
extern "C" {
pub fn ion_writer_get_symbol_table(hwriter: hWRITER, p_hsymtab: *mut hSYMTAB) -> iERR;
}
extern "C" {
#[doc = " Adds the given list of imports to the writer's list of imports. These imports will only be used in the writer's"]
#[doc = " current symbol table context. To configure the writer to use the same list of imports for each new symbol table"]
#[doc = " context, convey that list of imports through ION_WRITER_OPTIONS."]
#[doc = ""]
#[doc = " If the writer's current symbol table context must be serialized, forces the writer to finish and flush its current"]
#[doc = " symbol table context (with the same side-effects as `ion_writer_finish`) first. A new symbol table context is then"]
#[doc = " created, starting with any imports specified in ION_WRITER_OPTIONS, and followed by the list of imports given to this"]
#[doc = " function."]
#[doc = ""]
#[doc = " This function may be called multiple times in succession without changing the current symbol table context as long as"]
#[doc = " no values have been written in between calls; in this case, this function appends to the writer's list of imports."]
#[doc = ""]
#[doc = " Raises an error if a manually-written symbol table is in progress, if the writer is not at the top level, or if the"]
#[doc = " writer has pending annotations."]
pub fn ion_writer_add_imported_tables(hwriter: hWRITER, imports: *mut ION_COLLECTION) -> iERR;
}
extern "C" {
#[doc = " Sets the writer's current field name. Only valid if the writer is currently in a struct. It is the caller's"]
#[doc = " responsibility to keep `name` in scope until the writer's next value is written."]
pub fn ion_writer_write_field_name(hwriter: hWRITER, name: iSTRING) -> iERR;
}
extern "C" {
#[doc = " Sets the writer's current field name from the given Ion symbol. Only valid if the writer is currently in a struct."]
#[doc = " It is the caller's responsibility to keep `field_name` in scope until the writer's next value is written."]
pub fn ion_writer_write_field_name_symbol(
hwriter: hWRITER,
field_name: *mut ION_SYMBOL,
) -> iERR;
}
extern "C" {
pub fn ion_writer_clear_field_name(hwriter: hWRITER) -> iERR;
}
extern "C" {
pub fn ion_writer_add_annotation(hwriter: hWRITER, annotation: iSTRING) -> iERR;
}
extern "C" {
pub fn ion_writer_add_annotation_symbol(hwriter: hWRITER, annotation: *mut ION_SYMBOL) -> iERR;
}
extern "C" {
pub fn ion_writer_write_annotations(
hwriter: hWRITER,
p_annotations: iSTRING,
count: SIZE,
) -> iERR;
}
extern "C" {
pub fn ion_writer_write_annotation_symbols(
hwriter: hWRITER,
annotations: *mut ION_SYMBOL,
count: SIZE,
) -> iERR;
}
extern "C" {
pub fn ion_writer_clear_annotations(hwriter: hWRITER) -> iERR;
}
extern "C" {
pub fn ion_writer_write_null(hwriter: hWRITER) -> iERR;
}
extern "C" {
pub fn ion_writer_write_typed_null(hwriter: hWRITER, type_: ION_TYPE) -> iERR;
}
extern "C" {
pub fn ion_writer_write_bool(hwriter: hWRITER, value: BOOL) -> iERR;
}
extern "C" {
pub fn ion_writer_write_int(hwriter: hWRITER, value: ::std::os::raw::c_int) -> iERR;
}
extern "C" {
pub fn ion_writer_write_int32(hwriter: hWRITER, value: i32) -> iERR;
}
extern "C" {
pub fn ion_writer_write_int64(hwriter: hWRITER, value: i64) -> iERR;
}
extern "C" {
pub fn ion_writer_write_long(hwriter: hWRITER, value: ::std::os::raw::c_long) -> iERR;
}
extern "C" {
pub fn ion_writer_write_ion_int(hwriter: hWRITER, value: *mut ION_INT) -> iERR;
}
extern "C" {
pub fn ion_writer_write_double(hwriter: hWRITER, value: f64) -> iERR;
}
extern "C" {
#[doc = " @deprecated use of decQuads directly is deprecated. ION_DECIMAL should be used. See `ion_writer_write_ion_decimal`."]
pub fn ion_writer_write_decimal(hwriter: hWRITER, value: *mut decQuad) -> iERR;
}
extern "C" {
pub fn ion_writer_write_ion_decimal(hwriter: hWRITER, value: *mut ION_DECIMAL) -> iERR;
}
extern "C" {
pub fn ion_writer_write_timestamp(hwriter: hWRITER, value: iTIMESTAMP) -> iERR;
}
extern "C" {
pub fn ion_writer_write_symbol(hwriter: hWRITER, p_value: iSTRING) -> iERR;
}
extern "C" {
pub fn ion_writer_write_ion_symbol(hwriter: hWRITER, symbol: *mut ION_SYMBOL) -> iERR;
}
extern "C" {
pub fn ion_writer_write_string(hwriter: hWRITER, p_value: iSTRING) -> iERR;
}
extern "C" {
pub fn ion_writer_write_clob(hwriter: hWRITER, p_buf: *mut BYTE, length: SIZE) -> iERR;
}
extern "C" {
pub fn ion_writer_write_blob(hwriter: hWRITER, p_buf: *mut BYTE, length: SIZE) -> iERR;
}
extern "C" {
pub fn ion_writer_start_lob(hwriter: hWRITER, lob_type: ION_TYPE) -> iERR;
}
extern "C" {
pub fn ion_writer_append_lob(hwriter: hWRITER, p_buf: *mut BYTE, length: SIZE) -> iERR;
}
extern "C" {
pub fn ion_writer_finish_lob(hwriter: hWRITER) -> iERR;
}
extern "C" {
pub fn ion_writer_start_container(hwriter: hWRITER, container_type: ION_TYPE) -> iERR;
}
extern "C" {
pub fn ion_writer_finish_container(hwriter: hWRITER) -> iERR;
}
extern "C" {
pub fn ion_writer_write_one_value(hwriter: hWRITER, hreader: hREADER) -> iERR;
}
extern "C" {
pub fn ion_writer_write_all_values(hwriter: hWRITER, hreader: hREADER) -> iERR;
}
extern "C" {
#[doc = " Flushes pending bytes without forcing an Ion Version Marker or ending the current symbol table context."]
#[doc = " If writer was created using open_stream, also flushes write buffer to stream. If any value is in-progress, flushing"]
#[doc = " any writer is an error."]
#[doc = " @param p_bytes_flushed - the number of bytes written into the buffer/stream."]
pub fn ion_writer_flush(hwriter: hWRITER, p_bytes_flushed: *mut SIZE) -> iERR;
}
extern "C" {
#[doc = " Flushes pending bytes, ending the current symbol table context and forcing an Ion Version Marker if the writer"]
#[doc = " continues writing to the stream. If writer was created using open_stream, also flushes write buffer to stream."]
#[doc = " If any value is in-progress, finishing any writer is an error."]
#[doc = " @param p_bytes_flushed - the number of bytes written into the buffer/stream."]
pub fn ion_writer_finish(hwriter: hWRITER, p_bytes_flushed: *mut SIZE) -> iERR;
}
extern "C" {
#[doc = " Finishes the writer, frees the writer's associated resources, and finally frees the writer itself. The writer may"]
#[doc = " not continue writing to the stream after this function is called. If any value is in-progress, closing any writer"]
#[doc = " raises an error, but still frees the writer and any associated memory."]
pub fn ion_writer_close(hwriter: hWRITER) -> iERR;
}
extern "C" {
#[doc = " Allocates a new catalog with itself as its memory owner. Must be freed using `ion_catalog_close`."]
#[doc = " @param p_hcatalog - Pointer to a handle to the newly-allocated catalog."]
pub fn ion_catalog_open(p_hcatalog: *mut hCATALOG) -> iERR;
}
extern "C" {
#[doc = " Allocates a new catalog with the given owner as its memory owner."]
#[doc = " @param p_hcatalog - Pointer to a handle to the newly-allocated catalog."]
#[doc = " @param owner - Handle to the new catalog's memory owner. If NULL, the resulting catalog is its own memory owner and"]
#[doc = " must be freed using `ion_catalog_close`."]
pub fn ion_catalog_open_with_owner(p_hcatalog: *mut hCATALOG, owner: hOWNER) -> iERR;
}
extern "C" {
pub fn ion_catalog_get_symbol_table_count(hcatalog: hCATALOG, p_count: *mut i32) -> iERR;
}
extern "C" {
pub fn ion_catalog_add_symbol_table(hcatalog: hCATALOG, symtab: hSYMTAB) -> iERR;
}
extern "C" {
pub fn ion_catalog_find_symbol_table(
hcatalog: hCATALOG,
name: iSTRING,
version: ::std::os::raw::c_long,
p_symtab: *mut hSYMTAB,
) -> iERR;
}
extern "C" {
pub fn ion_catalog_find_best_match(
hcatalog: hCATALOG,
name: iSTRING,
version: ::std::os::raw::c_long,
p_symtab: *mut hSYMTAB,
) -> iERR;
}
extern "C" {
pub fn ion_catalog_release_symbol_table(hcatalog: hCATALOG, symtab: hSYMTAB) -> iERR;
}
extern "C" {
#[doc = " If the given catalog is its own memory owner, its memory and everything it owns is freed. If the given catalog has an"]
#[doc = " external owner and that owner has not been freed, this does nothing; this catalog will be freed when its memory owner"]
#[doc = " is freed. If the given symbol table has an external owner which has been freed, the behavior of this function is"]
#[doc = " undefined."]
pub fn ion_catalog_close(hcatalog: hCATALOG) -> iERR;
}
extern "C" {
pub static mut g_ion_debug_tracing: BOOL;
}
extern "C" {
pub fn ion_debug_has_tracing() -> BOOL;
}
extern "C" {
pub fn ion_debug_set_tracing(state: BOOL);
}
extern "C" {
pub fn _ion_decimal_number_alloc(
owner: *mut ::std::os::raw::c_void,
decimal_digits: SIZE,
p_number: *mut *mut decNumber,
) -> iERR;
}
extern "C" {
pub fn _ion_decimal_from_string_helper(
str_: *const ::std::os::raw::c_char,
context: *mut decContext,
owner: hOWNER,
p_quad: *mut decQuad,
p_num: *mut *mut decNumber,
) -> iERR;
}
extern "C" {
pub fn _ion_decimal_to_string_quad_helper(
value: *const decQuad,
p_string: *mut ::std::os::raw::c_char,
) -> iERR;
}
extern "C" {
pub fn _ion_decimal_to_string_number_helper(
value: *const decNumber,
p_string: *mut ::std::os::raw::c_char,
) -> iERR;
}
pub type __builtin_va_list = [__va_list_tag; 1usize];
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct __va_list_tag {
pub gp_offset: ::std::os::raw::c_uint,
pub fp_offset: ::std::os::raw::c_uint,
pub overflow_arg_area: *mut ::std::os::raw::c_void,
pub reg_save_area: *mut ::std::os::raw::c_void,
}
#[test]
fn bindgen_test_layout___va_list_tag() {
assert_eq!(
::std::mem::size_of::<__va_list_tag>(),
24usize,
concat!("Size of: ", stringify!(__va_list_tag))
);
assert_eq!(
::std::mem::align_of::<__va_list_tag>(),
8usize,
concat!("Alignment of ", stringify!(__va_list_tag))
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<__va_list_tag>())).gp_offset as *const _ as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(__va_list_tag),
"::",
stringify!(gp_offset)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<__va_list_tag>())).fp_offset as *const _ as usize },
4usize,
concat!(
"Offset of field: ",
stringify!(__va_list_tag),
"::",
stringify!(fp_offset)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<__va_list_tag>())).overflow_arg_area as *const _ as usize },
8usize,
concat!(
"Offset of field: ",
stringify!(__va_list_tag),
"::",
stringify!(overflow_arg_area)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<__va_list_tag>())).reg_save_area as *const _ as usize },
16usize,
concat!(
"Offset of field: ",
stringify!(__va_list_tag),
"::",
stringify!(reg_save_area)
)
);
}
impl Default for __va_list_tag {
fn default() -> Self {
unsafe { ::std::mem::zeroed() }
}
}
#[repr(C)]
#[derive(Debug, Default, Copy, Clone)]
pub struct __locale_data {
pub _address: u8,
}