Quelle  mod.rs   Sprache: unbekannt

pub type clock_t = u32;

pub type sa_family_t = u8;
pub type speed_t = ::c_uint;
pub type tcflag_t = ::c_uint;
pub type clockid_t = ::c_int;
pub type timer_t = ::c_int;
pub type key_t = ::c_uint;
pub type id_t = ::c_int;

pub type useconds_t = u32;
pub type dev_t = u32;
pub type socklen_t = u32;
pub type mode_t = u32;
pub type rlim64_t = u64;
pub type mqd_t = ::c_int;
pub type nfds_t = ::c_uint;
pub type idtype_t = ::c_uint;
pub type errno_t = ::c_int;
pub type rsize_t = c_ulong;

pub type Elf32_Half = u16;
pub type Elf32_Word = u32;
pub type Elf32_Off = u32;
pub type Elf32_Addr = u32;
pub type Elf32_Lword = u64;
pub type Elf32_Sword = i32;

pub type Elf64_Half = u16;
pub type Elf64_Word = u32;
pub type Elf64_Off = u64;
pub type Elf64_Addr = u64;
pub type Elf64_Xword = u64;
pub type Elf64_Sxword = i64;
pub type Elf64_Lword = u64;
pub type Elf64_Sword = i32;

pub type Elf32_Section = u16;
pub type Elf64_Section = u16;

pub type _Time32t = u32;

pub type pthread_t = ::c_int;
pub type regoff_t = ::ssize_t;

pub type nlink_t = u32;
pub type blksize_t = u32;
pub type suseconds_t = i32;

pub type ino_t = u64;
pub type off_t = i64;
pub type blkcnt_t = u64;
pub type msgqnum_t = u64;
pub type msglen_t = u64;
pub type fsblkcnt_t = u64;
pub type fsfilcnt_t = u64;
pub type rlim_t = u64;
pub type posix_spawn_file_actions_t = *mut ::c_void;
pub type posix_spawnattr_t = ::uintptr_t;

pub type pthread_mutex_t = ::sync_t;
pub type pthread_mutexattr_t = ::_sync_attr;
pub type pthread_cond_t = ::sync_t;
pub type pthread_condattr_t = ::_sync_attr;
pub type pthread_rwlockattr_t = ::_sync_attr;
pub type pthread_key_t = ::c_int;
pub type pthread_spinlock_t = sync_t;
pub type pthread_barrierattr_t = _sync_attr;
pub type sem_t = sync_t;

pub type nl_item = ::c_int;

#[cfg_attr(feature = "extra_traits", derive(Debug))]
pub enum timezone {}
impl ::Copy for timezone {}
impl ::Clone for timezone {
    fn clone(&self) -> timezone {
        *self
    }
}

