/* automatically generated by rust-bindgen */

pub const _STDIO_H : u32 = 1 ; pub const _FEATURES_H : u32 = 1 ; pub const _DEFAULT_SOURCE : u32 = 1 ; 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 _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 __STDC_NO_THREADS__ : u32 = 1 ; pub const __GNU_LIBRARY__ : u32 = 6 ; pub const __GLIBC__ : u32 = 2 ; pub const __GLIBC_MINOR__ : u32 = 27 ; 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 __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_FUNCS_EXT : u32 = 0 ; pub const __GLIBC_USE_IEC_60559_TYPES_EXT : u32 = 0 ; pub const _BITS_TYPES_H : u32 = 1 ; 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 __FD_SETSIZE : u32 = 1024 ; pub const ____FILE_defined : u32 = 1 ; pub const __FILE_defined : u32 = 1 ; pub const _BITS_LIBIO_H : u32 = 1 ; pub const _BITS_G_CONFIG_H : u32 = 1 ; pub const ____mbstate_t_defined : u32 = 1 ; pub const _G_HAVE_MMAP : u32 = 1 ; pub const _G_HAVE_MREMAP : u32 = 1 ; pub const _G_IO_IO_FILE_VERSION : u32 = 131073 ; pub const _G_BUFSIZ : u32 = 8192 ; pub const _IO_BUFSIZ : u32 = 8192 ; pub const __GNUC_VA_LIST : u32 = 1 ; pub const _IO_UNIFIED_JUMPTABLES : u32 = 1 ; pub const EOF : i32 = -1 ; pub const _IOS_INPUT : u32 = 1 ; pub const _IOS_OUTPUT : u32 = 2 ; pub const _IOS_ATEND : u32 = 4 ; pub const _IOS_APPEND : u32 = 8 ; pub const _IOS_TRUNC : u32 = 16 ; pub const _IOS_NOCREATE : u32 = 32 ; pub const _IOS_NOREPLACE : u32 = 64 ; pub const _IOS_BIN : u32 = 128 ; pub const _IO_MAGIC : u32 = 4222418944 ; pub const _OLD_STDIO_MAGIC : u32 = 4206624768 ; pub const _IO_MAGIC_MASK : u32 = 4294901760 ; pub const _IO_USER_BUF : u32 = 1 ; pub const _IO_UNBUFFERED : u32 = 2 ; pub const _IO_NO_READS : u32 = 4 ; pub const _IO_NO_WRITES : u32 = 8 ; pub const _IO_EOF_SEEN : u32 = 16 ; pub const _IO_ERR_SEEN : u32 = 32 ; pub const _IO_DELETE_DONT_CLOSE : u32 = 64 ; pub const _IO_LINKED : u32 = 128 ; pub const _IO_IN_BACKUP : u32 = 256 ; pub const _IO_LINE_BUF : u32 = 512 ; pub const _IO_TIED_PUT_GET : u32 = 1024 ; pub const _IO_CURRENTLY_PUTTING : u32 = 2048 ; pub const _IO_IS_APPENDING : u32 = 4096 ; pub const _IO_IS_FILEBUF : u32 = 8192 ; pub const _IO_BAD_SEEN : u32 = 16384 ; pub const _IO_USER_LOCK : u32 = 32768 ; pub const _IO_FLAGS2_MMAP : u32 = 1 ; pub const _IO_FLAGS2_NOTCANCEL : u32 = 2 ; pub const _IO_FLAGS2_USER_WBUF : u32 = 8 ; pub const _IO_SKIPWS : u32 = 1 ; pub const _IO_LEFT : u32 = 2 ; pub const _IO_RIGHT : u32 = 4 ; pub const _IO_INTERNAL : u32 = 8 ; pub const _IO_DEC : u32 = 16 ; pub const _IO_OCT : u32 = 32 ; pub const _IO_HEX : u32 = 64 ; pub const _IO_SHOWBASE : u32 = 128 ; pub const _IO_SHOWPOINT : u32 = 256 ; pub const _IO_UPPERCASE : u32 = 512 ; pub const _IO_SHOWPOS : u32 = 1024 ; pub const _IO_SCIENTIFIC : u32 = 2048 ; pub const _IO_FIXED : u32 = 4096 ; pub const _IO_UNITBUF : u32 = 8192 ; pub const _IO_STDIO : u32 = 16384 ; pub const _IO_DONT_CLOSE : u32 = 32768 ; pub const _IO_BOOLALPHA : u32 = 65536 ; pub const _IOFBF : u32 = 0 ; pub const _IOLBF : u32 = 1 ; pub const _IONBF : u32 = 2 ; pub const BUFSIZ : u32 = 8192 ; 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 _STDINT_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 CMARK_GFM_VERSION : u32 = 1900544 ; pub const CMARK_GFM_VERSION_STRING : & 'static [ u8 ; 13usize ] = b"0.29.0.gfm.0\0" ; pub const CMARK_NODE_TYPE_PRESENT : u32 = 32768 ; pub const CMARK_NODE_TYPE_BLOCK : u32 = 32768 ; pub const CMARK_NODE_TYPE_INLINE : u32 = 49152 ; pub const CMARK_NODE_TYPE_MASK : u32 = 49152 ; pub const CMARK_NODE_VALUE_MASK : u32 = 16383 ; pub const CMARK_OPT_DEFAULT : u32 = 0 ; pub const CMARK_OPT_SOURCEPOS : u32 = 2 ; pub const CMARK_OPT_HARDBREAKS : u32 = 4 ; pub const CMARK_OPT_SAFE : u32 = 8 ; pub const CMARK_OPT_UNSAFE : u32 = 131072 ; pub const CMARK_OPT_NOBREAKS : u32 = 16 ; pub const CMARK_OPT_NORMALIZE : u32 = 256 ; pub const CMARK_OPT_VALIDATE_UTF8 : u32 = 512 ; pub const CMARK_OPT_SMART : u32 = 1024 ; pub const CMARK_OPT_GITHUB_PRE_LANG : u32 = 2048 ; pub const CMARK_OPT_LIBERAL_HTML_TAG : u32 = 4096 ; pub const CMARK_OPT_FOOTNOTES : u32 = 8192 ; pub const CMARK_OPT_STRIKETHROUGH_DOUBLE_TILDE : u32 = 16384 ; pub const CMARK_OPT_TABLE_PREFER_STYLE_ATTRIBUTES : u32 = 32768 ; pub const CMARK_OPT_FULL_INFO_STRING : u32 = 65536 ; 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 __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 , 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 __FILE = _IO_FILE ; pub type FILE = _IO_FILE ; # [ 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 ] , _bindgen_union_align : u32 , } # [ 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 ) ) ) ; } # [ 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 ) ) ) ; } # [ 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 ) ) ) ; } # [ 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 ) ) ) ; } pub type va_list = __builtin_va_list ; pub type __gnuc_va_list = __builtin_va_list ; # [ repr ( C ) ] # [ derive ( Debug , Copy , Clone ) ] pub struct _IO_jump_t { _unused : [ u8 ; 0 ] , } pub type _IO_lock_t = :: std :: os :: raw :: c_void ; # [ repr ( C ) ] # [ derive ( Debug , Copy , Clone ) ] pub struct _IO_marker { pub _next : * mut _IO_marker , pub _sbuf : * mut _IO_FILE , pub _pos : :: std :: os :: raw :: c_int , } # [ test ] fn bindgen_test_layout__IO_marker ( ) { assert_eq ! ( :: std :: mem :: size_of :: < _IO_marker > ( ) , 24usize , concat ! ( "Size of: " , stringify ! ( _IO_marker ) ) ) ; assert_eq ! ( :: std :: mem :: align_of :: < _IO_marker > ( ) , 8usize , concat ! ( "Alignment of " , stringify ! ( _IO_marker ) ) ) ; assert_eq ! ( unsafe { & ( * ( :: std :: ptr :: null :: < _IO_marker > ( ) ) ) . _next as * const _ as usize } , 0usize , concat ! ( "Offset of field: " , stringify ! ( _IO_marker ) , "::" , stringify ! ( _next ) ) ) ; assert_eq ! ( unsafe { & ( * ( :: std :: ptr :: null :: < _IO_marker > ( ) ) ) . _sbuf as * const _ as usize } , 8usize , concat ! ( "Offset of field: " , stringify ! ( _IO_marker ) , "::" , stringify ! ( _sbuf ) ) ) ; assert_eq ! ( unsafe { & ( * ( :: std :: ptr :: null :: < _IO_marker > ( ) ) ) . _pos as * const _ as usize } , 16usize , concat ! ( "Offset of field: " , stringify ! ( _IO_marker ) , "::" , stringify ! ( _pos ) ) ) ; } pub const __codecvt_result___codecvt_ok : __codecvt_result = 0 ; pub const __codecvt_result___codecvt_partial : __codecvt_result = 1 ; pub const __codecvt_result___codecvt_error : __codecvt_result = 2 ; pub const __codecvt_result___codecvt_noconv : __codecvt_result = 3 ; pub type __codecvt_result = u32 ; # [ 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 __pad1 : * mut :: std :: os :: raw :: c_void , pub __pad2 : * mut :: std :: os :: raw :: c_void , pub __pad3 : * mut :: std :: os :: raw :: c_void , pub __pad4 : * mut :: std :: os :: raw :: c_void , pub __pad5 : usize , 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 > ( ) ) ) . __pad1 as * const _ as usize } , 152usize , concat ! ( "Offset of field: " , stringify ! ( _IO_FILE ) , "::" , stringify ! ( __pad1 ) ) ) ; assert_eq ! ( unsafe { & ( * ( :: std :: ptr :: null :: < _IO_FILE > ( ) ) ) . __pad2 as * const _ as usize } , 160usize , concat ! ( "Offset of field: " , stringify ! ( _IO_FILE ) , "::" , stringify ! ( __pad2 ) ) ) ; assert_eq ! ( unsafe { & ( * ( :: std :: ptr :: null :: < _IO_FILE > ( ) ) ) . __pad3 as * const _ as usize } , 168usize , concat ! ( "Offset of field: " , stringify ! ( _IO_FILE ) , "::" , stringify ! ( __pad3 ) ) ) ; assert_eq ! ( unsafe { & ( * ( :: std :: ptr :: null :: < _IO_FILE > ( ) ) ) . __pad4 as * const _ as usize } , 176usize , concat ! ( "Offset of field: " , stringify ! ( _IO_FILE ) , "::" , stringify ! ( __pad4 ) ) ) ; 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 ) ) ) ; } # [ repr ( C ) ] # [ derive ( Debug , Copy , Clone ) ] pub struct _IO_FILE_plus { _unused : [ u8 ; 0 ] , } extern "C" { pub static mut _IO_2_1_stdin_ : _IO_FILE_plus ; } extern "C" { pub static mut _IO_2_1_stdout_ : _IO_FILE_plus ; } extern "C" { pub static mut _IO_2_1_stderr_ : _IO_FILE_plus ; } pub type __io_read_fn = :: std :: option :: Option < unsafe extern "C" fn ( __cookie : * mut :: std :: os :: raw :: c_void , __buf : * mut :: std :: os :: raw :: c_char , __nbytes : usize ) -> __ssize_t > ; pub type __io_write_fn = :: std :: option :: Option < unsafe extern "C" fn ( __cookie : * mut :: std :: os :: raw :: c_void , __buf : * const :: std :: os :: raw :: c_char , __n : usize ) -> __ssize_t > ; pub type __io_seek_fn = :: std :: option :: Option < unsafe extern "C" fn ( __cookie : * mut :: std :: os :: raw :: c_void , __pos : * mut __off64_t , __w : :: std :: os :: raw :: c_int ) -> :: std :: os :: raw :: c_int > ; pub type __io_close_fn = :: std :: option :: Option < unsafe extern "C" fn ( __cookie : * mut :: std :: os :: raw :: c_void ) -> :: std :: os :: raw :: c_int > ; extern "C" { pub fn __underflow ( arg1 : * mut _IO_FILE ) -> :: std :: os :: raw :: c_int ; } extern "C" { pub fn __uflow ( arg1 : * mut _IO_FILE ) -> :: std :: os :: raw :: c_int ; } extern "C" { pub fn __overflow ( arg1 : * mut _IO_FILE , arg2 : :: std :: os :: raw :: c_int ) -> :: std :: os :: raw :: c_int ; } extern "C" { pub fn _IO_getc ( __fp : * mut _IO_FILE ) -> :: std :: os :: raw :: c_int ; } extern "C" { pub fn _IO_putc ( __c : :: std :: os :: raw :: c_int , __fp : * mut _IO_FILE ) -> :: std :: os :: raw :: c_int ; } extern "C" { pub fn _IO_feof ( __fp : * mut _IO_FILE ) -> :: std :: os :: raw :: c_int ; } extern "C" { pub fn _IO_ferror ( __fp : * mut _IO_FILE ) -> :: std :: os :: raw :: c_int ; } extern "C" { pub fn _IO_peekc_locked ( __fp : * mut _IO_FILE ) -> :: std :: os :: raw :: c_int ; } extern "C" { pub fn _IO_flockfile ( arg1 : * mut _IO_FILE ) ; } extern "C" { pub fn _IO_funlockfile ( arg1 : * mut _IO_FILE ) ; } extern "C" { pub fn _IO_ftrylockfile ( arg1 : * mut _IO_FILE ) -> :: std :: os :: raw :: c_int ; } extern "C" { pub fn _IO_vfscanf ( arg1 : * mut _IO_FILE , arg2 : * const :: std :: os :: raw :: c_char , arg3 : * mut __va_list_tag , arg4 : * mut :: std :: os :: raw :: c_int ) -> :: std :: os :: raw :: c_int ; } extern "C" { pub fn _IO_vfprintf ( arg1 : * mut _IO_FILE , arg2 : * const :: std :: os :: raw :: c_char , arg3 : * mut __va_list_tag ) -> :: std :: os :: raw :: c_int ; } extern "C" { pub fn _IO_padn ( arg1 : * mut _IO_FILE , arg2 : :: std :: os :: raw :: c_int , arg3 : __ssize_t ) -> __ssize_t ; } extern "C" { pub fn _IO_sgetn ( arg1 : * mut _IO_FILE , arg2 : * mut :: std :: os :: raw :: c_void , arg3 : usize ) -> usize ; } extern "C" { pub fn _IO_seekoff ( arg1 : * mut _IO_FILE , arg2 : __off64_t , arg3 : :: std :: os :: raw :: c_int , arg4 : :: std :: os :: raw :: c_int ) -> __off64_t ; } extern "C" { pub fn _IO_seekpos ( arg1 : * mut _IO_FILE , arg2 : __off64_t , arg3 : :: std :: os :: raw :: c_int ) -> __off64_t ; } extern "C" { pub fn _IO_free_backup_area ( arg1 : * mut _IO_FILE ) ; } pub type off_t = __off_t ; pub type fpos_t = _G_fpos_t ; extern "C" { pub static mut stdin : * mut _IO_FILE ; } extern "C" { pub static mut stdout : * mut _IO_FILE ; } extern "C" { pub static mut stderr : * mut _IO_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 : usize , __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 usize ) -> * 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 : usize ) -> :: std :: os :: raw :: c_int ; } extern "C" { pub fn setbuffer ( __stream : * mut FILE , __buf : * mut :: std :: os :: raw :: c_char , __size : usize ) ; } 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 usize , __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 usize , __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 usize , __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 : usize , __n : usize , __stream : * mut FILE ) -> usize ; } extern "C" { pub fn fwrite ( __ptr : * const :: std :: os :: raw :: c_void , __size : usize , __n : usize , __s : * mut FILE ) -> usize ; } extern "C" { pub fn fread_unlocked ( __ptr : * mut :: std :: os :: raw :: c_void , __size : usize , __n : usize , __stream : * mut FILE ) -> usize ; } extern "C" { pub fn fwrite_unlocked ( __ptr : * const :: std :: os :: raw :: c_void , __size : usize , __n : usize , __stream : * mut FILE ) -> usize ; } 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 ) ; } pub type int_least8_t = :: std :: os :: raw :: c_schar ; pub type int_least16_t = :: std :: os :: raw :: c_short ; pub type int_least32_t = :: std :: os :: raw :: c_int ; pub type int_least64_t = :: std :: os :: raw :: c_long ; pub type uint_least8_t = :: std :: os :: raw :: c_uchar ; pub type uint_least16_t = :: std :: os :: raw :: c_ushort ; pub type uint_least32_t = :: std :: os :: raw :: c_uint ; pub type uint_least64_t = :: std :: os :: raw :: c_ulong ; 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 ; extern "C" { # [ doc = " Convert 'text' (assumed to be a UTF-8 encoded string with length" ] # [ doc = " 'len') from CommonMark Markdown to HTML, returning a null-terminated," ] # [ doc = " UTF-8-encoded string. It is the caller's responsibility" ] # [ doc = " to free the returned buffer." ] pub fn cmark_markdown_to_html ( text : * const :: std :: os :: raw :: c_char , len : usize , options : :: std :: os :: raw :: c_int ) -> * mut :: std :: os :: raw :: c_char ; } pub const cmark_node_type_CMARK_NODE_NONE : cmark_node_type = 0 ; pub const cmark_node_type_CMARK_NODE_DOCUMENT : cmark_node_type = 32769 ; pub const cmark_node_type_CMARK_NODE_BLOCK_QUOTE : cmark_node_type = 32770 ; pub const cmark_node_type_CMARK_NODE_LIST : cmark_node_type = 32771 ; pub const cmark_node_type_CMARK_NODE_ITEM : cmark_node_type = 32772 ; pub const cmark_node_type_CMARK_NODE_CODE_BLOCK : cmark_node_type = 32773 ; pub const cmark_node_type_CMARK_NODE_HTML_BLOCK : cmark_node_type = 32774 ; pub const cmark_node_type_CMARK_NODE_CUSTOM_BLOCK : cmark_node_type = 32775 ; pub const cmark_node_type_CMARK_NODE_PARAGRAPH : cmark_node_type = 32776 ; pub const cmark_node_type_CMARK_NODE_HEADING : cmark_node_type = 32777 ; pub const cmark_node_type_CMARK_NODE_THEMATIC_BREAK : cmark_node_type = 32778 ; pub const cmark_node_type_CMARK_NODE_FOOTNOTE_DEFINITION : cmark_node_type = 32779 ; pub const cmark_node_type_CMARK_NODE_TEXT : cmark_node_type = 49153 ; pub const cmark_node_type_CMARK_NODE_SOFTBREAK : cmark_node_type = 49154 ; pub const cmark_node_type_CMARK_NODE_LINEBREAK : cmark_node_type = 49155 ; pub const cmark_node_type_CMARK_NODE_CODE : cmark_node_type = 49156 ; pub const cmark_node_type_CMARK_NODE_HTML_INLINE : cmark_node_type = 49157 ; pub const cmark_node_type_CMARK_NODE_CUSTOM_INLINE : cmark_node_type = 49158 ; pub const cmark_node_type_CMARK_NODE_EMPH : cmark_node_type = 49159 ; pub const cmark_node_type_CMARK_NODE_STRONG : cmark_node_type = 49160 ; pub const cmark_node_type_CMARK_NODE_LINK : cmark_node_type = 49161 ; pub const cmark_node_type_CMARK_NODE_IMAGE : cmark_node_type = 49162 ; pub const cmark_node_type_CMARK_NODE_FOOTNOTE_REFERENCE : cmark_node_type = 49163 ; pub type cmark_node_type = u32 ; extern "C" { pub static mut CMARK_NODE_LAST_BLOCK : cmark_node_type ; } extern "C" { pub static mut CMARK_NODE_LAST_INLINE : cmark_node_type ; } pub const cmark_list_type_CMARK_NO_LIST : cmark_list_type = 0 ; pub const cmark_list_type_CMARK_BULLET_LIST : cmark_list_type = 1 ; pub const cmark_list_type_CMARK_ORDERED_LIST : cmark_list_type = 2 ; pub type cmark_list_type = u32 ; pub const cmark_delim_type_CMARK_NO_DELIM : cmark_delim_type = 0 ; pub const cmark_delim_type_CMARK_PERIOD_DELIM : cmark_delim_type = 1 ; pub const cmark_delim_type_CMARK_PAREN_DELIM : cmark_delim_type = 2 ; pub type cmark_delim_type = u32 ; # [ repr ( C ) ] # [ derive ( Debug , Copy , Clone ) ] pub struct cmark_node { _unused : [ u8 ; 0 ] , } # [ repr ( C ) ] # [ derive ( Debug , Copy , Clone ) ] pub struct cmark_parser { _unused : [ u8 ; 0 ] , } # [ repr ( C ) ] # [ derive ( Debug , Copy , Clone ) ] pub struct cmark_iter { _unused : [ u8 ; 0 ] , } # [ repr ( C ) ] # [ derive ( Debug , Copy , Clone ) ] pub struct cmark_syntax_extension { _unused : [ u8 ; 0 ] , } # [ doc = " Defines the memory allocation functions to be used by CMark" ] # [ doc = " when parsing and allocating a document tree" ] # [ repr ( C ) ] # [ derive ( Debug , Copy , Clone ) ] pub struct cmark_mem { pub calloc : :: std :: option :: Option < unsafe extern "C" fn ( arg1 : usize , arg2 : usize ) -> * mut :: std :: os :: raw :: c_void > , pub realloc : :: std :: option :: Option < unsafe extern "C" fn ( arg1 : * mut :: std :: os :: raw :: c_void , arg2 : usize ) -> * mut :: std :: os :: raw :: c_void > , pub free : :: std :: option :: Option < unsafe extern "C" fn ( arg1 : * mut :: std :: os :: raw :: c_void ) > , } # [ test ] fn bindgen_test_layout_cmark_mem ( ) { assert_eq ! ( :: std :: mem :: size_of :: < cmark_mem > ( ) , 24usize , concat ! ( "Size of: " , stringify ! ( cmark_mem ) ) ) ; assert_eq ! ( :: std :: mem :: align_of :: < cmark_mem > ( ) , 8usize , concat ! ( "Alignment of " , stringify ! ( cmark_mem ) ) ) ; assert_eq ! ( unsafe { & ( * ( :: std :: ptr :: null :: < cmark_mem > ( ) ) ) . calloc as * const _ as usize } , 0usize , concat ! ( "Offset of field: " , stringify ! ( cmark_mem ) , "::" , stringify ! ( calloc ) ) ) ; assert_eq ! ( unsafe { & ( * ( :: std :: ptr :: null :: < cmark_mem > ( ) ) ) . realloc as * const _ as usize } , 8usize , concat ! ( "Offset of field: " , stringify ! ( cmark_mem ) , "::" , stringify ! ( realloc ) ) ) ; assert_eq ! ( unsafe { & ( * ( :: std :: ptr :: null :: < cmark_mem > ( ) ) ) . free as * const _ as usize } , 16usize , concat ! ( "Offset of field: " , stringify ! ( cmark_mem ) , "::" , stringify ! ( free ) ) ) ; } extern "C" { # [ doc = " The default memory allocator; uses the system's calloc," ] # [ doc = " realloc and free." ] pub fn cmark_get_default_mem_allocator ( ) -> * mut cmark_mem ; } extern "C" { # [ doc = " An arena allocator; uses system calloc to allocate large" ] # [ doc = " slabs of memory.  Memory in these slabs is not reused at all." ] pub fn cmark_get_arena_mem_allocator ( ) -> * mut cmark_mem ; } extern "C" { # [ doc = " Resets the arena allocator, quickly returning all used memory" ] # [ doc = " to the operating system." ] pub fn cmark_arena_reset ( ) ; } # [ doc = " Callback for freeing user data with a 'cmark_mem' context." ] pub type cmark_free_func = :: std :: option :: Option < unsafe extern "C" fn ( mem : * mut cmark_mem , user_data : * mut :: std :: os :: raw :: c_void ) > ; # [ doc = " A generic singly linked list." ] # [ repr ( C ) ] # [ derive ( Debug , Copy , Clone ) ] pub struct _cmark_llist { pub next : * mut _cmark_llist , pub data : * mut :: std :: os :: raw :: c_void , } # [ test ] fn bindgen_test_layout__cmark_llist ( ) { assert_eq ! ( :: std :: mem :: size_of :: < _cmark_llist > ( ) , 16usize , concat ! ( "Size of: " , stringify ! ( _cmark_llist ) ) ) ; assert_eq ! ( :: std :: mem :: align_of :: < _cmark_llist > ( ) , 8usize , concat ! ( "Alignment of " , stringify ! ( _cmark_llist ) ) ) ; assert_eq ! ( unsafe { & ( * ( :: std :: ptr :: null :: < _cmark_llist > ( ) ) ) . next as * const _ as usize } , 0usize , concat ! ( "Offset of field: " , stringify ! ( _cmark_llist ) , "::" , stringify ! ( next ) ) ) ; assert_eq ! ( unsafe { & ( * ( :: std :: ptr :: null :: < _cmark_llist > ( ) ) ) . data as * const _ as usize } , 8usize , concat ! ( "Offset of field: " , stringify ! ( _cmark_llist ) , "::" , stringify ! ( data ) ) ) ; } pub type cmark_llist = _cmark_llist ; extern "C" { # [ doc = " Append an element to the linked list, return the possibly modified" ] # [ doc = " head of the list." ] pub fn cmark_llist_append ( mem : * mut cmark_mem , head : * mut cmark_llist , data : * mut :: std :: os :: raw :: c_void ) -> * mut cmark_llist ; } extern "C" { # [ doc = " Free the list starting with 'head', calling 'free_func' with the" ] # [ doc = "  data pointer of each of its elements" ] pub fn cmark_llist_free_full ( mem : * mut cmark_mem , head : * mut cmark_llist , free_func : cmark_free_func ) ; } extern "C" { # [ doc = " Free the list starting with 'head'" ] pub fn cmark_llist_free ( mem : * mut cmark_mem , head : * mut cmark_llist ) ; } extern "C" { # [ doc = " Creates a new node of type 'type'.  Note that the node may have" ] # [ doc = " other required properties, which it is the caller's responsibility" ] # [ doc = " to assign." ] pub fn cmark_node_new ( type_ : cmark_node_type ) -> * mut cmark_node ; } extern "C" { # [ doc = " Same as `cmark_node_new`, but explicitly listing the memory" ] # [ doc = " allocator used to allocate the node.  Note:  be sure to use the same" ] # [ doc = " allocator for every node in a tree, or bad things can happen." ] pub fn cmark_node_new_with_mem ( type_ : cmark_node_type , mem : * mut cmark_mem ) -> * mut cmark_node ; } extern "C" { pub fn cmark_node_new_with_ext ( type_ : cmark_node_type , extension : * mut cmark_syntax_extension ) -> * mut cmark_node ; } extern "C" { pub fn cmark_node_new_with_mem_and_ext ( type_ : cmark_node_type , mem : * mut cmark_mem , extension : * mut cmark_syntax_extension ) -> * mut cmark_node ; } extern "C" { # [ doc = " Frees the memory allocated for a node and any children." ] pub fn cmark_node_free ( node : * mut cmark_node ) ; } extern "C" { # [ doc = " Returns the next node in the sequence after 'node', or NULL if" ] # [ doc = " there is none." ] pub fn cmark_node_next ( node : * mut cmark_node ) -> * mut cmark_node ; } extern "C" { # [ doc = " Returns the previous node in the sequence after 'node', or NULL if" ] # [ doc = " there is none." ] pub fn cmark_node_previous ( node : * mut cmark_node ) -> * mut cmark_node ; } extern "C" { # [ doc = " Returns the parent of 'node', or NULL if there is none." ] pub fn cmark_node_parent ( node : * mut cmark_node ) -> * mut cmark_node ; } extern "C" { # [ doc = " Returns the first child of 'node', or NULL if 'node' has no children." ] pub fn cmark_node_first_child ( node : * mut cmark_node ) -> * mut cmark_node ; } extern "C" { # [ doc = " Returns the last child of 'node', or NULL if 'node' has no children." ] pub fn cmark_node_last_child ( node : * mut cmark_node ) -> * mut cmark_node ; } pub const cmark_event_type_CMARK_EVENT_NONE : cmark_event_type = 0 ; pub const cmark_event_type_CMARK_EVENT_DONE : cmark_event_type = 1 ; pub const cmark_event_type_CMARK_EVENT_ENTER : cmark_event_type = 2 ; pub const cmark_event_type_CMARK_EVENT_EXIT : cmark_event_type = 3 ; # [ doc = " ## Iterator" ] # [ doc = "" ] # [ doc = " An iterator will walk through a tree of nodes, starting from a root" ] # [ doc = " node, returning one node at a time, together with information about" ] # [ doc = " whether the node is being entered or exited.  The iterator will" ] # [ doc = " first descend to a child node, if there is one.  When there is no" ] # [ doc = " child, the iterator will go to the next sibling.  When there is no" ] # [ doc = " next sibling, the iterator will return to the parent (but with" ] # [ doc = " a 'cmark_event_type' of `CMARK_EVENT_EXIT`).  The iterator will" ] # [ doc = " return `CMARK_EVENT_DONE` when it reaches the root node again." ] # [ doc = " One natural application is an HTML renderer, where an `ENTER` event" ] # [ doc = " outputs an open tag and an `EXIT` event outputs a close tag." ] # [ doc = " An iterator might also be used to transform an AST in some systematic" ] # [ doc = " way, for example, turning all level-3 headings into regular paragraphs." ] # [ doc = "" ] # [ doc = "     void" ] # [ doc = "     usage_example(cmark_node *root) {" ] # [ doc = "         cmark_event_type ev_type;" ] # [ doc = "         cmark_iter *iter = cmark_iter_new(root);" ] # [ doc = "" ] # [ doc = "         while ((ev_type = cmark_iter_next(iter)) != CMARK_EVENT_DONE) {" ] # [ doc = "             cmark_node *cur = cmark_iter_get_node(iter);" ] # [ doc = "             // Do something with `cur` and `ev_type`" ] # [ doc = "         }" ] # [ doc = "" ] # [ doc = "         cmark_iter_free(iter);" ] # [ doc = "     }" ] # [ doc = "" ] # [ doc = " Iterators will never return `EXIT` events for leaf nodes, which are nodes" ] # [ doc = " of type:" ] # [ doc = "" ] # [ doc = " * CMARK_NODE_HTML_BLOCK" ] # [ doc = " * CMARK_NODE_THEMATIC_BREAK" ] # [ doc = " * CMARK_NODE_CODE_BLOCK" ] # [ doc = " * CMARK_NODE_TEXT" ] # [ doc = " * CMARK_NODE_SOFTBREAK" ] # [ doc = " * CMARK_NODE_LINEBREAK" ] # [ doc = " * CMARK_NODE_CODE" ] # [ doc = " * CMARK_NODE_HTML_INLINE" ] # [ doc = "" ] # [ doc = " Nodes must only be modified after an `EXIT` event, or an `ENTER` event for" ] # [ doc = " leaf nodes." ] pub type cmark_event_type = u32 ; extern "C" { # [ doc = " Creates a new iterator starting at 'root'.  The current node and event" ] # [ doc = " type are undefined until 'cmark_iter_next' is called for the first time." ] # [ doc = " The memory allocated for the iterator should be released using" ] # [ doc = " 'cmark_iter_free' when it is no longer needed." ] pub fn cmark_iter_new ( root : * mut cmark_node ) -> * mut cmark_iter ; } extern "C" { # [ doc = " Frees the memory allocated for an iterator." ] pub fn cmark_iter_free ( iter : * mut cmark_iter ) ; } extern "C" { # [ doc = " Advances to the next node and returns the event type (`CMARK_EVENT_ENTER`," ] # [ doc = " `CMARK_EVENT_EXIT` or `CMARK_EVENT_DONE`)." ] pub fn cmark_iter_next ( iter : * mut cmark_iter ) -> cmark_event_type ; } extern "C" { # [ doc = " Returns the current node." ] pub fn cmark_iter_get_node ( iter : * mut cmark_iter ) -> * mut cmark_node ; } extern "C" { # [ doc = " Returns the current event type." ] pub fn cmark_iter_get_event_type ( iter : * mut cmark_iter ) -> cmark_event_type ; } extern "C" { # [ doc = " Returns the root node." ] pub fn cmark_iter_get_root ( iter : * mut cmark_iter ) -> * mut cmark_node ; } extern "C" { # [ doc = " Resets the iterator so that the current node is 'current' and" ] # [ doc = " the event type is 'event_type'.  The new current node must be a" ] # [ doc = " descendant of the root node or the root node itself." ] pub fn cmark_iter_reset ( iter : * mut cmark_iter , current : * mut cmark_node , event_type : cmark_event_type ) ; } extern "C" { # [ doc = " Returns the user data of 'node'." ] pub fn cmark_node_get_user_data ( node : * mut cmark_node ) -> * mut :: std :: os :: raw :: c_void ; } extern "C" { # [ doc = " Sets arbitrary user data for 'node'.  Returns 1 on success," ] # [ doc = " 0 on failure." ] pub fn cmark_node_set_user_data ( node : * mut cmark_node , user_data : * mut :: std :: os :: raw :: c_void ) -> :: std :: os :: raw :: c_int ; } extern "C" { # [ doc = " Set free function for user data" ] pub fn cmark_node_set_user_data_free_func ( node : * mut cmark_node , free_func : cmark_free_func ) -> :: std :: os :: raw :: c_int ; } extern "C" { # [ doc = " Returns the type of 'node', or `CMARK_NODE_NONE` on error." ] pub fn cmark_node_get_type ( node : * mut cmark_node ) -> cmark_node_type ; } extern "C" { # [ doc = " Like 'cmark_node_get_type', but returns a string representation" ] # [ doc = "of the type, or `\"<unknown>\"`." ] pub fn cmark_node_get_type_string ( node : * mut cmark_node ) -> * const :: std :: os :: raw :: c_char ; } extern "C" { # [ doc = " Returns the string contents of 'node', or an empty" ] # [ doc = "string if none is set.  Returns NULL if called on a" ] # [ doc = "node that does not have string content." ] pub fn cmark_node_get_literal ( node : * mut cmark_node ) -> * const :: std :: os :: raw :: c_char ; } extern "C" { # [ doc = " Sets the string contents of 'node'.  Returns 1 on success," ] # [ doc = " 0 on failure." ] pub fn cmark_node_set_literal ( node : * mut cmark_node , content : * const :: std :: os :: raw :: c_char ) -> :: std :: os :: raw :: c_int ; } extern "C" { # [ doc = " Returns the heading level of 'node', or 0 if 'node' is not a heading." ] pub fn cmark_node_get_heading_level ( node : * mut cmark_node ) -> :: std :: os :: raw :: c_int ; } extern "C" { # [ doc = " Sets the heading level of 'node', returning 1 on success and 0 on error." ] pub fn cmark_node_set_heading_level ( node : * mut cmark_node , level : :: std :: os :: raw :: c_int ) -> :: std :: os :: raw :: c_int ; } extern "C" { # [ doc = " Returns the list type of 'node', or `CMARK_NO_LIST` if 'node'" ] # [ doc = " is not a list." ] pub fn cmark_node_get_list_type ( node : * mut cmark_node ) -> cmark_list_type ; } extern "C" { # [ doc = " Sets the list type of 'node', returning 1 on success and 0 on error." ] pub fn cmark_node_set_list_type ( node : * mut cmark_node , type_ : cmark_list_type ) -> :: std :: os :: raw :: c_int ; } extern "C" { # [ doc = " Returns the list delimiter type of 'node', or `CMARK_NO_DELIM` if 'node'" ] # [ doc = " is not a list." ] pub fn cmark_node_get_list_delim ( node : * mut cmark_node ) -> cmark_delim_type ; } extern "C" { # [ doc = " Sets the list delimiter type of 'node', returning 1 on success and 0" ] # [ doc = " on error." ] pub fn cmark_node_set_list_delim ( node : * mut cmark_node , delim : cmark_delim_type ) -> :: std :: os :: raw :: c_int ; } extern "C" { # [ doc = " Returns starting number of 'node', if it is an ordered list, otherwise 0." ] pub fn cmark_node_get_list_start ( node : * mut cmark_node ) -> :: std :: os :: raw :: c_int ; } extern "C" { # [ doc = " Sets starting number of 'node', if it is an ordered list. Returns 1" ] # [ doc = " on success, 0 on failure." ] pub fn cmark_node_set_list_start ( node : * mut cmark_node , start : :: std :: os :: raw :: c_int ) -> :: std :: os :: raw :: c_int ; } extern "C" { # [ doc = " Returns 1 if 'node' is a tight list, 0 otherwise." ] pub fn cmark_node_get_list_tight ( node : * mut cmark_node ) -> :: std :: os :: raw :: c_int ; } extern "C" { # [ doc = " Sets the \"tightness\" of a list.  Returns 1 on success, 0 on failure." ] pub fn cmark_node_set_list_tight ( node : * mut cmark_node , tight : :: std :: os :: raw :: c_int ) -> :: std :: os :: raw :: c_int ; } extern "C" { # [ doc = " Returns the info string from a fenced code block." ] pub fn cmark_node_get_fence_info ( node : * mut cmark_node ) -> * const :: std :: os :: raw :: c_char ; } extern "C" { # [ doc = " Sets the info string in a fenced code block, returning 1 on" ] # [ doc = " success and 0 on failure." ] pub fn cmark_node_set_fence_info ( node : * mut cmark_node , info : * const :: std :: os :: raw :: c_char ) -> :: std :: os :: raw :: c_int ; } extern "C" { # [ doc = " Sets code blocks fencing details" ] pub fn cmark_node_set_fenced ( node : * mut cmark_node , fenced : :: std :: os :: raw :: c_int , length : :: std :: os :: raw :: c_int , offset : :: std :: os :: raw :: c_int , character : :: std :: os :: raw :: c_char ) -> :: std :: os :: raw :: c_int ; } extern "C" { # [ doc = " Returns code blocks fencing details" ] pub fn cmark_node_get_fenced ( node : * mut cmark_node , length : * mut :: std :: os :: raw :: c_int , offset : * mut :: std :: os :: raw :: c_int , character : * mut :: std :: os :: raw :: c_char ) -> :: std :: os :: raw :: c_int ; } extern "C" { # [ doc = " Returns the URL of a link or image 'node', or an empty string" ] # [ doc = "if no URL is set.  Returns NULL if called on a node that is" ] # [ doc = "not a link or image." ] pub fn cmark_node_get_url ( node : * mut cmark_node ) -> * const :: std :: os :: raw :: c_char ; } extern "C" { # [ doc = " Sets the URL of a link or image 'node'. Returns 1 on success," ] # [ doc = " 0 on failure." ] pub fn cmark_node_set_url ( node : * mut cmark_node , url : * const :: std :: os :: raw :: c_char ) -> :: std :: os :: raw :: c_int ; } extern "C" { # [ doc = " Returns the title of a link or image 'node', or an empty" ] # [ doc = "string if no title is set.  Returns NULL if called on a node" ] # [ doc = "that is not a link or image." ] pub fn cmark_node_get_title ( node : * mut cmark_node ) -> * const :: std :: os :: raw :: c_char ; } extern "C" { # [ doc = " Sets the title of a link or image 'node'. Returns 1 on success," ] # [ doc = " 0 on failure." ] pub fn cmark_node_set_title ( node : * mut cmark_node , title : * const :: std :: os :: raw :: c_char ) -> :: std :: os :: raw :: c_int ; } extern "C" { # [ doc = " Returns the literal \"on enter\" text for a custom 'node', or" ] # [ doc = "an empty string if no on_enter is set.  Returns NULL if called" ] # [ doc = "on a non-custom node." ] pub fn cmark_node_get_on_enter ( node : * mut cmark_node ) -> * const :: std :: os :: raw :: c_char ; } extern "C" { # [ doc = " Sets the literal text to render \"on enter\" for a custom 'node'." ] # [ doc = "Any children of the node will be rendered after this text." ] # [ doc = "Returns 1 on success 0 on failure." ] pub fn cmark_node_set_on_enter ( node : * mut cmark_node , on_enter : * const :: std :: os :: raw :: c_char ) -> :: std :: os :: raw :: c_int ; } extern "C" { # [ doc = " Returns the literal \"on exit\" text for a custom 'node', or" ] # [ doc = "an empty string if no on_exit is set.  Returns NULL if" ] # [ doc = "called on a non-custom node." ] pub fn cmark_node_get_on_exit ( node : * mut cmark_node ) -> * const :: std :: os :: raw :: c_char ; } extern "C" { # [ doc = " Sets the literal text to render \"on exit\" for a custom 'node'." ] # [ doc = "Any children of the node will be rendered before this text." ] # [ doc = "Returns 1 on success 0 on failure." ] pub fn cmark_node_set_on_exit ( node : * mut cmark_node , on_exit : * const :: std :: os :: raw :: c_char ) -> :: std :: os :: raw :: c_int ; } extern "C" { # [ doc = " Returns the line on which 'node' begins." ] pub fn cmark_node_get_start_line ( node : * mut cmark_node ) -> :: std :: os :: raw :: c_int ; } extern "C" { # [ doc = " Returns the column at which 'node' begins." ] pub fn cmark_node_get_start_column ( node : * mut cmark_node ) -> :: std :: os :: raw :: c_int ; } extern "C" { # [ doc = " Returns the line on which 'node' ends." ] pub fn cmark_node_get_end_line ( node : * mut cmark_node ) -> :: std :: os :: raw :: c_int ; } extern "C" { # [ doc = " Returns the column at which 'node' ends." ] pub fn cmark_node_get_end_column ( node : * mut cmark_node ) -> :: std :: os :: raw :: c_int ; } extern "C" { # [ doc = " Unlinks a 'node', removing it from the tree, but not freeing its" ] # [ doc = " memory.  (Use 'cmark_node_free' for that.)" ] pub fn cmark_node_unlink ( node : * mut cmark_node ) ; } extern "C" { # [ doc = " Inserts 'sibling' before 'node'.  Returns 1 on success, 0 on failure." ] pub fn cmark_node_insert_before ( node : * mut cmark_node , sibling : * mut cmark_node ) -> :: std :: os :: raw :: c_int ; } extern "C" { # [ doc = " Inserts 'sibling' after 'node'. Returns 1 on success, 0 on failure." ] pub fn cmark_node_insert_after ( node : * mut cmark_node , sibling : * mut cmark_node ) -> :: std :: os :: raw :: c_int ; } extern "C" { # [ doc = " Replaces 'oldnode' with 'newnode' and unlinks 'oldnode' (but does" ] # [ doc = " not free its memory)." ] # [ doc = " Returns 1 on success, 0 on failure." ] pub fn cmark_node_replace ( oldnode : * mut cmark_node , newnode : * mut cmark_node ) -> :: std :: os :: raw :: c_int ; } extern "C" { # [ doc = " Adds 'child' to the beginning of the children of 'node'." ] # [ doc = " Returns 1 on success, 0 on failure." ] pub fn cmark_node_prepend_child ( node : * mut cmark_node , child : * mut cmark_node ) -> :: std :: os :: raw :: c_int ; } extern "C" { # [ doc = " Adds 'child' to the end of the children of 'node'." ] # [ doc = " Returns 1 on success, 0 on failure." ] pub fn cmark_node_append_child ( node : * mut cmark_node , child : * mut cmark_node ) -> :: std :: os :: raw :: c_int ; } extern "C" { # [ doc = " Consolidates adjacent text nodes." ] pub fn cmark_consolidate_text_nodes ( root : * mut cmark_node ) ; } extern "C" { # [ doc = " Ensures a node and all its children own their own chunk memory." ] pub fn cmark_node_own ( root : * mut cmark_node ) ; } extern "C" { # [ doc = " Creates a new parser object." ] pub fn cmark_parser_new ( options : :: std :: os :: raw :: c_int ) -> * mut cmark_parser ; } extern "C" { # [ doc = " Creates a new parser object with the given memory allocator" ] pub fn cmark_parser_new_with_mem ( options : :: std :: os :: raw :: c_int , mem : * mut cmark_mem ) -> * mut cmark_parser ; } extern "C" { # [ doc = " Frees memory allocated for a parser object." ] pub fn cmark_parser_free ( parser : * mut cmark_parser ) ; } extern "C" { # [ doc = " Feeds a string of length 'len' to 'parser'." ] pub fn cmark_parser_feed ( parser : * mut cmark_parser , buffer : * const :: std :: os :: raw :: c_char , len : usize ) ; } extern "C" { # [ doc = " Finish parsing and return a pointer to a tree of nodes." ] pub fn cmark_parser_finish ( parser : * mut cmark_parser ) -> * mut cmark_node ; } extern "C" { # [ doc = " Parse a CommonMark document in 'buffer' of length 'len'." ] # [ doc = " Returns a pointer to a tree of nodes.  The memory allocated for" ] # [ doc = " the node tree should be released using 'cmark_node_free'" ] # [ doc = " when it is no longer needed." ] pub fn cmark_parse_document ( buffer : * const :: std :: os :: raw :: c_char , len : usize , options : :: std :: os :: raw :: c_int ) -> * mut cmark_node ; } extern "C" { # [ doc = " Parse a CommonMark document in file 'f', returning a pointer to" ] # [ doc = " a tree of nodes.  The memory allocated for the node tree should be" ] # [ doc = " released using 'cmark_node_free' when it is no longer needed." ] pub fn cmark_parse_file ( f : * mut FILE , options : :: std :: os :: raw :: c_int ) -> * mut cmark_node ; } extern "C" { # [ doc = " Render a 'node' tree as XML.  It is the caller's responsibility" ] # [ doc = " to free the returned buffer." ] pub fn cmark_render_xml ( root : * mut cmark_node , options : :: std :: os :: raw :: c_int ) -> * mut :: std :: os :: raw :: c_char ; } extern "C" { # [ doc = " As for 'cmark_render_xml', but specifying the allocator to use for" ] # [ doc = " the resulting string." ] pub fn cmark_render_xml_with_mem ( root : * mut cmark_node , options : :: std :: os :: raw :: c_int , mem : * mut cmark_mem ) -> * mut :: std :: os :: raw :: c_char ; } extern "C" { # [ doc = " Render a 'node' tree as an HTML fragment.  It is up to the user" ] # [ doc = " to add an appropriate header and footer. It is the caller's" ] # [ doc = " responsibility to free the returned buffer." ] pub fn cmark_render_html ( root : * mut cmark_node , options : :: std :: os :: raw :: c_int , extensions : * mut cmark_llist ) -> * mut :: std :: os :: raw :: c_char ; } extern "C" { # [ doc = " As for 'cmark_render_html', but specifying the allocator to use for" ] # [ doc = " the resulting string." ] pub fn cmark_render_html_with_mem ( root : * mut cmark_node , options : :: std :: os :: raw :: c_int , extensions : * mut cmark_llist , mem : * mut cmark_mem ) -> * mut :: std :: os :: raw :: c_char ; } extern "C" { # [ doc = " Render a 'node' tree as a groff man page, without the header." ] # [ doc = " It is the caller's responsibility to free the returned buffer." ] pub fn cmark_render_man ( root : * mut cmark_node , options : :: std :: os :: raw :: c_int , width : :: std :: os :: raw :: c_int ) -> * mut :: std :: os :: raw :: c_char ; } extern "C" { # [ doc = " As for 'cmark_render_man', but specifying the allocator to use for" ] # [ doc = " the resulting string." ] pub fn cmark_render_man_with_mem ( root : * mut cmark_node , options : :: std :: os :: raw :: c_int , width : :: std :: os :: raw :: c_int , mem : * mut cmark_mem ) -> * mut :: std :: os :: raw :: c_char ; } extern "C" { # [ doc = " Render a 'node' tree as a commonmark document." ] # [ doc = " It is the caller's responsibility to free the returned buffer." ] pub fn cmark_render_commonmark ( root : * mut cmark_node , options : :: std :: os :: raw :: c_int , width : :: std :: os :: raw :: c_int ) -> * mut :: std :: os :: raw :: c_char ; } extern "C" { # [ doc = " As for 'cmark_render_commonmark', but specifying the allocator to use for" ] # [ doc = " the resulting string." ] pub fn cmark_render_commonmark_with_mem ( root : * mut cmark_node , options : :: std :: os :: raw :: c_int , width : :: std :: os :: raw :: c_int , mem : * mut cmark_mem ) -> * mut :: std :: os :: raw :: c_char ; } extern "C" { # [ doc = " Render a 'node' tree as a plain text document." ] # [ doc = " It is the caller's responsibility to free the returned buffer." ] pub fn cmark_render_plaintext ( root : * mut cmark_node , options : :: std :: os :: raw :: c_int , width : :: std :: os :: raw :: c_int ) -> * mut :: std :: os :: raw :: c_char ; } extern "C" { # [ doc = " As for 'cmark_render_plaintext', but specifying the allocator to use for" ] # [ doc = " the resulting string." ] pub fn cmark_render_plaintext_with_mem ( root : * mut cmark_node , options : :: std :: os :: raw :: c_int , width : :: std :: os :: raw :: c_int , mem : * mut cmark_mem ) -> * mut :: std :: os :: raw :: c_char ; } extern "C" { # [ doc = " Render a 'node' tree as a LaTeX document." ] # [ doc = " It is the caller's responsibility to free the returned buffer." ] pub fn cmark_render_latex ( root : * mut cmark_node , options : :: std :: os :: raw :: c_int , width : :: std :: os :: raw :: c_int ) -> * mut :: std :: os :: raw :: c_char ; } extern "C" { # [ doc = " As for 'cmark_render_latex', but specifying the allocator to use for" ] # [ doc = " the resulting string." ] pub fn cmark_render_latex_with_mem ( root : * mut cmark_node , options : :: std :: os :: raw :: c_int , width : :: std :: os :: raw :: c_int , mem : * mut cmark_mem ) -> * mut :: std :: os :: raw :: c_char ; } extern "C" { # [ doc = " The library version as integer for runtime checks. Also available as" ] # [ doc = " macro CMARK_VERSION for compile time checks." ] # [ doc = "" ] # [ doc = " * Bits 16-23 contain the major version." ] # [ doc = " * Bits 8-15 contain the minor version." ] # [ doc = " * Bits 0-7 contain the patchlevel." ] # [ doc = "" ] # [ doc = " In hexadecimal format, the number 0x010203 represents version 1.2.3." ] pub fn cmark_version ( ) -> :: std :: os :: raw :: c_int ; } extern "C" { # [ doc = " The library version string for runtime checks. Also available as" ] # [ doc = " macro CMARK_VERSION_STRING for compile time checks." ] pub fn cmark_version_string ( ) -> * const :: std :: os :: raw :: c_char ; } pub type bufsize_t = i32 ; # [ repr ( C ) ] # [ derive ( Debug , Copy , Clone ) ] pub struct cmark_renderer { _unused : [ u8 ; 0 ] , } # [ repr ( C ) ] # [ derive ( Debug , Copy , Clone ) ] pub struct cmark_html_renderer { _unused : [ u8 ; 0 ] , } # [ repr ( C ) ] # [ derive ( Debug , Copy , Clone ) ] pub struct cmark_chunk { _unused : [ u8 ; 0 ] , } # [ repr ( C ) ] # [ derive ( Debug , Copy , Clone ) ] pub struct cmark_plugin { _unused : [ u8 ; 0 ] , } # [ repr ( C ) ] # [ derive ( Debug , Copy , Clone ) ] pub struct subject { _unused : [ u8 ; 0 ] , } # [ doc = " A syntax extension that can be attached to a cmark_parser" ] # [ doc = " with cmark_parser_attach_syntax_extension()." ] # [ doc = "" ] # [ doc = " Extension writers should assign functions matching" ] # [ doc = " the signature of the following 'virtual methods' to" ] # [ doc = " implement new functionality." ] # [ doc = "" ] # [ doc = " Their calling order and expected behaviour match the procedure outlined" ] # [ doc = " at <http://spec.commonmark.org/0.24/#phase-1-block-structure>:" ] # [ doc = "" ] # [ doc = " During step 1, cmark will call the function provided through" ] # [ doc = " 'cmark_syntax_extension_set_match_block_func' when it" ] # [ doc = " iterates over an open block created by this extension," ] # [ doc = " to determine  whether it could contain the new line." ] # [ doc = " If no function was provided, cmark will close the block." ] # [ doc = "" ] # [ doc = " During step 2, if and only if the new line doesn't match any" ] # [ doc = " of the standard syntax rules, cmark will call the function" ] # [ doc = " provided through 'cmark_syntax_extension_set_open_block_func'" ] # [ doc = " to let the extension determine whether that new line matches" ] # [ doc = " one of its syntax rules." ] # [ doc = " It is the responsibility of the parser to create and add the" ] # [ doc = " new block with cmark_parser_make_block and cmark_parser_add_child." ] # [ doc = " If no function was provided is NULL, the extension will have" ] # [ doc = " no effect at all on the final block structure of the AST." ] # [ doc = "" ] # [ doc = " #### Inline parsing phase hooks" ] # [ doc = "" ] # [ doc = " For each character provided by the extension through" ] # [ doc = " 'cmark_syntax_extension_set_special_inline_chars'," ] # [ doc = " the function provided by the extension through" ] # [ doc = " 'cmark_syntax_extension_set_match_inline_func'" ] # [ doc = " will get called, it is the responsibility of the extension" ] # [ doc = " to scan the characters located at the current inline parsing offset" ] # [ doc = " with the cmark_inline_parser API." ] # [ doc = "" ] # [ doc = " Depending on the type of the extension, it can either:" ] # [ doc = "" ] # [ doc = " * Scan forward, determine that the syntax matches and return" ] # [ doc = "   a newly-created inline node with the appropriate type." ] # [ doc = "   This is the technique that would be used if inline code" ] # [ doc = "   (with backticks) was implemented as an extension." ] # [ doc = " * Scan only the character(s) that its syntax rules require" ] # [ doc = "   for opening and closing nodes, push a delimiter on the" ] # [ doc = "   delimiter stack, and return a simple text node with its" ] # [ doc = "   contents set to the character(s) consumed." ] # [ doc = "   This is the technique that would be used if emphasis" ] # [ doc = "   inlines were implemented as an extension." ] # [ doc = "" ] # [ doc = " When an extension has pushed delimiters on the stack," ] # [ doc = " the function provided through" ] # [ doc = " 'cmark_syntax_extension_set_inline_from_delim_func'" ] # [ doc = " will get called in a latter phase," ] # [ doc = " when the inline parser has matched opener and closer delimiters" ] # [ doc = " created by the extension together." ] # [ doc = "" ] # [ doc = " It is then the responsibility of the extension to modify" ] # [ doc = " and populate the opener inline text node, and to remove" ] # [ doc = " the necessary delimiters from the delimiter stack." ] # [ doc = "" ] # [ doc = " Finally, the extension should return NULL if its scan didn't" ] # [ doc = " match its syntax rules." ] # [ doc = "" ] # [ doc = " The extension can store whatever private data it might need" ] # [ doc = " with 'cmark_syntax_extension_set_private'," ] # [ doc = " and optionally define a free function for this data." ] pub type cmark_inline_parser = subject ; # [ doc = " Exposed raw for now" ] # [ repr ( C ) ] # [ derive ( Debug , Copy , Clone ) ] pub struct delimiter { pub previous : * mut delimiter , pub next : * mut delimiter , pub inl_text : * mut cmark_node , pub length : bufsize_t , pub delim_char : :: std :: os :: raw :: c_uchar , pub can_open : :: std :: os :: raw :: c_int , pub can_close : :: std :: os :: raw :: c_int , } # [ test ] fn bindgen_test_layout_delimiter ( ) { assert_eq ! ( :: std :: mem :: size_of :: < delimiter > ( ) , 40usize , concat ! ( "Size of: " , stringify ! ( delimiter ) ) ) ; assert_eq ! ( :: std :: mem :: align_of :: < delimiter > ( ) , 8usize , concat ! ( "Alignment of " , stringify ! ( delimiter ) ) ) ; assert_eq ! ( unsafe { & ( * ( :: std :: ptr :: null :: < delimiter > ( ) ) ) . previous as * const _ as usize } , 0usize , concat ! ( "Offset of field: " , stringify ! ( delimiter ) , "::" , stringify ! ( previous ) ) ) ; assert_eq ! ( unsafe { & ( * ( :: std :: ptr :: null :: < delimiter > ( ) ) ) . next as * const _ as usize } , 8usize , concat ! ( "Offset of field: " , stringify ! ( delimiter ) , "::" , stringify ! ( next ) ) ) ; assert_eq ! ( unsafe { & ( * ( :: std :: ptr :: null :: < delimiter > ( ) ) ) . inl_text as * const _ as usize } , 16usize , concat ! ( "Offset of field: " , stringify ! ( delimiter ) , "::" , stringify ! ( inl_text ) ) ) ; assert_eq ! ( unsafe { & ( * ( :: std :: ptr :: null :: < delimiter > ( ) ) ) . length as * const _ as usize } , 24usize , concat ! ( "Offset of field: " , stringify ! ( delimiter ) , "::" , stringify ! ( length ) ) ) ; assert_eq ! ( unsafe { & ( * ( :: std :: ptr :: null :: < delimiter > ( ) ) ) . delim_char as * const _ as usize } , 28usize , concat ! ( "Offset of field: " , stringify ! ( delimiter ) , "::" , stringify ! ( delim_char ) ) ) ; assert_eq ! ( unsafe { & ( * ( :: std :: ptr :: null :: < delimiter > ( ) ) ) . can_open as * const _ as usize } , 32usize , concat ! ( "Offset of field: " , stringify ! ( delimiter ) , "::" , stringify ! ( can_open ) ) ) ; assert_eq ! ( unsafe { & ( * ( :: std :: ptr :: null :: < delimiter > ( ) ) ) . can_close as * const _ as usize } , 36usize , concat ! ( "Offset of field: " , stringify ! ( delimiter ) , "::" , stringify ! ( can_close ) ) ) ; } # [ doc = " The prototype plugins' init function should follow." ] pub type cmark_plugin_init_func = :: std :: option :: Option < unsafe extern "C" fn ( plugin : * mut cmark_plugin ) -> :: std :: os :: raw :: c_int > ; extern "C" { # [ doc = " Register a syntax 'extension' with the 'plugin', it will be made" ] # [ doc = " available as an extension and, if attached to a cmark_parser" ] # [ doc = " with 'cmark_parser_attach_syntax_extension', it will contribute" ] # [ doc = " to the block parsing process." ] # [ doc = "" ] # [ doc = " See the documentation for 'cmark_syntax_extension' for information" ] # [ doc = " on how to implement one." ] # [ doc = "" ] # [ doc = " This function will typically be called from the init function" ] # [ doc = " of external modules." ] # [ doc = "" ] # [ doc = " This takes ownership of 'extension', one should not call" ] # [ doc = " 'cmark_syntax_extension_free' on a registered extension." ] pub fn cmark_plugin_register_syntax_extension ( plugin : * mut cmark_plugin , extension : * mut cmark_syntax_extension ) -> :: std :: os :: raw :: c_int ; } extern "C" { # [ doc = " This will search for the syntax extension named 'name' among the" ] # [ doc = "  registered syntax extensions." ] # [ doc = "" ] # [ doc = "  It can then be attached to a cmark_parser" ] # [ doc = "  with the cmark_parser_attach_syntax_extension method." ] pub fn cmark_find_syntax_extension ( name : * const :: std :: os :: raw :: c_char ) -> * mut cmark_syntax_extension ; } # [ doc = " Should create and add a new open block to 'parent_container' if" ] # [ doc = " 'input' matches a syntax rule for that block type. It is allowed" ] # [ doc = " to modify the type of 'parent_container'." ] # [ doc = "" ] # [ doc = " Should return the newly created block if there is one, or" ] # [ doc = " 'parent_container' if its type was modified, or NULL." ] pub type cmark_open_block_func = :: std :: option :: Option < unsafe extern "C" fn ( extension : * mut cmark_syntax_extension , indented : :: std :: os :: raw :: c_int , parser : * mut cmark_parser , parent_container : * mut cmark_node , input : * mut :: std :: os :: raw :: c_uchar , len : :: std :: os :: raw :: c_int ) -> * mut cmark_node > ; pub type cmark_match_inline_func = :: std :: option :: Option < unsafe extern "C" fn ( extension : * mut cmark_syntax_extension , parser : * mut cmark_parser , parent : * mut cmark_node , character : :: std :: os :: raw :: c_uchar , inline_parser : * mut cmark_inline_parser ) -> * mut cmark_node > ; pub type cmark_inline_from_delim_func = :: std :: option :: Option < unsafe extern "C" fn ( extension : * mut cmark_syntax_extension , parser : * mut cmark_parser , inline_parser : * mut cmark_inline_parser , opener : * mut delimiter , closer : * mut delimiter ) -> * mut delimiter > ; # [ doc = " Should return 'true' if 'input' can be contained in 'container'," ] # [ doc = "  'false' otherwise." ] pub type cmark_match_block_func = :: std :: option :: Option < unsafe extern "C" fn ( extension : * mut cmark_syntax_extension , parser : * mut cmark_parser , input : * mut :: std :: os :: raw :: c_uchar , len : :: std :: os :: raw :: c_int , container : * mut cmark_node ) -> :: std :: os :: raw :: c_int > ; pub type cmark_get_type_string_func = :: std :: option :: Option < unsafe extern "C" fn ( extension : * mut cmark_syntax_extension , node : * mut cmark_node ) -> * const :: std :: os :: raw :: c_char > ; pub type cmark_can_contain_func = :: std :: option :: Option < unsafe extern "C" fn ( extension : * mut cmark_syntax_extension , node : * mut cmark_node , child : cmark_node_type ) -> :: std :: os :: raw :: c_int > ; pub type cmark_contains_inlines_func = :: std :: option :: Option < unsafe extern "C" fn ( extension : * mut cmark_syntax_extension , node : * mut cmark_node ) -> :: std :: os :: raw :: c_int > ; pub type cmark_common_render_func = :: std :: option :: Option < unsafe extern "C" fn ( extension : * mut cmark_syntax_extension , renderer : * mut cmark_renderer , node : * mut cmark_node , ev_type : cmark_event_type , options : :: std :: os :: raw :: c_int ) > ; pub type cmark_commonmark_escape_func = :: std :: option :: Option < unsafe extern "C" fn ( extension : * mut cmark_syntax_extension , node : * mut cmark_node , c : :: std :: os :: raw :: c_int ) -> :: std :: os :: raw :: c_int > ; pub type cmark_xml_attr_func = :: std :: option :: Option < unsafe extern "C" fn ( extension : * mut cmark_syntax_extension , node : * mut cmark_node ) -> * const :: std :: os :: raw :: c_char > ; pub type cmark_html_render_func = :: std :: option :: Option < unsafe extern "C" fn ( extension : * mut cmark_syntax_extension , renderer : * mut cmark_html_renderer , node : * mut cmark_node , ev_type : cmark_event_type , options : :: std :: os :: raw :: c_int ) > ; pub type cmark_html_filter_func = :: std :: option :: Option < unsafe extern "C" fn ( extension : * mut cmark_syntax_extension , tag : * const :: std :: os :: raw :: c_uchar , tag_len : usize ) -> :: std :: os :: raw :: c_int > ; pub type cmark_postprocess_func = :: std :: option :: Option < unsafe extern "C" fn ( extension : * mut cmark_syntax_extension , parser : * mut cmark_parser , root : * mut cmark_node ) -> * mut cmark_node > ; pub type cmark_ispunct_func = :: std :: option :: Option < unsafe extern "C" fn ( c : :: std :: os :: raw :: c_char ) -> :: std :: os :: raw :: c_int > ; pub type cmark_opaque_alloc_func = :: std :: option :: Option < unsafe extern "C" fn ( extension : * mut cmark_syntax_extension , mem : * mut cmark_mem , node : * mut cmark_node ) > ; pub type cmark_opaque_free_func = :: std :: option :: Option < unsafe extern "C" fn ( extension : * mut cmark_syntax_extension , mem : * mut cmark_mem , node : * mut cmark_node ) > ; extern "C" { # [ doc = " Free a cmark_syntax_extension." ] pub fn cmark_syntax_extension_free ( mem : * mut cmark_mem , extension : * mut cmark_syntax_extension ) ; } extern "C" { # [ doc = " Return a newly-constructed cmark_syntax_extension, named 'name'." ] pub fn cmark_syntax_extension_new ( name : * const :: std :: os :: raw :: c_char ) -> * mut cmark_syntax_extension ; } extern "C" { pub fn cmark_syntax_extension_add_node ( is_inline : :: std :: os :: raw :: c_int ) -> cmark_node_type ; } extern "C" { pub fn cmark_syntax_extension_set_emphasis ( extension : * mut cmark_syntax_extension , emphasis : :: std :: os :: raw :: c_int ) ; } extern "C" { # [ doc = " See the documentation for 'cmark_syntax_extension'" ] pub fn cmark_syntax_extension_set_open_block_func ( extension : * mut cmark_syntax_extension , func : cmark_open_block_func ) ; } extern "C" { # [ doc = " See the documentation for 'cmark_syntax_extension'" ] pub fn cmark_syntax_extension_set_match_block_func ( extension : * mut cmark_syntax_extension , func : cmark_match_block_func ) ; } extern "C" { # [ doc = " See the documentation for 'cmark_syntax_extension'" ] pub fn cmark_syntax_extension_set_match_inline_func ( extension : * mut cmark_syntax_extension , func : cmark_match_inline_func ) ; } extern "C" { # [ doc = " See the documentation for 'cmark_syntax_extension'" ] pub fn cmark_syntax_extension_set_inline_from_delim_func ( extension : * mut cmark_syntax_extension , func : cmark_inline_from_delim_func ) ; } extern "C" { # [ doc = " See the documentation for 'cmark_syntax_extension'" ] pub fn cmark_syntax_extension_set_special_inline_chars ( extension : * mut cmark_syntax_extension , special_chars : * mut cmark_llist ) ; } extern "C" { # [ doc = " See the documentation for 'cmark_syntax_extension'" ] pub fn cmark_syntax_extension_set_get_type_string_func ( extension : * mut cmark_syntax_extension , func : cmark_get_type_string_func ) ; } extern "C" { # [ doc = " See the documentation for 'cmark_syntax_extension'" ] pub fn cmark_syntax_extension_set_can_contain_func ( extension : * mut cmark_syntax_extension , func : cmark_can_contain_func ) ; } extern "C" { # [ doc = " See the documentation for 'cmark_syntax_extension'" ] pub fn cmark_syntax_extension_set_contains_inlines_func ( extension : * mut cmark_syntax_extension , func : cmark_contains_inlines_func ) ; } extern "C" { # [ doc = " See the documentation for 'cmark_syntax_extension'" ] pub fn cmark_syntax_extension_set_commonmark_render_func ( extension : * mut cmark_syntax_extension , func : cmark_common_render_func ) ; } extern "C" { # [ doc = " See the documentation for 'cmark_syntax_extension'" ] pub fn cmark_syntax_extension_set_plaintext_render_func ( extension : * mut cmark_syntax_extension , func : cmark_common_render_func ) ; } extern "C" { # [ doc = " See the documentation for 'cmark_syntax_extension'" ] pub fn cmark_syntax_extension_set_latex_render_func ( extension : * mut cmark_syntax_extension , func : cmark_common_render_func ) ; } extern "C" { # [ doc = " See the documentation for 'cmark_syntax_extension'" ] pub fn cmark_syntax_extension_set_xml_attr_func ( extension : * mut cmark_syntax_extension , func : cmark_xml_attr_func ) ; } extern "C" { # [ doc = " See the documentation for 'cmark_syntax_extension'" ] pub fn cmark_syntax_extension_set_man_render_func ( extension : * mut cmark_syntax_extension , func : cmark_common_render_func ) ; } extern "C" { # [ doc = " See the documentation for 'cmark_syntax_extension'" ] pub fn cmark_syntax_extension_set_html_render_func ( extension : * mut cmark_syntax_extension , func : cmark_html_render_func ) ; } extern "C" { # [ doc = " See the documentation for 'cmark_syntax_extension'" ] pub fn cmark_syntax_extension_set_html_filter_func ( extension : * mut cmark_syntax_extension , func : cmark_html_filter_func ) ; } extern "C" { # [ doc = " See the documentation for 'cmark_syntax_extension'" ] pub fn cmark_syntax_extension_set_commonmark_escape_func ( extension : * mut cmark_syntax_extension , func : cmark_commonmark_escape_func ) ; } extern "C" { # [ doc = " See the documentation for 'cmark_syntax_extension'" ] pub fn cmark_syntax_extension_set_private ( extension : * mut cmark_syntax_extension , priv_ : * mut :: std :: os :: raw :: c_void , free_func : cmark_free_func ) ; } extern "C" { # [ doc = " See the documentation for 'cmark_syntax_extension'" ] pub fn cmark_syntax_extension_get_private ( extension : * mut cmark_syntax_extension ) -> * mut :: std :: os :: raw :: c_void ; } extern "C" { # [ doc = " See the documentation for 'cmark_syntax_extension'" ] pub fn cmark_syntax_extension_set_postprocess_func ( extension : * mut cmark_syntax_extension , func : cmark_postprocess_func ) ; } extern "C" { # [ doc = " See the documentation for 'cmark_syntax_extension'" ] pub fn cmark_syntax_extension_set_opaque_alloc_func ( extension : * mut cmark_syntax_extension , func : cmark_opaque_alloc_func ) ; } extern "C" { # [ doc = " See the documentation for 'cmark_syntax_extension'" ] pub fn cmark_syntax_extension_set_opaque_free_func ( extension : * mut cmark_syntax_extension , func : cmark_opaque_free_func ) ; } extern "C" { # [ doc = " See the documentation for 'cmark_syntax_extension'" ] pub fn cmark_parser_set_backslash_ispunct_func ( parser : * mut cmark_parser , func : cmark_ispunct_func ) ; } extern "C" { # [ doc = " Return the index of the line currently being parsed, starting with 1." ] pub fn cmark_parser_get_line_number ( parser : * mut cmark_parser ) -> :: std :: os :: raw :: c_int ; } extern "C" { # [ doc = " Return the offset in bytes in the line being processed." ] # [ doc = "" ] # [ doc = " Example:" ] # [ doc = "" ] # [ doc = " ### foo" ] # [ doc = "" ] # [ doc = " Here, offset will first be 0, then 5 (the index of the 'f' character)." ] pub fn cmark_parser_get_offset ( parser : * mut cmark_parser ) -> :: std :: os :: raw :: c_int ; } extern "C" { # [ doc = " Return the offset in 'columns' in the line being processed." ] # [ doc = "" ] # [ doc = " This value may differ from the value returned by" ] # [ doc = " cmark_parser_get_offset() in that it accounts for tabs," ] # [ doc = " and as such should not be used as an index in the current line's" ] # [ doc = " buffer." ] # [ doc = "" ] # [ doc = " Example:" ] # [ doc = "" ] # [ doc = " cmark_parser_advance_offset() can be called to advance the" ] # [ doc = " offset by a number of columns, instead of a number of bytes." ] # [ doc = "" ] # [ doc = " In that case, if offset falls \"in the middle\" of a tab" ] # [ doc = " character, 'column' and offset will differ." ] # [ doc = "" ] # [ doc = " ```" ] # [ doc = " foo                 \\t bar" ] # [ doc = " ^                   ^^" ] # [ doc = " offset (0)          20" ] # [ doc = " ```" ] # [ doc = "" ] # [ doc = " If cmark_parser_advance_offset is called here with 'columns'" ] # [ doc = " set to 'true' and 'offset' set to 22, cmark_parser_get_offset()" ] # [ doc = " will return 20, whereas cmark_parser_get_column() will return" ] # [ doc = " 22." ] # [ doc = "" ] # [ doc = " Additionally, as tabs expand to the next multiple of 4 column," ] # [ doc = " cmark_parser_has_partially_consumed_tab() will now return" ] # [ doc = " 'true'." ] pub fn cmark_parser_get_column ( parser : * mut cmark_parser ) -> :: std :: os :: raw :: c_int ; } extern "C" { # [ doc = " Return the absolute index in bytes of the first nonspace" ] # [ doc = " character coming after the offset as returned by" ] # [ doc = " cmark_parser_get_offset() in the line currently being processed." ] # [ doc = "" ] # [ doc = " Example:" ] # [ doc = "" ] # [ doc = " ```" ] # [ doc = "   foo        bar            baz  \\n" ] # [ doc = " ^               ^           ^" ] # [ doc = " 0            offset (16) first_nonspace (28)" ] # [ doc = " ```" ] pub fn cmark_parser_get_first_nonspace ( parser : * mut cmark_parser ) -> :: std :: os :: raw :: c_int ; } extern "C" { # [ doc = " Return the absolute index of the first nonspace column coming after 'offset'" ] # [ doc = " in the line currently being processed, counting tabs as multiple" ] # [ doc = " columns as appropriate." ] # [ doc = "" ] # [ doc = " See the documentation for cmark_parser_get_first_nonspace() and" ] # [ doc = " cmark_parser_get_column() for more information." ] pub fn cmark_parser_get_first_nonspace_column ( parser : * mut cmark_parser ) -> :: std :: os :: raw :: c_int ; } extern "C" { # [ doc = " Return the difference between the values returned by" ] # [ doc = " cmark_parser_get_first_nonspace_column() and" ] # [ doc = " cmark_parser_get_column()." ] # [ doc = "" ] # [ doc = " This is not a byte offset, as it can count one tab as multiple" ] # [ doc = " characters." ] pub fn cmark_parser_get_indent ( parser : * mut cmark_parser ) -> :: std :: os :: raw :: c_int ; } extern "C" { # [ doc = " Return 'true' if the line currently being processed has been entirely" ] # [ doc = " consumed, 'false' otherwise." ] # [ doc = "" ] # [ doc = " Example:" ] # [ doc = "" ] # [ doc = " ```" ] # [ doc = "   foo        bar            baz  \\n" ] # [ doc = " ^" ] # [ doc = " offset" ] # [ doc = " ```" ] # [ doc = "" ] # [ doc = " This function will return 'false' here." ] # [ doc = "" ] # [ doc = " ```" ] # [ doc = "   foo        bar            baz  \\n" ] # [ doc = "                 ^" ] # [ doc = "              offset" ] # [ doc = " ```" ] # [ doc = " This function will still return 'false'." ] # [ doc = "" ] # [ doc = " ```" ] # [ doc = "   foo        bar            baz  \\n" ] # [ doc = "                                ^" ] # [ doc = "                             offset" ] # [ doc = " ```" ] # [ doc = "" ] # [ doc = " At this point, this function will now return 'true'." ] pub fn cmark_parser_is_blank ( parser : * mut cmark_parser ) -> :: std :: os :: raw :: c_int ; } extern "C" { # [ doc = " Return 'true' if the value returned by cmark_parser_get_offset()" ] # [ doc = " is 'inside' an expanded tab." ] # [ doc = "" ] # [ doc = " See the documentation for cmark_parser_get_column() for more" ] # [ doc = " information." ] pub fn cmark_parser_has_partially_consumed_tab ( parser : * mut cmark_parser ) -> :: std :: os :: raw :: c_int ; } extern "C" { # [ doc = " Return the length in bytes of the previously processed line, excluding potential" ] # [ doc = " newline (\\n) and carriage return (\\r) trailing characters." ] pub fn cmark_parser_get_last_line_length ( parser : * mut cmark_parser ) -> :: std :: os :: raw :: c_int ; } extern "C" { # [ doc = " Add a child to 'parent' during the parsing process." ] # [ doc = "" ] # [ doc = " If 'parent' isn't the kind of node that can accept this child," ] # [ doc = " this function will back up till it hits a node that can, closing" ] # [ doc = " blocks as appropriate." ] pub fn cmark_parser_add_child ( parser : * mut cmark_parser , parent : * mut cmark_node , block_type : cmark_node_type , start_column : :: std :: os :: raw :: c_int ) -> * mut cmark_node ; } extern "C" { # [ doc = " Advance the 'offset' of the parser in the current line." ] # [ doc = "" ] # [ doc = " See the documentation of cmark_parser_get_offset() and" ] # [ doc = " cmark_parser_get_column() for more information." ] pub fn cmark_parser_advance_offset ( parser : * mut cmark_parser , input : * const :: std :: os :: raw :: c_char , count : :: std :: os :: raw :: c_int , columns : :: std :: os :: raw :: c_int ) ; } extern "C" { pub fn cmark_parser_feed_reentrant ( parser : * mut cmark_parser , buffer : * const :: std :: os :: raw :: c_char , len : usize ) ; } extern "C" { # [ doc = " Attach the syntax 'extension' to the 'parser', to provide extra syntax" ] # [ doc = "  rules." ] # [ doc = "  See the documentation for cmark_syntax_extension for more information." ] # [ doc = "" ] # [ doc = "  Returns 'true' if the 'extension' was successfully attached," ] # [ doc = "  'false' otherwise." ] pub fn cmark_parser_attach_syntax_extension ( parser : * mut cmark_parser , extension : * mut cmark_syntax_extension ) -> :: std :: os :: raw :: c_int ; } extern "C" { # [ doc = " Change the type of 'node'." ] # [ doc = "" ] # [ doc = " Return 0 if the type could be changed, 1 otherwise." ] pub fn cmark_node_set_type ( node : * mut cmark_node , type_ : cmark_node_type ) -> :: std :: os :: raw :: c_int ; } extern "C" { # [ doc = " Return the string content for all types of 'node'." ] # [ doc = "  The pointer stays valid as long as 'node' isn't freed." ] pub fn cmark_node_get_string_content ( node : * mut cmark_node ) -> * const :: std :: os :: raw :: c_char ; } extern "C" { # [ doc = " Set the string 'content' for all types of 'node'." ] # [ doc = "  Copies 'content'." ] pub fn cmark_node_set_string_content ( node : * mut cmark_node , content : * const :: std :: os :: raw :: c_char ) -> :: std :: os :: raw :: c_int ; } extern "C" { # [ doc = " Get the syntax extension responsible for the creation of 'node'." ] # [ doc = "  Return NULL if 'node' was created because it matched standard syntax rules." ] pub fn cmark_node_get_syntax_extension ( node : * mut cmark_node ) -> * mut cmark_syntax_extension ; } extern "C" { # [ doc = " Set the syntax extension responsible for creating 'node'." ] pub fn cmark_node_set_syntax_extension ( node : * mut cmark_node , extension : * mut cmark_syntax_extension ) -> :: std :: os :: raw :: c_int ; } # [ doc = " Should return 'true' if the predicate matches 'c', 'false' otherwise" ] pub type cmark_inline_predicate = :: std :: option :: Option < unsafe extern "C" fn ( c : :: std :: os :: raw :: c_int ) -> :: std :: os :: raw :: c_int > ; extern "C" { # [ doc = " Advance the current inline parsing offset" ] pub fn cmark_inline_parser_advance_offset ( parser : * mut cmark_inline_parser ) ; } extern "C" { # [ doc = " Get the current inline parsing offset" ] pub fn cmark_inline_parser_get_offset ( parser : * mut cmark_inline_parser ) -> :: std :: os :: raw :: c_int ; } extern "C" { # [ doc = " Set the offset in bytes in the chunk being processed by the given inline parser." ] pub fn cmark_inline_parser_set_offset ( parser : * mut cmark_inline_parser , offset : :: std :: os :: raw :: c_int ) ; } extern "C" { # [ doc = " Gets the cmark_chunk being operated on by the given inline parser." ] # [ doc = " Use cmark_inline_parser_get_offset to get our current position in the chunk." ] pub fn cmark_inline_parser_get_chunk ( parser : * mut cmark_inline_parser ) -> * mut cmark_chunk ; } extern "C" { # [ doc = " Returns 1 if the inline parser is currently in a bracket; pass 1 for 'image'" ] # [ doc = " if you want to know about an image-type bracket, 0 for link-type." ] pub fn cmark_inline_parser_in_bracket ( parser : * mut cmark_inline_parser , image : :: std :: os :: raw :: c_int ) -> :: std :: os :: raw :: c_int ; } extern "C" { # [ doc = " Remove the last n characters from the last child of the given node." ] # [ doc = " This only works where all n characters are in the single last child, and the last" ] # [ doc = " child is CMARK_NODE_TEXT." ] pub fn cmark_node_unput ( node : * mut cmark_node , n : :: std :: os :: raw :: c_int ) ; } extern "C" { # [ doc = " Get the character located at the current inline parsing offset" ] pub fn cmark_inline_parser_peek_char ( parser : * mut cmark_inline_parser ) -> :: std :: os :: raw :: c_uchar ; } extern "C" { # [ doc = " Get the character located 'pos' bytes in the current line." ] pub fn cmark_inline_parser_peek_at ( parser : * mut cmark_inline_parser , pos : :: std :: os :: raw :: c_int ) -> :: std :: os :: raw :: c_uchar ; } extern "C" { # [ doc = " Whether the inline parser has reached the end of the current line" ] pub fn cmark_inline_parser_is_eof ( parser : * mut cmark_inline_parser ) -> :: std :: os :: raw :: c_int ; } extern "C" { # [ doc = " Get the characters located after the current inline parsing offset" ] # [ doc = " while 'pred' matches. Free after usage." ] pub fn cmark_inline_parser_take_while ( parser : * mut cmark_inline_parser , pred : cmark_inline_predicate ) -> * mut :: std :: os :: raw :: c_char ; } extern "C" { # [ doc = " Push a delimiter on the delimiter stack." ] # [ doc = " See <<http://spec.commonmark.org/0.24/#phase-2-inline-structure> for" ] # [ doc = " more information on the parameters" ] pub fn cmark_inline_parser_push_delimiter ( parser : * mut cmark_inline_parser , c : :: std :: os :: raw :: c_uchar , can_open : :: std :: os :: raw :: c_int , can_close : :: std :: os :: raw :: c_int , inl_text : * mut cmark_node ) ; } extern "C" { # [ doc = " Remove 'delim' from the delimiter stack" ] pub fn cmark_inline_parser_remove_delimiter ( parser : * mut cmark_inline_parser , delim : * mut delimiter ) ; } extern "C" { pub fn cmark_inline_parser_get_last_delimiter ( parser : * mut cmark_inline_parser ) -> * mut delimiter ; } extern "C" { pub fn cmark_inline_parser_get_line ( parser : * mut cmark_inline_parser ) -> :: std :: os :: raw :: c_int ; } extern "C" { pub fn cmark_inline_parser_get_column ( parser : * mut cmark_inline_parser ) -> :: std :: os :: raw :: c_int ; } extern "C" { # [ doc = " Convenience function to scan a given delimiter." ] # [ doc = "" ] # [ doc = " 'left_flanking' and 'right_flanking' will be set to true if they" ] # [ doc = " respectively precede and follow a non-space, non-punctuation" ] # [ doc = " character." ] # [ doc = "" ] # [ doc = " Additionally, 'punct_before' and 'punct_after' will respectively be set" ] # [ doc = " if the preceding or following character is a punctuation character." ] # [ doc = "" ] # [ doc = " Note that 'left_flanking' and 'right_flanking' can both be 'true'." ] # [ doc = "" ] # [ doc = " Returns the number of delimiters encountered, in the limit" ] # [ doc = " of 'max_delims', and advances the inline parsing offset." ] pub fn cmark_inline_parser_scan_delimiters ( parser : * mut cmark_inline_parser , max_delims : :: std :: os :: raw :: c_int , c : :: std :: os :: raw :: c_uchar , left_flanking : * mut :: std :: os :: raw :: c_int , right_flanking : * mut :: std :: os :: raw :: c_int , punct_before : * mut :: std :: os :: raw :: c_int , punct_after : * mut :: std :: os :: raw :: c_int ) -> :: std :: os :: raw :: c_int ; } extern "C" { pub fn cmark_manage_extensions_special_characters ( parser : * mut cmark_parser , add : :: std :: os :: raw :: c_int ) ; } extern "C" { pub fn cmark_parser_get_syntax_extensions ( parser : * mut cmark_parser ) -> * mut cmark_llist ; } extern "C" { pub fn cmark_arena_push ( ) ; } extern "C" { pub fn cmark_arena_pop ( ) -> :: std :: os :: raw :: c_int ; } extern "C" { pub fn cmark_gfm_core_extensions_ensure_registered ( ) ; } extern "C" { pub fn cmark_gfm_extensions_get_table_columns ( node : * mut cmark_node ) -> u16 ; } extern "C" { pub fn cmark_gfm_extensions_get_table_alignments ( node : * mut cmark_node ) -> * mut u8 ; } extern "C" { pub fn cmark_gfm_extensions_get_table_row_is_header ( node : * mut cmark_node ) -> :: std :: os :: raw :: c_int ; } extern "C" { pub fn cmark_gfm_extensions_get_tasklist_state ( node : * mut cmark_node ) -> * mut :: std :: os :: raw :: c_char ; } 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 ) ) ) ; }