s! {
    pub struct dirent_extra {
        pub d_datalen: u16,
        pub d_type: u16,
        pub d_reserved: u32,
    }

    pub struct stat {
        pub st_ino: ::ino_t,
        pub st_size: ::off_t,
        pub st_dev: ::dev_t,
        pub st_rdev: ::dev_t,
        pub st_uid: ::uid_t,
        pub st_gid: ::gid_t,
        pub __old_st_mtime: ::_Time32t,
        pub __old_st_atime: ::_Time32t,
        pub __old_st_ctime: ::_Time32t,
        pub st_mode: ::mode_t,
        pub st_nlink: ::nlink_t,
        pub st_blocksize: ::blksize_t,
        pub st_nblocks: i32,
        pub st_blksize: ::blksize_t,
        pub st_blocks: ::blkcnt_t,
        pub st_mtim:    ::timespec,
        pub st_atim:    ::timespec,
        pub st_ctim:    ::timespec,
    }

    pub struct ip_mreq {
        pub imr_multiaddr: in_addr,
        pub imr_interface: in_addr,
    }

    #[repr(packed)]
    pub struct in_addr {
        pub s_addr: ::in_addr_t,
    }

    pub struct sockaddr {
        pub sa_len: u8,
        pub sa_family: sa_family_t,
        pub sa_data: [::c_char; 14],
    }

    pub struct sockaddr_in {
        pub sin_len: u8,
        pub sin_family: sa_family_t,
        pub sin_port: ::in_port_t,
        pub sin_addr: ::in_addr,
        pub sin_zero: [i8; 8],
    }

    pub struct sockaddr_in6 {
        pub sin6_len: u8,
        pub sin6_family: sa_family_t,
        pub sin6_port: ::in_port_t,
        pub sin6_flowinfo: u32,
        pub sin6_addr: ::in6_addr,
        pub sin6_scope_id: u32,
    }

    // The order of the `ai_addr` field in this struct is crucial
    // for converting between the Rust and C types.
    pub struct addrinfo {
        pub ai_flags: ::c_int,
        pub ai_family: ::c_int,
        pub ai_socktype: ::c_int,
        pub ai_protocol: ::c_int,
        pub ai_addrlen: socklen_t,
        pub ai_canonname: *mut c_char,
        pub ai_addr: *mut ::sockaddr,
        pub ai_next: *mut addrinfo,
    }

    pub struct fd_set {
        fds_bits: [::c_uint; 2 * FD_SETSIZE / ULONG_SIZE],
    }

    pub struct tm {
        pub tm_sec: ::c_int,
        pub tm_min: ::c_int,
        pub tm_hour: ::c_int,
        pub tm_mday: ::c_int,
        pub tm_mon: ::c_int,
        pub tm_year: ::c_int,
        pub tm_wday: ::c_int,
        pub tm_yday: ::c_int,
        pub tm_isdst: ::c_int,
        pub tm_gmtoff: ::c_long,
        pub tm_zone: *const ::c_char,
    }

    #[repr(align(8))]
    pub struct sched_param {
        pub sched_priority: ::c_int,
        pub sched_curpriority: ::c_int,
        pub reserved: [::c_int; 10],
    }

    #[repr(align(8))]
    pub struct __sched_param {
        pub __sched_priority: ::c_int,
        pub __sched_curpriority: ::c_int,
        pub reserved: [::c_int; 10],
    }

    pub struct Dl_info {
        pub dli_fname: *const ::c_char,
        pub dli_fbase: *mut ::c_void,
        pub dli_sname: *const ::c_char,
        pub dli_saddr: *mut ::c_void,
    }

    pub struct lconv {
        pub currency_symbol: *mut ::c_char,
        pub int_curr_symbol: *mut ::c_char,
        pub mon_decimal_point: *mut ::c_char,
        pub mon_grouping: *mut ::c_char,
        pub mon_thousands_sep: *mut ::c_char,
        pub negative_sign: *mut ::c_char,
        pub positive_sign: *mut ::c_char,
        pub frac_digits: ::c_char,
        pub int_frac_digits: ::c_char,
        pub n_cs_precedes: ::c_char,
        pub n_sep_by_space: ::c_char,
        pub n_sign_posn: ::c_char,
        pub p_cs_precedes: ::c_char,
        pub p_sep_by_space: ::c_char,
        pub p_sign_posn: ::c_char,

        pub int_n_cs_precedes: ::c_char,
        pub int_n_sep_by_space: ::c_char,
        pub int_n_sign_posn: ::c_char,
        pub int_p_cs_precedes: ::c_char,
        pub int_p_sep_by_space: ::c_char,
        pub int_p_sign_posn: ::c_char,

        pub decimal_point: *mut ::c_char,
        pub grouping: *mut ::c_char,
        pub thousands_sep: *mut ::c_char,

        pub _Frac_grouping: *mut ::c_char,
        pub _Frac_sep: *mut ::c_char,
        pub _False: *mut ::c_char,
        pub _True: *mut ::c_char,

        pub _No: *mut ::c_char,
        pub _Yes: *mut ::c_char,
        pub _Nostr: *mut ::c_char,
        pub _Yesstr: *mut ::c_char,
        pub _Reserved: [*mut ::c_char; 8],
        }

    pub struct in_pktinfo {
        pub ipi_addr: ::in_addr,
        pub ipi_ifindex: ::c_uint,
    }

    pub struct ifaddrs {
        pub ifa_next: *mut ifaddrs,
        pub ifa_name: *mut c_char,
        pub ifa_flags: ::c_uint,
        pub ifa_addr: *mut ::sockaddr,
        pub ifa_netmask: *mut ::sockaddr,
        pub ifa_dstaddr: *mut ::sockaddr,
        pub ifa_data: *mut ::c_void
    }

    pub struct arpreq {
        pub arp_pa: ::sockaddr,
        pub arp_ha: ::sockaddr,
        pub arp_flags: ::c_int,
    }

    #[repr(packed)]
    pub struct arphdr {
        pub ar_hrd: u16,
        pub ar_pro: u16,
        pub ar_hln: u8,
        pub ar_pln: u8,
        pub ar_op: u16,
    }

    pub struct mmsghdr {
        pub msg_hdr: ::msghdr,
        pub msg_len: ::c_uint,
    }

    #[repr(align(8))]
    pub struct siginfo_t {
        pub si_signo: ::c_int,
        pub si_code: ::c_int,
        pub si_errno: ::c_int,
        __data: [u8; 36], // union
    }

    pub struct sigaction {
        pub sa_sigaction: ::sighandler_t,
        pub sa_flags: ::c_int,
        pub sa_mask: ::sigset_t,
    }

    pub struct _sync {
        _union: ::c_uint,
        __owner: ::c_uint,
    }
    pub struct rlimit64 {
        pub rlim_cur: rlim64_t,
        pub rlim_max: rlim64_t,
    }

    pub struct glob_t {
        pub gl_pathc: ::size_t,
        pub gl_matchc: ::c_int,
        pub gl_pathv: *mut *mut c_char,
        pub gl_offs: ::size_t,
        pub gl_flags: ::c_int,
        pub gl_errfunc: extern "C" fn(*const ::c_char, ::c_int) -> ::c_int,

        __unused1: *mut ::c_void,
        __unused2: *mut ::c_void,
        __unused3: *mut ::c_void,
        __unused4: *mut ::c_void,
        __unused5: *mut ::c_void,
    }

    pub struct passwd {
        pub pw_name: *mut ::c_char,
        pub pw_passwd: *mut ::c_char,
        pub pw_uid: ::uid_t,
        pub pw_gid: ::gid_t,
        pub pw_age: *mut ::c_char,
        pub pw_comment: *mut ::c_char,
        pub pw_gecos: *mut ::c_char,
        pub pw_dir: *mut ::c_char,
        pub pw_shell: *mut ::c_char,
    }

    pub struct if_nameindex {
        pub if_index: ::c_uint,
        pub if_name: *mut ::c_char,
    }

    pub struct sembuf {
        pub sem_num: ::c_ushort,
        pub sem_op: ::c_short,
        pub sem_flg: ::c_short,
    }

    pub struct Elf32_Ehdr {
        pub e_ident: [::c_uchar; 16],
        pub e_type: Elf32_Half,
        pub e_machine: Elf32_Half,
        pub e_version: Elf32_Word,
        pub e_entry: Elf32_Addr,
        pub e_phoff: Elf32_Off,
        pub e_shoff: Elf32_Off,
        pub e_flags: Elf32_Word,
        pub e_ehsize: Elf32_Half,
        pub e_phentsize: Elf32_Half,
        pub e_phnum: Elf32_Half,
        pub e_shentsize: Elf32_Half,
        pub e_shnum: Elf32_Half,
        pub e_shstrndx: Elf32_Half,
    }

    pub struct Elf64_Ehdr {
        pub e_ident: [::c_uchar; 16],
        pub e_type: Elf64_Half,
        pub e_machine: Elf64_Half,
        pub e_version: Elf64_Word,
        pub e_entry: Elf64_Addr,
        pub e_phoff: Elf64_Off,
        pub e_shoff: Elf64_Off,
        pub e_flags: Elf64_Word,
        pub e_ehsize: Elf64_Half,
        pub e_phentsize: Elf64_Half,
        pub e_phnum: Elf64_Half,
        pub e_shentsize: Elf64_Half,
        pub e_shnum: Elf64_Half,
        pub e_shstrndx: Elf64_Half,
    }

    pub struct Elf32_Sym {
        pub st_name: Elf32_Word,
        pub st_value: Elf32_Addr,
        pub st_size: Elf32_Word,
        pub st_info: ::c_uchar,
        pub st_other: ::c_uchar,
        pub st_shndx: Elf32_Section,
    }

    pub struct Elf64_Sym {
        pub st_name: Elf64_Word,
        pub st_info: ::c_uchar,
        pub st_other: ::c_uchar,
        pub st_shndx: Elf64_Section,
        pub st_value: Elf64_Addr,
        pub st_size: Elf64_Xword,
    }

    pub struct Elf32_Phdr {
        pub p_type: Elf32_Word,
        pub p_offset: Elf32_Off,
        pub p_vaddr: Elf32_Addr,
        pub p_paddr: Elf32_Addr,
        pub p_filesz: Elf32_Word,
        pub p_memsz: Elf32_Word,
        pub p_flags: Elf32_Word,
        pub p_align: Elf32_Word,
    }

    pub struct Elf64_Phdr {
        pub p_type: Elf64_Word,
        pub p_flags: Elf64_Word,
        pub p_offset: Elf64_Off,
        pub p_vaddr: Elf64_Addr,
        pub p_paddr: Elf64_Addr,
        pub p_filesz: Elf64_Xword,
        pub p_memsz: Elf64_Xword,
        pub p_align: Elf64_Xword,
    }

    pub struct Elf32_Shdr {
        pub sh_name: Elf32_Word,
        pub sh_type: Elf32_Word,
        pub sh_flags: Elf32_Word,
        pub sh_addr: Elf32_Addr,
        pub sh_offset: Elf32_Off,
        pub sh_size: Elf32_Word,
        pub sh_link: Elf32_Word,
        pub sh_info: Elf32_Word,
        pub sh_addralign: Elf32_Word,
        pub sh_entsize: Elf32_Word,
    }

    pub struct Elf64_Shdr {
        pub sh_name: Elf64_Word,
        pub sh_type: Elf64_Word,
        pub sh_flags: Elf64_Xword,
        pub sh_addr: Elf64_Addr,
        pub sh_offset: Elf64_Off,
        pub sh_size: Elf64_Xword,
        pub sh_link: Elf64_Word,
        pub sh_info: Elf64_Word,
        pub sh_addralign: Elf64_Xword,
        pub sh_entsize: Elf64_Xword,
    }

    pub struct in6_pktinfo {
        pub ipi6_addr: ::in6_addr,
        pub ipi6_ifindex: ::c_uint,
    }

    pub struct inotify_event {
        pub wd: ::c_int,
        pub mask: u32,
        pub cookie: u32,
        pub len: u32
    }

    pub struct regmatch_t {
        pub rm_so: regoff_t,
        pub rm_eo: regoff_t,
    }

    pub struct msghdr {
        pub msg_name: *mut ::c_void,
        pub msg_namelen: ::socklen_t,
        pub msg_iov: *mut ::iovec,
        pub msg_iovlen: ::c_int,
        pub msg_control: *mut ::c_void,
        pub msg_controllen: ::socklen_t,
        pub msg_flags: ::c_int,
    }

    pub struct cmsghdr {
        pub cmsg_len: ::socklen_t,
        pub cmsg_level: ::c_int,
        pub cmsg_type: ::c_int,
    }

    pub struct termios {
        pub c_iflag: ::tcflag_t,
        pub c_oflag: ::tcflag_t,
        pub c_cflag: ::tcflag_t,
        pub c_lflag: ::tcflag_t,
        pub c_cc: [::cc_t; ::NCCS],
        __reserved: [::c_uint; 3],
        pub c_ispeed: ::speed_t,
        pub c_ospeed: ::speed_t,
    }

    pub struct mallinfo {
        pub arena: ::c_int,
        pub ordblks: ::c_int,
        pub smblks: ::c_int,
        pub hblks: ::c_int,
        pub hblkhd: ::c_int,
        pub usmblks: ::c_int,
        pub fsmblks: ::c_int,
        pub uordblks: ::c_int,
        pub fordblks: ::c_int,
        pub keepcost: ::c_int,
    }

    pub struct flock {
        pub l_type: i16,
        pub l_whence: i16,
        pub l_zero1: i32,
        pub l_start: ::off_t,
        pub l_len: ::off_t,
        pub l_pid: ::pid_t,
        pub l_sysid: u32,
    }

    pub struct statvfs {
        pub f_bsize: ::c_ulong,
        pub f_frsize: ::c_ulong,
        pub f_blocks: ::fsblkcnt_t,
        pub f_bfree: ::fsblkcnt_t,
        pub f_bavail: ::fsblkcnt_t,
        pub f_files: ::fsfilcnt_t,
        pub f_ffree: ::fsfilcnt_t,
        pub f_favail: ::fsfilcnt_t,
        pub f_fsid: ::c_ulong,
        pub f_basetype: [::c_char; 16],
        pub f_flag: ::c_ulong,
        pub f_namemax: ::c_ulong,
        f_filler: [::c_uint; 21],
    }

    pub struct aiocb {
        pub aio_fildes: ::c_int,
        pub aio_reqprio: ::c_int,
        pub aio_offset: off_t,
        pub aio_buf: *mut ::c_void,
        pub aio_nbytes: ::size_t,
        pub aio_sigevent: ::sigevent,
        pub aio_lio_opcode: ::c_int,
        pub _aio_lio_state: *mut ::c_void,
        _aio_pad: [::c_int; 3],
        pub _aio_next: *mut ::aiocb,
        pub _aio_flag: ::c_uint,
        pub _aio_iotype: ::c_uint,
        pub _aio_result: ::ssize_t,
        pub _aio_error: ::c_uint,
        pub _aio_suspend: *mut ::c_void,
        pub _aio_plist: *mut ::c_void,
        pub _aio_policy: ::c_int,
        pub _aio_param: ::__sched_param,
    }

    pub struct pthread_attr_t {
        __data1: ::c_long,
        __data2: [u8; 96]
    }

    pub struct ipc_perm {
        pub uid: ::uid_t,
        pub gid: ::gid_t,
        pub cuid: ::uid_t,
        pub cgid: ::gid_t,
        pub mode: ::mode_t,
        pub seq: ::c_uint,
        pub key: ::key_t,
        _reserved: [::c_int; 4],
    }

    pub struct regex_t {
        re_magic: ::c_int,
        re_nsub: ::size_t,
        re_endp: *const ::c_char,
        re_g: *mut ::c_void,
    }

    pub struct _thread_attr {
        pub __flags: ::c_int,
        pub __stacksize: ::size_t,
        pub __stackaddr: *mut ::c_void,
        pub __exitfunc: ::Option<unsafe extern "C" fn(_fake: *mut ::c_void)>,
        pub __policy: ::c_int,
        pub __param: ::__sched_param,
        pub __guardsize: ::c_uint,
        pub __prealloc: ::c_uint,
        __spare: [::c_int; 2],
    }

    pub struct _sync_attr {
        pub __protocol: ::c_int,
        pub __flags: ::c_int,
        pub __prioceiling: ::c_int,
        pub __clockid: ::c_int,
        pub __count: ::c_int,
        __reserved: [::c_int; 3],
    }

    pub struct sockcred {
        pub sc_uid: ::uid_t,
        pub sc_euid: ::uid_t,
        pub sc_gid: ::gid_t,
        pub sc_egid: ::gid_t,
        pub sc_ngroups: ::c_int,
        pub sc_groups: [::gid_t; 1],
    }

    pub struct bpf_program {
        pub bf_len: ::c_uint,
        pub bf_insns: *mut ::bpf_insn,
    }

    pub struct bpf_stat {
        pub bs_recv: u64,
        pub bs_drop: u64,
        pub bs_capt: u64,
        bs_padding: [u64; 13],
    }

    pub struct bpf_version {
        pub bv_major: ::c_ushort,
        pub bv_minor: ::c_ushort,
    }

    pub struct bpf_hdr {
        pub bh_tstamp: ::timeval,
        pub bh_caplen: u32,
        pub bh_datalen: u32,
        pub bh_hdrlen: u16,
    }

    pub struct bpf_insn {
        pub code: u16,
        pub jt: ::c_uchar,
        pub jf: ::c_uchar,
        pub k: u32,
    }

    pub struct bpf_dltlist {
        pub bfl_len: ::c_uint,
        pub bfl_list: *mut ::c_uint,
    }

    pub struct unpcbid {
        pub unp_pid: ::pid_t,
        pub unp_euid: ::uid_t,
        pub unp_egid: ::gid_t,
    }

    pub struct dl_phdr_info {
        pub dlpi_addr: ::Elf64_Addr,
        pub dlpi_name: *const ::c_char,
        pub dlpi_phdr: *const ::Elf64_Phdr,
        pub dlpi_phnum: ::Elf64_Half,
    }

    #[repr(align(8))]
    pub struct ucontext_t {
        pub uc_link: *mut ucontext_t,
        pub uc_sigmask: ::sigset_t,
        pub uc_stack: stack_t,
        pub uc_mcontext: mcontext_t,
    }
}

s_no_extra_traits! {
    pub struct sockaddr_un {
        pub sun_len: u8,
        pub sun_family: sa_family_t,
        pub sun_path: [::c_char; 104]
    }

    pub struct sockaddr_storage {
        pub ss_len: u8,
        pub ss_family: sa_family_t,
        __ss_pad1: [::c_char; 6],
        __ss_align: i64,
        __ss_pad2: [::c_char; 112],
    }

    pub struct utsname {
        pub sysname: [::c_char; _SYSNAME_SIZE],
        pub nodename: [::c_char; _SYSNAME_SIZE],
        pub release: [::c_char; _SYSNAME_SIZE],
        pub version: [::c_char; _SYSNAME_SIZE],
        pub machine: [::c_char; _SYSNAME_SIZE],
    }

    pub struct sigevent {
        pub sigev_notify: ::c_int,
        pub __padding1: ::c_int,
        pub sigev_signo: ::c_int, // union
        pub __padding2: ::c_int,
        pub sigev_value: ::sigval,
        __sigev_un2: usize, // union

    }
    pub struct dirent {
        pub d_ino: ::ino_t,
        pub d_offset: ::off_t,
        pub d_reclen: ::c_short,
        pub d_namelen: ::c_short,
        pub d_name: [::c_char; 1], // flex array
    }

    pub struct sigset_t {
        __val: [u32; 2],
    }

    pub struct mq_attr {
        pub mq_maxmsg: ::c_long,
        pub mq_msgsize: ::c_long,
        pub mq_flags: ::c_long,
        pub mq_curmsgs: ::c_long,
        pub mq_sendwait: ::c_long,
        pub mq_recvwait: ::c_long,
    }

    pub struct msg {
        pub msg_next: *mut ::msg,
        pub msg_type: ::c_long,
        pub msg_ts: ::c_ushort,
        pub msg_spot: ::c_short,
        _pad: [u8; 4],
    }

    pub struct msqid_ds {
        pub msg_perm: ::ipc_perm,
        pub msg_first: *mut ::msg,
        pub msg_last: *mut ::msg,
        pub msg_cbytes: ::msglen_t,
        pub msg_qnum: ::msgqnum_t,
        pub msg_qbytes: ::msglen_t,
        pub msg_lspid: ::pid_t,
        pub msg_lrpid: ::pid_t,
        pub msg_stime: ::time_t,
        msg_pad1: ::c_long,
        pub msg_rtime: ::time_t,
        msg_pad2: ::c_long,
        pub msg_ctime: ::time_t,
        msg_pad3: ::c_long,
        msg_pad4: [::c_long; 4],
    }

    pub struct sockaddr_dl {
        pub sdl_len: ::c_uchar,
        pub sdl_family: ::sa_family_t,
        pub sdl_index: u16,
        pub sdl_type: ::c_uchar,
        pub sdl_nlen: ::c_uchar,
        pub sdl_alen: ::c_uchar,
        pub sdl_slen: ::c_uchar,
        pub sdl_data: [::c_char; 12],
    }

    pub struct sync_t {
        __u: ::c_uint,                     // union
        pub __owner: ::c_uint,
    }

    #[repr(align(4))]
    pub struct pthread_barrier_t {         // union
        __pad: [u8; 28],                   // union
    }

    pub struct pthread_rwlock_t {
        pub __active: ::c_int,
        pub __blockedwriters: ::c_int,
        pub __blockedreaders: ::c_int,
        pub __heavy: ::c_int,
        pub __lock: ::pthread_mutex_t,     // union
        pub __rcond: ::pthread_cond_t,     // union
        pub __wcond: ::pthread_cond_t,     // union
        pub __owner: ::c_uint,
        pub __spare: ::c_uint,
    }
}

cfg_if! {
    if #[cfg(feature = "extra_traits")] {
        // sigevent
        impl PartialEq for sigevent {
            fn eq(&self, other: &sigevent) -> bool {
                self.sigev_notify == other.sigev_notify
                    && self.sigev_signo == other.sigev_signo
                    && self.sigev_value == other.sigev_value
                    && self.__sigev_un2
                        == other.__sigev_un2
            }
        }
        impl Eq for sigevent {}
        impl ::fmt::Debug for sigevent {
            fn fmt(&self, f: &mut ::fmt::Formatter) -> ::fmt::Result {
                f.debug_struct("sigevent")
                    .field("sigev_notify", &self.sigev_notify)
                    .field("sigev_signo", &self.sigev_signo)
                    .field("sigev_value", &self.sigev_value)
                    .field("__sigev_un2",
                        &self.__sigev_un2)
                    .finish()
            }
        }
        impl ::hash::Hash for sigevent {
            fn hash<H: ::hash::Hasher>(&self, state: &mut H) {
                self.sigev_notify.hash(state);
                self.sigev_signo.hash(state);
                self.sigev_value.hash(state);
                self.__sigev_un2.hash(state);
            }
        }

        impl PartialEq for sockaddr_un {
            fn eq(&self, other: &sockaddr_un) -> bool {
                self.sun_len == other.sun_len
                    && self.sun_family == other.sun_family
                    && self
                    .sun_path
                    .iter()
                    .zip(other.sun_path.iter())
                    .all(|(a,b)| a == b)
            }
        }
        impl Eq for sockaddr_un {}
        impl ::fmt::Debug for sockaddr_un {
            fn fmt(&self, f: &mut ::fmt::Formatter) -> ::fmt::Result {
                f.debug_struct("sockaddr_un")
                    .field("sun_len", &self.sun_len)
                    .field("sun_family", &self.sun_family)
                    // FIXME: .field("sun_path", &self.sun_path)
                    .finish()
            }
        }

        impl ::hash::Hash for sockaddr_un {
            fn hash<H: ::hash::Hasher>(&self, state: &mut H) {
                self.sun_len.hash(state);
                self.sun_family.hash(state);
                self.sun_path.hash(state);
            }
        }

        // sigset_t
        impl PartialEq for sigset_t {
            fn eq(&self, other: &sigset_t) -> bool {
                self.__val == other.__val
            }
        }
        impl Eq for sigset_t {}
        impl ::fmt::Debug for sigset_t {
            fn fmt(&self, f: &mut ::fmt::Formatter) -> ::fmt::Result {
                f.debug_struct("sigset_t")
                    .field("__val", &self.__val)
                    .finish()
            }
        }
        impl ::hash::Hash for sigset_t {
            fn hash<H: ::hash::Hasher>(&self, state: &mut H) {
                self.__val.hash(state);
            }
        }

        // msg
        impl ::fmt::Debug for msg {
            fn fmt(&self, f: &mut ::fmt::Formatter) -> ::fmt::Result {
                f.debug_struct("msg")
                    .field("msg_next", &self.msg_next)
                    .field("msg_type", &self.msg_type)
                    .field("msg_ts", &self.msg_ts)
                    .field("msg_spot", &self.msg_spot)
                .finish()
            }
        }

        // msqid_ds
        impl ::fmt::Debug for msqid_ds {
            fn fmt(&self, f: &mut ::fmt::Formatter) -> ::fmt::Result {
                f.debug_struct("msqid_ds")
                    .field("msg_perm", &self.msg_perm)
                    .field("msg_first", &self.msg_first)
                    .field("msg_cbytes", &self.msg_cbytes)
                    .field("msg_qnum", &self.msg_qnum)
                    .field("msg_qbytes", &self.msg_qbytes)
                    .field("msg_lspid", &self.msg_lspid)
                    .field("msg_lrpid", &self.msg_lrpid)
                    .field("msg_stime", &self.msg_stime)
                    .field("msg_rtime", &self.msg_rtime)
                    .field("msg_ctime", &self.msg_ctime)
                    .finish()
            }
        }

        // sockaddr_dl
        impl ::fmt::Debug for sockaddr_dl {
            fn fmt(&self, f: &mut ::fmt::Formatter) -> ::fmt::Result {
                f.debug_struct("sockaddr_dl")
                    .field("sdl_len", &self.sdl_len)
                    .field("sdl_family", &self.sdl_family)
                    .field("sdl_index", &self.sdl_index)
                    .field("sdl_type", &self.sdl_type)
                    .field("sdl_nlen", &self.sdl_nlen)
                    .field("sdl_alen", &self.sdl_alen)
                    .field("sdl_slen", &self.sdl_slen)
                    .field("sdl_data", &self.sdl_data)
                    .finish()
            }
        }
        impl PartialEq for sockaddr_dl {
            fn eq(&self, other: &sockaddr_dl) -> bool {
                self.sdl_len == other.sdl_len
                    && self.sdl_family == other.sdl_family
                    && self.sdl_index == other.sdl_index
                    && self.sdl_type == other.sdl_type
                    && self.sdl_nlen == other.sdl_nlen
                    && self.sdl_alen == other.sdl_alen
                    && self.sdl_slen == other.sdl_slen
                    && self
                    .sdl_data
                    .iter()
                    .zip(other.sdl_data.iter())
                    .all(|(a,b)| a == b)
            }
        }
        impl Eq for sockaddr_dl {}
        impl ::hash::Hash for sockaddr_dl {
            fn hash<H: ::hash::Hasher>(&self, state: &mut H) {
                self.sdl_len.hash(state);
                self.sdl_family.hash(state);
                self.sdl_index.hash(state);
                self.sdl_type.hash(state);
                self.sdl_nlen.hash(state);
                self.sdl_alen.hash(state);
                self.sdl_slen.hash(state);
                self.sdl_data.hash(state);
            }
        }

        // sync_t
        impl ::fmt::Debug for sync_t {
            fn fmt(&self, f: &mut ::fmt::Formatter) -> ::fmt::Result {
                f.debug_struct("sync_t")
                    .field("__owner", &self.__owner)
                    .field("__u", &self.__u)
                    .finish()
            }
        }

        // pthread_barrier_t
        impl ::fmt::Debug for pthread_barrier_t {
            fn fmt(&self, f: &mut ::fmt::Formatter) -> ::fmt::Result {
                f.debug_struct("pthread_barrier_t")
                    .field("__pad", &self.__pad)
                    .finish()
            }
        }

        // pthread_rwlock_t
        impl ::fmt::Debug for pthread_rwlock_t {
            fn fmt(&self, f: &mut ::fmt::Formatter) -> ::fmt::Result {
                f.debug_struct("pthread_rwlock_t")
                    .field("__active", &self.__active)
                    .field("__blockedwriters", &self.__blockedwriters)
                    .field("__blockedreaders", &self.__blockedreaders)
                    .field("__heavy", &self.__heavy)
                    .field("__lock", &self.__lock)
                    .field("__rcond", &self.__rcond)
                    .field("__wcond", &self.__wcond)
                    .field("__owner", &self.__owner)
                    .field("__spare", &self.__spare)
                .finish()
            }
        }

        // syspage_entry
        impl ::fmt::Debug for syspage_entry {
            fn fmt(&self, f: &mut ::fmt::Formatter) -> ::fmt::Result {
                f.debug_struct("syspage_entry")
                    .field("size", &self.size)
                    .field("total_size", &self.total_size)
                    .field("type_", &self.type_)
                    .field("num_cpu", &self.num_cpu)
                    .field("system_private", &self.system_private)
                    .field("old_asinfo", &self.old_asinfo)
                    .field("hwinfo", &self.hwinfo)
                    .field("old_cpuinfo", &self.old_cpuinfo)
                    .field("old_cacheattr", &self.old_cacheattr)
                    .field("qtime", &self.qtime)
                    .field("callout", &self.callout)
                    .field("callin", &self.callin)
                    .field("typed_strings", &self.typed_strings)
                    .field("strings", &self.strings)
                    .field("old_intrinfo", &self.old_intrinfo)
                    .field("smp", &self.smp)
                    .field("pminfo", &self.pminfo)
                    .field("old_mdriver", &self.old_mdriver)
                    .field("new_asinfo", &self.new_asinfo)
                    .field("new_cpuinfo", &self.new_cpuinfo)
                    .field("new_cacheattr", &self.new_cacheattr)
                    .field("new_intrinfo", &self.new_intrinfo)
                    .field("new_mdriver", &self.new_mdriver)
                    .finish()
            }
        }

        impl PartialEq for utsname {
            fn eq(&self, other: &utsname) -> bool {
                self.sysname
                    .iter()
                    .zip(other.sysname.iter())
                    .all(|(a,b)| a == b)
                    && self
                    .nodename
                    .iter()
                    .zip(other.nodename.iter())
                    .all(|(a,b)| a == b)
                    && self
                    .release
                    .iter()
                    .zip(other.release.iter())
                    .all(|(a,b)| a == b)
                    && self
                    .version
                    .iter()
                    .zip(other.version.iter())
                    .all(|(a,b)| a == b)
                    && self
                    .machine
                    .iter()
                    .zip(other.machine.iter())
                    .all(|(a,b)| a == b)
            }
        }

        impl Eq for utsname {}

        impl ::fmt::Debug for utsname {
            fn fmt(&self, f: &mut ::fmt::Formatter) -> ::fmt::Result {
                f.debug_struct("utsname")
                // FIXME: .field("sysname", &self.sysname)
                // FIXME: .field("nodename", &self.nodename)
                // FIXME: .field("release", &self.release)
                // FIXME: .field("version", &self.version)
                // FIXME: .field("machine", &self.machine)
                    .finish()
            }
        }

        impl ::hash::Hash for utsname {
            fn hash<H: ::hash::Hasher>(&self, state: &mut H) {
                self.sysname.hash(state);
                self.nodename.hash(state);
                self.release.hash(state);
                self.version.hash(state);
                self.machine.hash(state);
            }
        }

        impl PartialEq for mq_attr {
            fn eq(&self, other: &mq_attr) -> bool {
                self.mq_maxmsg == other.mq_maxmsg &&
                self.mq_msgsize == other.mq_msgsize &&
                self.mq_flags == other.mq_flags &&
                self.mq_curmsgs == other.mq_curmsgs &&
                self.mq_msgsize == other.mq_msgsize &&
                self.mq_sendwait == other.mq_sendwait &&
                self.mq_recvwait == other.mq_recvwait
            }
        }

        impl Eq for mq_attr {}

        impl ::fmt::Debug for mq_attr {
            fn fmt(&self, f: &mut ::fmt::Formatter) -> ::fmt::Result {
                f.debug_struct("mq_attr")
                    .field("mq_maxmsg", &self.mq_maxmsg)
                    .field("mq_msgsize", &self.mq_msgsize)
                    .field("mq_flags", &self.mq_flags)
                    .field("mq_curmsgs", &self.mq_curmsgs)
                    .field("mq_msgsize", &self.mq_msgsize)
                    .field("mq_sendwait", &self.mq_sendwait)
                    .field("mq_recvwait", &self.mq_recvwait)
                    .finish()
            }
        }
        impl ::hash::Hash for mq_attr {
            fn hash<H: ::hash::Hasher>(&self, state: &mut H) {
                self.mq_maxmsg.hash(state);
                self.mq_msgsize.hash(state);
                self.mq_flags.hash(state);
                self.mq_curmsgs.hash(state);
                self.mq_sendwait.hash(state);
                self.mq_recvwait.hash(state);
            }
        }

        impl PartialEq for sockaddr_storage {
            fn eq(&self, other: &sockaddr_storage) -> bool {
                self.ss_len == other.ss_len
                    && self.ss_family == other.ss_family
                    && self.__ss_pad1 == other.__ss_pad1
                    && self.__ss_align == other.__ss_align
                    && self
                    .__ss_pad2
                    .iter()
                    .zip(other.__ss_pad2.iter())
                    .all(|(a, b)| a == b)
            }
        }

        impl Eq for sockaddr_storage {}

        impl ::fmt::Debug for sockaddr_storage {
            fn fmt(&self, f: &mut ::fmt::Formatter) -> ::fmt::Result {
                f.debug_struct("sockaddr_storage")
                    .field("ss_len", &self.ss_len)
                    .field("ss_family", &self.ss_family)
                    .field("__ss_pad1", &self.__ss_pad1)
                    .field("__ss_align", &self.__ss_align)
                    // FIXME: .field("__ss_pad2", &self.__ss_pad2)
                    .finish()
            }
        }

        impl ::hash::Hash for sockaddr_storage {
            fn hash<H: ::hash::Hasher>(&self, state: &mut H) {
                self.ss_len.hash(state);
                self.ss_family.hash(state);
                self.__ss_pad1.hash(state);
                self.__ss_align.hash(state);
                self.__ss_pad2.hash(state);
            }
        }

        impl PartialEq for dirent {
            fn eq(&self, other: &dirent) -> bool {
                self.d_ino == other.d_ino
                    && self.d_offset == other.d_offset
                    && self.d_reclen == other.d_reclen
                    && self.d_namelen == other.d_namelen
                    && self
                    .d_name[..self.d_namelen as _]
                    .iter()
                    .zip(other.d_name.iter())
                    .all(|(a,b)| a == b)
            }
        }

        impl Eq for dirent {}

        impl ::fmt::Debug for dirent {
            fn fmt(&self, f: &mut ::fmt::Formatter) -> ::fmt::Result {
                f.debug_struct("dirent")
                    .field("d_ino", &self.d_ino)
                    .field("d_offset", &self.d_offset)
                    .field("d_reclen", &self.d_reclen)
                    .field("d_namelen", &self.d_namelen)
                    .field("d_name", &&self.d_name[..self.d_namelen as _])
                    .finish()
            }
        }

        impl ::hash::Hash for dirent {
            fn hash<H: ::hash::Hasher>(&self, state: &mut H) {
                self.d_ino.hash(state);
                self.d_offset.hash(state);
                self.d_reclen.hash(state);
                self.d_namelen.hash(state);
                self.d_name[..self.d_namelen as _].hash(state);
            }
        }
    }
}

pub const _SYSNAME_SIZE: usize = 256 + 1;
pub const RLIM_INFINITY: ::rlim_t = 0xfffffffffffffffd;
pub const O_LARGEFILE: ::c_int = 0o0100000;

// intentionally not public, only used for fd_set
cfg_if! {
    if #[cfg(target_pointer_width = "32")] {
        const ULONG_SIZE: usize = 32;
    } else if #[cfg(target_pointer_width = "64")] {
        const ULONG_SIZE: usize = 64;
    } else {
        // Unknown target_pointer_width
    }
}

pub const EXIT_FAILURE: ::c_int = 1;
pub const EXIT_SUCCESS: ::c_int = 0;
pub const RAND_MAX: ::c_int = 32767;
pub const EOF: ::c_int = -1;
pub const SEEK_SET: ::c_int = 0;
pub const SEEK_CUR: ::c_int = 1;
pub const SEEK_END: ::c_int = 2;
pub const _IOFBF: ::c_int = 0;
pub const _IONBF: ::c_int = 2;
pub const _IOLBF: ::c_int = 1;

pub const F_DUPFD: ::c_int = 0;
pub const F_GETFD: ::c_int = 1;
pub const F_SETFD: ::c_int = 2;
pub const F_GETFL: ::c_int = 3;
pub const F_SETFL: ::c_int = 4;

pub const F_DUPFD_CLOEXEC: ::c_int = 5;

pub const SIGTRAP: ::c_int = 5;

pub const CLOCK_REALTIME: ::clockid_t = 0;
pub const CLOCK_MONOTONIC: ::clockid_t = 2;
pub const CLOCK_PROCESS_CPUTIME_ID: ::clockid_t = 3;
pub const CLOCK_THREAD_CPUTIME_ID: ::clockid_t = 4;
pub const TIMER_ABSTIME: ::c_uint = 0x80000000;

pub const RUSAGE_SELF: ::c_int = 0;

pub const F_OK: ::c_int = 0;
pub const X_OK: ::c_int = 1;
pub const W_OK: ::c_int = 2;
pub const R_OK: ::c_int = 4;

pub const STDIN_FILENO: ::c_int = 0;
pub const STDOUT_FILENO: ::c_int = 1;
pub const STDERR_FILENO: ::c_int = 2;

pub const SIGHUP: ::c_int = 1;
pub const SIGINT: ::c_int = 2;
pub const SIGQUIT: ::c_int = 3;
pub const SIGILL: ::c_int = 4;
pub const SIGABRT: ::c_int = 6;
pub const SIGFPE: ::c_int = 8;
pub const SIGKILL: ::c_int = 9;
pub const SIGSEGV: ::c_int = 11;
pub const SIGPIPE: ::c_int = 13;
pub const SIGALRM: ::c_int = 14;
pub const SIGTERM: ::c_int = 15;

pub const PROT_NONE: ::c_int = 0x00000000;
pub const PROT_READ: ::c_int = 0x00000100;
pub const PROT_WRITE: ::c_int = 0x00000200;
pub const PROT_EXEC: ::c_int = 0x00000400;

pub const MAP_FILE: ::c_int = 0;
pub const MAP_SHARED: ::c_int = 1;
pub const MAP_PRIVATE: ::c_int = 2;
pub const MAP_FIXED: ::c_int = 0x10;

pub const MAP_FAILED: *mut ::c_void = !0 as *mut ::c_void;

pub const MS_ASYNC: ::c_int = 1;
pub const MS_INVALIDATE: ::c_int = 4;
pub const MS_SYNC: ::c_int = 2;

pub const SCM_RIGHTS: ::c_int = 0x01;
pub const SCM_TIMESTAMP: ::c_int = 0x02;
pub const SCM_CREDS: ::c_int = 0x04;

pub const MAP_TYPE: ::c_int = 0x3;

pub const IFF_UP: ::c_int = 0x00000001;
pub const IFF_BROADCAST: ::c_int = 0x00000002;
pub const IFF_DEBUG: ::c_int = 0x00000004;
pub const IFF_LOOPBACK: ::c_int = 0x00000008;
pub const IFF_POINTOPOINT: ::c_int = 0x00000010;
pub const IFF_NOTRAILERS: ::c_int = 0x00000020;
pub const IFF_RUNNING: ::c_int = 0x00000040;
pub const IFF_NOARP: ::c_int = 0x00000080;
pub const IFF_PROMISC: ::c_int = 0x00000100;
pub const IFF_ALLMULTI: ::c_int = 0x00000200;
pub const IFF_MULTICAST: ::c_int = 0x00008000;

pub const AF_UNSPEC: ::c_int = 0;
pub const AF_UNIX: ::c_int = AF_LOCAL;
pub const AF_LOCAL: ::c_int = 1;
pub const AF_INET: ::c_int = 2;
pub const AF_IPX: ::c_int = 23;
pub const AF_APPLETALK: ::c_int = 16;
pub const AF_INET6: ::c_int = 24;
pub const AF_ROUTE: ::c_int = 17;
pub const AF_SNA: ::c_int = 11;
pub const AF_BLUETOOTH: ::c_int = 31;
pub const AF_ISDN: ::c_int = 26;

pub const PF_UNSPEC: ::c_int = AF_UNSPEC;
pub const PF_UNIX: ::c_int = PF_LOCAL;
pub const PF_LOCAL: ::c_int = AF_LOCAL;
pub const PF_INET: ::c_int = AF_INET;
pub const PF_IPX: ::c_int = AF_IPX;
pub const PF_APPLETALK: ::c_int = AF_APPLETALK;
pub const PF_INET6: ::c_int = AF_INET6;
pub const pseudo_AF_KEY: ::c_int = 29;
pub const PF_KEY: ::c_int = pseudo_AF_KEY;
pub const PF_ROUTE: ::c_int = AF_ROUTE;
pub const PF_SNA: ::c_int = AF_SNA;

pub const PF_BLUETOOTH: ::c_int = AF_BLUETOOTH;
pub const PF_ISDN: ::c_int = AF_ISDN;

pub const SOMAXCONN: ::c_int = 128;

pub const MSG_OOB: ::c_int = 0x0001;
pub const MSG_PEEK: ::c_int = 0x0002;
pub const MSG_DONTROUTE: ::c_int = 0x0004;
pub const MSG_CTRUNC: ::c_int = 0x0020;
pub const MSG_TRUNC: ::c_int = 0x0010;
pub const MSG_DONTWAIT: ::c_int = 0x0080;
pub const MSG_EOR: ::c_int = 0x0008;
pub const MSG_WAITALL: ::c_int = 0x0040;
pub const MSG_NOSIGNAL: ::c_int = 0x0800;
pub const MSG_WAITFORONE: ::c_int = 0x2000;

pub const IP_TOS: ::c_int = 3;
pub const IP_TTL: ::c_int = 4;
pub const IP_HDRINCL: ::c_int = 2;
pub const IP_OPTIONS: ::c_int = 1;
pub const IP_RECVOPTS: ::c_int = 5;
pub const IP_RETOPTS: ::c_int = 8;
pub const IP_PKTINFO: ::c_int = 25;
pub const IP_IPSEC_POLICY_COMPAT: ::c_int = 22;
pub const IP_MULTICAST_IF: ::c_int = 9;
pub const IP_MULTICAST_TTL: ::c_int = 10;
pub const IP_MULTICAST_LOOP: ::c_int = 11;
pub const IP_ADD_MEMBERSHIP: ::c_int = 12;
pub const IP_DROP_MEMBERSHIP: ::c_int = 13;
pub const IP_DEFAULT_MULTICAST_TTL: ::c_int = 1;
pub const IP_DEFAULT_MULTICAST_LOOP: ::c_int = 1;

pub const IPPROTO_HOPOPTS: ::c_int = 0;
pub const IPPROTO_IGMP: ::c_int = 2;
pub const IPPROTO_IPIP: ::c_int = 4;
pub const IPPROTO_EGP: ::c_int = 8;
pub const IPPROTO_PUP: ::c_int = 12;
pub const IPPROTO_IDP: ::c_int = 22;
pub const IPPROTO_TP: ::c_int = 29;
pub const IPPROTO_ROUTING: ::c_int = 43;
pub const IPPROTO_FRAGMENT: ::c_int = 44;
pub const IPPROTO_RSVP: ::c_int = 46;
pub const IPPROTO_GRE: ::c_int = 47;
pub const IPPROTO_ESP: ::c_int = 50;
pub const IPPROTO_AH: ::c_int = 51;
pub const IPPROTO_NONE: ::c_int = 59;
pub const IPPROTO_DSTOPTS: ::c_int = 60;
pub const IPPROTO_ENCAP: ::c_int = 98;
pub const IPPROTO_PIM: ::c_int = 103;
pub const IPPROTO_SCTP: ::c_int = 132;
pub const IPPROTO_RAW: ::c_int = 255;
pub const IPPROTO_MAX: ::c_int = 256;
pub const IPPROTO_CARP: ::c_int = 112;
pub const IPPROTO_DIVERT: ::c_int = 259;
pub const IPPROTO_DONE: ::c_int = 257;
pub const IPPROTO_EON: ::c_int = 80;
pub const IPPROTO_ETHERIP: ::c_int = 97;
pub const IPPROTO_GGP: ::c_int = 3;
pub const IPPROTO_IPCOMP: ::c_int = 108;
pub const IPPROTO_MOBILE: ::c_int = 55;

pub const IPV6_RTHDR_LOOSE: ::c_int = 0;
pub const IPV6_RTHDR_STRICT: ::c_int = 1;
pub const IPV6_UNICAST_HOPS: ::c_int = 4;
pub const IPV6_MULTICAST_IF: ::c_int = 9;
pub const IPV6_MULTICAST_HOPS: ::c_int = 10;
pub const IPV6_MULTICAST_LOOP: ::c_int = 11;
pub const IPV6_JOIN_GROUP: ::c_int = 12;
pub const IPV6_LEAVE_GROUP: ::c_int = 13;
pub const IPV6_CHECKSUM: ::c_int = 26;
pub const IPV6_V6ONLY: ::c_int = 27;
pub const IPV6_IPSEC_POLICY_COMPAT: ::c_int = 28;
pub const IPV6_RTHDRDSTOPTS: ::c_int = 35;
pub const IPV6_RECVPKTINFO: ::c_int = 36;
pub const IPV6_RECVHOPLIMIT: ::c_int = 37;
pub const IPV6_RECVRTHDR: ::c_int = 38;
pub const IPV6_RECVHOPOPTS: ::c_int = 39;
pub const IPV6_RECVDSTOPTS: ::c_int = 40;
pub const IPV6_RECVPATHMTU: ::c_int = 43;
pub const IPV6_PATHMTU: ::c_int = 44;
pub const IPV6_PKTINFO: ::c_int = 46;
pub const IPV6_HOPLIMIT: ::c_int = 47;
pub const IPV6_NEXTHOP: ::c_int = 48;
pub const IPV6_HOPOPTS: ::c_int = 49;
pub const IPV6_DSTOPTS: ::c_int = 50;
pub const IPV6_RECVTCLASS: ::c_int = 57;
pub const IPV6_TCLASS: ::c_int = 61;
pub const IPV6_DONTFRAG: ::c_int = 62;

pub const TCP_NODELAY: ::c_int = 0x01;
pub const TCP_MAXSEG: ::c_int = 0x02;
pub const TCP_MD5SIG: ::c_int = 0x10;
pub const TCP_KEEPALIVE: ::c_int = 0x04;

pub const SHUT_RD: ::c_int = 0;
pub const SHUT_WR: ::c_int = 1;
pub const SHUT_RDWR: ::c_int = 2;

pub const LOCK_SH: ::c_int = 0x1;
pub const LOCK_EX: ::c_int = 0x2;
pub const LOCK_NB: ::c_int = 0x4;
pub const LOCK_UN: ::c_int = 0x8;

pub const SS_ONSTACK: ::c_int = 1;
pub const SS_DISABLE: ::c_int = 2;

pub const PATH_MAX: ::c_int = 1024;

pub const UIO_MAXIOV: ::c_int = 1024;

pub const FD_SETSIZE: usize = 256;

pub const TCIOFF: ::c_int = 0x0002;
pub const TCION: ::c_int = 0x0003;
pub const TCOOFF: ::c_int = 0x0000;
pub const TCOON: ::c_int = 0x0001;
pub const TCIFLUSH: ::c_int = 0;
pub const TCOFLUSH: ::c_int = 1;
pub const TCIOFLUSH: ::c_int = 2;
pub const NL0: ::tcflag_t = 0x000;
pub const NL1: ::tcflag_t = 0x100;
pub const TAB0: ::tcflag_t = 0x0000;
pub const CR0: ::tcflag_t = 0x000;
pub const FF0: ::tcflag_t = 0x0000;
pub const BS0: ::tcflag_t = 0x0000;
pub const VT0: ::tcflag_t = 0x0000;
pub const VERASE: usize = 2;
pub const VKILL: usize = 3;
pub const VINTR: usize = 0;
pub const VQUIT: usize = 1;
pub const VLNEXT: usize = 15;
pub const IGNBRK: ::tcflag_t = 0x00000001;
pub const BRKINT: ::tcflag_t = 0x00000002;
pub const IGNPAR: ::tcflag_t = 0x00000004;
pub const PARMRK: ::tcflag_t = 0x00000008;
pub const INPCK: ::tcflag_t = 0x00000010;
pub const ISTRIP: ::tcflag_t = 0x00000020;
pub const INLCR: ::tcflag_t = 0x00000040;
pub const IGNCR: ::tcflag_t = 0x00000080;
pub const ICRNL: ::tcflag_t = 0x00000100;
pub const IXANY: ::tcflag_t = 0x00000800;
pub const IMAXBEL: ::tcflag_t = 0x00002000;
pub const OPOST: ::tcflag_t = 0x00000001;
pub const CS5: ::tcflag_t = 0x00;
pub const ECHO: ::tcflag_t = 0x00000008;
pub const OCRNL: ::tcflag_t = 0x00000008;
pub const ONOCR: ::tcflag_t = 0x00000010;
pub const ONLRET: ::tcflag_t = 0x00000020;
pub const OFILL: ::tcflag_t = 0x00000040;
pub const OFDEL: ::tcflag_t = 0x00000080;

pub const WNOHANG: ::c_int = 0x0040;
pub const WUNTRACED: ::c_int = 0x0004;
pub const WSTOPPED: ::c_int = WUNTRACED;
pub const WEXITED: ::c_int = 0x0001;
pub const WCONTINUED: ::c_int = 0x0008;
pub const WNOWAIT: ::c_int = 0x0080;
pub const WTRAPPED: ::c_int = 0x0002;

pub const RTLD_LOCAL: ::c_int = 0x0200;
pub const RTLD_LAZY: ::c_int = 0x0001;

pub const POSIX_FADV_NORMAL: ::c_int = 0;
pub const POSIX_FADV_RANDOM: ::c_int = 2;
pub const POSIX_FADV_SEQUENTIAL: ::c_int = 1;
pub const POSIX_FADV_WILLNEED: ::c_int = 3;

pub const AT_FDCWD: ::c_int = -100;
pub const AT_EACCESS: ::c_int = 0x0001;
pub const AT_SYMLINK_NOFOLLOW: ::c_int = 0x0002;
pub const AT_SYMLINK_FOLLOW: ::c_int = 0x0004;
pub const AT_REMOVEDIR: ::c_int = 0x0008;

pub const LOG_CRON: ::c_int = 9 << 3;
pub const LOG_AUTHPRIV: ::c_int = 10 << 3;
pub const LOG_FTP: ::c_int = 11 << 3;
pub const LOG_PERROR: ::c_int = 0x20;

pub const PIPE_BUF: usize = 5120;

pub const CLD_EXITED: ::c_int = 1;
pub const CLD_KILLED: ::c_int = 2;
pub const CLD_DUMPED: ::c_int = 3;
pub const CLD_TRAPPED: ::c_int = 4;
pub const CLD_STOPPED: ::c_int = 5;
pub const CLD_CONTINUED: ::c_int = 6;

pub const UTIME_OMIT: c_long = 0x40000002;
pub const UTIME_NOW: c_long = 0x40000001;

pub const POLLIN: ::c_short = POLLRDNORM | POLLRDBAND;
pub const POLLPRI: ::c_short = 0x0008;
pub const POLLOUT: ::c_short = 0x0002;
pub const POLLERR: ::c_short = 0x0020;
pub const POLLHUP: ::c_short = 0x0040;
pub const POLLNVAL: ::c_short = 0x1000;
pub const POLLRDNORM: ::c_short = 0x0001;
pub const POLLRDBAND: ::c_short = 0x0004;

pub const IPTOS_LOWDELAY: u8 = 0x10;
pub const IPTOS_THROUGHPUT: u8 = 0x08;
pub const IPTOS_RELIABILITY: u8 = 0x04;
pub const IPTOS_MINCOST: u8 = 0x02;

pub const IPTOS_PREC_NETCONTROL: u8 = 0xe0;
pub const IPTOS_PREC_INTERNETCONTROL: u8 = 0xc0;
pub const IPTOS_PREC_CRITIC_ECP: u8 = 0xa0;
pub const IPTOS_PREC_FLASHOVERRIDE: u8 = 0x80;
pub const IPTOS_PREC_FLASH: u8 = 0x60;
pub const IPTOS_PREC_IMMEDIATE: u8 = 0x40;
pub const IPTOS_PREC_PRIORITY: u8 = 0x20;
pub const IPTOS_PREC_ROUTINE: u8 = 0x00;

pub const IPTOS_ECN_MASK: u8 = 0x03;
pub const IPTOS_ECN_ECT1: u8 = 0x01;
pub const IPTOS_ECN_ECT0: u8 = 0x02;
pub const IPTOS_ECN_CE: u8 = 0x03;

pub const IPOPT_CONTROL: u8 = 0x00;
pub const IPOPT_RESERVED1: u8 = 0x20;
pub const IPOPT_RESERVED2: u8 = 0x60;
pub const IPOPT_LSRR: u8 = 131;
pub const IPOPT_RR: u8 = 7;
pub const IPOPT_SSRR: u8 = 137;
pub const IPDEFTTL: u8 = 64;
pub const IPOPT_OPTVAL: u8 = 0;
pub const IPOPT_OLEN: u8 = 1;
pub const IPOPT_OFFSET: u8 = 2;
pub const IPOPT_MINOFF: u8 = 4;
pub const IPOPT_NOP: u8 = 1;
pub const IPOPT_EOL: u8 = 0;
pub const IPOPT_TS: u8 = 68;
pub const IPOPT_TS_TSONLY: u8 = 0;
pub const IPOPT_TS_TSANDADDR: u8 = 1;
pub const IPOPT_TS_PRESPEC: u8 = 3;

pub const MAX_IPOPTLEN: u8 = 40;
pub const IPVERSION: u8 = 4;
pub const MAXTTL: u8 = 255;

pub const ARPHRD_ETHER: u16 = 1;
pub const ARPHRD_IEEE802: u16 = 6;
pub const ARPHRD_ARCNET: u16 = 7;
pub const ARPHRD_IEEE1394: u16 = 24;

pub const SOL_SOCKET: ::c_int = 0xffff;

pub const SO_DEBUG: ::c_int = 0x0001;
pub const SO_REUSEADDR: ::c_int = 0x0004;
pub const SO_TYPE: ::c_int = 0x1008;
pub const SO_ERROR: ::c_int = 0x1007;
pub const SO_DONTROUTE: ::c_int = 0x0010;
pub const SO_BROADCAST: ::c_int = 0x0020;
pub const SO_SNDBUF: ::c_int = 0x1001;
pub const SO_RCVBUF: ::c_int = 0x1002;
pub const SO_KEEPALIVE: ::c_int = 0x0008;
pub const SO_OOBINLINE: ::c_int = 0x0100;
pub const SO_LINGER: ::c_int = 0x0080;
pub const SO_REUSEPORT: ::c_int = 0x0200;
pub const SO_RCVLOWAT: ::c_int = 0x1004;
pub const SO_SNDLOWAT: ::c_int = 0x1003;
pub const SO_RCVTIMEO: ::c_int = 0x1006;
pub const SO_SNDTIMEO: ::c_int = 0x1005;
pub const SO_BINDTODEVICE: ::c_int = 0x0800;
pub const SO_TIMESTAMP: ::c_int = 0x0400;
pub const SO_ACCEPTCONN: ::c_int = 0x0002;

pub const TIOCM_LE: ::c_int = 0x0100;
pub const TIOCM_DTR: ::c_int = 0x0001;
pub const TIOCM_RTS: ::c_int = 0x0002;
pub const TIOCM_ST: ::c_int = 0x0200;
pub const TIOCM_SR: ::c_int = 0x0400;
pub const TIOCM_CTS: ::c_int = 0x1000;
pub const TIOCM_CAR: ::c_int = TIOCM_CD;
pub const TIOCM_CD: ::c_int = 0x8000;
pub const TIOCM_RNG: ::c_int = TIOCM_RI;
pub const TIOCM_RI: ::c_int = 0x4000;
pub const TIOCM_DSR: ::c_int = 0x2000;

pub const SCHED_OTHER: ::c_int = 3;
pub const SCHED_FIFO: ::c_int = 1;
pub const SCHED_RR: ::c_int = 2;

pub const IPC_PRIVATE: ::key_t = 0;

pub const IPC_CREAT: ::c_int = 0o001000;
pub const IPC_EXCL: ::c_int = 0o002000;
pub const IPC_NOWAIT: ::c_int = 0o004000;

pub const IPC_RMID: ::c_int = 0;
pub const IPC_SET: ::c_int = 1;
pub const IPC_STAT: ::c_int = 2;

pub const MSG_NOERROR: ::c_int = 0o010000;

pub const LOG_NFACILITIES: ::c_int = 24;

pub const SEM_FAILED: *mut ::sem_t = 0xFFFFFFFFFFFFFFFF as *mut sem_t;

pub const AI_PASSIVE: ::c_int = 0x00000001;
pub const AI_CANONNAME: ::c_int = 0x00000002;
pub const AI_NUMERICHOST: ::c_int = 0x00000004;

pub const AI_NUMERICSERV: ::c_int = 0x00000008;

pub const EAI_BADFLAGS: ::c_int = 3;
pub const EAI_NONAME: ::c_int = 8;
pub const EAI_AGAIN: ::c_int = 2;
pub const EAI_FAIL: ::c_int = 4;
pub const EAI_NODATA: ::c_int = 7;
pub const EAI_FAMILY: ::c_int = 5;
pub const EAI_SOCKTYPE: ::c_int = 10;
pub const EAI_SERVICE: ::c_int = 9;
pub const EAI_MEMORY: ::c_int = 6;
pub const EAI_SYSTEM: ::c_int = 11;
pub const EAI_OVERFLOW: ::c_int = 14;

pub const NI_NUMERICHOST: ::c_int = 0x00000002;
pub const NI_NUMERICSERV: ::c_int = 0x00000008;
pub const NI_NOFQDN: ::c_int = 0x00000001;
pub const NI_NAMEREQD: ::c_int = 0x00000004;
pub const NI_DGRAM: ::c_int = 0x00000010;

pub const AIO_CANCELED: ::c_int = 0;
pub const AIO_NOTCANCELED: ::c_int = 2;
pub const AIO_ALLDONE: ::c_int = 1;
pub const LIO_READ: ::c_int = 1;
pub const LIO_WRITE: ::c_int = 2;
pub const LIO_NOP: ::c_int = 0;
pub const LIO_WAIT: ::c_int = 1;
pub const LIO_NOWAIT: ::c_int = 0;

pub const ITIMER_REAL: ::c_int = 0;
pub const ITIMER_VIRTUAL: ::c_int = 1;
pub const ITIMER_PROF: ::c_int = 2;

pub const POSIX_SPAWN_RESETIDS: ::c_int = 0x00000010;
pub const POSIX_SPAWN_SETPGROUP: ::c_int = 0x00000001;
pub const POSIX_SPAWN_SETSIGDEF: ::c_int = 0x00000004;
pub const POSIX_SPAWN_SETSIGMASK: ::c_int = 0x00000002;
pub const POSIX_SPAWN_SETSCHEDPARAM: ::c_int = 0x00000400;
pub const POSIX_SPAWN_SETSCHEDULER: ::c_int = 0x00000040;

pub const IPTOS_ECN_NOT_ECT: u8 = 0x00;

pub const RTF_UP: ::c_ushort = 0x0001;
pub const RTF_GATEWAY: ::c_ushort = 0x0002;

pub const RTF_HOST: ::c_ushort = 0x0004;
pub const RTF_DYNAMIC: ::c_ushort = 0x0010;
pub const RTF_MODIFIED: ::c_ushort = 0x0020;
pub const RTF_REJECT: ::c_ushort = 0x0008;
pub const RTF_STATIC: ::c_ushort = 0x0800;
pub const RTF_XRESOLVE: ::c_ushort = 0x0200;
pub const RTF_BROADCAST: u32 = 0x80000;
pub const RTM_NEWADDR: u16 = 0xc;
pub const RTM_DELADDR: u16 = 0xd;
pub const RTA_DST: ::c_ushort = 0x1;
pub const RTA_GATEWAY: ::c_ushort = 0x2;

pub const UDP_ENCAP: ::c_int = 100;

pub const IN_ACCESS: u32 = 0x00000001;
pub const IN_MODIFY: u32 = 0x00000002;
pub const IN_ATTRIB: u32 = 0x00000004;
pub const IN_CLOSE_WRITE: u32 = 0x00000008;
pub const IN_CLOSE_NOWRITE: u32 = 0x00000010;
pub const IN_CLOSE: u32 = IN_CLOSE_WRITE | IN_CLOSE_NOWRITE;
pub const IN_OPEN: u32 = 0x00000020;
pub const IN_MOVED_FROM: u32 = 0x00000040;
pub const IN_MOVED_TO: u32 = 0x00000080;
pub const IN_MOVE: u32 = IN_MOVED_FROM | IN_MOVED_TO;
pub const IN_CREATE: u32 = 0x00000100;
pub const IN_DELETE: u32 = 0x00000200;
pub const IN_DELETE_SELF: u32 = 0x00000400;
pub const IN_MOVE_SELF: u32 = 0x00000800;
pub const IN_UNMOUNT: u32 = 0x00002000;
pub const IN_Q_OVERFLOW: u32 = 0x00004000;
pub const IN_IGNORED: u32 = 0x00008000;
pub const IN_ONLYDIR: u32 = 0x01000000;
pub const IN_DONT_FOLLOW: u32 = 0x02000000;

pub const IN_ISDIR: u32 = 0x40000000;
pub const IN_ONESHOT: u32 = 0x80000000;

pub const REG_EXTENDED: ::c_int = 0o0001;
pub const REG_ICASE: ::c_int = 0o0002;
pub const REG_NEWLINE: ::c_int = 0o0010;
pub const REG_NOSUB: ::c_int = 0o0004;

pub const REG_NOTBOL: ::c_int = 0o00001;
pub const REG_NOTEOL: ::c_int = 0o00002;

pub const REG_ENOSYS: ::c_int = 17;
pub const REG_NOMATCH: ::c_int = 1;
pub const REG_BADPAT: ::c_int = 2;
pub const REG_ECOLLATE: ::c_int = 3;
pub const REG_ECTYPE: ::c_int = 4;
pub const REG_EESCAPE: ::c_int = 5;
pub const REG_ESUBREG: ::c_int = 6;
pub const REG_EBRACK: ::c_int = 7;
pub const REG_EPAREN: ::c_int = 8;
pub const REG_EBRACE: ::c_int = 9;
pub const REG_BADBR: ::c_int = 10;
pub const REG_ERANGE: ::c_int = 11;
pub const REG_ESPACE: ::c_int = 12;
pub const REG_BADRPT: ::c_int = 13;

// errno.h
pub const EOK: ::c_int = 0;
pub const EWOULDBLOCK: ::c_int = EAGAIN;
pub const EPERM: ::c_int = 1;
pub const ENOENT: ::c_int = 2;
pub const ESRCH: ::c_int = 3;
pub const EINTR: ::c_int = 4;
pub const EIO: ::c_int = 5;
pub const ENXIO: ::c_int = 6;
pub const E2BIG: ::c_int = 7;
pub const ENOEXEC: ::c_int = 8;
pub const EBADF: ::c_int = 9;
pub const ECHILD: ::c_int = 10;
pub const EAGAIN: ::c_int = 11;
pub const ENOMEM: ::c_int = 12;
pub const EACCES: ::c_int = 13;
pub const EFAULT: ::c_int = 14;
pub const ENOTBLK: ::c_int = 15;
pub const EBUSY: ::c_int = 16;
pub const EEXIST: ::c_int = 17;
pub const EXDEV: ::c_int = 18;
pub const ENODEV: ::c_int = 19;
pub const ENOTDIR: ::c_int = 20;
pub const EISDIR: ::c_int = 21;
pub const EINVAL: ::c_int = 22;
pub const ENFILE: ::c_int = 23;
pub const EMFILE: ::c_int = 24;
pub const ENOTTY: ::c_int = 25;
pub const ETXTBSY: ::c_int = 26;
pub const EFBIG: ::c_int = 27;
pub const ENOSPC: ::c_int = 28;
pub const ESPIPE: ::c_int = 29;
pub const EROFS: ::c_int = 30;
pub const EMLINK: ::c_int = 31;
pub const EPIPE: ::c_int = 32;
pub const EDOM: ::c_int = 33;
pub const ERANGE: ::c_int = 34;
pub const ENOMSG: ::c_int = 35;
pub const EIDRM: ::c_int = 36;
pub const ECHRNG: ::c_int = 37;
pub const EL2NSYNC: ::c_int = 38;
pub const EL3HLT: ::c_int = 39;
pub const EL3RST: ::c_int = 40;
pub const ELNRNG: ::c_int = 41;
pub const EUNATCH: ::c_int = 42;
pub const ENOCSI: ::c_int = 43;
pub const EL2HLT: ::c_int = 44;
pub const EDEADLK: ::c_int = 45;
pub const ENOLCK: ::c_int = 46;
pub const ECANCELED: ::c_int = 47;
pub const EDQUOT: ::c_int = 49;
pub const EBADE: ::c_int = 50;
pub const EBADR: ::c_int = 51;
pub const EXFULL: ::c_int = 52;
pub const ENOANO: ::c_int = 53;
pub const EBADRQC: ::c_int = 54;
pub const EBADSLT: ::c_int = 55;
pub const EDEADLOCK: ::c_int = 56;
pub const EBFONT: ::c_int = 57;
pub const EOWNERDEAD: ::c_int = 58;
pub const ENOSTR: ::c_int = 60;
pub const ENODATA: ::c_int = 61;
pub const ETIME: ::c_int = 62;
pub const ENOSR: ::c_int = 63;
pub const ENONET: ::c_int = 64;
pub const ENOPKG: ::c_int = 65;
pub const EREMOTE: ::c_int = 66;
pub const ENOLINK: ::c_int = 67;
pub const EADV: ::c_int = 68;
pub const ESRMNT: ::c_int = 69;
pub const ECOMM: ::c_int = 70;
pub const EPROTO: ::c_int = 71;
pub const EMULTIHOP: ::c_int = 74;
pub const EBADMSG: ::c_int = 77;
pub const ENAMETOOLONG: ::c_int = 78;
pub const EOVERFLOW: ::c_int = 79;
pub const ENOTUNIQ: ::c_int = 80;
pub const EBADFD: ::c_int = 81;
pub const EREMCHG: ::c_int = 82;
pub const ELIBACC: ::c_int = 83;
pub const ELIBBAD: ::c_int = 84;
pub const ELIBSCN: ::c_int = 85;
pub const ELIBMAX: ::c_int = 86;
pub const ELIBEXEC: ::c_int = 87;
pub const EILSEQ: ::c_int = 88;
pub const ENOSYS: ::c_int = 89;
pub const ELOOP: ::c_int = 90;
pub const ERESTART: ::c_int = 91;
pub const ESTRPIPE: ::c_int = 92;
pub const ENOTEMPTY: ::c_int = 93;
pub const EUSERS: ::c_int = 94;
pub const ENOTRECOVERABLE: ::c_int = 95;
pub const EOPNOTSUPP: ::c_int = 103;
pub const EFPOS: ::c_int = 110;
pub const ESTALE: ::c_int = 122;
pub const EINPROGRESS: ::c_int = 236;
pub const EALREADY: ::c_int = 237;
pub const ENOTSOCK: ::c_int = 238;
pub const EDESTADDRREQ: ::c_int = 239;
pub const EMSGSIZE: ::c_int = 240;
pub const EPROTOTYPE: ::c_int = 241;
pub const ENOPROTOOPT: ::c_int = 242;
pub const EPROTONOSUPPORT: ::c_int = 243;
pub const ESOCKTNOSUPPORT: ::c_int = 244;
pub const EPFNOSUPPORT: ::c_int = 246;
pub const EAFNOSUPPORT: ::c_int = 247;
pub const EADDRINUSE: ::c_int = 248;
pub const EADDRNOTAVAIL: ::c_int = 249;
pub const ENETDOWN: ::c_int = 250;
pub const ENETUNREACH: ::c_int = 251;
pub const ENETRESET: ::c_int = 252;
pub const ECONNABORTED: ::c_int = 253;
pub const ECONNRESET: ::c_int = 254;
pub const ENOBUFS: ::c_int = 255;
pub const EISCONN: ::c_int = 256;
pub const ENOTCONN: ::c_int = 257;
pub const ESHUTDOWN: ::c_int = 258;
pub const ETOOMANYREFS: ::c_int = 259;
pub const ETIMEDOUT: ::c_int = 260;
pub const ECONNREFUSED: ::c_int = 261;
pub const EHOSTDOWN: ::c_int = 264;
pub const EHOSTUNREACH: ::c_int = 265;
pub const EBADRPC: ::c_int = 272;
pub const ERPCMISMATCH: ::c_int = 273;
pub const EPROGUNAVAIL: ::c_int = 274;
pub const EPROGMISMATCH: ::c_int = 275;
pub const EPROCUNAVAIL: ::c_int = 276;
pub const ENOREMOTE: ::c_int = 300;
pub const ENONDP: ::c_int = 301;
pub const EBADFSYS: ::c_int = 302;
pub const EMORE: ::c_int = 309;
pub const ECTRLTERM: ::c_int = 310;
pub const ENOLIC: ::c_int = 311;
pub const ESRVRFAULT: ::c_int = 312;
pub const EENDIAN: ::c_int = 313;
pub const ESECTYPEINVAL: ::c_int = 314;

pub const RUSAGE_CHILDREN: ::c_int = -1;
pub const L_tmpnam: ::c_uint = 255;

pub const _PC_LINK_MAX: ::c_int = 1;
pub const _PC_MAX_CANON: ::c_int = 2;
pub const _PC_MAX_INPUT: ::c_int = 3;
pub const _PC_NAME_MAX: ::c_int = 4;
pub const _PC_PATH_MAX: ::c_int = 5;
pub const _PC_PIPE_BUF: ::c_int = 6;
pub const _PC_CHOWN_RESTRICTED: ::c_int = 9;
pub const _PC_NO_TRUNC: ::c_int = 7;
pub const _PC_VDISABLE: ::c_int = 8;
pub const _PC_SYNC_IO: ::c_int = 14;
pub const _PC_ASYNC_IO: ::c_int = 12;
pub const _PC_PRIO_IO: ::c_int = 13;
pub const _PC_SOCK_MAXBUF: ::c_int = 15;
pub const _PC_FILESIZEBITS: ::c_int = 16;
pub const _PC_REC_INCR_XFER_SIZE: ::c_int = 22;
pub const _PC_REC_MAX_XFER_SIZE: ::c_int = 23;
pub const _PC_REC_MIN_XFER_SIZE: ::c_int = 24;
pub const _PC_REC_XFER_ALIGN: ::c_int = 25;
pub const _PC_ALLOC_SIZE_MIN: ::c_int = 21;
pub const _PC_SYMLINK_MAX: ::c_int = 17;
pub const _PC_2_SYMLINKS: ::c_int = 20;

pub const _SC_PAGE_SIZE: ::c_int = _SC_PAGESIZE;
pub const _SC_ARG_MAX: ::c_int = 1;
pub const _SC_CHILD_MAX: ::c_int = 2;
pub const _SC_CLK_TCK: ::c_int = 3;
pub const _SC_NGROUPS_MAX: ::c_int = 4;
pub const _SC_OPEN_MAX: ::c_int = 5;
pub const _SC_JOB_CONTROL: ::c_int = 6;
pub const _SC_SAVED_IDS: ::c_int = 7;
pub const _SC_VERSION: ::c_int = 8;
pub const _SC_PASS_MAX: ::c_int = 9;
pub const _SC_PAGESIZE: ::c_int = 11;
pub const _SC_XOPEN_VERSION: ::c_int = 12;
pub const _SC_STREAM_MAX: ::c_int = 13;
pub const _SC_TZNAME_MAX: ::c_int = 14;
pub const _SC_AIO_LISTIO_MAX: ::c_int = 15;
pub const _SC_AIO_MAX: ::c_int = 16;
pub const _SC_AIO_PRIO_DELTA_MAX: ::c_int = 17;
pub const _SC_DELAYTIMER_MAX: ::c_int = 18;
pub const _SC_MQ_OPEN_MAX: ::c_int = 19;
pub const _SC_MQ_PRIO_MAX: ::c_int = 20;
pub const _SC_RTSIG_MAX: ::c_int = 21;
pub const _SC_SEM_NSEMS_MAX: ::c_int = 22;
pub const _SC_SEM_VALUE_MAX: ::c_int = 23;
pub const _SC_SIGQUEUE_MAX: ::c_int = 24;
pub const _SC_TIMER_MAX: ::c_int = 25;
pub const _SC_ASYNCHRONOUS_IO: ::c_int = 26;
pub const _SC_FSYNC: ::c_int = 27;
pub const _SC_MAPPED_FILES: ::c_int = 28;
pub const _SC_MEMLOCK: ::c_int = 29;
pub const _SC_MEMLOCK_RANGE: ::c_int = 30;
pub const _SC_MEMORY_PROTECTION: ::c_int = 31;
pub const _SC_MESSAGE_PASSING: ::c_int = 32;
pub const _SC_PRIORITIZED_IO: ::c_int = 33;
pub const _SC_PRIORITY_SCHEDULING: ::c_int = 34;
pub const _SC_REALTIME_SIGNALS: ::c_int = 35;
pub const _SC_SEMAPHORES: ::c_int = 36;
pub const _SC_SHARED_MEMORY_OBJECTS: ::c_int = 37;
pub const _SC_SYNCHRONIZED_IO: ::c_int = 38;
pub const _SC_TIMERS: ::c_int = 39;
pub const _SC_GETGR_R_SIZE_MAX: ::c_int = 40;
pub const _SC_GETPW_R_SIZE_MAX: ::c_int = 41;
pub const _SC_LOGIN_NAME_MAX: ::c_int = 42;
pub const _SC_THREAD_DESTRUCTOR_ITERATIONS: ::c_int = 43;
pub const _SC_THREAD_KEYS_MAX: ::c_int = 44;
pub const _SC_THREAD_STACK_MIN: ::c_int = 45;
pub const _SC_THREAD_THREADS_MAX: ::c_int = 46;
pub const _SC_TTY_NAME_MAX: ::c_int = 47;
pub const _SC_THREADS: ::c_int = 48;
pub const _SC_THREAD_ATTR_STACKADDR: ::c_int = 49;
pub const _SC_THREAD_ATTR_STACKSIZE: ::c_int = 50;
pub const _SC_THREAD_PRIORITY_SCHEDULING: ::c_int = 51;
pub const _SC_THREAD_PRIO_INHERIT: ::c_int = 52;
pub const _SC_THREAD_PRIO_PROTECT: ::c_int = 53;
pub const _SC_THREAD_PROCESS_SHARED: ::c_int = 54;
pub const _SC_THREAD_SAFE_FUNCTIONS: ::c_int = 55;
pub const _SC_2_CHAR_TERM: ::c_int = 56;
pub const _SC_2_C_BIND: ::c_int = 57;
pub const _SC_2_C_DEV: ::c_int = 58;
pub const _SC_2_C_VERSION: ::c_int = 59;
pub const _SC_2_FORT_DEV: ::c_int = 60;
pub const _SC_2_FORT_RUN: ::c_int = 61;
pub const _SC_2_LOCALEDEF: ::c_int = 62;
pub const _SC_2_SW_DEV: ::c_int = 63;
pub const _SC_2_UPE: ::c_int = 64;
pub const _SC_2_VERSION: ::c_int = 65;
pub const _SC_ATEXIT_MAX: ::c_int = 66;
pub const _SC_AVPHYS_PAGES: ::c_int = 67;
pub const _SC_BC_BASE_MAX: ::c_int = 68;
pub const _SC_BC_DIM_MAX: ::c_int = 69;
pub const _SC_BC_SCALE_MAX: ::c_int = 70;
pub const _SC_BC_STRING_MAX: ::c_int = 71;
pub const _SC_CHARCLASS_NAME_MAX: ::c_int = 72;
pub const _SC_CHAR_BIT: ::c_int = 73;
pub const _SC_CHAR_MAX: ::c_int = 74;
pub const _SC_CHAR_MIN: ::c_int = 75;
pub const _SC_COLL_WEIGHTS_MAX: ::c_int = 76;
pub const _SC_EQUIV_CLASS_MAX: ::c_int = 77;
pub const _SC_EXPR_NEST_MAX: ::c_int = 78;
pub const _SC_INT_MAX: ::c_int = 79;
pub const _SC_INT_MIN: ::c_int = 80;
pub const _SC_LINE_MAX: ::c_int = 81;
pub const _SC_LONG_BIT: ::c_int = 82;
pub const _SC_MB_LEN_MAX: ::c_int = 83;
pub const _SC_NL_ARGMAX: ::c_int = 84;
pub const _SC_NL_LANGMAX: ::c_int = 85;
pub const _SC_NL_MSGMAX: ::c_int = 86;
pub const _SC_NL_NMAX: ::c_int = 87;
pub const _SC_NL_SETMAX: ::c_int = 88;
pub const _SC_NL_TEXTMAX: ::c_int = 89;
pub const _SC_NPROCESSORS_CONF: ::c_int = 90;
pub const _SC_NPROCESSORS_ONLN: ::c_int = 91;
pub const _SC_NZERO: ::c_int = 92;
pub const _SC_PHYS_PAGES: ::c_int = 93;
pub const _SC_PII: ::c_int = 94;
pub const _SC_PII_INTERNET: ::c_int = 95;
pub const _SC_PII_INTERNET_DGRAM: ::c_int = 96;
pub const _SC_PII_INTERNET_STREAM: ::c_int = 97;
pub const _SC_PII_OSI: ::c_int = 98;
pub const _SC_PII_OSI_CLTS: ::c_int = 99;
pub const _SC_PII_OSI_COTS: ::c_int = 100;
pub const _SC_PII_OSI_M: ::c_int = 101;
pub const _SC_PII_SOCKET: ::c_int = 102;
pub const _SC_PII_XTI: ::c_int = 103;
pub const _SC_POLL: ::c_int = 104;
pub const _SC_RE_DUP_MAX: ::c_int = 105;
pub const _SC_SCHAR_MAX: ::c_int = 106;
pub const _SC_SCHAR_MIN: ::c_int = 107;
pub const _SC_SELECT: ::c_int = 108;
pub const _SC_SHRT_MAX: ::c_int = 109;
pub const _SC_SHRT_MIN: ::c_int = 110;
pub const _SC_SSIZE_MAX: ::c_int = 111;
pub const _SC_T_IOV_MAX: ::c_int = 112;
pub const _SC_UCHAR_MAX: ::c_int = 113;
pub const _SC_UINT_MAX: ::c_int = 114;
pub const _SC_UIO_MAXIOV: ::c_int = 115;
pub const _SC_ULONG_MAX: ::c_int = 116;
pub const _SC_USHRT_MAX: ::c_int = 117;
pub const _SC_WORD_BIT: ::c_int = 118;
pub const _SC_XOPEN_CRYPT: ::c_int = 119;
pub const _SC_XOPEN_ENH_I18N: ::c_int = 120;
pub const _SC_XOPEN_SHM: ::c_int = 121;
pub const _SC_XOPEN_UNIX: ::c_int = 122;
pub const _SC_XOPEN_XCU_VERSION: ::c_int = 123;
pub const _SC_XOPEN_XPG2: ::c_int = 124;
pub const _SC_XOPEN_XPG3: ::c_int = 125;
pub const _SC_XOPEN_XPG4: ::c_int = 126;
pub const _SC_XBS5_ILP32_OFF32: ::c_int = 127;
pub const _SC_XBS5_ILP32_OFFBIG: ::c_int = 128;
pub const _SC_XBS5_LP64_OFF64: ::c_int = 129;
pub const _SC_XBS5_LPBIG_OFFBIG: ::c_int = 130;
pub const _SC_ADVISORY_INFO: ::c_int = 131;
pub const _SC_CPUTIME: ::c_int = 132;
pub const _SC_SPAWN: ::c_int = 133;
pub const _SC_SPORADIC_SERVER: ::c_int = 134;
pub const _SC_THREAD_CPUTIME: ::c_int = 135;
pub const _SC_THREAD_SPORADIC_SERVER: ::c_int = 136;
pub const _SC_TIMEOUTS: ::c_int = 137;
pub const _SC_BARRIERS: ::c_int = 138;
pub const _SC_CLOCK_SELECTION: ::c_int = 139;
pub const _SC_MONOTONIC_CLOCK: ::c_int = 140;
pub const _SC_READER_WRITER_LOCKS: ::c_int = 141;
pub const _SC_SPIN_LOCKS: ::c_int = 142;
pub const _SC_TYPED_MEMORY_OBJECTS: ::c_int = 143;
pub const _SC_TRACE_EVENT_FILTER: ::c_int = 144;
pub const _SC_TRACE: ::c_int = 145;
pub const _SC_TRACE_INHERIT: ::c_int = 146;
pub const _SC_TRACE_LOG: ::c_int = 147;
pub const _SC_2_PBS: ::c_int = 148;
pub const _SC_2_PBS_ACCOUNTING: ::c_int = 149;
pub const _SC_2_PBS_CHECKPOINT: ::c_int = 150;
pub const _SC_2_PBS_LOCATE: ::c_int = 151;
pub const _SC_2_PBS_MESSAGE: ::c_int = 152;
pub const _SC_2_PBS_TRACK: ::c_int = 153;
pub const _SC_HOST_NAME_MAX: ::c_int = 154;
pub const _SC_IOV_MAX: ::c_int = 155;
pub const _SC_IPV6: ::c_int = 156;
pub const _SC_RAW_SOCKETS: ::c_int = 157;
pub const _SC_REGEXP: ::c_int = 158;
pub const _SC_SHELL: ::c_int = 159;
pub const _SC_SS_REPL_MAX: ::c_int = 160;
pub const _SC_SYMLOOP_MAX: ::c_int = 161;
pub const _SC_TRACE_EVENT_NAME_MAX: ::c_int = 162;
pub const _SC_TRACE_NAME_MAX: ::c_int = 163;
pub const _SC_TRACE_SYS_MAX: ::c_int = 164;
pub const _SC_TRACE_USER_EVENT_MAX: ::c_int = 165;
pub const _SC_V6_ILP32_OFF32: ::c_int = 166;
pub const _SC_V6_ILP32_OFFBIG: ::c_int = 167;
pub const _SC_V6_LP64_OFF64: ::c_int = 168;
pub const _SC_V6_LPBIG_OFFBIG: ::c_int = 169;
pub const _SC_XOPEN_REALTIME: ::c_int = 170;
pub const _SC_XOPEN_REALTIME_THREADS: ::c_int = 171;
--> --------------------

--> maximum size reached

--> --------------------